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

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

import {
  __spreadValues
} from "./chunk-DFMI36TU.mjs";
import {
  GenerationCommonConfigSchema
} from "@genkit-ai/ai/model";
import { lookupSchema } from "@genkit-ai/core/registry";
import { parseSchema, toJsonSchema } from "@genkit-ai/core/schema";
import z from "zod";
import { picoschema } from "./picoschema.js";
const PromptFrontmatterSchema = z.object({
  name: z.string().optional(),
  variant: z.string().optional(),
  model: z.string().optional(),
  tools: z.array(z.string()).optional(),
  candidates: z.number().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(fmSchema) {
  if (!fmSchema)
    return {};
  if (typeof fmSchema === "string")
    return lookupSchema(fmSchema);
  return { jsonSchema: picoschema(fmSchema) };
}
function toMetadata(attributes) {
  const fm = parseSchema(attributes, {
    schema: PromptFrontmatterSchema
  });
  let input;
  if (fm.input) {
    input = __spreadValues({ default: fm.input.default }, fmSchemaToSchema(fm.input.schema));
  }
  let output;
  if (fm.output) {
    output = __spreadValues({
      format: fm.output.format
    }, fmSchemaToSchema(fm.output.schema));
  }
  return stripUndefinedOrNull({
    name: fm.name,
    variant: fm.variant,
    model: fm.model,
    config: fm.config,
    input,
    output,
    metadata: fm.metadata,
    tools: fm.tools,
    candidates: fm.candidates
  });
}
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;
      }
    ),
    candidates: md.candidates
  });
}
export {
  PromptFrontmatterSchema,
  toFrontmatter,
  toMetadata
};
//# sourceMappingURL=metadata.mjs.map