@genkit-ai/dotprompt/lib/metadata.mjs

Genkit AI framework `.prompt` file format and management library.

import {
  __spreadValues
} from "./chunk-RGHW4PYM.mjs";
import {
  GenerationCommonConfigSchema
} from "@genkit-ai/ai/model";
import { z } from "@genkit-ai/core";
import { parseSchema, toJsonSchema } from "@genkit-ai/core/schema";
import { picoschema } from "./picoschema.js";
const PromptFrontmatterSchema = z.object({
  name: z.string().optional(),
  description: z.string().optional(),
  variant: z.string().optional(),
  model: z.string().optional(),
  tools: z.array(z.string()).optional(),
  config: GenerationCommonConfigSchema.passthrough().optional(),
  input: z.object({
    default: z.any(),
    schema: z.unknown()
  }).optional(),
  output: z.object({
    format: z.enum(["json", "text", "media"]).optional(),
    schema: z.unknown().optional()
  }).optional(),
  metadata: z.record(z.unknown()).optional()
});
function stripUndefinedOrNull(obj) {
  if (typeof obj !== "object" || obj === null) {
    return obj;
  }
  for (const key in obj) {
    if (obj[key] === void 0 || obj[key] === null) {
      delete obj[key];
    } else if (typeof obj[key] === "object") {
      stripUndefinedOrNull(obj[key]);
    }
  }
  return obj;
}
function fmSchemaToSchema(registry, fmSchema) {
  if (!fmSchema) return {};
  if (typeof fmSchema === "string") return registry.lookupSchema(fmSchema);
  return { jsonSchema: picoschema(fmSchema) };
}
function toMetadata(registry, attributes) {
  const fm = parseSchema(attributes, {
    schema: PromptFrontmatterSchema
  });
  let input;
  if (fm.input) {
    input = __spreadValues({
      default: fm.input.default
    }, fmSchemaToSchema(registry, fm.input.schema));
  }
  let output;
  if (fm.output) {
    output = __spreadValues({
      format: fm.output.format
    }, fmSchemaToSchema(registry, fm.output.schema));
  }
  return stripUndefinedOrNull({
    name: fm.name,
    description: fm.description,
    variant: fm.variant,
    model: fm.model,
    config: fm.config,
    input,
    output,
    metadata: fm.metadata,
    tools: fm.tools
  });
}
function toFrontmatter(md) {
  var _a, _b;
  return stripUndefinedOrNull({
    name: md.name,
    variant: md.variant,
    model: typeof md.model === "string" ? md.model : (_a = md.model) == null ? void 0 : _a.name,
    config: md.config,
    input: md.input ? {
      default: md.input.default,
      schema: toJsonSchema({
        schema: md.input.schema,
        jsonSchema: md.input.jsonSchema
      })
    } : void 0,
    output: md.output ? {
      format: md.output.format,
      schema: toJsonSchema({
        schema: md.output.schema,
        jsonSchema: md.output.jsonSchema
      })
    } : void 0,
    metadata: md.metadata,
    tools: (_b = md.tools) == null ? void 0 : _b.map(
      (t) => {
        var _a2;
        return typeof t === "string" ? t : ((_a2 = t.__action) == null ? void 0 : _a2.name) || t.name;
      }
    )
  });
}
export {
  PromptFrontmatterSchema,
  toFrontmatter,
  toMetadata
};
//# sourceMappingURL=metadata.mjs.map