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

Genkit AI framework core libraries.

import {
  __async
} from "./chunk-XEFTB2OF.mjs";
import { JSONSchema7 } from "json-schema";
import { AsyncLocalStorage } from "node:async_hooks";
import { lookupPlugin, registerAction } from "./registry.js";
import { parseSchema } from "./schema.js";
import {
  SPAN_TYPE_ATTR,
  runInNewSpan,
  setCustomMetadataAttributes
} from "./tracing.js";
import { Status, StatusCodes, StatusSchema } from "./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 = parseSchema(input, {
      schema: config.inputSchema,
      jsonSchema: config.inputJsonSchema
    });
    let output = yield runInNewSpan(
      {
        metadata: {
          name: actionName
        },
        labels: {
          [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 = 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 (!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) => {
    setCustomMetadataAttributes({ subtype: config.actionType });
    return fn(i);
  });
  act.__action.actionType = config.actionType;
  registerAction(config.actionType, act);
  return act;
}
const streamingAls = new 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;
}
export {
  JSONSchema7,
  Status,
  StatusCodes,
  StatusSchema,
  action,
  actionWithMiddleware,
  defineAction,
  getStreamingCallback,
  runWithStreamingCallback
};
//# sourceMappingURL=action.mjs.map