@gjermundgaraba/effect-actions 0.10.0 → 0.12.0

package/dist/internal/tools.mjs

@@ -1,44 +0,0 @@
-import { assertOnce, projectedErrors } from "./actions.mjs";
-import { acquire } from "./implementation.mjs";
-import { Effect, Schema } from "effect";
-import { Tool, Toolkit } from "effect/ai";
-//#region src/internal/tools.ts
-/** `tool` annotated with `value` under `key`, or as it is where `value` is not given. */
-const annotateIf = (tool, key, value) => value === void 0 ? tool : tool.annotate(key, value);
-/**
-* A tool's annotations: read-only exactly when its action is, and the contract's `mcp` ones
-* where given, so the native defaults, MCP's, stand for the others. A read-only tool is not
-* destructive unless it says so, where the native default calls every tool destructive.
-*/
-const annotate = (tool, { readOnly, mcp }) => {
-	const destructive = mcp.destructiveHint ?? (readOnly ? false : void 0);
-	const meta = mcp._meta === void 0 ? void 0 : { ...mcp._meta };
-	const hinted = annotateIf(annotateIf(annotateIf(tool.annotate(Tool.Readonly, readOnly), Tool.Destructive, destructive), Tool.Idempotent, mcp.idempotentHint), Tool.OpenWorld, mcp.openWorldHint);
-	return annotateIf(annotateIf(hinted, Tool.Title, mcp.title), Tool.Meta, meta);
-};
-/**
-* The native tool of `action`. A model and an MCP client speak JSON, so it takes and gives
-* the JSON encoding its schemas advertise, the whole success; handlers and callers see decoded
-* values. A refusal by authentication or `authorize`, or a handler's built-in failure, is the implementation's failure, so
-* it declares the built-in errors alongside the action's own, and returns them as its result.
-*/
-const toolOf = (action) => Tool.make(action.name, {
-	description: action.description,
-	parameters: Schema.toCodecJson(action.input),
-	success: Schema.toCodecJson(action.success),
-	failure: Schema.toCodecJson(Schema.Union(projectedErrors(action))),
-	failureMode: "return"
-});
-/**
-* Project actions as tools named after them, sharing each implementation's built handlers.
-*/
-const bindTools = (apps, projection) => {
-	assertOnce(projection.label, apps.flatMap((app) => app.actions));
-	const toolkit = Toolkit.make(...apps.flatMap((app) => app.actions.map((action) => annotate(projection.tool(toolOf(action), action, app), action))));
-	return {
-		toolkit,
-		layer: toolkit.toLayer(Effect.map(acquire(apps), (bound) => Object.fromEntries(bound.map(([action, run]) => [action.name, projection.handler?.(run, action) ?? run]))))
-	};
-};
-//#endregion
-export { bindTools };