@genkit-ai/ai/lib/generate/middleware.js

Genkit AI framework generative AI APIs.

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var middleware_exports = {};
__export(middleware_exports, {
  MiddlewareDescSchema: () => MiddlewareDescSchema,
  generateMiddleware: () => generateMiddleware,
  resolveMiddleware: () => resolveMiddleware
});
module.exports = __toCommonJS(middleware_exports);
var import_core = require("@genkit-ai/core");
var import_schema = require("@genkit-ai/core/schema");
var import_genkit_ai = require("../genkit-ai.js");
const MiddlewareDescSchema = import_core.z.object({
  /** Unique name of the middleware. */
  name: import_core.z.string(),
  /** Human-readable description of what the middleware does. */
  description: import_core.z.string().optional(),
  /** JSON Schema for the middleware's configuration. */
  configSchema: import_core.z.record(import_core.z.any()).nullish(),
  /** User defined metadata for the middleware. */
  metadata: import_core.z.record(import_core.z.any()).nullish()
});
function generateMiddleware(options, middlewareFn) {
  const def = function(config) {
    return {
      name: options.name,
      config,
      __def: def
    };
  };
  Object.defineProperty(def, "name", { value: options.name });
  def.configSchema = options.configSchema;
  def.description = options.description;
  def.metadata = options.metadata;
  def.instantiate = middlewareFn;
  def.plugin = (pluginConfig) => ({
    name: `middleware:${options.name}`,
    version: "v2",
    middleware: () => {
      const wrappedDef = Object.assign(
        function(config) {
          return def(config);
        },
        def,
        { pluginOptions: pluginConfig }
      );
      Object.defineProperty(wrappedDef, "name", { value: options.name });
      return [wrappedDef];
    },
    model: (_) => {
      throw new Error("Not supported for middleware plugins");
    }
  });
  def.toJson = () => ({
    name: options.name,
    description: options.description,
    configSchema: options.configSchema ? (0, import_schema.toJsonSchema)({ schema: options.configSchema }) : void 0,
    metadata: options.metadata
  });
  return def;
}
async function resolveMiddleware(registry, refs) {
  const result = [];
  if (!refs) return result;
  const ai = new import_genkit_ai.GenkitAI(registry);
  for (const ref of refs) {
    const def = await registry.lookupValue(
      "middleware",
      ref.name
    );
    if (!def) {
      throw new import_core.GenkitError({
        status: "NOT_FOUND",
        message: `Middleware ${ref.name} not found in registry.`
      });
    }
    result.push(
      def.instantiate({
        config: ref.config,
        ai,
        pluginConfig: def.pluginOptions
      })
    );
  }
  return result;
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  MiddlewareDescSchema,
  generateMiddleware,
  resolveMiddleware
});
//# sourceMappingURL=middleware.js.map