@effect-uai/core 0.2.0 → 0.4.0

package/dist/tool/Resolvers.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"Resolvers.mjs","names":[],"sources":["../../src/tool/Resolvers.ts"],"sourcesContent":["/**\n * Approval helpers for the two transport flavors.\n *\n * These helpers only decide which calls are approved and which synthetic\n * results must be returned to the model. Tool execution stays explicit at\n * the recipe boundary via `Toolkit.executeAll`.\n */\nimport { Deferred, Effect, Queue, Scope, Stream } from \"effect\"\nimport type { FunctionCall } from \"../domain/Items.js\"\nimport { type ToolResult, cancelled, denied } from \"./Outcome.js\"\nimport type { ToolEvent } from \"./ToolEvent.js\"\n\nexport interface ToolCallPlan {\n  readonly approved: ReadonlyArray<FunctionCall>\n  readonly rejected: ReadonlyArray<ToolResult>\n}\n\nexport type ToolCallDecision =\n  | { readonly _tag: \"Approved\"; readonly call: FunctionCall }\n  | { readonly _tag: \"Rejected\"; readonly result: ToolResult }\n\nexport const approve = (call: FunctionCall): ToolCallDecision => ({\n  _tag: \"Approved\",\n  call,\n})\n\nexport const reject = (result: ToolResult): ToolCallDecision => ({\n  _tag: \"Rejected\",\n  result,\n})\n\nexport const splitToolCallDecisions = (\n  decisions: ReadonlyArray<ToolCallDecision>,\n): ToolCallPlan =>\n  decisions.reduce<ToolCallPlan>(\n    (acc, decision) =>\n      decision._tag === \"Approved\"\n        ? { ...acc, approved: [...acc.approved, decision.call] }\n        : { ...acc, rejected: [...acc.rejected, decision.result] },\n    { approved: [], rejected: [] },\n  )\n\nexport const approvalRequested = (call: FunctionCall): ToolEvent => ({\n  _tag: \"ApprovalRequested\",\n  call_id: call.call_id,\n  tool: call.name,\n  arguments: call.arguments,\n})\n\n// ---------------------------------------------------------------------------\n// Verdict queue (WebSocket-style transport).\n// ---------------------------------------------------------------------------\n\nexport interface Verdict {\n  readonly call_id: string\n  readonly decision: \"approve\" | \"deny\"\n  readonly reason?: string\n}\n\n/**\n * Queue-backed approval planner. Safe calls are returned immediately in\n * `approved`; gated calls emit `ApprovalRequested` events and later produce\n * one `ToolCallDecision` when their matching verdict arrives.\n */\nexport const fromVerdictQueue =\n  (\n    predicate: (call: FunctionCall) => boolean,\n    verdicts: Queue.Dequeue<Verdict>,\n  ) =>\n  (\n    calls: ReadonlyArray<FunctionCall>,\n  ): Effect.Effect<\n    {\n      readonly approved: ReadonlyArray<FunctionCall>\n      readonly decisions: Stream.Stream<ToolCallDecision>\n      readonly announce: Stream.Stream<ToolEvent>\n    },\n    never,\n    Scope.Scope\n  > =>\n    Effect.gen(function* () {\n      const gated = calls.filter(predicate)\n      const approved = calls.filter((call) => !predicate(call))\n\n      const entries = yield* Effect.forEach(gated, (call) =>\n        Deferred.make<Verdict>().pipe(Effect.map((d) => [call.call_id, d] as const)),\n      )\n      const deferreds: ReadonlyMap<string, Deferred.Deferred<Verdict>> = new Map(entries)\n\n      // Router is forked into the surrounding Scope so it lives as long\n      // as the consumer is pulling events. Recipes typically supply the\n      // scope by wrapping the events construction in `Stream.unwrap`.\n      yield* Effect.forkScoped(\n        Effect.forever(\n          Effect.gen(function* () {\n            const v = yield* Queue.take(verdicts)\n            const d = deferreds.get(v.call_id)\n            if (d !== undefined) yield* Deferred.succeed(d, v)\n          }),\n        ),\n      )\n\n      const decisions = Stream.fromIterable(gated).pipe(\n        Stream.flatMap(\n          (call) => {\n            const d = deferreds.get(call.call_id)!\n            return Stream.fromEffect(\n              Deferred.await(d).pipe(\n                Effect.map((v) =>\n                  v.decision === \"approve\" ? approve(call) : reject(denied(call, v.reason)),\n                ),\n              ),\n            )\n          },\n          { concurrency: \"unbounded\" },\n        ),\n      )\n\n      const announce = Stream.fromIterable<ToolEvent>(gated.map(approvalRequested))\n\n      return { approved, decisions, announce }\n    })\n\n// ---------------------------------------------------------------------------\n// Approval map (HTTP-style transport). Verdicts arrive synchronously\n// bundled in the request payload. Missing entries → cancelled.\n// ---------------------------------------------------------------------------\n\nexport type ApprovalMapEntry =\n  | { readonly decision: \"approve\" }\n  | { readonly decision: \"deny\"; readonly reason?: string }\n\nexport const fromApprovalMap =\n  (\n    predicate: (call: FunctionCall) => boolean,\n    approvals: ReadonlyMap<string, ApprovalMapEntry>,\n  ) =>\n  (calls: ReadonlyArray<FunctionCall>): ToolCallPlan =>\n    splitToolCallDecisions(\n      calls.map((call) => {\n        if (!predicate(call)) return approve(call)\n        const v = approvals.get(call.call_id)\n        if (v === undefined) return reject(cancelled(call))\n        return v.decision === \"approve\" ? approve(call) : reject(denied(call, v.reason))\n      }),\n    )\n\n"],"mappings":";;;;;;;;;;AAqBA,MAAa,WAAW,UAA0C;CAChE,MAAM;CACN;CACD;AAED,MAAa,UAAU,YAA0C;CAC/D,MAAM;CACN;CACD;AAED,MAAa,0BACX,cAEA,UAAU,QACP,KAAK,aACJ,SAAS,SAAS,aACd;CAAE,GAAG;CAAK,UAAU,CAAC,GAAG,IAAI,UAAU,SAAS,KAAK;CAAE,GACtD;CAAE,GAAG;CAAK,UAAU,CAAC,GAAG,IAAI,UAAU,SAAS,OAAO;CAAE,EAC9D;CAAE,UAAU,EAAE;CAAE,UAAU,EAAE;CAAE,CAC/B;AAEH,MAAa,qBAAqB,UAAmC;CACnE,MAAM;CACN,SAAS,KAAK;CACd,MAAM,KAAK;CACX,WAAW,KAAK;CACjB;;;;;;AAiBD,MAAa,oBAET,WACA,cAGA,UAUA,OAAO,IAAI,aAAa;CACtB,MAAM,QAAQ,MAAM,OAAO,UAAU;CACrC,MAAM,WAAW,MAAM,QAAQ,SAAS,CAAC,UAAU,KAAK,CAAC;CAEzD,MAAM,UAAU,OAAO,OAAO,QAAQ,QAAQ,SAC5C,SAAS,MAAe,CAAC,KAAK,OAAO,KAAK,MAAM,CAAC,KAAK,SAAS,EAAE,CAAU,CAAC,CAC7E;CACD,MAAM,YAA6D,IAAI,IAAI,QAAQ;AAKnF,QAAO,OAAO,WACZ,OAAO,QACL,OAAO,IAAI,aAAa;EACtB,MAAM,IAAI,OAAO,MAAM,KAAK,SAAS;EACrC,MAAM,IAAI,UAAU,IAAI,EAAE,QAAQ;AAClC,MAAI,MAAM,KAAA,EAAW,QAAO,SAAS,QAAQ,GAAG,EAAE;GAClD,CACH,CACF;AAoBD,QAAO;EAAE;EAAU,WAlBD,OAAO,aAAa,MAAM,CAAC,KAC3C,OAAO,SACJ,SAAS;GACR,MAAM,IAAI,UAAU,IAAI,KAAK,QAAQ;AACrC,UAAO,OAAO,WACZ,SAAS,MAAM,EAAE,CAAC,KAChB,OAAO,KAAK,MACV,EAAE,aAAa,YAAY,QAAQ,KAAK,GAAG,OAAO,OAAO,MAAM,EAAE,OAAO,CAAC,CAC1E,CACF,CACF;KAEH,EAAE,aAAa,aAAa,CAC7B,CAKyB;EAAE,UAFb,OAAO,aAAwB,MAAM,IAAI,kBAAkB,CAEtC;EAAE;EACxC;AAWN,MAAa,mBAET,WACA,eAED,UACC,uBACE,MAAM,KAAK,SAAS;AAClB,KAAI,CAAC,UAAU,KAAK,CAAE,QAAO,QAAQ,KAAK;CAC1C,MAAM,IAAI,UAAU,IAAI,KAAK,QAAQ;AACrC,KAAI,MAAM,KAAA,EAAW,QAAO,OAAO,UAAU,KAAK,CAAC;AACnD,QAAO,EAAE,aAAa,YAAY,QAAQ,KAAK,GAAG,OAAO,OAAO,MAAM,EAAE,OAAO,CAAC;EAChF,CACH"}
+{"version":3,"file":"Resolvers.mjs","names":[],"sources":["../../src/tool/Resolvers.ts"],"sourcesContent":["/**\n * Approval helpers for the two transport flavors.\n *\n * These helpers only decide which calls are approved and which synthetic\n * results must be returned to the model. Tool execution stays explicit at\n * the recipe boundary via `Toolkit.executeAll`.\n */\nimport { Deferred, Effect, Queue, Scope, Stream } from \"effect\"\nimport type { FunctionCall } from \"../domain/Items.js\"\nimport { type ToolResult, cancelled, denied } from \"./Outcome.js\"\nimport type { ToolEvent } from \"./ToolEvent.js\"\n\nexport type ToolCallPlan = {\n  readonly approved: ReadonlyArray<FunctionCall>\n  readonly rejected: ReadonlyArray<ToolResult>\n}\n\nexport type ToolCallDecision =\n  | { readonly _tag: \"Approved\"; readonly call: FunctionCall }\n  | { readonly _tag: \"Rejected\"; readonly result: ToolResult }\n\nexport const approve = (call: FunctionCall): ToolCallDecision => ({\n  _tag: \"Approved\",\n  call,\n})\n\nexport const reject = (result: ToolResult): ToolCallDecision => ({\n  _tag: \"Rejected\",\n  result,\n})\n\nexport const splitToolCallDecisions = (decisions: ReadonlyArray<ToolCallDecision>): ToolCallPlan =>\n  decisions.reduce<ToolCallPlan>(\n    (acc, decision) =>\n      decision._tag === \"Approved\"\n        ? { ...acc, approved: [...acc.approved, decision.call] }\n        : { ...acc, rejected: [...acc.rejected, decision.result] },\n    { approved: [], rejected: [] },\n  )\n\nexport const approvalRequested = (call: FunctionCall): ToolEvent => ({\n  _tag: \"ApprovalRequested\",\n  call_id: call.call_id,\n  tool: call.name,\n  arguments: call.arguments,\n})\n\n// ---------------------------------------------------------------------------\n// Verdict queue (WebSocket-style transport).\n// ---------------------------------------------------------------------------\n\nexport type Verdict = {\n  readonly call_id: string\n  readonly decision: \"approve\" | \"deny\"\n  readonly reason?: string\n}\n\n/**\n * Queue-backed approval planner. Safe calls are returned immediately in\n * `approved`; gated calls emit `ApprovalRequested` events and later produce\n * one `ToolCallDecision` when their matching verdict arrives.\n */\nexport const fromVerdictQueue =\n  (predicate: (call: FunctionCall) => boolean, verdicts: Queue.Dequeue<Verdict>) =>\n  (\n    calls: ReadonlyArray<FunctionCall>,\n  ): Effect.Effect<\n    {\n      readonly approved: ReadonlyArray<FunctionCall>\n      readonly decisions: Stream.Stream<ToolCallDecision>\n      readonly announce: Stream.Stream<ToolEvent>\n    },\n    never,\n    Scope.Scope\n  > =>\n    Effect.gen(function* () {\n      const gated = calls.filter(predicate)\n      const approved = calls.filter((call) => !predicate(call))\n\n      const entries = yield* Effect.forEach(gated, (call) =>\n        Deferred.make<Verdict>().pipe(Effect.map((d) => [call.call_id, d] as const)),\n      )\n      const deferreds: ReadonlyMap<string, Deferred.Deferred<Verdict>> = new Map(entries)\n\n      // Router is forked into the surrounding Scope so it lives as long\n      // as the consumer is pulling events. Recipes typically supply the\n      // scope by wrapping the events construction in `Stream.unwrap`.\n      yield* Effect.forkScoped(\n        Effect.forever(\n          Effect.gen(function* () {\n            const v = yield* Queue.take(verdicts)\n            const d = deferreds.get(v.call_id)\n            if (d !== undefined) yield* Deferred.succeed(d, v)\n          }),\n        ),\n      )\n\n      const decisions = Stream.fromIterable(gated).pipe(\n        Stream.flatMap(\n          (call) => {\n            const d = deferreds.get(call.call_id)!\n            return Stream.fromEffect(\n              Deferred.await(d).pipe(\n                Effect.map((v) =>\n                  v.decision === \"approve\" ? approve(call) : reject(denied(call, v.reason)),\n                ),\n              ),\n            )\n          },\n          { concurrency: \"unbounded\" },\n        ),\n      )\n\n      const announce = Stream.fromIterable<ToolEvent>(gated.map(approvalRequested))\n\n      return { approved, decisions, announce }\n    })\n\n// ---------------------------------------------------------------------------\n// Approval map (HTTP-style transport). Verdicts arrive synchronously\n// bundled in the request payload. Missing entries → cancelled.\n// ---------------------------------------------------------------------------\n\nexport type ApprovalMapEntry =\n  | { readonly decision: \"approve\" }\n  | { readonly decision: \"deny\"; readonly reason?: string }\n\nexport const fromApprovalMap =\n  (predicate: (call: FunctionCall) => boolean, approvals: ReadonlyMap<string, ApprovalMapEntry>) =>\n  (calls: ReadonlyArray<FunctionCall>): ToolCallPlan =>\n    splitToolCallDecisions(\n      calls.map((call) => {\n        if (!predicate(call)) return approve(call)\n        const v = approvals.get(call.call_id)\n        if (v === undefined) return reject(cancelled(call))\n        return v.decision === \"approve\" ? approve(call) : reject(denied(call, v.reason))\n      }),\n    )\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAqBA,MAAa,WAAW,UAA0C;CAChE,MAAM;CACN;CACD;AAED,MAAa,UAAU,YAA0C;CAC/D,MAAM;CACN;CACD;AAED,MAAa,0BAA0B,cACrC,UAAU,QACP,KAAK,aACJ,SAAS,SAAS,aACd;CAAE,GAAG;CAAK,UAAU,CAAC,GAAG,IAAI,UAAU,SAAS,KAAK;CAAE,GACtD;CAAE,GAAG;CAAK,UAAU,CAAC,GAAG,IAAI,UAAU,SAAS,OAAO;CAAE,EAC9D;CAAE,UAAU,EAAE;CAAE,UAAU,EAAE;CAAE,CAC/B;AAEH,MAAa,qBAAqB,UAAmC;CACnE,MAAM;CACN,SAAS,KAAK;CACd,MAAM,KAAK;CACX,WAAW,KAAK;CACjB;;;;;;AAiBD,MAAa,oBACV,WAA4C,cAE3C,UAUA,OAAO,IAAI,aAAa;CACtB,MAAM,QAAQ,MAAM,OAAO,UAAU;CACrC,MAAM,WAAW,MAAM,QAAQ,SAAS,CAAC,UAAU,KAAK,CAAC;CAEzD,MAAM,UAAU,OAAO,OAAO,QAAQ,QAAQ,SAC5C,SAAS,MAAe,CAAC,KAAK,OAAO,KAAK,MAAM,CAAC,KAAK,SAAS,EAAE,CAAU,CAAC,CAC7E;CACD,MAAM,YAA6D,IAAI,IAAI,QAAQ;AAKnF,QAAO,OAAO,WACZ,OAAO,QACL,OAAO,IAAI,aAAa;EACtB,MAAM,IAAI,OAAO,MAAM,KAAK,SAAS;EACrC,MAAM,IAAI,UAAU,IAAI,EAAE,QAAQ;AAClC,MAAI,MAAM,KAAA,EAAW,QAAO,SAAS,QAAQ,GAAG,EAAE;GAClD,CACH,CACF;AAoBD,QAAO;EAAE;EAAU,WAlBD,OAAO,aAAa,MAAM,CAAC,KAC3C,OAAO,SACJ,SAAS;GACR,MAAM,IAAI,UAAU,IAAI,KAAK,QAAQ;AACrC,UAAO,OAAO,WACZ,SAAS,MAAM,EAAE,CAAC,KAChB,OAAO,KAAK,MACV,EAAE,aAAa,YAAY,QAAQ,KAAK,GAAG,OAAO,OAAO,MAAM,EAAE,OAAO,CAAC,CAC1E,CACF,CACF;KAEH,EAAE,aAAa,aAAa,CAC7B,CAKyB;EAAE,UAFb,OAAO,aAAwB,MAAM,IAAI,kBAAkB,CAEtC;EAAE;EACxC;AAWN,MAAa,mBACV,WAA4C,eAC5C,UACC,uBACE,MAAM,KAAK,SAAS;AAClB,KAAI,CAAC,UAAU,KAAK,CAAE,QAAO,QAAQ,KAAK;CAC1C,MAAM,IAAI,UAAU,IAAI,KAAK,QAAQ;AACrC,KAAI,MAAM,KAAA,EAAW,QAAO,OAAO,UAAU,KAAK,CAAC;AACnD,QAAO,EAAE,aAAa,YAAY,QAAQ,KAAK,GAAG,OAAO,OAAO,MAAM,EAAE,OAAO,CAAC;EAChF,CACH"}

package/dist/tool/Resolvers.test.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/tool/Resolvers.test.mjs

@@ -0,0 +1,317 @@
+import { functionCallOutput, userText } from "../domain/Items.mjs";
+import { fromEffectSchema, make, streaming } from "./Tool.mjs";
+import { isFailure, isValue, toFunctionCallOutput } from "./Outcome.mjs";
+import { isApprovalRequested, isIntermediate, isOutput } from "./ToolEvent.mjs";
+import { executeAll, outputEvent, outputEvents } from "./Toolkit.mjs";
+import { fromApprovalMap, fromVerdictQueue } from "./Resolvers.mjs";
+import { cancelAllPending, findUnansweredCalls, isReconciled } from "./HistoryCheck.mjs";
+import { i as it, n as globalExpect, r as describe } from "../dist-DV5ISja1.mjs";
+import { Effect, Queue, Schema, Stream } from "effect";
+//#region src/tool/Resolvers.test.ts
+/**
+* Tests for approval planners + history-reconciliation primitives. Exercises
+* the full HITL + streaming-tool stack end-to-end by composing approval plans
+* with `executeAll`, with the four wire-shaped scenarios:
+*
+*   1. Approval        : gated calls approved → tools execute, structured Values
+*   2. Denial          : gated calls denied   → Failure(denied) results
+*   3. Cancellation    : missing verdicts     → Failure(cancelled) results
+*   4. Mixed + history : reconciliation via cancelAllPending
+*
+* Plus: hallucinated tool name (graceful Failure), unknown_tool kind.
+*/
+const allTools = [
+	streaming({
+		name: "web_search",
+		description: "search",
+		inputSchema: fromEffectSchema(Schema.Struct({ query: Schema.String })),
+		run: ({ query }) => Stream.fromIterable([
+			{
+				url: "a",
+				title: `${query} 1`
+			},
+			{
+				url: "b",
+				title: `${query} 2`
+			},
+			{
+				url: "c",
+				title: `${query} 3`
+			}
+		]),
+		finalize: (hits) => ({ count: hits.length })
+	}),
+	streaming({
+		name: "bulk_email",
+		description: "send",
+		inputSchema: fromEffectSchema(Schema.Struct({
+			recipients: Schema.Array(Schema.String),
+			subject: Schema.String
+		})),
+		run: ({ recipients }) => Stream.fromIterable(recipients.map((_, i) => ({
+			type: "progress",
+			sent: i + 1,
+			total: recipients.length
+		}))),
+		finalize: (events) => ({
+			status: "sent",
+			delivered: events.length
+		})
+	}),
+	make({
+		name: "delete_database",
+		description: "drop",
+		inputSchema: fromEffectSchema(Schema.Struct({ name: Schema.String })),
+		run: ({ name }) => Effect.succeed({
+			status: "dropped",
+			name
+		})
+	})
+];
+const SENSITIVE = new Set(["bulk_email", "delete_database"]);
+const isSensitive = (call) => SENSITIVE.has(call.name);
+const fc = (call_id, name, args) => ({
+	type: "function_call",
+	call_id,
+	name,
+	arguments: JSON.stringify(args)
+});
+const calls = [
+	fc("c1", "web_search", { query: "effect" }),
+	fc("c2", "bulk_email", {
+		recipients: ["a@x", "b@x"],
+		subject: "Hi"
+	}),
+	fc("c3", "delete_database", { name: "prod" })
+];
+const resultsFrom = (collected) => collected.filter(isOutput).map((e) => e.result);
+const byCallId = (results) => new Map(results.map((r) => [r.call_id, r]));
+const eventsFromApprovalMap = (approvals) => {
+	const plan = fromApprovalMap(isSensitive, approvals)(calls);
+	return Stream.merge(executeAll(allTools, plan.approved), outputEvents(plan.rejected));
+};
+const eventsFromDecision = (decision) => decision._tag === "Approved" ? executeAll(allTools, [decision.call]) : Stream.succeed(outputEvent(decision.result));
+describe("fromApprovalMap + executeAll", () => {
+	it("approval: all gated approved → tools execute, structured Values", async () => {
+		const approvals = new Map([["c2", { decision: "approve" }], ["c3", { decision: "approve" }]]);
+		const collected = await Effect.runPromise(Stream.runCollect(eventsFromApprovalMap(approvals)));
+		const by = byCallId(resultsFrom(collected));
+		globalExpect(by.get("c1")).toMatchObject({
+			_tag: "Value",
+			value: { count: 3 }
+		});
+		globalExpect(by.get("c2")).toMatchObject({
+			_tag: "Value",
+			value: {
+				status: "sent",
+				delivered: 2
+			}
+		});
+		globalExpect(by.get("c3")).toMatchObject({
+			_tag: "Value",
+			value: {
+				status: "dropped",
+				name: "prod"
+			}
+		});
+		globalExpect(collected.filter(isApprovalRequested)).toHaveLength(0);
+	});
+	it("denial: gated denied → Failure(denied), no execution", async () => {
+		const approvals = new Map([["c2", {
+			decision: "deny",
+			reason: "spam concern"
+		}], ["c3", {
+			decision: "deny",
+			reason: "prod is sacred"
+		}]]);
+		const collected = await Effect.runPromise(Stream.runCollect(eventsFromApprovalMap(approvals)));
+		globalExpect(collected.filter(isIntermediate).filter((e) => e.tool === "bulk_email")).toHaveLength(0);
+		const by = byCallId(resultsFrom(collected));
+		globalExpect(by.get("c2")).toMatchObject({
+			_tag: "Failure",
+			kind: "denied",
+			reason: "spam concern"
+		});
+		globalExpect(by.get("c3")).toMatchObject({
+			_tag: "Failure",
+			kind: "denied",
+			reason: "prod is sacred"
+		});
+	});
+	it("cancellation: missing verdicts → Failure(cancelled)", async () => {
+		const by = byCallId(resultsFrom(await Effect.runPromise(Stream.runCollect(eventsFromApprovalMap(/* @__PURE__ */ new Map())))));
+		globalExpect(by.get("c1")).toMatchObject({
+			_tag: "Value",
+			value: { count: 3 }
+		});
+		globalExpect(by.get("c2")).toMatchObject({
+			_tag: "Failure",
+			kind: "cancelled"
+		});
+		globalExpect(by.get("c3")).toMatchObject({
+			_tag: "Failure",
+			kind: "cancelled"
+		});
+	});
+	it("mixed: approve + deny + omit → all three kinds", async () => {
+		const approvals = new Map([["c2", { decision: "approve" }]]);
+		const by = byCallId(resultsFrom(await Effect.runPromise(Stream.runCollect(eventsFromApprovalMap(approvals)))));
+		globalExpect(by.get("c1")).toMatchObject({
+			_tag: "Value",
+			value: { count: 3 }
+		});
+		globalExpect(by.get("c2")).toMatchObject({
+			_tag: "Value",
+			value: { status: "sent" }
+		});
+		globalExpect(by.get("c3")).toMatchObject({
+			_tag: "Failure",
+			kind: "cancelled"
+		});
+	});
+});
+describe("executeAll: graceful degradation", () => {
+	it("unknown tool name → Failure(unknown_tool); other calls still execute", async () => {
+		const callsWithBogus = [
+			fc("c1", "web_search", { query: "x" }),
+			fc("c2", "does_not_exist", {}),
+			fc("c3", "delete_database", { name: "prod" })
+		];
+		const by = byCallId(resultsFrom(await Effect.runPromise(Stream.runCollect((() => {
+			const plan = fromApprovalMap(isSensitive, new Map([["c3", { decision: "approve" }]]))(callsWithBogus);
+			return Stream.merge(executeAll(allTools, plan.approved), outputEvents(plan.rejected));
+		})()))));
+		globalExpect(by.get("c1")).toMatchObject({ _tag: "Value" });
+		globalExpect(by.get("c2")).toMatchObject({
+			_tag: "Failure",
+			kind: "unknown_tool"
+		});
+		globalExpect(by.get("c3")).toMatchObject({
+			_tag: "Value",
+			value: { status: "dropped" }
+		});
+	});
+});
+describe("fromVerdictQueue + executeAll", () => {
+	it("queue-driven: approve + deny resolve correctly with ApprovalRequested events", async () => {
+		const collected = await Effect.runPromise(Effect.gen(function* () {
+			const verdicts = yield* Queue.unbounded();
+			yield* Queue.offer(verdicts, {
+				call_id: "c2",
+				decision: "approve"
+			});
+			yield* Queue.offer(verdicts, {
+				call_id: "c3",
+				decision: "deny",
+				reason: "too risky"
+			});
+			const events = Stream.unwrap(Effect.gen(function* () {
+				const { approved, decisions, announce } = yield* fromVerdictQueue(isSensitive, verdicts)(calls);
+				return Stream.merge(announce, Stream.merge(executeAll(allTools, approved), decisions.pipe(Stream.flatMap(eventsFromDecision))));
+			}));
+			return yield* Stream.runCollect(events);
+		}));
+		globalExpect(collected.filter(isApprovalRequested)).toHaveLength(2);
+		const by = byCallId(resultsFrom(collected));
+		globalExpect(by.get("c2")).toMatchObject({
+			_tag: "Value",
+			value: { status: "sent" }
+		});
+		globalExpect(by.get("c3")).toMatchObject({
+			_tag: "Failure",
+			kind: "denied",
+			reason: "too risky"
+		});
+	});
+});
+describe("findUnansweredCalls / cancelAllPending / isReconciled", () => {
+	const orphan = fc("c99", "delete_database", { name: "prod" });
+	const answered = fc("c98", "web_search", { query: "x" });
+	const answeredOutput = functionCallOutput("c98", JSON.stringify({ count: 0 }));
+	it("findUnansweredCalls returns only orphans", () => {
+		const unanswered = findUnansweredCalls([
+			userText("hi"),
+			answered,
+			orphan,
+			answeredOutput
+		]);
+		globalExpect(unanswered).toHaveLength(1);
+		globalExpect(unanswered[0].call_id).toBe("c99");
+	});
+	it("isReconciled is false when orphans exist, true otherwise", () => {
+		const stale = [userText("hi"), orphan];
+		globalExpect(isReconciled(stale)).toBe(false);
+		globalExpect(isReconciled([...stale, ...cancelAllPending(stale).map(toFunctionCallOutput)])).toBe(true);
+	});
+	it("cancelAllPending synthesizes one Failure(cancelled) per orphan", () => {
+		const closures = cancelAllPending([
+			userText("hi"),
+			answered,
+			orphan,
+			answeredOutput
+		], "user moved on");
+		globalExpect(closures).toHaveLength(1);
+		const c = closures[0];
+		globalExpect(isFailure(c)).toBe(true);
+		globalExpect(c).toMatchObject({
+			_tag: "Failure",
+			call_id: "c99",
+			kind: "cancelled",
+			reason: "user moved on"
+		});
+	});
+	it("follow-up: map closures to FunctionCallOutput before appending new user message", () => {
+		const stale = [userText("first request"), orphan];
+		const closures = cancelAllPending(stale, "user redirected");
+		globalExpect(findUnansweredCalls([
+			...stale,
+			...closures.map(toFunctionCallOutput),
+			userText("never mind")
+		])).toHaveLength(0);
+	});
+});
+describe("toFunctionCallOutput", () => {
+	it("round-trips a Value result", () => {
+		const out = toFunctionCallOutput({
+			_tag: "Value",
+			call_id: "c1",
+			tool: "web_search",
+			value: { count: 3 }
+		});
+		globalExpect(out.call_id).toBe("c1");
+		globalExpect(JSON.parse(out.output)).toEqual({ count: 3 });
+	});
+	it("round-trips a Failure result with reason", () => {
+		const out = toFunctionCallOutput({
+			_tag: "Failure",
+			call_id: "c2",
+			tool: "bulk_email",
+			kind: "denied",
+			reason: "spam concern"
+		});
+		globalExpect(JSON.parse(out.output)).toEqual({
+			kind: "denied",
+			reason: "spam concern"
+		});
+	});
+	it("round-trips a Failure result without reason (omits the field)", () => {
+		const out = toFunctionCallOutput({
+			_tag: "Failure",
+			call_id: "c3",
+			tool: "delete_database",
+			kind: "cancelled"
+		});
+		globalExpect(JSON.parse(out.output)).toEqual({ kind: "cancelled" });
+	});
+});
+describe("executeAll", () => {
+	it("runs all calls passed to it", async () => {
+		const collected = await Effect.runPromise(Stream.runCollect(executeAll(allTools, calls)));
+		globalExpect(collected.filter(isOutput)).toHaveLength(3);
+		globalExpect(collected.filter(isOutput).every((e) => isValue(e.result))).toBe(true);
+	});
+});
+//#endregion
+export {};
+
+//# sourceMappingURL=Resolvers.test.mjs.map

package/dist/tool/Resolvers.test.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Resolvers.test.mjs","names":["makeTool","Items.functionCallOutput","Items.userText"],"sources":["../../src/tool/Resolvers.test.ts"],"sourcesContent":["/**\n * Tests for approval planners + history-reconciliation primitives. Exercises\n * the full HITL + streaming-tool stack end-to-end by composing approval plans\n * with `executeAll`, with the four wire-shaped scenarios:\n *\n *   1. Approval        : gated calls approved → tools execute, structured Values\n *   2. Denial          : gated calls denied   → Failure(denied) results\n *   3. Cancellation    : missing verdicts     → Failure(cancelled) results\n *   4. Mixed + history : reconciliation via cancelAllPending\n *\n * Plus: hallucinated tool name (graceful Failure), unknown_tool kind.\n */\nimport { Effect, Queue, Schema, Stream } from \"effect\"\nimport { describe, expect, it } from \"vitest\"\nimport * as Items from \"../domain/Items.js\"\nimport { findUnansweredCalls, cancelAllPending, isReconciled } from \"./HistoryCheck.js\"\nimport { type ToolResult, isFailure, isValue, toFunctionCallOutput } from \"./Outcome.js\"\nimport {\n  type ApprovalMapEntry,\n  type ToolCallDecision,\n  fromApprovalMap,\n  fromVerdictQueue,\n} from \"./Resolvers.js\"\nimport { fromEffectSchema, make as makeTool, streaming } from \"./Tool.js\"\nimport { executeAll, outputEvent, outputEvents } from \"./Toolkit.js\"\nimport { type ToolEvent, isApprovalRequested, isIntermediate, isOutput } from \"./ToolEvent.js\"\n\n// ---------------------------------------------------------------------------\n// Three demo tools covering the matrix:\n//   - web_search      : streaming, no approval\n//   - bulk_email      : streaming, requires approval\n//   - delete_database : non-streaming, requires approval\n// ---------------------------------------------------------------------------\n\nconst webSearch = streaming({\n  name: \"web_search\",\n  description: \"search\",\n  inputSchema: fromEffectSchema(Schema.Struct({ query: Schema.String })),\n  run: ({ query }) =>\n    Stream.fromIterable([\n      { url: \"a\", title: `${query} 1` },\n      { url: \"b\", title: `${query} 2` },\n      { url: \"c\", title: `${query} 3` },\n    ]),\n  finalize: (hits) => ({ count: hits.length }),\n})\n\nconst bulkEmail = streaming({\n  name: \"bulk_email\",\n  description: \"send\",\n  inputSchema: fromEffectSchema(\n    Schema.Struct({ recipients: Schema.Array(Schema.String), subject: Schema.String }),\n  ),\n  run: ({ recipients }) =>\n    Stream.fromIterable(\n      recipients.map((_, i) => ({\n        type: \"progress\" as const,\n        sent: i + 1,\n        total: recipients.length,\n      })),\n    ),\n  finalize: (events) => ({ status: \"sent\" as const, delivered: events.length }),\n})\n\nconst deleteDatabase = makeTool({\n  name: \"delete_database\",\n  description: \"drop\",\n  inputSchema: fromEffectSchema(Schema.Struct({ name: Schema.String })),\n  run: ({ name }) => Effect.succeed({ status: \"dropped\", name }),\n})\n\nconst allTools = [webSearch, bulkEmail, deleteDatabase]\nconst SENSITIVE = new Set([\"bulk_email\", \"delete_database\"])\nconst isSensitive = (call: Items.FunctionCall) => SENSITIVE.has(call.name)\n\nconst fc = (call_id: string, name: string, args: unknown): Items.FunctionCall => ({\n  type: \"function_call\",\n  call_id,\n  name,\n  arguments: JSON.stringify(args),\n})\n\nconst calls = [\n  fc(\"c1\", \"web_search\", { query: \"effect\" }),\n  fc(\"c2\", \"bulk_email\", { recipients: [\"a@x\", \"b@x\"], subject: \"Hi\" }),\n  fc(\"c3\", \"delete_database\", { name: \"prod\" }),\n]\n\nconst resultsFrom = (collected: ReadonlyArray<ToolEvent>): ReadonlyArray<ToolResult> =>\n  collected.filter(isOutput).map((e) => e.result)\n\nconst byCallId = (results: ReadonlyArray<ToolResult>) => new Map(results.map((r) => [r.call_id, r]))\n\nconst eventsFromApprovalMap = (approvals: ReadonlyMap<string, ApprovalMapEntry>) => {\n  const plan = fromApprovalMap(isSensitive, approvals)(calls)\n  return Stream.merge(executeAll(allTools, plan.approved), outputEvents(plan.rejected))\n}\n\nconst eventsFromDecision = (decision: ToolCallDecision): Stream.Stream<ToolEvent> =>\n  decision._tag === \"Approved\"\n    ? executeAll(allTools, [decision.call])\n    : Stream.succeed(outputEvent(decision.result))\n\n// ---------------------------------------------------------------------------\n// fromApprovalMap: HTTP-style scenarios\n// ---------------------------------------------------------------------------\n\ndescribe(\"fromApprovalMap + executeAll\", () => {\n  it(\"approval: all gated approved → tools execute, structured Values\", async () => {\n    const approvals = new Map<string, ApprovalMapEntry>([\n      [\"c2\", { decision: \"approve\" }],\n      [\"c3\", { decision: \"approve\" }],\n    ])\n    const collected = await Effect.runPromise(Stream.runCollect(eventsFromApprovalMap(approvals)))\n    const by = byCallId(resultsFrom(collected))\n    expect(by.get(\"c1\")).toMatchObject({ _tag: \"Value\", value: { count: 3 } })\n    expect(by.get(\"c2\")).toMatchObject({\n      _tag: \"Value\",\n      value: { status: \"sent\", delivered: 2 },\n    })\n    expect(by.get(\"c3\")).toMatchObject({\n      _tag: \"Value\",\n      value: { status: \"dropped\", name: \"prod\" },\n    })\n\n    // No ApprovalRequested events from the pure HTTP flow.\n    expect(collected.filter(isApprovalRequested)).toHaveLength(0)\n  })\n\n  it(\"denial: gated denied → Failure(denied), no execution\", async () => {\n    const approvals = new Map<string, ApprovalMapEntry>([\n      [\"c2\", { decision: \"deny\", reason: \"spam concern\" }],\n      [\"c3\", { decision: \"deny\", reason: \"prod is sacred\" }],\n    ])\n    const collected = await Effect.runPromise(Stream.runCollect(eventsFromApprovalMap(approvals)))\n\n    // bulk_email never ran.\n    expect(collected.filter(isIntermediate).filter((e) => e.tool === \"bulk_email\")).toHaveLength(0)\n\n    const by = byCallId(resultsFrom(collected))\n    expect(by.get(\"c2\")).toMatchObject({\n      _tag: \"Failure\",\n      kind: \"denied\",\n      reason: \"spam concern\",\n    })\n    expect(by.get(\"c3\")).toMatchObject({\n      _tag: \"Failure\",\n      kind: \"denied\",\n      reason: \"prod is sacred\",\n    })\n  })\n\n  it(\"cancellation: missing verdicts → Failure(cancelled)\", async () => {\n    const collected = await Effect.runPromise(Stream.runCollect(eventsFromApprovalMap(new Map())))\n    const by = byCallId(resultsFrom(collected))\n    expect(by.get(\"c1\")).toMatchObject({ _tag: \"Value\", value: { count: 3 } })\n    expect(by.get(\"c2\")).toMatchObject({ _tag: \"Failure\", kind: \"cancelled\" })\n    expect(by.get(\"c3\")).toMatchObject({ _tag: \"Failure\", kind: \"cancelled\" })\n  })\n\n  it(\"mixed: approve + deny + omit → all three kinds\", async () => {\n    const approvals = new Map<string, ApprovalMapEntry>([\n      [\"c2\", { decision: \"approve\" }],\n      // c3 omitted → cancelled\n    ])\n    const collected = await Effect.runPromise(Stream.runCollect(eventsFromApprovalMap(approvals)))\n    const by = byCallId(resultsFrom(collected))\n    expect(by.get(\"c1\")).toMatchObject({ _tag: \"Value\", value: { count: 3 } })\n    expect(by.get(\"c2\")).toMatchObject({ _tag: \"Value\", value: { status: \"sent\" } })\n    expect(by.get(\"c3\")).toMatchObject({ _tag: \"Failure\", kind: \"cancelled\" })\n  })\n})\n\n// ---------------------------------------------------------------------------\n// Graceful degradation: hallucinated tool name doesn't kill the turn.\n// ---------------------------------------------------------------------------\n\ndescribe(\"executeAll: graceful degradation\", () => {\n  it(\"unknown tool name → Failure(unknown_tool); other calls still execute\", async () => {\n    const callsWithBogus = [\n      fc(\"c1\", \"web_search\", { query: \"x\" }),\n      fc(\"c2\", \"does_not_exist\", {}),\n      fc(\"c3\", \"delete_database\", { name: \"prod\" }),\n    ]\n    const collected = await Effect.runPromise(\n      Stream.runCollect(\n        (() => {\n          const plan = fromApprovalMap(\n            isSensitive,\n            new Map([[\"c3\", { decision: \"approve\" }]]),\n          )(callsWithBogus)\n          return Stream.merge(executeAll(allTools, plan.approved), outputEvents(plan.rejected))\n        })(),\n      ),\n    )\n    const by = byCallId(resultsFrom(collected))\n    expect(by.get(\"c1\")).toMatchObject({ _tag: \"Value\" })\n    expect(by.get(\"c2\")).toMatchObject({ _tag: \"Failure\", kind: \"unknown_tool\" })\n    expect(by.get(\"c3\")).toMatchObject({ _tag: \"Value\", value: { status: \"dropped\" } })\n  })\n})\n\n// ---------------------------------------------------------------------------\n// fromVerdictQueue: WebSocket-style scenarios\n// ---------------------------------------------------------------------------\n\ndescribe(\"fromVerdictQueue + executeAll\", () => {\n  it(\"queue-driven: approve + deny resolve correctly with ApprovalRequested events\", async () => {\n    const collected = await Effect.runPromise(\n      Effect.gen(function* () {\n        const verdicts = yield* Queue.unbounded<{\n          readonly call_id: string\n          readonly decision: \"approve\" | \"deny\"\n          readonly reason?: string\n        }>()\n        yield* Queue.offer(verdicts, { call_id: \"c2\", decision: \"approve\" })\n        yield* Queue.offer(verdicts, {\n          call_id: \"c3\",\n          decision: \"deny\",\n          reason: \"too risky\",\n        })\n\n        // Stream.unwrap supplies the Scope for fromVerdictQueue's router.\n        const events = Stream.unwrap(\n          Effect.gen(function* () {\n            const { approved, decisions, announce } = yield* fromVerdictQueue(\n              isSensitive,\n              verdicts,\n            )(calls)\n            return Stream.merge(\n              announce,\n              Stream.merge(\n                executeAll(allTools, approved),\n                decisions.pipe(Stream.flatMap(eventsFromDecision)),\n              ),\n            )\n          }),\n        )\n        return yield* Stream.runCollect(events)\n      }),\n    )\n\n    expect(collected.filter(isApprovalRequested)).toHaveLength(2)\n\n    const by = byCallId(resultsFrom(collected))\n    expect(by.get(\"c2\")).toMatchObject({ _tag: \"Value\", value: { status: \"sent\" } })\n    expect(by.get(\"c3\")).toMatchObject({\n      _tag: \"Failure\",\n      kind: \"denied\",\n      reason: \"too risky\",\n    })\n  })\n})\n\n// ---------------------------------------------------------------------------\n// History reconciliation\n// ---------------------------------------------------------------------------\n\ndescribe(\"findUnansweredCalls / cancelAllPending / isReconciled\", () => {\n  const orphan = fc(\"c99\", \"delete_database\", { name: \"prod\" })\n  const answered = fc(\"c98\", \"web_search\", { query: \"x\" })\n  const answeredOutput = Items.functionCallOutput(\"c98\", JSON.stringify({ count: 0 }))\n\n  it(\"findUnansweredCalls returns only orphans\", () => {\n    const history = [Items.userText(\"hi\"), answered, orphan, answeredOutput]\n    const unanswered = findUnansweredCalls(history)\n    expect(unanswered).toHaveLength(1)\n    expect(unanswered[0]!.call_id).toBe(\"c99\")\n  })\n\n  it(\"isReconciled is false when orphans exist, true otherwise\", () => {\n    const stale = [Items.userText(\"hi\"), orphan]\n    expect(isReconciled(stale)).toBe(false)\n    const reconciled = [...stale, ...cancelAllPending(stale).map(toFunctionCallOutput)]\n    expect(isReconciled(reconciled)).toBe(true)\n  })\n\n  it(\"cancelAllPending synthesizes one Failure(cancelled) per orphan\", () => {\n    const history = [Items.userText(\"hi\"), answered, orphan, answeredOutput]\n    const closures = cancelAllPending(history, \"user moved on\")\n    expect(closures).toHaveLength(1)\n    const c = closures[0]!\n    expect(isFailure(c)).toBe(true)\n    expect(c).toMatchObject({\n      _tag: \"Failure\",\n      call_id: \"c99\",\n      kind: \"cancelled\",\n      reason: \"user moved on\",\n    })\n  })\n\n  it(\"follow-up: map closures to FunctionCallOutput before appending new user message\", () => {\n    const stale = [Items.userText(\"first request\"), orphan]\n    const closures = cancelAllPending(stale, \"user redirected\")\n    const reconciled = [\n      ...stale,\n      ...closures.map(toFunctionCallOutput),\n      Items.userText(\"never mind\"),\n    ]\n    expect(findUnansweredCalls(reconciled)).toHaveLength(0)\n  })\n})\n\n// ---------------------------------------------------------------------------\n// Wire conversion\n// ---------------------------------------------------------------------------\n\ndescribe(\"toFunctionCallOutput\", () => {\n  it(\"round-trips a Value result\", () => {\n    const r: ToolResult = {\n      _tag: \"Value\",\n      call_id: \"c1\",\n      tool: \"web_search\",\n      value: { count: 3 },\n    }\n    const out = toFunctionCallOutput(r)\n    expect(out.call_id).toBe(\"c1\")\n    expect(JSON.parse(out.output)).toEqual({ count: 3 })\n  })\n\n  it(\"round-trips a Failure result with reason\", () => {\n    const r: ToolResult = {\n      _tag: \"Failure\",\n      call_id: \"c2\",\n      tool: \"bulk_email\",\n      kind: \"denied\",\n      reason: \"spam concern\",\n    }\n    const out = toFunctionCallOutput(r)\n    expect(JSON.parse(out.output)).toEqual({ kind: \"denied\", reason: \"spam concern\" })\n  })\n\n  it(\"round-trips a Failure result without reason (omits the field)\", () => {\n    const r: ToolResult = {\n      _tag: \"Failure\",\n      call_id: \"c3\",\n      tool: \"delete_database\",\n      kind: \"cancelled\",\n    }\n    const out = toFunctionCallOutput(r)\n    expect(JSON.parse(out.output)).toEqual({ kind: \"cancelled\" })\n  })\n})\n\n// ---------------------------------------------------------------------------\n// executeAll\n// ---------------------------------------------------------------------------\n\ndescribe(\"executeAll\", () => {\n  it(\"runs all calls passed to it\", async () => {\n    const collected = await Effect.runPromise(Stream.runCollect(executeAll(allTools, calls)))\n    expect(collected.filter(isOutput)).toHaveLength(3)\n    expect(collected.filter(isOutput).every((e) => isValue(e.result))).toBe(true)\n  })\n})\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAuEA,MAAM,WAAW;CArCC,UAAU;EAC1B,MAAM;EACN,aAAa;EACb,aAAa,iBAAiB,OAAO,OAAO,EAAE,OAAO,OAAO,QAAQ,CAAC,CAAC;EACtE,MAAM,EAAE,YACN,OAAO,aAAa;GAClB;IAAE,KAAK;IAAK,OAAO,GAAG,MAAM;IAAK;GACjC;IAAE,KAAK;IAAK,OAAO,GAAG,MAAM;IAAK;GACjC;IAAE,KAAK;IAAK,OAAO,GAAG,MAAM;IAAK;GAClC,CAAC;EACJ,WAAW,UAAU,EAAE,OAAO,KAAK,QAAQ;EAC5C,CA0B0B;CAxBT,UAAU;EAC1B,MAAM;EACN,aAAa;EACb,aAAa,iBACX,OAAO,OAAO;GAAE,YAAY,OAAO,MAAM,OAAO,OAAO;GAAE,SAAS,OAAO;GAAQ,CAAC,CACnF;EACD,MAAM,EAAE,iBACN,OAAO,aACL,WAAW,KAAK,GAAG,OAAO;GACxB,MAAM;GACN,MAAM,IAAI;GACV,OAAO,WAAW;GACnB,EAAE,CACJ;EACH,WAAW,YAAY;GAAE,QAAQ;GAAiB,WAAW,OAAO;GAAQ;EAC7E,CASqC;CAPfA,KAAS;EAC9B,MAAM;EACN,aAAa;EACb,aAAa,iBAAiB,OAAO,OAAO,EAAE,MAAM,OAAO,QAAQ,CAAC,CAAC;EACrE,MAAM,EAAE,WAAW,OAAO,QAAQ;GAAE,QAAQ;GAAW;GAAM,CAAC;EAC/D,CAEqD;CAAC;AACvD,MAAM,YAAY,IAAI,IAAI,CAAC,cAAc,kBAAkB,CAAC;AAC5D,MAAM,eAAe,SAA6B,UAAU,IAAI,KAAK,KAAK;AAE1E,MAAM,MAAM,SAAiB,MAAc,UAAuC;CAChF,MAAM;CACN;CACA;CACA,WAAW,KAAK,UAAU,KAAK;CAChC;AAED,MAAM,QAAQ;CACZ,GAAG,MAAM,cAAc,EAAE,OAAO,UAAU,CAAC;CAC3C,GAAG,MAAM,cAAc;EAAE,YAAY,CAAC,OAAO,MAAM;EAAE,SAAS;EAAM,CAAC;CACrE,GAAG,MAAM,mBAAmB,EAAE,MAAM,QAAQ,CAAC;CAC9C;AAED,MAAM,eAAe,cACnB,UAAU,OAAO,SAAS,CAAC,KAAK,MAAM,EAAE,OAAO;AAEjD,MAAM,YAAY,YAAuC,IAAI,IAAI,QAAQ,KAAK,MAAM,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC;AAEpG,MAAM,yBAAyB,cAAqD;CAClF,MAAM,OAAO,gBAAgB,aAAa,UAAU,CAAC,MAAM;AAC3D,QAAO,OAAO,MAAM,WAAW,UAAU,KAAK,SAAS,EAAE,aAAa,KAAK,SAAS,CAAC;;AAGvF,MAAM,sBAAsB,aAC1B,SAAS,SAAS,aACd,WAAW,UAAU,CAAC,SAAS,KAAK,CAAC,GACrC,OAAO,QAAQ,YAAY,SAAS,OAAO,CAAC;AAMlD,SAAS,sCAAsC;AAC7C,IAAG,mEAAmE,YAAY;EAChF,MAAM,YAAY,IAAI,IAA8B,CAClD,CAAC,MAAM,EAAE,UAAU,WAAW,CAAC,EAC/B,CAAC,MAAM,EAAE,UAAU,WAAW,CAAC,CAChC,CAAC;EACF,MAAM,YAAY,MAAM,OAAO,WAAW,OAAO,WAAW,sBAAsB,UAAU,CAAC,CAAC;EAC9F,MAAM,KAAK,SAAS,YAAY,UAAU,CAAC;AAC3C,eAAO,GAAG,IAAI,KAAK,CAAC,CAAC,cAAc;GAAE,MAAM;GAAS,OAAO,EAAE,OAAO,GAAG;GAAE,CAAC;AAC1E,eAAO,GAAG,IAAI,KAAK,CAAC,CAAC,cAAc;GACjC,MAAM;GACN,OAAO;IAAE,QAAQ;IAAQ,WAAW;IAAG;GACxC,CAAC;AACF,eAAO,GAAG,IAAI,KAAK,CAAC,CAAC,cAAc;GACjC,MAAM;GACN,OAAO;IAAE,QAAQ;IAAW,MAAM;IAAQ;GAC3C,CAAC;AAGF,eAAO,UAAU,OAAO,oBAAoB,CAAC,CAAC,aAAa,EAAE;GAC7D;AAEF,IAAG,wDAAwD,YAAY;EACrE,MAAM,YAAY,IAAI,IAA8B,CAClD,CAAC,MAAM;GAAE,UAAU;GAAQ,QAAQ;GAAgB,CAAC,EACpD,CAAC,MAAM;GAAE,UAAU;GAAQ,QAAQ;GAAkB,CAAC,CACvD,CAAC;EACF,MAAM,YAAY,MAAM,OAAO,WAAW,OAAO,WAAW,sBAAsB,UAAU,CAAC,CAAC;AAG9F,eAAO,UAAU,OAAO,eAAe,CAAC,QAAQ,MAAM,EAAE,SAAS,aAAa,CAAC,CAAC,aAAa,EAAE;EAE/F,MAAM,KAAK,SAAS,YAAY,UAAU,CAAC;AAC3C,eAAO,GAAG,IAAI,KAAK,CAAC,CAAC,cAAc;GACjC,MAAM;GACN,MAAM;GACN,QAAQ;GACT,CAAC;AACF,eAAO,GAAG,IAAI,KAAK,CAAC,CAAC,cAAc;GACjC,MAAM;GACN,MAAM;GACN,QAAQ;GACT,CAAC;GACF;AAEF,IAAG,uDAAuD,YAAY;EAEpE,MAAM,KAAK,SAAS,YAAY,MADR,OAAO,WAAW,OAAO,WAAW,sCAAsB,IAAI,KAAK,CAAC,CAAC,CAAC,CACpD,CAAC;AAC3C,eAAO,GAAG,IAAI,KAAK,CAAC,CAAC,cAAc;GAAE,MAAM;GAAS,OAAO,EAAE,OAAO,GAAG;GAAE,CAAC;AAC1E,eAAO,GAAG,IAAI,KAAK,CAAC,CAAC,cAAc;GAAE,MAAM;GAAW,MAAM;GAAa,CAAC;AAC1E,eAAO,GAAG,IAAI,KAAK,CAAC,CAAC,cAAc;GAAE,MAAM;GAAW,MAAM;GAAa,CAAC;GAC1E;AAEF,IAAG,kDAAkD,YAAY;EAC/D,MAAM,YAAY,IAAI,IAA8B,CAClD,CAAC,MAAM,EAAE,UAAU,WAAW,CAAC,CAEhC,CAAC;EAEF,MAAM,KAAK,SAAS,YAAY,MADR,OAAO,WAAW,OAAO,WAAW,sBAAsB,UAAU,CAAC,CAAC,CACpD,CAAC;AAC3C,eAAO,GAAG,IAAI,KAAK,CAAC,CAAC,cAAc;GAAE,MAAM;GAAS,OAAO,EAAE,OAAO,GAAG;GAAE,CAAC;AAC1E,eAAO,GAAG,IAAI,KAAK,CAAC,CAAC,cAAc;GAAE,MAAM;GAAS,OAAO,EAAE,QAAQ,QAAQ;GAAE,CAAC;AAChF,eAAO,GAAG,IAAI,KAAK,CAAC,CAAC,cAAc;GAAE,MAAM;GAAW,MAAM;GAAa,CAAC;GAC1E;EACF;AAMF,SAAS,0CAA0C;AACjD,IAAG,wEAAwE,YAAY;EACrF,MAAM,iBAAiB;GACrB,GAAG,MAAM,cAAc,EAAE,OAAO,KAAK,CAAC;GACtC,GAAG,MAAM,kBAAkB,EAAE,CAAC;GAC9B,GAAG,MAAM,mBAAmB,EAAE,MAAM,QAAQ,CAAC;GAC9C;EAYD,MAAM,KAAK,SAAS,YAAY,MAXR,OAAO,WAC7B,OAAO,kBACE;GACL,MAAM,OAAO,gBACX,aACA,IAAI,IAAI,CAAC,CAAC,MAAM,EAAE,UAAU,WAAW,CAAC,CAAC,CAAC,CAC3C,CAAC,eAAe;AACjB,UAAO,OAAO,MAAM,WAAW,UAAU,KAAK,SAAS,EAAE,aAAa,KAAK,SAAS,CAAC;MACnF,CACL,CACF,CACyC,CAAC;AAC3C,eAAO,GAAG,IAAI,KAAK,CAAC,CAAC,cAAc,EAAE,MAAM,SAAS,CAAC;AACrD,eAAO,GAAG,IAAI,KAAK,CAAC,CAAC,cAAc;GAAE,MAAM;GAAW,MAAM;GAAgB,CAAC;AAC7E,eAAO,GAAG,IAAI,KAAK,CAAC,CAAC,cAAc;GAAE,MAAM;GAAS,OAAO,EAAE,QAAQ,WAAW;GAAE,CAAC;GACnF;EACF;AAMF,SAAS,uCAAuC;AAC9C,IAAG,gFAAgF,YAAY;EAC7F,MAAM,YAAY,MAAM,OAAO,WAC7B,OAAO,IAAI,aAAa;GACtB,MAAM,WAAW,OAAO,MAAM,WAI1B;AACJ,UAAO,MAAM,MAAM,UAAU;IAAE,SAAS;IAAM,UAAU;IAAW,CAAC;AACpE,UAAO,MAAM,MAAM,UAAU;IAC3B,SAAS;IACT,UAAU;IACV,QAAQ;IACT,CAAC;GAGF,MAAM,SAAS,OAAO,OACpB,OAAO,IAAI,aAAa;IACtB,MAAM,EAAE,UAAU,WAAW,aAAa,OAAO,iBAC/C,aACA,SACD,CAAC,MAAM;AACR,WAAO,OAAO,MACZ,UACA,OAAO,MACL,WAAW,UAAU,SAAS,EAC9B,UAAU,KAAK,OAAO,QAAQ,mBAAmB,CAAC,CACnD,CACF;KACD,CACH;AACD,UAAO,OAAO,OAAO,WAAW,OAAO;IACvC,CACH;AAED,eAAO,UAAU,OAAO,oBAAoB,CAAC,CAAC,aAAa,EAAE;EAE7D,MAAM,KAAK,SAAS,YAAY,UAAU,CAAC;AAC3C,eAAO,GAAG,IAAI,KAAK,CAAC,CAAC,cAAc;GAAE,MAAM;GAAS,OAAO,EAAE,QAAQ,QAAQ;GAAE,CAAC;AAChF,eAAO,GAAG,IAAI,KAAK,CAAC,CAAC,cAAc;GACjC,MAAM;GACN,MAAM;GACN,QAAQ;GACT,CAAC;GACF;EACF;AAMF,SAAS,+DAA+D;CACtE,MAAM,SAAS,GAAG,OAAO,mBAAmB,EAAE,MAAM,QAAQ,CAAC;CAC7D,MAAM,WAAW,GAAG,OAAO,cAAc,EAAE,OAAO,KAAK,CAAC;CACxD,MAAM,iBAAiBC,mBAAyB,OAAO,KAAK,UAAU,EAAE,OAAO,GAAG,CAAC,CAAC;AAEpF,IAAG,kDAAkD;EAEnD,MAAM,aAAa,oBAAoB;GADtBC,SAAe,KAAK;GAAE;GAAU;GAAQ;GACX,CAAC;AAC/C,eAAO,WAAW,CAAC,aAAa,EAAE;AAClC,eAAO,WAAW,GAAI,QAAQ,CAAC,KAAK,MAAM;GAC1C;AAEF,IAAG,kEAAkE;EACnE,MAAM,QAAQ,CAACA,SAAe,KAAK,EAAE,OAAO;AAC5C,eAAO,aAAa,MAAM,CAAC,CAAC,KAAK,MAAM;AAEvC,eAAO,aAAa,CADA,GAAG,OAAO,GAAG,iBAAiB,MAAM,CAAC,IAAI,qBAAqB,CACpD,CAAC,CAAC,CAAC,KAAK,KAAK;GAC3C;AAEF,IAAG,wEAAwE;EAEzE,MAAM,WAAW,iBAAiB;GADjBA,SAAe,KAAK;GAAE;GAAU;GAAQ;GAChB,EAAE,gBAAgB;AAC3D,eAAO,SAAS,CAAC,aAAa,EAAE;EAChC,MAAM,IAAI,SAAS;AACnB,eAAO,UAAU,EAAE,CAAC,CAAC,KAAK,KAAK;AAC/B,eAAO,EAAE,CAAC,cAAc;GACtB,MAAM;GACN,SAAS;GACT,MAAM;GACN,QAAQ;GACT,CAAC;GACF;AAEF,IAAG,yFAAyF;EAC1F,MAAM,QAAQ,CAACA,SAAe,gBAAgB,EAAE,OAAO;EACvD,MAAM,WAAW,iBAAiB,OAAO,kBAAkB;AAM3D,eAAO,oBAAoB;GAJzB,GAAG;GACH,GAAG,SAAS,IAAI,qBAAqB;GACrCA,SAAe,aAAa;GAEO,CAAC,CAAC,CAAC,aAAa,EAAE;GACvD;EACF;AAMF,SAAS,8BAA8B;AACrC,IAAG,oCAAoC;EAOrC,MAAM,MAAM,qBAAqB;GAL/B,MAAM;GACN,SAAS;GACT,MAAM;GACN,OAAO,EAAE,OAAO,GAAG;GAEa,CAAC;AACnC,eAAO,IAAI,QAAQ,CAAC,KAAK,KAAK;AAC9B,eAAO,KAAK,MAAM,IAAI,OAAO,CAAC,CAAC,QAAQ,EAAE,OAAO,GAAG,CAAC;GACpD;AAEF,IAAG,kDAAkD;EAQnD,MAAM,MAAM,qBAAqB;GAN/B,MAAM;GACN,SAAS;GACT,MAAM;GACN,MAAM;GACN,QAAQ;GAEwB,CAAC;AACnC,eAAO,KAAK,MAAM,IAAI,OAAO,CAAC,CAAC,QAAQ;GAAE,MAAM;GAAU,QAAQ;GAAgB,CAAC;GAClF;AAEF,IAAG,uEAAuE;EAOxE,MAAM,MAAM,qBAAqB;GAL/B,MAAM;GACN,SAAS;GACT,MAAM;GACN,MAAM;GAE0B,CAAC;AACnC,eAAO,KAAK,MAAM,IAAI,OAAO,CAAC,CAAC,QAAQ,EAAE,MAAM,aAAa,CAAC;GAC7D;EACF;AAMF,SAAS,oBAAoB;AAC3B,IAAG,+BAA+B,YAAY;EAC5C,MAAM,YAAY,MAAM,OAAO,WAAW,OAAO,WAAW,WAAW,UAAU,MAAM,CAAC,CAAC;AACzF,eAAO,UAAU,OAAO,SAAS,CAAC,CAAC,aAAa,EAAE;AAClD,eAAO,UAAU,OAAO,SAAS,CAAC,OAAO,MAAM,QAAQ,EAAE,OAAO,CAAC,CAAC,CAAC,KAAK,KAAK;GAC7E;EACF"}

package/dist/tool/Tool.d.mts

@@ -1,2 +1,2 @@
-import { a as Tool, c as ToolInputSchema, d as fromEffectSchema, f as isStreamingTool, h as toDescriptors, i as StreamingTool, m as streaming, n as AnyPlainTool, o as ToolDescriptor, p as make, r as AnyStreamingTool, s as ToolError, t as AnyKindTool, u as execute } from "../Tool-5wxOCuOh.mjs";
+import { a as Tool, c as ToolInputSchema, d as fromEffectSchema, f as isStreamingTool, h as toDescriptors, i as StreamingTool, m as streaming, n as AnyPlainTool, o as ToolDescriptor, p as make, r as AnyStreamingTool, s as ToolError, t as AnyKindTool, u as execute } from "../Tool-B8B5qVEy.mjs";
 export { AnyKindTool, AnyPlainTool, AnyStreamingTool, StreamingTool, Tool, ToolDescriptor, ToolError, ToolInputSchema, execute, fromEffectSchema, isStreamingTool, make, streaming, toDescriptors };

package/dist/tool/Tool.mjs

@@ -1,4 +1,4 @@
-import { t as __exportAll } from "../chunk-CfYAbeIz.mjs";
+import { n as __exportAll } from "../chunk-uyGKjUfl.mjs";
 import { functionCallOutput } from "../domain/Items.mjs";
 import { Effect, Schema } from "effect";
 //#region src/tool/Tool.ts

package/dist/tool/Tool.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"Tool.mjs","names":[],"sources":["../../src/tool/Tool.ts"],"sourcesContent":["import type { StandardJSONSchemaV1, StandardSchemaV1 } from \"@standard-schema/spec\"\nimport { Effect, Schema, Stream } from \"effect\"\nimport type { FunctionCall, FunctionCallOutput } from \"../domain/Items.js\"\nimport { functionCallOutput } from \"../domain/Items.js\"\n\nexport class ToolError extends Schema.TaggedErrorClass<ToolError>(\"@betalyra/effect-uai/ToolError\")(\n  \"ToolError\",\n  {\n    call_id: Schema.String,\n    tool: Schema.String,\n    message: Schema.String,\n    cause: Schema.optional(Schema.Unknown),\n  },\n) {}\n\n/**\n * Schemas accepted on `Tool.inputSchema`. Must implement both Standard\n * Schema validation and JSON Schema conversion (for rendering tool\n * descriptors to provider request bodies).\n *\n * Any Standard-Schema-compliant library that exposes both interfaces\n * works directly: Zod 4+, Valibot, ArkType, Effect Schema (after\n * `fromEffectSchema`), etc.\n */\nexport type ToolInputSchema<Input = unknown> = StandardSchemaV1<unknown, Input> &\n  StandardJSONSchemaV1<unknown, Input>\n\n/**\n * Convenience wrapper for Effect Schema users - adds both the\n * `validate` and `jsonSchema` extensions to a plain Effect Schema so it\n * can be used as a `Tool.inputSchema`.\n */\nexport const fromEffectSchema = <S extends Schema.Codec<any, any, never, any>>(\n  schema: S,\n): S & ToolInputSchema<S[\"Type\"]> =>\n  Schema.toStandardJSONSchemaV1(Schema.toStandardSchemaV1(schema)) as unknown as S &\n    ToolInputSchema<S[\"Type\"]>\n\nexport interface Tool<Name extends string, Input, Output, R = never> {\n  readonly name: Name\n  readonly description: string\n  readonly inputSchema: ToolInputSchema<Input>\n  readonly run: (input: Input) => Effect.Effect<Output, unknown, R>\n  /**\n   * Whether the provider should render this tool with its strict-mode\n   * flag (OpenAI's `strict: true`, etc). Default: true. The framework\n   * never rewrites the schema; if the rendered JSON Schema isn't\n   * compatible, the provider returns an error.\n   */\n  readonly strict?: boolean\n}\n\n/**\n * Provider-agnostic tool descriptor. Each provider maps `inputSchema`\n * to its own wire field (OpenAI → `parameters`, Anthropic →\n * `input_schema`). Built from a `Tool` by `Toolkit.toDescriptors`.\n */\nexport interface ToolDescriptor {\n  readonly name: string\n  readonly description: string\n  readonly inputSchema: Record<string, unknown>\n  readonly strict?: boolean\n}\n\nexport const make = <Name extends string, Input, Output, R = never>(\n  spec: Tool<Name, Input, Output, R>,\n): Tool<Name, Input, Output, R> => spec\n\n// ---------------------------------------------------------------------------\n// Streaming tools\n//\n// `run` returns a `Stream<Event>` instead of an `Effect<Output>`. Events\n// flow through to the consumer as `ToolEvent.Intermediate`s in real time;\n// at end-of-stream `finalize(events)` reduces them to the model-facing\n// `Output`. Sub-agents, slow downloads with progress, recipe streamers.\n// ---------------------------------------------------------------------------\n\nexport interface StreamingTool<Name extends string, Input, Event, Output, R = never> {\n  readonly _kind: \"streaming\"\n  readonly name: Name\n  readonly description: string\n  readonly inputSchema: ToolInputSchema<Input>\n  readonly run: (input: Input) => Stream.Stream<Event, unknown, R>\n  readonly finalize: (events: ReadonlyArray<Event>) => Output\n  readonly strict?: boolean\n}\n\nexport const streaming = <Name extends string, Input, Event, Output, R = never>(\n  spec: Omit<StreamingTool<Name, Input, Event, Output, R>, \"_kind\">,\n): StreamingTool<Name, Input, Event, Output, R> => ({ _kind: \"streaming\", ...spec })\n\nexport type AnyStreamingTool = StreamingTool<string, any, any, any, never>\nexport type AnyPlainTool = Tool<string, any, any, never>\nexport type AnyKindTool = AnyStreamingTool | AnyPlainTool\n\nexport const isStreamingTool = (t: AnyKindTool): t is AnyStreamingTool =>\n  \"_kind\" in t && t._kind === \"streaming\"\n\n/**\n * Render any-kind tools (mixed plain and streaming) to provider-agnostic\n * descriptors. Mirrors `Toolkit.toDescriptors` but accepts the union type\n * so a single list can carry both kinds.\n */\nexport const toDescriptors = (\n  tools: ReadonlyArray<AnyKindTool>,\n): ReadonlyArray<ToolDescriptor> =>\n  tools.map((tool) => {\n    const inputSchema = tool.inputSchema[\"~standard\"].jsonSchema.input({\n      target: \"draft-2020-12\",\n    })\n    return tool.strict !== undefined\n      ? { name: tool.name, description: tool.description, inputSchema, strict: tool.strict }\n      : { name: tool.name, description: tool.description, inputSchema }\n  })\n\nconst toToolError = (call: FunctionCall, toolName: string, message: string) => (cause: unknown) =>\n  new ToolError({ call_id: call.call_id, tool: toolName, message, cause })\n\n/**\n * Decode and validate the JSON arguments of a function_call against the\n * tool's input schema, run the tool, and serialize the output into a\n * function_call_output item.\n */\nexport const execute = <Name extends string, Input, Output, R>(\n  tool: Tool<Name, Input, Output, R>,\n  call: FunctionCall,\n): Effect.Effect<FunctionCallOutput, ToolError, R> =>\n  Effect.gen(function* () {\n    const parsed = yield* Effect.try({\n      try: () => JSON.parse(call.arguments) as unknown,\n      catch: toToolError(call, tool.name, \"Failed to parse JSON arguments\"),\n    })\n\n    const result = yield* Effect.promise(() =>\n      Promise.resolve(tool.inputSchema[\"~standard\"].validate(parsed)),\n    )\n    if (result.issues !== undefined) {\n      return yield* new ToolError({\n        call_id: call.call_id,\n        tool: tool.name,\n        message: \"Tool input failed schema validation\",\n        cause: result.issues,\n      })\n    }\n\n    const output = yield* tool\n      .run(result.value)\n      .pipe(Effect.mapError(toToolError(call, tool.name, \"Tool execution failed\")))\n    return functionCallOutput(call.call_id, JSON.stringify(output))\n  })\n"],"mappings":";;;;;;;;;;;;;AAKA,IAAa,YAAb,cAA+B,OAAO,iBAA4B,iCAAiC,CACjG,aACA;CACE,SAAS,OAAO;CAChB,MAAM,OAAO;CACb,SAAS,OAAO;CAChB,OAAO,OAAO,SAAS,OAAO,QAAQ;CACvC,CACF,CAAC;;;;;;AAmBF,MAAa,oBACX,WAEA,OAAO,uBAAuB,OAAO,mBAAmB,OAAO,CAAC;AA6BlE,MAAa,QACX,SACiC;AAqBnC,MAAa,aACX,UACkD;CAAE,OAAO;CAAa,GAAG;CAAM;AAMnF,MAAa,mBAAmB,MAC9B,WAAW,KAAK,EAAE,UAAU;;;;;;AAO9B,MAAa,iBACX,UAEA,MAAM,KAAK,SAAS;CAClB,MAAM,cAAc,KAAK,YAAY,aAAa,WAAW,MAAM,EACjE,QAAQ,iBACT,CAAC;AACF,QAAO,KAAK,WAAW,KAAA,IACnB;EAAE,MAAM,KAAK;EAAM,aAAa,KAAK;EAAa;EAAa,QAAQ,KAAK;EAAQ,GACpF;EAAE,MAAM,KAAK;EAAM,aAAa,KAAK;EAAa;EAAa;EACnE;AAEJ,MAAM,eAAe,MAAoB,UAAkB,aAAqB,UAC9E,IAAI,UAAU;CAAE,SAAS,KAAK;CAAS,MAAM;CAAU;CAAS;CAAO,CAAC;;;;;;AAO1E,MAAa,WACX,MACA,SAEA,OAAO,IAAI,aAAa;CACtB,MAAM,SAAS,OAAO,OAAO,IAAI;EAC/B,WAAW,KAAK,MAAM,KAAK,UAAU;EACrC,OAAO,YAAY,MAAM,KAAK,MAAM,iCAAiC;EACtE,CAAC;CAEF,MAAM,SAAS,OAAO,OAAO,cAC3B,QAAQ,QAAQ,KAAK,YAAY,aAAa,SAAS,OAAO,CAAC,CAChE;AACD,KAAI,OAAO,WAAW,KAAA,EACpB,QAAO,OAAO,IAAI,UAAU;EAC1B,SAAS,KAAK;EACd,MAAM,KAAK;EACX,SAAS;EACT,OAAO,OAAO;EACf,CAAC;CAGJ,MAAM,SAAS,OAAO,KACnB,IAAI,OAAO,MAAM,CACjB,KAAK,OAAO,SAAS,YAAY,MAAM,KAAK,MAAM,wBAAwB,CAAC,CAAC;AAC/E,QAAO,mBAAmB,KAAK,SAAS,KAAK,UAAU,OAAO,CAAC;EAC/D"}
+{"version":3,"file":"Tool.mjs","names":[],"sources":["../../src/tool/Tool.ts"],"sourcesContent":["import type { StandardJSONSchemaV1, StandardSchemaV1 } from \"@standard-schema/spec\"\nimport { Effect, Schema, Stream } from \"effect\"\nimport type { FunctionCall, FunctionCallOutput } from \"../domain/Items.js\"\nimport { functionCallOutput } from \"../domain/Items.js\"\n\nexport class ToolError extends Schema.TaggedErrorClass<ToolError>(\"@betalyra/effect-uai/ToolError\")(\n  \"ToolError\",\n  {\n    call_id: Schema.String,\n    tool: Schema.String,\n    message: Schema.String,\n    cause: Schema.optional(Schema.Unknown),\n  },\n) {}\n\n/**\n * Schemas accepted on `Tool.inputSchema`. Must implement both Standard\n * Schema validation and JSON Schema conversion (for rendering tool\n * descriptors to provider request bodies).\n *\n * Any Standard-Schema-compliant library that exposes both interfaces\n * works directly: Zod 4+, Valibot, ArkType, Effect Schema (after\n * `fromEffectSchema`), etc.\n */\nexport type ToolInputSchema<Input = unknown> = StandardSchemaV1<unknown, Input> &\n  StandardJSONSchemaV1<unknown, Input>\n\n/**\n * Convenience wrapper for Effect Schema users - adds both the\n * `validate` and `jsonSchema` extensions to a plain Effect Schema so it\n * can be used as a `Tool.inputSchema`.\n */\nexport const fromEffectSchema = <S extends Schema.Codec<any, any, never, any>>(\n  schema: S,\n): S & ToolInputSchema<S[\"Type\"]> =>\n  Schema.toStandardJSONSchemaV1(Schema.toStandardSchemaV1(schema)) as unknown as S &\n    ToolInputSchema<S[\"Type\"]>\n\nexport type Tool<Name extends string, Input, Output, R = never> = {\n  readonly name: Name\n  readonly description: string\n  readonly inputSchema: ToolInputSchema<Input>\n  readonly run: (input: Input) => Effect.Effect<Output, unknown, R>\n  /**\n   * Whether the provider should render this tool with its strict-mode\n   * flag (OpenAI's `strict: true`, etc). Default: true. The framework\n   * never rewrites the schema; if the rendered JSON Schema isn't\n   * compatible, the provider returns an error.\n   */\n  readonly strict?: boolean\n}\n\n/**\n * Provider-agnostic tool descriptor. Each provider maps `inputSchema`\n * to its own wire field (OpenAI → `parameters`, Anthropic →\n * `input_schema`). Built from a `Tool` by `Toolkit.toDescriptors`.\n */\nexport type ToolDescriptor = {\n  readonly name: string\n  readonly description: string\n  readonly inputSchema: Record<string, unknown>\n  readonly strict?: boolean\n}\n\nexport const make = <Name extends string, Input, Output, R = never>(\n  spec: Tool<Name, Input, Output, R>,\n): Tool<Name, Input, Output, R> => spec\n\n// ---------------------------------------------------------------------------\n// Streaming tools\n//\n// `run` returns a `Stream<Event>` instead of an `Effect<Output>`. Events\n// flow through to the consumer as `ToolEvent.Intermediate`s in real time;\n// at end-of-stream `finalize(events)` reduces them to the model-facing\n// `Output`. Sub-agents, slow downloads with progress, recipe streamers.\n// ---------------------------------------------------------------------------\n\nexport type StreamingTool<Name extends string, Input, Event, Output, R = never> = {\n  readonly _kind: \"streaming\"\n  readonly name: Name\n  readonly description: string\n  readonly inputSchema: ToolInputSchema<Input>\n  readonly run: (input: Input) => Stream.Stream<Event, unknown, R>\n  readonly finalize: (events: ReadonlyArray<Event>) => Output\n  readonly strict?: boolean\n}\n\nexport const streaming = <Name extends string, Input, Event, Output, R = never>(\n  spec: Omit<StreamingTool<Name, Input, Event, Output, R>, \"_kind\">,\n): StreamingTool<Name, Input, Event, Output, R> => ({ _kind: \"streaming\", ...spec })\n\nexport type AnyStreamingTool<R = any> = StreamingTool<string, any, any, any, R>\nexport type AnyPlainTool<R = any> = Tool<string, any, any, R>\nexport type AnyKindTool<R = any> = AnyStreamingTool<R> | AnyPlainTool<R>\n\nexport const isStreamingTool = <R>(t: AnyKindTool<R>): t is AnyStreamingTool<R> =>\n  \"_kind\" in t && t._kind === \"streaming\"\n\n/**\n * Render any-kind tools (mixed plain and streaming) to provider-agnostic\n * descriptors. Mirrors `Toolkit.toDescriptors` but accepts the union type\n * so a single list can carry both kinds.\n */\nexport const toDescriptors = <R>(\n  tools: ReadonlyArray<AnyKindTool<R>>,\n): ReadonlyArray<ToolDescriptor> =>\n  tools.map((tool) => {\n    const inputSchema = tool.inputSchema[\"~standard\"].jsonSchema.input({\n      target: \"draft-2020-12\",\n    })\n    return tool.strict !== undefined\n      ? { name: tool.name, description: tool.description, inputSchema, strict: tool.strict }\n      : { name: tool.name, description: tool.description, inputSchema }\n  })\n\nconst toToolError = (call: FunctionCall, toolName: string, message: string) => (cause: unknown) =>\n  new ToolError({ call_id: call.call_id, tool: toolName, message, cause })\n\n/**\n * Decode and validate the JSON arguments of a function_call against the\n * tool's input schema, run the tool, and serialize the output into a\n * function_call_output item.\n */\nexport const execute = <Name extends string, Input, Output, R>(\n  tool: Tool<Name, Input, Output, R>,\n  call: FunctionCall,\n): Effect.Effect<FunctionCallOutput, ToolError, R> =>\n  Effect.gen(function* () {\n    const parsed = yield* Effect.try({\n      try: () => JSON.parse(call.arguments) as unknown,\n      catch: toToolError(call, tool.name, \"Failed to parse JSON arguments\"),\n    })\n\n    const result = yield* Effect.promise(() =>\n      Promise.resolve(tool.inputSchema[\"~standard\"].validate(parsed)),\n    )\n    if (result.issues !== undefined) {\n      return yield* new ToolError({\n        call_id: call.call_id,\n        tool: tool.name,\n        message: \"Tool input failed schema validation\",\n        cause: result.issues,\n      })\n    }\n\n    const output = yield* tool\n      .run(result.value)\n      .pipe(Effect.mapError(toToolError(call, tool.name, \"Tool execution failed\")))\n    return functionCallOutput(call.call_id, JSON.stringify(output))\n  })\n"],"mappings":";;;;;;;;;;;;;AAKA,IAAa,YAAb,cAA+B,OAAO,iBAA4B,iCAAiC,CACjG,aACA;CACE,SAAS,OAAO;CAChB,MAAM,OAAO;CACb,SAAS,OAAO;CAChB,OAAO,OAAO,SAAS,OAAO,QAAQ;CACvC,CACF,CAAC;;;;;;AAmBF,MAAa,oBACX,WAEA,OAAO,uBAAuB,OAAO,mBAAmB,OAAO,CAAC;AA6BlE,MAAa,QACX,SACiC;AAqBnC,MAAa,aACX,UACkD;CAAE,OAAO;CAAa,GAAG;CAAM;AAMnF,MAAa,mBAAsB,MACjC,WAAW,KAAK,EAAE,UAAU;;;;;;AAO9B,MAAa,iBACX,UAEA,MAAM,KAAK,SAAS;CAClB,MAAM,cAAc,KAAK,YAAY,aAAa,WAAW,MAAM,EACjE,QAAQ,iBACT,CAAC;AACF,QAAO,KAAK,WAAW,KAAA,IACnB;EAAE,MAAM,KAAK;EAAM,aAAa,KAAK;EAAa;EAAa,QAAQ,KAAK;EAAQ,GACpF;EAAE,MAAM,KAAK;EAAM,aAAa,KAAK;EAAa;EAAa;EACnE;AAEJ,MAAM,eAAe,MAAoB,UAAkB,aAAqB,UAC9E,IAAI,UAAU;CAAE,SAAS,KAAK;CAAS,MAAM;CAAU;CAAS;CAAO,CAAC;;;;;;AAO1E,MAAa,WACX,MACA,SAEA,OAAO,IAAI,aAAa;CACtB,MAAM,SAAS,OAAO,OAAO,IAAI;EAC/B,WAAW,KAAK,MAAM,KAAK,UAAU;EACrC,OAAO,YAAY,MAAM,KAAK,MAAM,iCAAiC;EACtE,CAAC;CAEF,MAAM,SAAS,OAAO,OAAO,cAC3B,QAAQ,QAAQ,KAAK,YAAY,aAAa,SAAS,OAAO,CAAC,CAChE;AACD,KAAI,OAAO,WAAW,KAAA,EACpB,QAAO,OAAO,IAAI,UAAU;EAC1B,SAAS,KAAK;EACd,MAAM,KAAK;EACX,SAAS;EACT,OAAO,OAAO;EACf,CAAC;CAGJ,MAAM,SAAS,OAAO,KACnB,IAAI,OAAO,MAAM,CACjB,KAAK,OAAO,SAAS,YAAY,MAAM,KAAK,MAAM,wBAAwB,CAAC,CAAC;AAC/E,QAAO,mBAAmB,KAAK,SAAS,KAAK,UAAU,OAAO,CAAC;EAC/D"}

package/dist/tool/ToolEvent.d.mts

@@ -1,2 +1,151 @@
-import { i as isOutput, n as isApprovalRequested, r as isIntermediate, t as ToolEvent } from "../ToolEvent-wTMgb2GO.mjs";
-export { ToolEvent, isApprovalRequested, isIntermediate, isOutput };
+import { ToolResult } from "./Outcome.mjs";
+import { Data } from "effect";
+import * as _$effect_Unify0 from "effect/Unify";
+
+//#region src/tool/ToolEvent.d.ts
+declare namespace ToolEvent_d_exports {
+  export { ToolEvent, isApprovalRequested, isIntermediate, isOutput };
+}
+type ToolEvent = Data.TaggedEnum<{
+  ApprovalRequested: {
+    readonly call_id: string;
+    readonly tool: string;
+    readonly arguments: string;
+  };
+  Intermediate: {
+    readonly call_id: string;
+    readonly tool: string;
+    readonly data: unknown;
+  };
+  Output: {
+    readonly result: ToolResult;
+  };
+}>;
+/**
+ * Namespace of constructors, type guards, and matchers for `ToolEvent`,
+ * provided by `Data.taggedEnum`. Use `ToolEvent.Output({ result })` to build
+ * an event, `ToolEvent.$is("Output")` for type narrowing,
+ * `ToolEvent.$match({ ApprovalRequested, Intermediate, Output })` for
+ * exhaustive pattern matching.
+ */
+declare const ToolEvent: {
+  readonly ApprovalRequested: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "ApprovalRequested";
+    readonly call_id: string;
+    readonly tool: string;
+    readonly arguments: string;
+  }, "_tag">;
+  readonly Intermediate: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Intermediate";
+    readonly call_id: string;
+    readonly tool: string;
+    readonly data: unknown;
+  }, "_tag">;
+  readonly Output: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Output";
+    readonly result: ToolResult;
+  }, "_tag">;
+  readonly $is: <Tag extends "ApprovalRequested" | "Intermediate" | "Output">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "ApprovalRequested";
+    readonly call_id: string;
+    readonly tool: string;
+    readonly arguments: string;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Intermediate";
+    readonly call_id: string;
+    readonly tool: string;
+    readonly data: unknown;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Output";
+    readonly result: ToolResult;
+  }, {
+    readonly _tag: Tag;
+  }>;
+  readonly $match: {
+    <Cases extends {
+      readonly ApprovalRequested: (args: {
+        readonly _tag: "ApprovalRequested";
+        readonly call_id: string;
+        readonly tool: string;
+        readonly arguments: string;
+      }) => any;
+      readonly Intermediate: (args: {
+        readonly _tag: "Intermediate";
+        readonly call_id: string;
+        readonly tool: string;
+        readonly data: unknown;
+      }) => any;
+      readonly Output: (args: {
+        readonly _tag: "Output";
+        readonly result: ToolResult;
+      }) => any;
+    }>(cases: Cases): (value: {
+      readonly _tag: "ApprovalRequested";
+      readonly call_id: string;
+      readonly tool: string;
+      readonly arguments: string;
+    } | {
+      readonly _tag: "Intermediate";
+      readonly call_id: string;
+      readonly tool: string;
+      readonly data: unknown;
+    } | {
+      readonly _tag: "Output";
+      readonly result: ToolResult;
+    }) => _$effect_Unify0.Unify<ReturnType<Cases["ApprovalRequested" | "Intermediate" | "Output"]>>;
+    <Cases extends {
+      readonly ApprovalRequested: (args: {
+        readonly _tag: "ApprovalRequested";
+        readonly call_id: string;
+        readonly tool: string;
+        readonly arguments: string;
+      }) => any;
+      readonly Intermediate: (args: {
+        readonly _tag: "Intermediate";
+        readonly call_id: string;
+        readonly tool: string;
+        readonly data: unknown;
+      }) => any;
+      readonly Output: (args: {
+        readonly _tag: "Output";
+        readonly result: ToolResult;
+      }) => any;
+    }>(value: {
+      readonly _tag: "ApprovalRequested";
+      readonly call_id: string;
+      readonly tool: string;
+      readonly arguments: string;
+    } | {
+      readonly _tag: "Intermediate";
+      readonly call_id: string;
+      readonly tool: string;
+      readonly data: unknown;
+    } | {
+      readonly _tag: "Output";
+      readonly result: ToolResult;
+    }, cases: Cases): _$effect_Unify0.Unify<ReturnType<Cases["ApprovalRequested" | "Intermediate" | "Output"]>>;
+  };
+};
+declare const isApprovalRequested: (u: unknown) => u is {
+  readonly _tag: "ApprovalRequested";
+  readonly call_id: string;
+  readonly tool: string;
+  readonly arguments: string;
+};
+declare const isIntermediate: (u: unknown) => u is {
+  readonly _tag: "Intermediate";
+  readonly call_id: string;
+  readonly tool: string;
+  readonly data: unknown;
+};
+declare const isOutput: (u: unknown) => u is {
+  readonly _tag: "Output";
+  readonly result: ToolResult;
+};
+//#endregion
+export { ToolEvent, isApprovalRequested, isIntermediate, isOutput, ToolEvent_d_exports as t };
+//# sourceMappingURL=ToolEvent.d.mts.map

package/dist/tool/ToolEvent.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ToolEvent.d.mts","names":[],"sources":["../../src/tool/ToolEvent.ts"],"mappings":";;;;;;;;KAaY,SAAA,GAAY,IAAA,CAAK,UAAA;EAC3B,iBAAA;IAAA,SACW,OAAA;IAAA,SACA,IAAA;IAAA,SACA,SAAA;EAAA;EAEX,YAAA;IAAA,SACW,OAAA;IAAA,SACA,IAAA;IAAA,SACA,IAAA;EAAA;EAEX,MAAA;IAAA,SACW,MAAA,EAAQ,UAAA;EAAA;AAAA;;;;;AAWrB;;;cAAa,SAAA;EAAA;;;;;;;;;;;;;;qBAXQ,UAAA;EAAA;EAAA;;;;;;;;;;;;;;;;qBAAA,UAAA;EAAA;IAAA;;;;;;;;;;;;;;;;;;yBAAA,UAAA;MAAA;IAAA;;;;;;;;;;;;uBAAA,UAAA;IAAA;;;;;;;;;;;;;;;;yBAAA,UAAA;MAAA;IAAA;;;;;;;;;;;;uBAAA,UAAA;IAAA;;;cAaR,mBAAA,GAAmB,CAAA,cAAA,CAAA;EAAA;;;;;cACnB,cAAA,GAAc,CAAA,cAAA,CAAA;EAAA;;;;;cACd,QAAA,GAAQ,CAAA,cAAA,CAAA;EAAA;mBAfA,UAAA;AAAA"}

package/dist/tool/ToolEvent.mjs

@@ -1,8 +1,34 @@
+import { n as __exportAll } from "../chunk-uyGKjUfl.mjs";
+import { Data } from "effect";
 //#region src/tool/ToolEvent.ts
-const isApprovalRequested = (e) => e._tag === "ApprovalRequested";
-const isIntermediate = (e) => e._tag === "Intermediate";
-const isOutput = (e) => e._tag === "Output";
+/**
+* The event type emitted while handling tool calls.
+*
+*   - ApprovalRequested : gated calls waiting for approval
+*   - Intermediate      : per-element passthrough from a streaming tool's run
+*   - Output            : terminal result (carries a structured ToolResult)
+*
+* Recipes thread `ToolEvent.Output.result` through `continueWith` and apply
+* `toFunctionCallOutput` when appending to history.
+*/
+var ToolEvent_exports = /* @__PURE__ */ __exportAll({
+	ToolEvent: () => ToolEvent,
+	isApprovalRequested: () => isApprovalRequested,
+	isIntermediate: () => isIntermediate,
+	isOutput: () => isOutput
+});
+/**
+* Namespace of constructors, type guards, and matchers for `ToolEvent`,
+* provided by `Data.taggedEnum`. Use `ToolEvent.Output({ result })` to build
+* an event, `ToolEvent.$is("Output")` for type narrowing,
+* `ToolEvent.$match({ ApprovalRequested, Intermediate, Output })` for
+* exhaustive pattern matching.
+*/
+const ToolEvent = Data.taggedEnum();
+const isApprovalRequested = ToolEvent.$is("ApprovalRequested");
+const isIntermediate = ToolEvent.$is("Intermediate");
+const isOutput = ToolEvent.$is("Output");
 //#endregion
-export { isApprovalRequested, isIntermediate, isOutput };
+export { ToolEvent, isApprovalRequested, isIntermediate, isOutput, ToolEvent_exports as t };
 
 //# sourceMappingURL=ToolEvent.mjs.map