@warlock.js/ai 4.2.11 → 4.3.0

package/esm/testing/matchers.mjs

@@ -0,0 +1,37 @@
+import { matchConverge, matchOutputShape, matchPassStep, matchRouteTo } from "./matcher-logic.mjs";
+import { globalExpect } from "../node_modules/vitest/dist/chunks/test.DNmyFkvJ.mjs";
+
+//#region ../@warlock.js/ai/src/testing/matchers.ts
+let registered = false;
+/**
+* Register the `@warlock.js/ai` custom matchers on Vitest's global
+* `expect`. Call once per test file (or in a shared import) before
+* using `toRouteTo` / `toConverge` / `toPassStep` / `toOutputShape`.
+* Idempotent — repeated calls are a no-op.
+*
+* @example
+* import { registerAiMatchers } from "@warlock.js/ai";
+* registerAiMatchers();
+*/
+function registerAiMatchers() {
+	if (registered) return;
+	registered = true;
+	globalExpect.extend({
+		toRouteTo(received, intent) {
+			return matchRouteTo(received, intent);
+		},
+		toConverge(received) {
+			return matchConverge(received);
+		},
+		toPassStep(received, stepName) {
+			return matchPassStep(received, stepName);
+		},
+		toOutputShape(received, schema) {
+			return matchOutputShape(received, schema);
+		}
+	});
+}
+
+//#endregion
+export { registerAiMatchers };
+//# sourceMappingURL=matchers.mjs.map

package/esm/testing/matchers.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"matchers.mjs","names":[],"sources":["../../../../../../../@warlock.js/ai/src/testing/matchers.ts"],"sourcesContent":["import type { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport { expect } from \"vitest\";\nimport {\n  matchConverge,\n  matchOutputShape,\n  matchPassStep,\n  matchRouteTo,\n} from \"./matcher-logic\";\n\n/**\n * Custom Vitest matchers over the unified `@warlock.js/ai` report tree.\n *\n * - `toRouteTo(intent)` — a supervisor dispatched the named intent.\n * - `toConverge()` — a supervisor terminated cleanly on its own\n *   decision (not max-iterations / cancelled / error).\n * - `toPassStep(name)` — a workflow step completed successfully.\n * - `toOutputShape(schema)` — a result's `data` validates against a\n *   Standard Schema.\n *\n * @example\n * import { registerAiMatchers } from \"@warlock.js/ai\";\n * registerAiMatchers();\n *\n * expect(await supervisor.execute(input)).toRouteTo(\"critic\");\n * expect(await supervisor.execute(input)).toConverge();\n * expect(await workflow.execute(input)).toPassStep(\"draft\");\n * expect(await agent.execute(input, { output: schema })).toOutputShape(schema);\n */\nexport interface AiMatchers<R = unknown> {\n  /** Assert a supervisor dispatched the named intent across its run. */\n  toRouteTo(intent: string): R;\n  /** Assert a supervisor terminated cleanly on its own decision. */\n  toConverge(): R;\n  /** Assert a named workflow step completed successfully. */\n  toPassStep(stepName: string): R;\n  /** Assert a result's `data` validates against a Standard Schema. */\n  toOutputShape(schema: StandardSchemaV1): R;\n}\n\ndeclare module \"vitest\" {\n  // Vitest 4's augmentable `Matchers` interface is `Matchers<T = any>`\n  // — the type parameter must match exactly (TS2428) or the\n  // declaration is rejected. `T` is the assertion-chain return type.\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  interface Matchers<T = any> extends AiMatchers<T> {}\n}\n\nlet registered = false;\n\n/**\n * Register the `@warlock.js/ai` custom matchers on Vitest's global\n * `expect`. Call once per test file (or in a shared import) before\n * using `toRouteTo` / `toConverge` / `toPassStep` / `toOutputShape`.\n * Idempotent — repeated calls are a no-op.\n *\n * @example\n * import { registerAiMatchers } from \"@warlock.js/ai\";\n * registerAiMatchers();\n */\nexport function registerAiMatchers(): void {\n  if (registered) {\n    return;\n  }\n\n  registered = true;\n\n  expect.extend({\n    toRouteTo(received: unknown, intent: string) {\n      return matchRouteTo(received as never, intent);\n    },\n    toConverge(received: unknown) {\n      return matchConverge(received as never);\n    },\n    toPassStep(received: unknown, stepName: string) {\n      return matchPassStep(received as never, stepName);\n    },\n    toOutputShape(received: unknown, schema: StandardSchemaV1) {\n      return matchOutputShape(received as never, schema);\n    },\n  });\n}\n"],"mappings":";;;;AA+CA,IAAI,aAAa;;;;;;;;;;;AAYjB,SAAgB,qBAA2B;CACzC,IAAI,YACF;CAGF,aAAa;CAEb,aAAO,OAAO;EACZ,UAAU,UAAmB,QAAgB;GAC3C,OAAO,aAAa,UAAmB,MAAM;EAC/C;EACA,WAAW,UAAmB;GAC5B,OAAO,cAAc,QAAiB;EACxC;EACA,WAAW,UAAmB,UAAkB;GAC9C,OAAO,cAAc,UAAmB,QAAQ;EAClD;EACA,cAAc,UAAmB,QAA0B;GACzD,OAAO,iBAAiB,UAAmB,MAAM;EACnD;CACF,CAAC;AACH"}

package/esm/testing/register-lazy.d.mts

@@ -0,0 +1,20 @@
+//#region ../@warlock.js/ai/src/testing/register-lazy.d.ts
+/**
+ * Register the `@warlock.js/ai` custom Vitest matchers
+ * (`toRouteTo` / `toConverge` / `toPassStep` / `toOutputShape`) on the
+ * global `expect`. Call once from test code before using them. The
+ * underlying `vitest`-coupled implementation is imported lazily on the
+ * first call, so importing `@warlock.js/ai` in production never pulls in
+ * `vitest`. Idempotent — the underlying registration is itself a no-op on
+ * repeat calls.
+ *
+ * @example
+ * import { registerAiMatchers } from "@warlock.js/ai";
+ * await registerAiMatchers();
+ *
+ * expect(await supervisor.execute(input)).toRouteTo("critic");
+ */
+declare function registerAiMatchers(): Promise<void>;
+//#endregion
+export { registerAiMatchers };
+//# sourceMappingURL=register-lazy.d.mts.map

package/esm/testing/register-lazy.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register-lazy.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai/src/testing/register-lazy.ts"],"mappings":";;AA2BA;;;;AAAmD;;;;;;;;;;iBAA7B,kBAAA,IAAsB,OAAO"}

package/esm/testing/register-lazy.mjs

@@ -0,0 +1,24 @@
+//#region ../@warlock.js/ai/src/testing/register-lazy.ts
+/**
+* Register the `@warlock.js/ai` custom Vitest matchers
+* (`toRouteTo` / `toConverge` / `toPassStep` / `toOutputShape`) on the
+* global `expect`. Call once from test code before using them. The
+* underlying `vitest`-coupled implementation is imported lazily on the
+* first call, so importing `@warlock.js/ai` in production never pulls in
+* `vitest`. Idempotent — the underlying registration is itself a no-op on
+* repeat calls.
+*
+* @example
+* import { registerAiMatchers } from "@warlock.js/ai";
+* await registerAiMatchers();
+*
+* expect(await supervisor.execute(input)).toRouteTo("critic");
+*/
+async function registerAiMatchers() {
+	const { registerAiMatchers: register } = await import("./matchers.mjs");
+	register();
+}
+
+//#endregion
+export { registerAiMatchers };
+//# sourceMappingURL=register-lazy.mjs.map

package/esm/testing/register-lazy.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"register-lazy.mjs","names":[],"sources":["../../../../../../../@warlock.js/ai/src/testing/register-lazy.ts"],"sourcesContent":["// Lazy bridge for the vitest-coupled matcher registration.\n//\n// WHY: `@warlock.js/ai`'s root barrel (`src/index.ts`) is the package's\n// only public entry, and it is loaded by every production consumer.\n// `./matchers` statically imports `vitest` (a devDependency) at module\n// top to call `expect.extend`, so pulling it into the eager barrel would\n// force `vitest` to resolve in production — where it is not installed —\n// and crash the import. This wrapper defers that import to call time via\n// a dynamic `import()`, mirroring the package's optional-peer discipline,\n// so `registerAiMatchers` can ship on the root barrel while staying inert\n// (and `vitest`-free) until a test actually invokes it.\n\n/**\n * Register the `@warlock.js/ai` custom Vitest matchers\n * (`toRouteTo` / `toConverge` / `toPassStep` / `toOutputShape`) on the\n * global `expect`. Call once from test code before using them. The\n * underlying `vitest`-coupled implementation is imported lazily on the\n * first call, so importing `@warlock.js/ai` in production never pulls in\n * `vitest`. Idempotent — the underlying registration is itself a no-op on\n * repeat calls.\n *\n * @example\n * import { registerAiMatchers } from \"@warlock.js/ai\";\n * await registerAiMatchers();\n *\n * expect(await supervisor.execute(input)).toRouteTo(\"critic\");\n */\nexport async function registerAiMatchers(): Promise<void> {\n  const { registerAiMatchers: register } = await import(\"./matchers\");\n\n  register();\n}\n"],"mappings":";;;;;;;;;;;;;;;;AA2BA,eAAsB,qBAAoC;CACxD,MAAM,EAAE,oBAAoB,aAAa,MAAM,OAAO;CAEtD,SAAS;AACX"}

package/esm/tool/executable-as-tool.d.mts

@@ -0,0 +1,87 @@
+import { AIError } from "../errors/ai-error.mjs";
+import { BaseResult } from "../contracts/result/base-result.type.mjs";
+import { BaseReport } from "../contracts/result/base-report.type.mjs";
+import { ToolContract } from "./tool.mjs";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region ../@warlock.js/ai/src/tool/executable-as-tool.d.ts
+/**
+ * Envelope every executable's `execute()` resolves to. Agent, workflow,
+ * and supervisor results all satisfy this shape — `data` / `error`
+ * carry the outcome while `usage` and `report` are always present —
+ * which is exactly what {@link compositeAsTool} needs to nest the inner
+ * run under the outer tool-call node.
+ */
+type ExecutableEnvelope<TOutput> = BaseResult & {
+  data?: TOutput;
+  error?: AIError;
+  report: BaseReport;
+};
+/**
+ * Structural view of an executable primitive (agent / workflow /
+ * supervisor) when it is dropped straight into an agent's `tools: []`
+ * array WITHOUT being wrapped via `.asTool()` first.
+ *
+ * Only the fields the auto-adapt path reads are declared:
+ * - `name` — becomes the LLM tool name (required; anonymous executables
+ *   are rejected at author time, mirroring `.asTool()`).
+ * - `description` — the "when would the model pick this?" line.
+ * - `inputSchema` — opt-in Standard Schema typing the tool's arguments.
+ *   Surfaced on `WorkflowInstance` / `SupervisorContract` from the new
+ *   optional `inputSchema` config field. Absent for agents (which take
+ *   a plain string prompt).
+ * - `execute` — the dispatch entry every `ExecutableContract` exposes.
+ *
+ * `invoke` is declared `never` so a `ToolContract` (which HAS `invoke`)
+ * can never be mistaken for an executable by the {@link isExecutableTool}
+ * guard.
+ */
+type ExecutableTool<TInput = unknown, TOutput = unknown> = {
+  readonly name: string;
+  readonly description?: string;
+  readonly inputSchema?: StandardSchemaV1<TInput>;
+  execute(input: TInput, options?: unknown): Promise<ExecutableEnvelope<TOutput>>;
+  invoke?: never;
+};
+/**
+ * Entry accepted in an agent's `tools: []` array — either an already-
+ * built `ToolContract` (the `.asTool()` / `ai.tool()` path) or a raw
+ * executable primitive the framework auto-adapts on the caller's
+ * behalf.
+ */
+type AgentToolEntry<TInput = unknown, TOutput = unknown> = ToolContract<TInput, TOutput> | ExecutableTool<TInput, TOutput>;
+/**
+ * Type guard distinguishing a raw executable primitive from a built
+ * `ToolContract`. An executable exposes `execute()` and no `invoke()`;
+ * a `ToolContract` exposes `invoke()`. The `invoke` check is the
+ * load-bearing discriminator — `.asTool()`-wrapped composites keep
+ * their own `execute` too, so checking `execute` alone is insufficient.
+ */
+declare function isExecutableTool(entry: unknown): entry is ExecutableTool;
+/**
+ * Adapt a raw executable primitive (agent / workflow / supervisor) into
+ * a `ToolContract` so an agent can dispatch it inside its tool-call
+ * loop WITHOUT the caller writing `.asTool()`. Derives the LLM tool
+ * manifest from the executable's own `name` + `description` +
+ * (optional) `inputSchema`, then dispatches through the executable's
+ * `execute()` — the inner report nests under the outer tool-call node
+ * exactly like an explicit `.asTool()` wrapper.
+ *
+ * Throws `AgentExecutionError` at author time when the executable lacks
+ * a usable `name` — the agent's tool surface needs a stable id, the
+ * same constraint `.asTool()` enforces.
+ */
+declare function executableToTool<TInput, TOutput>(executable: ExecutableTool<TInput, TOutput>): ToolContract<TInput, TOutput>;
+/**
+ * Normalize an agent's `tools: []` array into a uniform
+ * `ToolContract[]` for the runtime. Already-built `ToolContract`s
+ * (`.asTool()` / `ai.tool()`) pass through untouched; raw executable
+ * primitives are auto-adapted via {@link executableToTool}.
+ *
+ * Returns `undefined` when no tools were supplied so the agent's
+ * existing `config.tools ?? []` fallbacks stay byte-identical.
+ */
+declare function normalizeAgentTools(tools: ReadonlyArray<AgentToolEntry> | undefined): ToolContract<unknown, unknown>[] | undefined;
+//#endregion
+export { AgentToolEntry, ExecutableTool, executableToTool, isExecutableTool, normalizeAgentTools };
+//# sourceMappingURL=executable-as-tool.d.mts.map

package/esm/tool/executable-as-tool.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"executable-as-tool.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai/src/tool/executable-as-tool.ts"],"mappings":";;;;;;;;;;AAK4D;;;;KASvD,kBAAA,YAA8B,UAAA;EACjC,IAAA,GAAO,OAAA;EACP,KAAA,GAAQ,OAAA;EACR,MAAA,EAAQ,UAAA;AAAA;;;;;;;;;;AAAU;AAsBpB;;;;;;;;;KAAY,cAAA;EAAA,SACD,IAAA;EAAA,SACA,WAAA;EAAA,SACA,WAAA,GAAc,gBAAA,CAAiB,MAAA;EACxC,OAAA,CAAQ,KAAA,EAAO,MAAA,EAAQ,OAAA,aAAoB,OAAA,CAAQ,kBAAA,CAAmB,OAAA;EACtE,MAAA;AAAA;;;;;;;KASU,cAAA,wCACR,YAAA,CAAa,MAAA,EAAQ,OAAA,IACrB,cAAA,CAAe,MAAA,EAAQ,OAAA;;;;;AAXnB;AASR;;iBA4BgB,gBAAA,CAAiB,KAAA,YAAiB,KAAA,IAAS,cAAc;;;;;;;;;;;;;;iBAuBzD,gBAAA,kBACd,UAAA,EAAY,cAAA,CAAe,MAAA,EAAQ,OAAA,IAClC,YAAA,CAAa,MAAA,EAAQ,OAAA;;;;AAnDU;AA0BlC;;;;;iBAmEgB,mBAAA,CACd,KAAA,EAAO,aAAA,CAAc,cAAA,gBACpB,YAAA"}

package/esm/tool/executable-as-tool.mjs

@@ -0,0 +1,81 @@
+import { AgentExecutionError } from "../errors/agent-execution-error.mjs";
+import "../errors/index.mjs";
+import { compositeAsTool } from "./tool.mjs";
+
+//#region ../@warlock.js/ai/src/tool/executable-as-tool.ts
+/**
+* Identity passthrough schema used when an executable is registered as
+* a tool without declaring an `inputSchema`. The model's raw arguments
+* flow straight to `execute()` unchanged — the executable validates
+* internally (workflows via their steps, supervisors/agents via their
+* own input handling).
+*/
+function passthroughSchema() {
+	return { "~standard": {
+		version: 1,
+		vendor: "warlock-ai",
+		validate: (value) => ({ value })
+	} };
+}
+/**
+* Type guard distinguishing a raw executable primitive from a built
+* `ToolContract`. An executable exposes `execute()` and no `invoke()`;
+* a `ToolContract` exposes `invoke()`. The `invoke` check is the
+* load-bearing discriminator — `.asTool()`-wrapped composites keep
+* their own `execute` too, so checking `execute` alone is insufficient.
+*/
+function isExecutableTool(entry) {
+	if (!entry || typeof entry !== "object") return false;
+	const candidate = entry;
+	return typeof candidate.execute === "function" && typeof candidate.invoke !== "function";
+}
+/**
+* Adapt a raw executable primitive (agent / workflow / supervisor) into
+* a `ToolContract` so an agent can dispatch it inside its tool-call
+* loop WITHOUT the caller writing `.asTool()`. Derives the LLM tool
+* manifest from the executable's own `name` + `description` +
+* (optional) `inputSchema`, then dispatches through the executable's
+* `execute()` — the inner report nests under the outer tool-call node
+* exactly like an explicit `.asTool()` wrapper.
+*
+* Throws `AgentExecutionError` at author time when the executable lacks
+* a usable `name` — the agent's tool surface needs a stable id, the
+* same constraint `.asTool()` enforces.
+*/
+function executableToTool(executable) {
+	if (!executable.name || typeof executable.name !== "string") throw new AgentExecutionError("tools[]: an executable (agent/workflow/supervisor) used as a tool must have a `name`", { context: { authoring: true } });
+	return compositeAsTool({
+		name: executable.name,
+		description: executable.description ?? `Invoke "${executable.name}" as a tool.`,
+		input: executable.inputSchema ?? passthroughSchema(),
+		execute: async (input) => {
+			const result = await executable.execute(input);
+			if (result.error) throw result.error;
+			return {
+				data: result.data,
+				usage: result.usage,
+				report: result.report
+			};
+		}
+	});
+}
+/**
+* Normalize an agent's `tools: []` array into a uniform
+* `ToolContract[]` for the runtime. Already-built `ToolContract`s
+* (`.asTool()` / `ai.tool()`) pass through untouched; raw executable
+* primitives are auto-adapted via {@link executableToTool}.
+*
+* Returns `undefined` when no tools were supplied so the agent's
+* existing `config.tools ?? []` fallbacks stay byte-identical.
+*/
+function normalizeAgentTools(tools) {
+	if (!tools) return;
+	return tools.map((entry) => {
+		if (isExecutableTool(entry)) return executableToTool(entry);
+		return entry;
+	});
+}
+
+//#endregion
+export { executableToTool, isExecutableTool, normalizeAgentTools };
+//# sourceMappingURL=executable-as-tool.mjs.map

package/esm/tool/executable-as-tool.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"executable-as-tool.mjs","names":[],"sources":["../../../../../../../@warlock.js/ai/src/tool/executable-as-tool.ts"],"sourcesContent":["import type { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport type { BaseReport } from \"../contracts/result/base-report.type\";\nimport type { BaseResult } from \"../contracts/result/base-result.type\";\nimport type { Usage } from \"../contracts/result/usage.type\";\nimport { AgentExecutionError, type AIError } from \"../errors\";\nimport { compositeAsTool, type ToolContract } from \"./tool\";\n\n/**\n * Envelope every executable's `execute()` resolves to. Agent, workflow,\n * and supervisor results all satisfy this shape — `data` / `error`\n * carry the outcome while `usage` and `report` are always present —\n * which is exactly what {@link compositeAsTool} needs to nest the inner\n * run under the outer tool-call node.\n */\ntype ExecutableEnvelope<TOutput> = BaseResult & {\n  data?: TOutput;\n  error?: AIError;\n  report: BaseReport;\n};\n\n/**\n * Structural view of an executable primitive (agent / workflow /\n * supervisor) when it is dropped straight into an agent's `tools: []`\n * array WITHOUT being wrapped via `.asTool()` first.\n *\n * Only the fields the auto-adapt path reads are declared:\n * - `name` — becomes the LLM tool name (required; anonymous executables\n *   are rejected at author time, mirroring `.asTool()`).\n * - `description` — the \"when would the model pick this?\" line.\n * - `inputSchema` — opt-in Standard Schema typing the tool's arguments.\n *   Surfaced on `WorkflowInstance` / `SupervisorContract` from the new\n *   optional `inputSchema` config field. Absent for agents (which take\n *   a plain string prompt).\n * - `execute` — the dispatch entry every `ExecutableContract` exposes.\n *\n * `invoke` is declared `never` so a `ToolContract` (which HAS `invoke`)\n * can never be mistaken for an executable by the {@link isExecutableTool}\n * guard.\n */\nexport type ExecutableTool<TInput = unknown, TOutput = unknown> = {\n  readonly name: string;\n  readonly description?: string;\n  readonly inputSchema?: StandardSchemaV1<TInput>;\n  execute(input: TInput, options?: unknown): Promise<ExecutableEnvelope<TOutput>>;\n  invoke?: never;\n};\n\n/**\n * Entry accepted in an agent's `tools: []` array — either an already-\n * built `ToolContract` (the `.asTool()` / `ai.tool()` path) or a raw\n * executable primitive the framework auto-adapts on the caller's\n * behalf.\n */\nexport type AgentToolEntry<TInput = unknown, TOutput = unknown> =\n  | ToolContract<TInput, TOutput>\n  | ExecutableTool<TInput, TOutput>;\n\n/**\n * Identity passthrough schema used when an executable is registered as\n * a tool without declaring an `inputSchema`. The model's raw arguments\n * flow straight to `execute()` unchanged — the executable validates\n * internally (workflows via their steps, supervisors/agents via their\n * own input handling).\n */\nfunction passthroughSchema<TInput>(): StandardSchemaV1<TInput> {\n  return {\n    \"~standard\": {\n      version: 1,\n      vendor: \"warlock-ai\",\n      validate: (value: unknown) => ({ value: value as TInput }),\n    },\n  };\n}\n\n/**\n * Type guard distinguishing a raw executable primitive from a built\n * `ToolContract`. An executable exposes `execute()` and no `invoke()`;\n * a `ToolContract` exposes `invoke()`. The `invoke` check is the\n * load-bearing discriminator — `.asTool()`-wrapped composites keep\n * their own `execute` too, so checking `execute` alone is insufficient.\n */\nexport function isExecutableTool(entry: unknown): entry is ExecutableTool {\n  if (!entry || typeof entry !== \"object\") {\n    return false;\n  }\n\n  const candidate = entry as { execute?: unknown; invoke?: unknown };\n\n  return typeof candidate.execute === \"function\" && typeof candidate.invoke !== \"function\";\n}\n\n/**\n * Adapt a raw executable primitive (agent / workflow / supervisor) into\n * a `ToolContract` so an agent can dispatch it inside its tool-call\n * loop WITHOUT the caller writing `.asTool()`. Derives the LLM tool\n * manifest from the executable's own `name` + `description` +\n * (optional) `inputSchema`, then dispatches through the executable's\n * `execute()` — the inner report nests under the outer tool-call node\n * exactly like an explicit `.asTool()` wrapper.\n *\n * Throws `AgentExecutionError` at author time when the executable lacks\n * a usable `name` — the agent's tool surface needs a stable id, the\n * same constraint `.asTool()` enforces.\n */\nexport function executableToTool<TInput, TOutput>(\n  executable: ExecutableTool<TInput, TOutput>,\n): ToolContract<TInput, TOutput> {\n  if (!executable.name || typeof executable.name !== \"string\") {\n    throw new AgentExecutionError(\n      \"tools[]: an executable (agent/workflow/supervisor) used as a tool must have a `name`\",\n      { context: { authoring: true } },\n    );\n  }\n\n  return compositeAsTool<TInput, TOutput>({\n    name: executable.name,\n    description: executable.description ?? `Invoke \"${executable.name}\" as a tool.`,\n    input: executable.inputSchema ?? passthroughSchema<TInput>(),\n    execute: async (input) => {\n      const result = await executable.execute(input);\n\n      if (result.error) {\n        // Surface the inner typed error so the surrounding\n        // `compositeAsTool` wrapper produces a `ToolExecutionError`\n        // with `cause` pointing back at the original subclass — the\n        // agent's tool-call loop sees one uniform error class\n        // regardless of which primitive failed.\n        throw result.error;\n      }\n\n      return {\n        data: result.data as TOutput,\n        usage: result.usage as Usage,\n        report: result.report,\n      };\n    },\n  });\n}\n\n/**\n * Normalize an agent's `tools: []` array into a uniform\n * `ToolContract[]` for the runtime. Already-built `ToolContract`s\n * (`.asTool()` / `ai.tool()`) pass through untouched; raw executable\n * primitives are auto-adapted via {@link executableToTool}.\n *\n * Returns `undefined` when no tools were supplied so the agent's\n * existing `config.tools ?? []` fallbacks stay byte-identical.\n */\nexport function normalizeAgentTools(\n  tools: ReadonlyArray<AgentToolEntry> | undefined,\n): ToolContract<unknown, unknown>[] | undefined {\n  if (!tools) {\n    return undefined;\n  }\n\n  return tools.map((entry) => {\n    if (isExecutableTool(entry)) {\n      return executableToTool(entry) as ToolContract<unknown, unknown>;\n    }\n\n    return entry as ToolContract<unknown, unknown>;\n  });\n}\n"],"mappings":";;;;;;;;;;;;AAgEA,SAAS,oBAAsD;CAC7D,OAAO,EACL,aAAa;EACX,SAAS;EACT,QAAQ;EACR,WAAW,WAAoB,EAAS,MAAgB;CAC1D,EACF;AACF;;;;;;;;AASA,SAAgB,iBAAiB,OAAyC;CACxE,IAAI,CAAC,SAAS,OAAO,UAAU,UAC7B,OAAO;CAGT,MAAM,YAAY;CAElB,OAAO,OAAO,UAAU,YAAY,cAAc,OAAO,UAAU,WAAW;AAChF;;;;;;;;;;;;;;AAeA,SAAgB,iBACd,YAC+B;CAC/B,IAAI,CAAC,WAAW,QAAQ,OAAO,WAAW,SAAS,UACjD,MAAM,IAAI,oBACR,wFACA,EAAE,SAAS,EAAE,WAAW,KAAK,EAAE,CACjC;CAGF,OAAO,gBAAiC;EACtC,MAAM,WAAW;EACjB,aAAa,WAAW,eAAe,WAAW,WAAW,KAAK;EAClE,OAAO,WAAW,eAAe,kBAA0B;EAC3D,SAAS,OAAO,UAAU;GACxB,MAAM,SAAS,MAAM,WAAW,QAAQ,KAAK;GAE7C,IAAI,OAAO,OAMT,MAAM,OAAO;GAGf,OAAO;IACL,MAAM,OAAO;IACb,OAAO,OAAO;IACd,QAAQ,OAAO;GACjB;EACF;CACF,CAAC;AACH;;;;;;;;;;AAWA,SAAgB,oBACd,OAC8C;CAC9C,IAAI,CAAC,OACH;CAGF,OAAO,MAAM,KAAK,UAAU;EAC1B,IAAI,iBAAiB,KAAK,GACxB,OAAO,iBAAiB,KAAK;EAG/B,OAAO;CACT,CAAC;AACH"}

package/esm/tool/index.d.mts

@@ -1 +1,2 @@
-import { ToolContract, ToolInvokeResult, tool } from "./tool.mjs";
+import { ToolContract, ToolInvokeResult, tool } from "./tool.mjs";
+import { AgentToolEntry, ExecutableTool, executableToTool, isExecutableTool, normalizeAgentTools } from "./executable-as-tool.mjs";

package/esm/tool/index.mjs

@@ -1,3 +1,4 @@
 import { tool } from "./tool.mjs";
+import { executableToTool, isExecutableTool, normalizeAgentTools } from "./executable-as-tool.mjs";
 
 export {  };

package/esm/workflow/as-tool.mjs

@@ -18,12 +18,6 @@ import { compositeAsTool } from "../tool/tool.mjs";
 *   `WorkflowError` subclass — the agent's tool-call loop sees a
 *   uniform error class regardless of which primitive failed.
 *
-* **Usage caveat (deferred to Phase 2):** the parent agent's
-* `result.usage` does NOT roll up tokens consumed inside the wrapped
-* workflow today. Nested-usage standardization lands with the
-* supervisor work; until then, sum workflow + agent usage manually if
-* you need a combined cost figure.
-*
 * @example
 * const wf = workflow({ name: "triage", steps: [...] });
 * const triageTool = asTool(wf, {

package/esm/workflow/as-tool.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"as-tool.mjs","names":[],"sources":["../../../../../../../@warlock.js/ai/src/workflow/as-tool.ts"],"sourcesContent":["import type { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport type { WorkflowInstance } from \"../contracts/workflow/workflow.contract\";\nimport { WorkflowError } from \"../errors\";\nimport { compositeAsTool, type ToolContract } from \"../tool/tool\";\n\n/**\n * Wrap a `WorkflowInstance` as a `ToolContract` so an agent can invoke\n * it inside its tool-call loop. Closes the agent-calls-workflow\n * composition gap.\n *\n * Behavior:\n * - Tool `name` mirrors `workflow.name` — workflows without a name throw\n *   `WorkflowError` at wrap time (the agent surface needs a stable id).\n * - Tool `input` is the supplied `inputSchema`; the validated value is\n *   forwarded straight to `workflow.execute(input)`.\n * - On `result.error`, the workflow error is wrapped in\n *   `ToolExecutionError` with `cause` set to the original\n *   `WorkflowError` subclass — the agent's tool-call loop sees a\n *   uniform error class regardless of which primitive failed.\n *\n * **Usage caveat (deferred to Phase 2):** the parent agent's\n * `result.usage` does NOT roll up tokens consumed inside the wrapped\n * workflow today. Nested-usage standardization lands with the\n * supervisor work; until then, sum workflow + agent usage manually if\n * you need a combined cost figure.\n *\n * @example\n * const wf = workflow({ name: \"triage\", steps: [...] });\n * const triageTool = asTool(wf, {\n *   description: \"Run the support-ticket triage flow\",\n *   inputSchema: ticketSchema,\n * });\n * const a = ai.agent({ model, tools: [triageTool] });\n */\nexport function asTool<TInput, TOutput, TToolInput = TInput>(\n  workflowInstance: WorkflowInstance<TInput, TOutput>,\n  options: {\n    description?: string;\n    inputSchema: StandardSchemaV1<TToolInput>;\n  },\n): ToolContract<TToolInput, TOutput> {\n  if (!workflowInstance.name || typeof workflowInstance.name !== \"string\") {\n    throw new WorkflowError(\n      \"workflow.asTool(): workflow must have a `name` to be wrapped as a tool\",\n    );\n  }\n\n  return compositeAsTool<TToolInput, TOutput>({\n    name: workflowInstance.name,\n    description: options.description ?? `Invoke workflow \"${workflowInstance.name}\" as a tool.`,\n    input: options.inputSchema,\n    execute: async (input) => {\n      const result = await workflowInstance.execute(input as unknown as TInput);\n\n      if (result.error) {\n        // Throw the workflow error so the surrounding wrapper catches\n        // it and produces a `ToolExecutionError` with `cause` pointing\n        // back at the original `WorkflowError` subclass — keeps the\n        // agent's tool-call loop seeing one uniform error class\n        // regardless of which primitive failed.\n        throw result.error;\n      }\n\n      return {\n        data: result.data as TOutput,\n        usage: result.usage,\n        report: result.report,\n      };\n    },\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,SAAgB,OACd,kBACA,SAImC;CACnC,IAAI,CAAC,iBAAiB,QAAQ,OAAO,iBAAiB,SAAS,UAC7D,MAAM,IAAI,cACR,wEACF;CAGF,OAAO,gBAAqC;EAC1C,MAAM,iBAAiB;EACvB,aAAa,QAAQ,eAAe,oBAAoB,iBAAiB,KAAK;EAC9E,OAAO,QAAQ;EACf,SAAS,OAAO,UAAU;GACxB,MAAM,SAAS,MAAM,iBAAiB,QAAQ,KAA0B;GAExE,IAAI,OAAO,OAMT,MAAM,OAAO;GAGf,OAAO;IACL,MAAM,OAAO;IACb,OAAO,OAAO;IACd,QAAQ,OAAO;GACjB;EACF;CACF,CAAC;AACH"}
+{"version":3,"file":"as-tool.mjs","names":[],"sources":["../../../../../../../@warlock.js/ai/src/workflow/as-tool.ts"],"sourcesContent":["import type { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport type { WorkflowInstance } from \"../contracts/workflow/workflow.contract\";\nimport { WorkflowError } from \"../errors\";\nimport { compositeAsTool, type ToolContract } from \"../tool/tool\";\n\n/**\n * Wrap a `WorkflowInstance` as a `ToolContract` so an agent can invoke\n * it inside its tool-call loop. Closes the agent-calls-workflow\n * composition gap.\n *\n * Behavior:\n * - Tool `name` mirrors `workflow.name` — workflows without a name throw\n *   `WorkflowError` at wrap time (the agent surface needs a stable id).\n * - Tool `input` is the supplied `inputSchema`; the validated value is\n *   forwarded straight to `workflow.execute(input)`.\n * - On `result.error`, the workflow error is wrapped in\n *   `ToolExecutionError` with `cause` set to the original\n *   `WorkflowError` subclass — the agent's tool-call loop sees a\n *   uniform error class regardless of which primitive failed.\n *\n * @example\n * const wf = workflow({ name: \"triage\", steps: [...] });\n * const triageTool = asTool(wf, {\n *   description: \"Run the support-ticket triage flow\",\n *   inputSchema: ticketSchema,\n * });\n * const a = ai.agent({ model, tools: [triageTool] });\n */\nexport function asTool<TInput, TOutput, TToolInput = TInput>(\n  workflowInstance: WorkflowInstance<TInput, TOutput>,\n  options: {\n    description?: string;\n    inputSchema: StandardSchemaV1<TToolInput>;\n  },\n): ToolContract<TToolInput, TOutput> {\n  if (!workflowInstance.name || typeof workflowInstance.name !== \"string\") {\n    throw new WorkflowError(\n      \"workflow.asTool(): workflow must have a `name` to be wrapped as a tool\",\n    );\n  }\n\n  return compositeAsTool<TToolInput, TOutput>({\n    name: workflowInstance.name,\n    description: options.description ?? `Invoke workflow \"${workflowInstance.name}\" as a tool.`,\n    input: options.inputSchema,\n    execute: async (input) => {\n      const result = await workflowInstance.execute(input as unknown as TInput);\n\n      if (result.error) {\n        // Throw the workflow error so the surrounding wrapper catches\n        // it and produces a `ToolExecutionError` with `cause` pointing\n        // back at the original `WorkflowError` subclass — keeps the\n        // agent's tool-call loop seeing one uniform error class\n        // regardless of which primitive failed.\n        throw result.error;\n      }\n\n      return {\n        data: result.data as TOutput,\n        usage: result.usage,\n        report: result.report,\n      };\n    },\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,SAAgB,OACd,kBACA,SAImC;CACnC,IAAI,CAAC,iBAAiB,QAAQ,OAAO,iBAAiB,SAAS,UAC7D,MAAM,IAAI,cACR,wEACF;CAGF,OAAO,gBAAqC;EAC1C,MAAM,iBAAiB;EACvB,aAAa,QAAQ,eAAe,oBAAoB,iBAAiB,KAAK;EAC9E,OAAO,QAAQ;EACf,SAAS,OAAO,UAAU;GACxB,MAAM,SAAS,MAAM,iBAAiB,QAAQ,KAA0B;GAExE,IAAI,OAAO,OAMT,MAAM,OAAO;GAGf,OAAO;IACL,MAAM,OAAO;IACb,OAAO,OAAO;IACd,QAAQ,OAAO;GACjB;EACF;CACF,CAAC;AACH"}

package/esm/workflow/engine.mjs

@@ -8,11 +8,11 @@ import "../errors/index.mjs";
 import { stampReportLineage } from "../utils/stamp-report-lineage.mjs";
 import "../utils/index.mjs";
 import { createCancelledError } from "./cancellation.mjs";
+import { cloneState, deepFreeze } from "./state.mjs";
+import { executeStep, finalizeSnapshot, toAIError } from "./step-runner.mjs";
 import { mapNextStep, nextDeclaredStep, resolveNextStep } from "./router.mjs";
 import { runScopedEmitter } from "./run-scoped-emitter.mjs";
 import { loadSnapshotForResume, persistSnapshot } from "./snapshot.mjs";
-import { cloneState, deepFreeze } from "./state.mjs";
-import { executeStep, finalizeSnapshot, toAIError } from "./step-runner.mjs";
 import { log } from "@warlock.js/logger";
 
 //#region ../@warlock.js/ai/src/workflow/engine.ts

package/esm/workflow/snapshot.mjs

@@ -1,16 +1,22 @@
 import { WorkflowError } from "../errors/workflow-error.mjs";
 import { WorkflowDriftError } from "../errors/workflow-drift-error.mjs";
 import "../errors/index.mjs";
-import { resolveDefaultStore } from "../config.mjs";
+import { resolveDefaultSnapshotStore } from "../config.mjs";
 
 //#region ../@warlock.js/ai/src/workflow/snapshot.ts
 /**
-* Resolve the effective snapshot store: the workflow's own
+* Resolve the effective {@link SnapshotStore}: the workflow's own
 * `snapshotStore` field wins; absent that, fall back to the global
-* default set via `ai.config({ defaultStore })`.
+* default set via `ai.config({ defaultSnapshotStore })`.
+*
+* The global default is typed for the supervisor snapshot shape, but
+* every store impl keys purely by `runId` and round-trips whatever
+* envelope it is handed — so it serves a `WorkflowSnapshot` just as
+* well. The cast re-tags the shape at this single boundary; the
+* workflow only ever hands it a `WorkflowSnapshot`.
 */
 function resolveSnapshotStore(definition) {
-	return definition.snapshotStore ?? resolveDefaultStore();
+	return definition.snapshotStore ?? resolveDefaultSnapshotStore();
 }
 /**
 * Write the current run's state to the configured `KVStore`. Returns
@@ -38,7 +44,7 @@ async function persistSnapshot(params) {
 		savedAt: (/* @__PURE__ */ new Date()).toISOString()
 	};
 	try {
-		await store.set(params.runId, snapshot);
+		await store.save(snapshot);
 		return { ok: true };
 	} catch (err) {
 		return {
@@ -55,8 +61,8 @@ async function persistSnapshot(params) {
 */
 async function loadSnapshotForResume(params) {
 	const store = resolveSnapshotStore(params.definition);
-	if (!store) throw new WorkflowError(`workflow "${params.definition.name}" has no store configured — set \`snapshotStore\` on the definition or call \`ai.config({ defaultStore })\` at boot before calling resume()`);
-	const snap = await store.get(params.runId) ?? null;
+	if (!store) throw new WorkflowError(`workflow "${params.definition.name}" has no store configured — set \`snapshotStore\` on the definition or call \`ai.config({ defaultSnapshotStore })\` at boot before calling resume()`);
+	const snap = await store.load(params.runId) ?? null;
 	if (!snap) throw new WorkflowError(`workflow "${params.definition.name}": no snapshot for runId "${params.runId}"`);
 	if (!params.options?.force && snap.signature !== params.signature) throw new WorkflowDriftError(`workflow "${params.definition.name}" signature drift on resume`, {
 		savedSignature: snap.signature,

package/esm/workflow/snapshot.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"snapshot.mjs","names":[],"sources":["../../../../../../../@warlock.js/ai/src/workflow/snapshot.ts"],"sourcesContent":["import { resolveDefaultStore } from \"../config\";\nimport type { StepSnapshot } from \"../contracts/result/step-result.type\";\nimport type { WorkflowSnapshot } from \"../contracts/workflow/workflow-snapshot.type\";\nimport type {\n  WorkflowDefinition,\n  WorkflowResumeOptions,\n} from \"../contracts/workflow/workflow.contract\";\nimport { WorkflowDriftError, WorkflowError } from \"../errors\";\n\n/**\n * Resolve the effective snapshot store: the workflow's own\n * `snapshotStore` field wins; absent that, fall back to the global\n * default set via `ai.config({ defaultStore })`.\n */\nfunction resolveSnapshotStore<T>(definition: WorkflowDefinition<any, T, any, any>) {\n  return definition.snapshotStore ?? resolveDefaultStore();\n}\n\nexport type PersistParams<T> = {\n  definition: WorkflowDefinition<any, T, any, any>;\n  signature: string;\n  runId: string;\n  startedAt: string;\n  input: unknown;\n  state: Record<string, unknown>;\n  steps: Record<string, StepSnapshot>;\n  next: string | null;\n  status: WorkflowSnapshot[\"status\"];\n};\n\nexport type PersistOutcome = { ok: true } | { ok: false; error: unknown };\n\n/**\n * Write the current run's state to the configured `KVStore`. Returns\n * an outcome object instead of throwing so the engine can surface\n * persistence failures via events + logs without aborting the run.\n * Callers decide whether a failed checkpoint is fatal.\n *\n * No-op (returns `{ ok: true }`) when the workflow has no store\n * configured — the common in-memory test case.\n */\nexport async function persistSnapshot<T>(\n  params: PersistParams<T>,\n): Promise<PersistOutcome> {\n  const store = resolveSnapshotStore(params.definition);\n\n  if (!store) return { ok: true };\n\n  const snapshot: WorkflowSnapshot = {\n    runId: params.runId,\n    workflowName: params.definition.name,\n    signature: params.signature,\n    version: params.definition.version,\n    input: params.input,\n    state: { ...params.state },\n    steps: { ...params.steps },\n    next: params.next,\n    status: params.status,\n    startedAt: params.startedAt,\n    savedAt: new Date().toISOString(),\n  };\n\n  try {\n    await store.set(params.runId, snapshot);\n    return { ok: true };\n  } catch (err) {\n    return { ok: false, error: err };\n  }\n}\n\n/**\n * Load a prior run's snapshot from the store and run the drift\n * check. Throws `WorkflowError` when no snapshot exists, and\n * `WorkflowDriftError` when the stored signature doesn't match the\n * current definition (unless `force` is set).\n */\nexport async function loadSnapshotForResume<T>(params: {\n  definition: WorkflowDefinition<any, T, any, any>;\n  signature: string;\n  runId: string;\n  options?: WorkflowResumeOptions;\n}): Promise<WorkflowSnapshot> {\n  const store = resolveSnapshotStore(params.definition);\n\n  if (!store) {\n    throw new WorkflowError(\n      `workflow \"${params.definition.name}\" has no store configured — set \\`snapshotStore\\` on the definition or call \\`ai.config({ defaultStore })\\` at boot before calling resume()`,\n    );\n  }\n\n  const snap = (await store.get<WorkflowSnapshot>(params.runId)) ?? null;\n\n  if (!snap) {\n    throw new WorkflowError(\n      `workflow \"${params.definition.name}\": no snapshot for runId \"${params.runId}\"`,\n    );\n  }\n\n  if (!params.options?.force && snap.signature !== params.signature) {\n    throw new WorkflowDriftError(\n      `workflow \"${params.definition.name}\" signature drift on resume`,\n      {\n        savedSignature: snap.signature,\n        currentSignature: params.signature,\n        runId: params.runId,\n      },\n    );\n  }\n\n  return snap;\n}\n"],"mappings":";;;;;;;;;;;AAcA,SAAS,qBAAwB,YAAkD;CACjF,OAAO,WAAW,iBAAiB,oBAAoB;AACzD;;;;;;;;;;AAyBA,eAAsB,gBACpB,QACyB;CACzB,MAAM,QAAQ,qBAAqB,OAAO,UAAU;CAEpD,IAAI,CAAC,OAAO,OAAO,EAAE,IAAI,KAAK;CAE9B,MAAM,WAA6B;EACjC,OAAO,OAAO;EACd,cAAc,OAAO,WAAW;EAChC,WAAW,OAAO;EAClB,SAAS,OAAO,WAAW;EAC3B,OAAO,OAAO;EACd,OAAO,EAAE,GAAG,OAAO,MAAM;EACzB,OAAO,EAAE,GAAG,OAAO,MAAM;EACzB,MAAM,OAAO;EACb,QAAQ,OAAO;EACf,WAAW,OAAO;EAClB,0BAAS,IAAI,KAAK,EAAC,CAAC,YAAY;CAClC;CAEA,IAAI;EACF,MAAM,MAAM,IAAI,OAAO,OAAO,QAAQ;EACtC,OAAO,EAAE,IAAI,KAAK;CACpB,SAAS,KAAK;EACZ,OAAO;GAAE,IAAI;GAAO,OAAO;EAAI;CACjC;AACF;;;;;;;AAQA,eAAsB,sBAAyB,QAKjB;CAC5B,MAAM,QAAQ,qBAAqB,OAAO,UAAU;CAEpD,IAAI,CAAC,OACH,MAAM,IAAI,cACR,aAAa,OAAO,WAAW,KAAK,4IACtC;CAGF,MAAM,OAAQ,MAAM,MAAM,IAAsB,OAAO,KAAK,KAAM;CAElE,IAAI,CAAC,MACH,MAAM,IAAI,cACR,aAAa,OAAO,WAAW,KAAK,4BAA4B,OAAO,MAAM,EAC/E;CAGF,IAAI,CAAC,OAAO,SAAS,SAAS,KAAK,cAAc,OAAO,WACtD,MAAM,IAAI,mBACR,aAAa,OAAO,WAAW,KAAK,8BACpC;EACE,gBAAgB,KAAK;EACrB,kBAAkB,OAAO;EACzB,OAAO,OAAO;CAChB,CACF;CAGF,OAAO;AACT"}
+{"version":3,"file":"snapshot.mjs","names":[],"sources":["../../../../../../../@warlock.js/ai/src/workflow/snapshot.ts"],"sourcesContent":["import { resolveDefaultSnapshotStore } from \"../config\";\nimport type { SnapshotStore } from \"../contracts/orchestrator/snapshot-store.contract\";\nimport type { StepSnapshot } from \"../contracts/result/step-result.type\";\nimport type { WorkflowSnapshot } from \"../contracts/workflow/workflow-snapshot.type\";\nimport type {\n  WorkflowDefinition,\n  WorkflowResumeOptions,\n} from \"../contracts/workflow/workflow.contract\";\nimport { WorkflowDriftError, WorkflowError } from \"../errors\";\n\n/**\n * Resolve the effective {@link SnapshotStore}: the workflow's own\n * `snapshotStore` field wins; absent that, fall back to the global\n * default set via `ai.config({ defaultSnapshotStore })`.\n *\n * The global default is typed for the supervisor snapshot shape, but\n * every store impl keys purely by `runId` and round-trips whatever\n * envelope it is handed — so it serves a `WorkflowSnapshot` just as\n * well. The cast re-tags the shape at this single boundary; the\n * workflow only ever hands it a `WorkflowSnapshot`.\n */\nfunction resolveSnapshotStore<T>(\n  definition: WorkflowDefinition<any, T, any, any>,\n): SnapshotStore<WorkflowSnapshot> | undefined {\n  return (\n    definition.snapshotStore ??\n    (resolveDefaultSnapshotStore() as SnapshotStore<WorkflowSnapshot> | undefined)\n  );\n}\n\nexport type PersistParams<T> = {\n  definition: WorkflowDefinition<any, T, any, any>;\n  signature: string;\n  runId: string;\n  startedAt: string;\n  input: unknown;\n  state: Record<string, unknown>;\n  steps: Record<string, StepSnapshot>;\n  next: string | null;\n  status: WorkflowSnapshot[\"status\"];\n};\n\nexport type PersistOutcome = { ok: true } | { ok: false; error: unknown };\n\n/**\n * Write the current run's state to the configured `KVStore`. Returns\n * an outcome object instead of throwing so the engine can surface\n * persistence failures via events + logs without aborting the run.\n * Callers decide whether a failed checkpoint is fatal.\n *\n * No-op (returns `{ ok: true }`) when the workflow has no store\n * configured — the common in-memory test case.\n */\nexport async function persistSnapshot<T>(\n  params: PersistParams<T>,\n): Promise<PersistOutcome> {\n  const store = resolveSnapshotStore(params.definition);\n\n  if (!store) return { ok: true };\n\n  const snapshot: WorkflowSnapshot = {\n    runId: params.runId,\n    workflowName: params.definition.name,\n    signature: params.signature,\n    version: params.definition.version,\n    input: params.input,\n    state: { ...params.state },\n    steps: { ...params.steps },\n    next: params.next,\n    status: params.status,\n    startedAt: params.startedAt,\n    savedAt: new Date().toISOString(),\n  };\n\n  try {\n    await store.save(snapshot);\n    return { ok: true };\n  } catch (err) {\n    return { ok: false, error: err };\n  }\n}\n\n/**\n * Load a prior run's snapshot from the store and run the drift\n * check. Throws `WorkflowError` when no snapshot exists, and\n * `WorkflowDriftError` when the stored signature doesn't match the\n * current definition (unless `force` is set).\n */\nexport async function loadSnapshotForResume<T>(params: {\n  definition: WorkflowDefinition<any, T, any, any>;\n  signature: string;\n  runId: string;\n  options?: WorkflowResumeOptions;\n}): Promise<WorkflowSnapshot> {\n  const store = resolveSnapshotStore(params.definition);\n\n  if (!store) {\n    throw new WorkflowError(\n      `workflow \"${params.definition.name}\" has no store configured — set \\`snapshotStore\\` on the definition or call \\`ai.config({ defaultSnapshotStore })\\` at boot before calling resume()`,\n    );\n  }\n\n  const snap = (await store.load(params.runId)) ?? null;\n\n  if (!snap) {\n    throw new WorkflowError(\n      `workflow \"${params.definition.name}\": no snapshot for runId \"${params.runId}\"`,\n    );\n  }\n\n  if (!params.options?.force && snap.signature !== params.signature) {\n    throw new WorkflowDriftError(\n      `workflow \"${params.definition.name}\" signature drift on resume`,\n      {\n        savedSignature: snap.signature,\n        currentSignature: params.signature,\n        runId: params.runId,\n      },\n    );\n  }\n\n  return snap;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAqBA,SAAS,qBACP,YAC6C;CAC7C,OACE,WAAW,iBACV,4BAA4B;AAEjC;;;;;;;;;;AAyBA,eAAsB,gBACpB,QACyB;CACzB,MAAM,QAAQ,qBAAqB,OAAO,UAAU;CAEpD,IAAI,CAAC,OAAO,OAAO,EAAE,IAAI,KAAK;CAE9B,MAAM,WAA6B;EACjC,OAAO,OAAO;EACd,cAAc,OAAO,WAAW;EAChC,WAAW,OAAO;EAClB,SAAS,OAAO,WAAW;EAC3B,OAAO,OAAO;EACd,OAAO,EAAE,GAAG,OAAO,MAAM;EACzB,OAAO,EAAE,GAAG,OAAO,MAAM;EACzB,MAAM,OAAO;EACb,QAAQ,OAAO;EACf,WAAW,OAAO;EAClB,0BAAS,IAAI,KAAK,EAAC,CAAC,YAAY;CAClC;CAEA,IAAI;EACF,MAAM,MAAM,KAAK,QAAQ;EACzB,OAAO,EAAE,IAAI,KAAK;CACpB,SAAS,KAAK;EACZ,OAAO;GAAE,IAAI;GAAO,OAAO;EAAI;CACjC;AACF;;;;;;;AAQA,eAAsB,sBAAyB,QAKjB;CAC5B,MAAM,QAAQ,qBAAqB,OAAO,UAAU;CAEpD,IAAI,CAAC,OACH,MAAM,IAAI,cACR,aAAa,OAAO,WAAW,KAAK,oJACtC;CAGF,MAAM,OAAQ,MAAM,MAAM,KAAK,OAAO,KAAK,KAAM;CAEjD,IAAI,CAAC,MACH,MAAM,IAAI,cACR,aAAa,OAAO,WAAW,KAAK,4BAA4B,OAAO,MAAM,EAC/E;CAGF,IAAI,CAAC,OAAO,SAAS,SAAS,KAAK,cAAc,OAAO,WACtD,MAAM,IAAI,mBACR,aAAa,OAAO,WAAW,KAAK,8BACpC;EACE,gBAAgB,KAAK;EACrB,kBAAkB,OAAO;EACzB,OAAO,OAAO;CAChB,CACF;CAGF,OAAO;AACT"}

package/esm/workflow/step-runner.mjs

@@ -4,9 +4,9 @@ import { SchemaValidationError } from "../errors/schema-validation-error.mjs";
 import { StepFailedError } from "../errors/step-failed-error.mjs";
 import { WorkflowCancelledError } from "../errors/workflow-cancelled-error.mjs";
 import "../errors/index.mjs";
+import { isAbortError, resolveBackoff, resolveRetryConfig } from "./retry.mjs";
 import { createCancelledError, sleep } from "./cancellation.mjs";
 import { cloneState, deepFreeze } from "./state.mjs";
-import { isAbortError, resolveBackoff, resolveRetryConfig } from "./retry.mjs";
 
 //#region ../@warlock.js/ai/src/workflow/step-runner.ts
 /**

package/esm/workflow/workflow.mjs

@@ -54,6 +54,7 @@ function workflow(definition) {
 	const instance = {
 		name: definition.name,
 		description: definition.description,
+		inputSchema: definition.inputSchema,
 		signature,
 		version: definition.version,
 		execute,

package/esm/workflow/workflow.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"workflow.mjs","names":["combined"],"sources":["../../../../../../../@warlock.js/ai/src/workflow/workflow.ts"],"sourcesContent":["import type { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport type { WorkflowEventMap } from \"../contracts/events/event-map.type\";\nimport type { WorkflowResult } from \"../contracts/result/workflow-result.type\";\nimport type {\n  WorkflowDefinition,\n  WorkflowEventHandler,\n  WorkflowExecuteOptions,\n  WorkflowInstance,\n  WorkflowResumeOptions,\n  WorkflowRunOptions,\n} from \"../contracts/workflow/workflow.contract\";\nimport { WorkflowError } from \"../errors\";\nimport type { ToolContract } from \"../tool/tool\";\nimport { asTool } from \"./as-tool\";\nimport { WorkflowEmitter } from \"./emitter\";\nimport { loadSnapshotForResume, runWorkflow } from \"./engine\";\nimport { computeSignature } from \"./signature\";\n\n/**\n * `ai.workflow(def)` — construct a `WorkflowInstance`. Validates the\n * definition, computes a stable structural signature, and wires up the\n * three-tier event subscription model.\n */\nexport function workflow<\n  TInput = unknown,\n  TOutput = unknown,\n  TState = Record<string, unknown>,\n  TContext = unknown,\n>(\n  definition: WorkflowDefinition<TInput, TOutput, TState, TContext>,\n): WorkflowInstance<TInput, TOutput, TState, TContext> {\n  validate(definition);\n  const signature = computeSignature(definition);\n  const emitter = new WorkflowEmitter(definition.on);\n\n  function execute(\n    inputOrOptions: TInput | WorkflowExecuteOptions<TInput, TContext>,\n    maybeOptions?: WorkflowRunOptions<TContext>,\n  ): Promise<WorkflowResult<TOutput>> {\n    const { input, options } = normalizeExecuteArgs<TInput, TContext>(\n      inputOrOptions,\n      maybeOptions,\n    );\n    const runId = options?.runId ?? generateRunId();\n    return runWorkflow<TOutput>({\n      definition,\n      signature,\n      emitter,\n      input,\n      context: options?.context,\n      runId,\n      signal: options?.signal,\n      executionHandlers: options?.on,\n      sessionId: options?.sessionId,\n    });\n  }\n\n  async function resume(\n    runId: string,\n    options?: WorkflowResumeOptions<TContext>,\n  ): Promise<WorkflowResult<TOutput>> {\n    const snapshot = await loadSnapshotForResume({\n      definition,\n      signature,\n      runId,\n      options,\n    });\n\n    return runWorkflow<TOutput>({\n      definition,\n      signature,\n      emitter,\n      input: snapshot.input,\n      context: options?.context,\n      runId,\n      signal: options?.signal,\n      executionHandlers: options?.on,\n      sessionId: options?.sessionId,\n      resumeFrom: snapshot,\n    });\n  }\n\n  const instance: WorkflowInstance<TInput, TOutput, TState, TContext> = {\n    name: definition.name,\n    description: definition.description,\n    signature,\n    version: definition.version,\n    execute,\n    resume,\n    on<K extends keyof WorkflowEventMap>(event: K, handler: WorkflowEventHandler<K>) {\n      return emitter.on(event, handler);\n    },\n    off<K extends keyof WorkflowEventMap>(event: K, handler: WorkflowEventHandler<K>) {\n      emitter.off(event, handler);\n    },\n    asTool<TToolInput = TInput>(options: {\n      description?: string;\n      inputSchema: StandardSchemaV1<TToolInput>;\n    }): ToolContract<TToolInput, TOutput> {\n      return asTool<TInput, TOutput, TToolInput>(instance, options);\n    },\n  };\n\n  return instance;\n}\n\n/**\n * Resolve the overloaded `execute()` call shape. If the caller passed\n * a single plain object with an `input` field, treat it as the\n * combined `WorkflowExecuteOptions`. Otherwise the first arg is the\n * raw workflow input and the second is the run options.\n *\n * Ambiguity note: if your real workflow `input` is itself an object\n * with a top-level `input` key, prefer `execute(rawInput, options)`\n * explicitly — the single-arg detection heuristic would mis-classify\n * it.\n */\nfunction normalizeExecuteArgs<TInput, TContext>(\n  inputOrOptions: TInput | WorkflowExecuteOptions<TInput, TContext>,\n  maybeOptions: WorkflowRunOptions<TContext> | undefined,\n): { input: TInput; options?: WorkflowRunOptions<TContext> } {\n  if (\n    maybeOptions === undefined &&\n    inputOrOptions !== null &&\n    typeof inputOrOptions === \"object\" &&\n    \"input\" in (inputOrOptions as object)\n  ) {\n    const combined = inputOrOptions as WorkflowExecuteOptions<TInput, TContext>;\n    const { input, ...options } = combined;\n    return { input, options };\n  }\n\n  return { input: inputOrOptions as TInput, options: maybeOptions };\n}\n\nfunction validate<TInput, TOutput, TState, TContext>(\n  definition: WorkflowDefinition<TInput, TOutput, TState, TContext>,\n): void {\n  if (!definition.name || typeof definition.name !== \"string\") {\n    throw new WorkflowError(\"ai.workflow: `name` is required\");\n  }\n\n  if (!Array.isArray(definition.steps) || definition.steps.length === 0) {\n    throw new WorkflowError(`ai.workflow(\"${definition.name}\"): at least one step is required`);\n  }\n\n  const seen = new Set<string>();\n  const walk = (name: string) => {\n    if (seen.has(name)) {\n      throw new WorkflowError(`ai.workflow(\"${definition.name}\"): duplicate step name \"${name}\"`);\n    }\n    seen.add(name);\n  };\n\n  for (const step of definition.steps) {\n    walk(step.name);\n\n    if (step.parallel) {\n      for (const child of step.parallel) {\n        walk(child.name);\n      }\n    }\n  }\n}\n\nfunction generateRunId(): string {\n  // Non-crypto random — adequate for ephemeral workflow runs.\n  return `wf_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;\n}\n"],"mappings":";;;;;;;;;;;;;;AAuBA,SAAgB,SAMd,YACqD;CACrD,SAAS,UAAU;CACnB,MAAM,YAAY,iBAAiB,UAAU;CAC7C,MAAM,UAAU,IAAI,gBAAgB,WAAW,EAAE;CAEjD,SAAS,QACP,gBACA,cACkC;EAClC,MAAM,EAAE,OAAO,YAAY,qBACzB,gBACA,YACF;EACA,MAAM,QAAQ,SAAS,SAAS,cAAc;EAC9C,OAAO,YAAqB;GAC1B;GACA;GACA;GACA;GACA,SAAS,SAAS;GAClB;GACA,QAAQ,SAAS;GACjB,mBAAmB,SAAS;GAC5B,WAAW,SAAS;EACtB,CAAC;CACH;CAEA,eAAe,OACb,OACA,SACkC;EAClC,MAAM,WAAW,MAAM,sBAAsB;GAC3C;GACA;GACA;GACA;EACF,CAAC;EAED,OAAO,YAAqB;GAC1B;GACA;GACA;GACA,OAAO,SAAS;GAChB,SAAS,SAAS;GAClB;GACA,QAAQ,SAAS;GACjB,mBAAmB,SAAS;GAC5B,WAAW,SAAS;GACpB,YAAY;EACd,CAAC;CACH;CAEA,MAAM,WAAgE;EACpE,MAAM,WAAW;EACjB,aAAa,WAAW;EACxB;EACA,SAAS,WAAW;EACpB;EACA;EACA,GAAqC,OAAU,SAAkC;GAC/E,OAAO,QAAQ,GAAG,OAAO,OAAO;EAClC;EACA,IAAsC,OAAU,SAAkC;GAChF,QAAQ,IAAI,OAAO,OAAO;EAC5B;EACA,OAA4B,SAGU;GACpC,OAAO,OAAoC,UAAU,OAAO;EAC9D;CACF;CAEA,OAAO;AACT;;;;;;;;;;;;AAaA,SAAS,qBACP,gBACA,cAC2D;CAC3D,IACE,iBAAiB,UACjB,mBAAmB,QACnB,OAAO,mBAAmB,YAC1B,WAAY,gBACZ;EAEA,MAAM,EAAE,OAAO,GAAG,YAAYA;EAC9B,OAAO;GAAE;GAAO;EAAQ;CAC1B;CAEA,OAAO;EAAE,OAAO;EAA0B,SAAS;CAAa;AAClE;AAEA,SAAS,SACP,YACM;CACN,IAAI,CAAC,WAAW,QAAQ,OAAO,WAAW,SAAS,UACjD,MAAM,IAAI,cAAc,iCAAiC;CAG3D,IAAI,CAAC,MAAM,QAAQ,WAAW,KAAK,KAAK,WAAW,MAAM,WAAW,GAClE,MAAM,IAAI,cAAc,gBAAgB,WAAW,KAAK,kCAAkC;CAG5F,MAAM,uBAAO,IAAI,IAAY;CAC7B,MAAM,QAAQ,SAAiB;EAC7B,IAAI,KAAK,IAAI,IAAI,GACf,MAAM,IAAI,cAAc,gBAAgB,WAAW,KAAK,2BAA2B,KAAK,EAAE;EAE5F,KAAK,IAAI,IAAI;CACf;CAEA,KAAK,MAAM,QAAQ,WAAW,OAAO;EACnC,KAAK,KAAK,IAAI;EAEd,IAAI,KAAK,UACP,KAAK,MAAM,SAAS,KAAK,UACvB,KAAK,MAAM,IAAI;CAGrB;AACF;AAEA,SAAS,gBAAwB;CAE/B,OAAO,MAAM,KAAK,IAAI,CAAC,CAAC,SAAS,EAAE,EAAE,GAAG,KAAK,OAAO,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,MAAM,GAAG,EAAE;AAChF"}
+{"version":3,"file":"workflow.mjs","names":["combined"],"sources":["../../../../../../../@warlock.js/ai/src/workflow/workflow.ts"],"sourcesContent":["import type { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport type { WorkflowEventMap } from \"../contracts/events/event-map.type\";\nimport type { WorkflowResult } from \"../contracts/result/workflow-result.type\";\nimport type {\n  WorkflowDefinition,\n  WorkflowEventHandler,\n  WorkflowExecuteOptions,\n  WorkflowInstance,\n  WorkflowResumeOptions,\n  WorkflowRunOptions,\n} from \"../contracts/workflow/workflow.contract\";\nimport { WorkflowError } from \"../errors\";\nimport type { ToolContract } from \"../tool/tool\";\nimport { asTool } from \"./as-tool\";\nimport { WorkflowEmitter } from \"./emitter\";\nimport { loadSnapshotForResume, runWorkflow } from \"./engine\";\nimport { computeSignature } from \"./signature\";\n\n/**\n * `ai.workflow(def)` — construct a `WorkflowInstance`. Validates the\n * definition, computes a stable structural signature, and wires up the\n * three-tier event subscription model.\n */\nexport function workflow<\n  TInput = unknown,\n  TOutput = unknown,\n  TState = Record<string, unknown>,\n  TContext = unknown,\n>(\n  definition: WorkflowDefinition<TInput, TOutput, TState, TContext>,\n): WorkflowInstance<TInput, TOutput, TState, TContext> {\n  validate(definition);\n  const signature = computeSignature(definition);\n  const emitter = new WorkflowEmitter(definition.on);\n\n  function execute(\n    inputOrOptions: TInput | WorkflowExecuteOptions<TInput, TContext>,\n    maybeOptions?: WorkflowRunOptions<TContext>,\n  ): Promise<WorkflowResult<TOutput>> {\n    const { input, options } = normalizeExecuteArgs<TInput, TContext>(\n      inputOrOptions,\n      maybeOptions,\n    );\n    const runId = options?.runId ?? generateRunId();\n    return runWorkflow<TOutput>({\n      definition,\n      signature,\n      emitter,\n      input,\n      context: options?.context,\n      runId,\n      signal: options?.signal,\n      executionHandlers: options?.on,\n      sessionId: options?.sessionId,\n    });\n  }\n\n  async function resume(\n    runId: string,\n    options?: WorkflowResumeOptions<TContext>,\n  ): Promise<WorkflowResult<TOutput>> {\n    const snapshot = await loadSnapshotForResume({\n      definition,\n      signature,\n      runId,\n      options,\n    });\n\n    return runWorkflow<TOutput>({\n      definition,\n      signature,\n      emitter,\n      input: snapshot.input,\n      context: options?.context,\n      runId,\n      signal: options?.signal,\n      executionHandlers: options?.on,\n      sessionId: options?.sessionId,\n      resumeFrom: snapshot,\n    });\n  }\n\n  const instance: WorkflowInstance<TInput, TOutput, TState, TContext> = {\n    name: definition.name,\n    description: definition.description,\n    inputSchema: definition.inputSchema,\n    signature,\n    version: definition.version,\n    execute,\n    resume,\n    on<K extends keyof WorkflowEventMap>(event: K, handler: WorkflowEventHandler<K>) {\n      return emitter.on(event, handler);\n    },\n    off<K extends keyof WorkflowEventMap>(event: K, handler: WorkflowEventHandler<K>) {\n      emitter.off(event, handler);\n    },\n    asTool<TToolInput = TInput>(options: {\n      description?: string;\n      inputSchema: StandardSchemaV1<TToolInput>;\n    }): ToolContract<TToolInput, TOutput> {\n      return asTool<TInput, TOutput, TToolInput>(instance, options);\n    },\n  };\n\n  return instance;\n}\n\n/**\n * Resolve the overloaded `execute()` call shape. If the caller passed\n * a single plain object with an `input` field, treat it as the\n * combined `WorkflowExecuteOptions`. Otherwise the first arg is the\n * raw workflow input and the second is the run options.\n *\n * Ambiguity note: if your real workflow `input` is itself an object\n * with a top-level `input` key, prefer `execute(rawInput, options)`\n * explicitly — the single-arg detection heuristic would mis-classify\n * it.\n */\nfunction normalizeExecuteArgs<TInput, TContext>(\n  inputOrOptions: TInput | WorkflowExecuteOptions<TInput, TContext>,\n  maybeOptions: WorkflowRunOptions<TContext> | undefined,\n): { input: TInput; options?: WorkflowRunOptions<TContext> } {\n  if (\n    maybeOptions === undefined &&\n    inputOrOptions !== null &&\n    typeof inputOrOptions === \"object\" &&\n    \"input\" in (inputOrOptions as object)\n  ) {\n    const combined = inputOrOptions as WorkflowExecuteOptions<TInput, TContext>;\n    const { input, ...options } = combined;\n    return { input, options };\n  }\n\n  return { input: inputOrOptions as TInput, options: maybeOptions };\n}\n\nfunction validate<TInput, TOutput, TState, TContext>(\n  definition: WorkflowDefinition<TInput, TOutput, TState, TContext>,\n): void {\n  if (!definition.name || typeof definition.name !== \"string\") {\n    throw new WorkflowError(\"ai.workflow: `name` is required\");\n  }\n\n  if (!Array.isArray(definition.steps) || definition.steps.length === 0) {\n    throw new WorkflowError(`ai.workflow(\"${definition.name}\"): at least one step is required`);\n  }\n\n  const seen = new Set<string>();\n  const walk = (name: string) => {\n    if (seen.has(name)) {\n      throw new WorkflowError(`ai.workflow(\"${definition.name}\"): duplicate step name \"${name}\"`);\n    }\n    seen.add(name);\n  };\n\n  for (const step of definition.steps) {\n    walk(step.name);\n\n    if (step.parallel) {\n      for (const child of step.parallel) {\n        walk(child.name);\n      }\n    }\n  }\n}\n\nfunction generateRunId(): string {\n  // Non-crypto random — adequate for ephemeral workflow runs.\n  return `wf_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;\n}\n"],"mappings":";;;;;;;;;;;;;;AAuBA,SAAgB,SAMd,YACqD;CACrD,SAAS,UAAU;CACnB,MAAM,YAAY,iBAAiB,UAAU;CAC7C,MAAM,UAAU,IAAI,gBAAgB,WAAW,EAAE;CAEjD,SAAS,QACP,gBACA,cACkC;EAClC,MAAM,EAAE,OAAO,YAAY,qBACzB,gBACA,YACF;EACA,MAAM,QAAQ,SAAS,SAAS,cAAc;EAC9C,OAAO,YAAqB;GAC1B;GACA;GACA;GACA;GACA,SAAS,SAAS;GAClB;GACA,QAAQ,SAAS;GACjB,mBAAmB,SAAS;GAC5B,WAAW,SAAS;EACtB,CAAC;CACH;CAEA,eAAe,OACb,OACA,SACkC;EAClC,MAAM,WAAW,MAAM,sBAAsB;GAC3C;GACA;GACA;GACA;EACF,CAAC;EAED,OAAO,YAAqB;GAC1B;GACA;GACA;GACA,OAAO,SAAS;GAChB,SAAS,SAAS;GAClB;GACA,QAAQ,SAAS;GACjB,mBAAmB,SAAS;GAC5B,WAAW,SAAS;GACpB,YAAY;EACd,CAAC;CACH;CAEA,MAAM,WAAgE;EACpE,MAAM,WAAW;EACjB,aAAa,WAAW;EACxB,aAAa,WAAW;EACxB;EACA,SAAS,WAAW;EACpB;EACA;EACA,GAAqC,OAAU,SAAkC;GAC/E,OAAO,QAAQ,GAAG,OAAO,OAAO;EAClC;EACA,IAAsC,OAAU,SAAkC;GAChF,QAAQ,IAAI,OAAO,OAAO;EAC5B;EACA,OAA4B,SAGU;GACpC,OAAO,OAAoC,UAAU,OAAO;EAC9D;CACF;CAEA,OAAO;AACT;;;;;;;;;;;;AAaA,SAAS,qBACP,gBACA,cAC2D;CAC3D,IACE,iBAAiB,UACjB,mBAAmB,QACnB,OAAO,mBAAmB,YAC1B,WAAY,gBACZ;EAEA,MAAM,EAAE,OAAO,GAAG,YAAYA;EAC9B,OAAO;GAAE;GAAO;EAAQ;CAC1B;CAEA,OAAO;EAAE,OAAO;EAA0B,SAAS;CAAa;AAClE;AAEA,SAAS,SACP,YACM;CACN,IAAI,CAAC,WAAW,QAAQ,OAAO,WAAW,SAAS,UACjD,MAAM,IAAI,cAAc,iCAAiC;CAG3D,IAAI,CAAC,MAAM,QAAQ,WAAW,KAAK,KAAK,WAAW,MAAM,WAAW,GAClE,MAAM,IAAI,cAAc,gBAAgB,WAAW,KAAK,kCAAkC;CAG5F,MAAM,uBAAO,IAAI,IAAY;CAC7B,MAAM,QAAQ,SAAiB;EAC7B,IAAI,KAAK,IAAI,IAAI,GACf,MAAM,IAAI,cAAc,gBAAgB,WAAW,KAAK,2BAA2B,KAAK,EAAE;EAE5F,KAAK,IAAI,IAAI;CACf;CAEA,KAAK,MAAM,QAAQ,WAAW,OAAO;EACnC,KAAK,KAAK,IAAI;EAEd,IAAI,KAAK,UACP,KAAK,MAAM,SAAS,KAAK,UACvB,KAAK,MAAM,IAAI;CAGrB;AACF;AAEA,SAAS,gBAAwB;CAE/B,OAAO,MAAM,KAAK,IAAI,CAAC,CAAC,SAAS,EAAE,EAAE,GAAG,KAAK,OAAO,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,MAAM,GAAG,EAAE;AAChF"}