@genkit-ai/core/lib/action.js

Genkit AI framework core libraries.

"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 __async = (__this, __arguments, generator) => {
  return new Promise((resolve, reject) => {
    var fulfilled = (value) => {
      try {
        step(generator.next(value));
      } catch (e) {
        reject(e);
      }
    };
    var rejected = (value) => {
      try {
        step(generator.throw(value));
      } catch (e) {
        reject(e);
      }
    };
    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
    step((generator = generator.apply(__this, __arguments)).next());
  });
};
var action_exports = {};
__export(action_exports, {
  JSONSchema7: () => import_json_schema.JSONSchema7,
  Status: () => import_statusTypes.Status,
  StatusCodes: () => import_statusTypes.StatusCodes,
  StatusSchema: () => import_statusTypes.StatusSchema,
  action: () => action,
  actionWithMiddleware: () => actionWithMiddleware,
  defineAction: () => defineAction,
  getStreamingCallback: () => getStreamingCallback,
  runWithStreamingCallback: () => runWithStreamingCallback
});
module.exports = __toCommonJS(action_exports);
var import_json_schema = require("json-schema");
var import_node_async_hooks = require("node:async_hooks");
var import_registry = require("./registry.js");
var import_schema = require("./schema.js");
var import_tracing = require("./tracing.js");
var import_statusTypes = require("./statusTypes.js");
function actionWithMiddleware(action2, middleware) {
  const wrapped = (req) => __async(this, null, function* () {
    const dispatch = (index, req2) => __async(this, null, function* () {
      if (index === middleware.length) {
        return yield action2(req2);
      }
      const currentMiddleware = middleware[index];
      return currentMiddleware(
        req2,
        (modifiedReq) => __async(this, null, function* () {
          return dispatch(index + 1, modifiedReq || req2);
        })
      );
    });
    return yield dispatch(0, req);
  });
  wrapped.__action = action2.__action;
  return wrapped;
}
function action(config, fn) {
  const actionName = typeof config.name === "string" ? validateActionName(config.name) : `${validatePluginName(config.name.pluginId)}/${validateActionId(config.name.actionId)}`;
  const actionFn = (input) => __async(this, null, function* () {
    input = (0, import_schema.parseSchema)(input, {
      schema: config.inputSchema,
      jsonSchema: config.inputJsonSchema
    });
    let output = yield (0, import_tracing.runInNewSpan)(
      {
        metadata: {
          name: actionName
        },
        labels: {
          [import_tracing.SPAN_TYPE_ATTR]: "action"
        }
      },
      (metadata) => __async(this, null, function* () {
        metadata.name = actionName;
        metadata.input = input;
        const output2 = yield fn(input);
        metadata.output = JSON.stringify(output2);
        return output2;
      })
    );
    output = (0, import_schema.parseSchema)(output, {
      schema: config.outputSchema,
      jsonSchema: config.outputJsonSchema
    });
    return output;
  });
  actionFn.__action = {
    name: actionName,
    description: config.description,
    inputSchema: config.inputSchema,
    inputJsonSchema: config.inputJsonSchema,
    outputSchema: config.outputSchema,
    outputJsonSchema: config.outputJsonSchema,
    metadata: config.metadata
  };
  if (config.use) {
    return actionWithMiddleware(actionFn, config.use);
  }
  return actionFn;
}
function validateActionName(name) {
  if (name.includes("/")) {
    validatePluginName(name.split("/", 1)[0]);
    validateActionId(name.substring(name.indexOf("/") + 1));
  }
  return name;
}
function validatePluginName(pluginId) {
  if (!(0, import_registry.lookupPlugin)(pluginId)) {
    throw new Error(
      `Unable to find plugin name used in the action name: ${pluginId}`
    );
  }
  return pluginId;
}
function validateActionId(actionId) {
  if (actionId.includes("/")) {
    throw new Error(`Action name must not include slashes (/): ${actionId}`);
  }
  return actionId;
}
function defineAction(config, fn) {
  const act = action(config, (i) => {
    (0, import_tracing.setCustomMetadataAttributes)({ subtype: config.actionType });
    return fn(i);
  });
  act.__action.actionType = config.actionType;
  (0, import_registry.registerAction)(config.actionType, act);
  return act;
}
const streamingAls = new import_node_async_hooks.AsyncLocalStorage();
const sentinelNoopCallback = () => null;
function runWithStreamingCallback(streamingCallback, fn) {
  return streamingAls.run(streamingCallback || sentinelNoopCallback, fn);
}
function getStreamingCallback() {
  const cb = streamingAls.getStore();
  if (cb === sentinelNoopCallback) {
    return void 0;
  }
  return cb;
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  JSONSchema7,
  Status,
  StatusCodes,
  StatusSchema,
  action,
  actionWithMiddleware,
  defineAction,
  getStreamingCallback,
  runWithStreamingCallback
});
//# sourceMappingURL=action.js.map