@effect-uai/core 0.8.0 → 0.10.0

package/dist/tool/Toolkit.test.mjs

@@ -1,11 +1,20 @@
-import { fromEffectSchema, make, toDescriptors } from "./Tool.mjs";
-import { isOk } from "./ToolResult.mjs";
-import { isOutput } from "./ToolEvent.mjs";
-import { run } from "./Toolkit.mjs";
-import { i as it, n as globalExpect, r as describe, t as import_dist } from "../dist-DV5ISja1.mjs";
-import { Context, Effect, Layer, Schema, Stream } from "effect";
+import { RateLimited, describe } from "../domain/AiError.mjs";
+import { isFailure, isOk, toToolCallOutput } from "./ToolResult.mjs";
+import { fail, fromEffectSchema, make, provider, signal, toDescriptors } from "./Tool.mjs";
+import { isOutput, isProgress } from "./ToolEvent.mjs";
+import { compose, describeFailures, fromArray, make as make$1, namespace, run, wrap } from "./Toolkit.mjs";
+import { a as describe$1, n as globalExpect, o as it, t as import_dist } from "../dist-B04dlFHg.mjs";
+import { Context, Effect, Layer, Schema, Stream, pipe } from "effect";
 //#region src/tool/Toolkit.test.ts
-describe("Tool.toDescriptors", () => {
+const Empty = Schema.Struct({});
+const toolCall = (name, id, args = "{}") => ({
+	type: "function_call",
+	call_id: id,
+	name,
+	arguments: args
+});
+const runToArray = (toolkit, calls, options) => run(toolkit, calls, options).pipe(Stream.runCollect, Effect.map((events) => Array.from(events)));
+describe$1("Tool.toDescriptors", () => {
 	const GetWeatherInput = Schema.Struct({ city: Schema.String });
 	const getWeather = make({
 		name: "get_weather",
@@ -43,7 +52,7 @@ describe("Tool.toDescriptors", () => {
 		globalExpect(l).not.toHaveProperty("strict");
 	});
 });
-describe("Toolkit.run - tools with R requirements", () => {
+describe$1("Toolkit.run - tools with R requirements", () => {
 	class WeatherApiKey extends Context.Service()("test/WeatherApiKey") {}
 	class GeoApiKey extends Context.Service()("test/GeoApiKey") {}
 	const Empty = Schema.Struct({});
@@ -78,11 +87,11 @@ describe("Toolkit.run - tools with R requirements", () => {
 		arguments: "{}"
 	});
 	it("propagates each tool's R into the resulting Stream's requirements", () => {
-		(0, import_dist.expectTypeOf)(run([getWeather, getCoords], [])).toEqualTypeOf();
+		(0, import_dist.expectTypeOf)(run(make$1(getWeather, getCoords), [])).toEqualTypeOf();
 	});
 	it("runs each tool with its own service injected", async () => {
 		const layer = Layer.mergeAll(Layer.succeed(WeatherApiKey, { key: "weather-123" }), Layer.succeed(GeoApiKey, { key: "geo-456" }));
-		const program = run([getWeather, getCoords], [call("get_weather", "c1"), call("get_coords", "c2")]).pipe(Stream.runCollect, Effect.provide(layer));
+		const program = run(make$1(getWeather, getCoords), [call("get_weather", "c1"), call("get_coords", "c2")]).pipe(Stream.runCollect, Effect.provide(layer));
 		const events = await Effect.runPromise(program);
 		const outputs = Array.from(events).filter(isOutput);
 		const byCall = new Map(outputs.map((e) => [e.result.call_id, e.result]));
@@ -97,6 +106,31 @@ describe("Toolkit.run - tools with R requirements", () => {
 			key: "geo-456"
 		});
 	});
+	it("reports non-local kinds as non_local_tool while local calls in the same turn still run", async () => {
+		const escalate = signal({
+			name: "escalate",
+			description: "",
+			inputSchema: fromEffectSchema(Empty)
+		});
+		const localPlain = make({
+			name: "plain",
+			description: "",
+			inputSchema: fromEffectSchema(Empty),
+			run: () => Effect.succeed({ ok: true })
+		});
+		const events = await Effect.runPromise(run(make$1(localPlain, escalate), [
+			call("escalate", "s1"),
+			call("plain", "p1"),
+			call("ghost", "g1")
+		]).pipe(Stream.runCollect));
+		const byCall = new Map(Array.from(events).filter(isOutput).map((e) => [e.result.call_id, e.result]));
+		const s = byCall.get("s1");
+		globalExpect(s?._tag === "Failure" && s.kind).toBe("non_local_tool");
+		const g = byCall.get("g1");
+		globalExpect(g?._tag === "Failure" && g.kind).toBe("unknown_tool");
+		const p = byCall.get("p1");
+		globalExpect(p !== void 0 && isOk(p) && p.value).toEqual({ ok: true });
+	});
 	it("with no service-needing tools, R is never", () => {
 		const plain = make({
 			name: "plain",
@@ -104,7 +138,233 @@ describe("Toolkit.run - tools with R requirements", () => {
 			inputSchema: fromEffectSchema(Empty),
 			run: () => Effect.succeed(0)
 		});
-		(0, import_dist.expectTypeOf)(run([plain], [])).toEqualTypeOf();
+		(0, import_dist.expectTypeOf)(run(make$1(plain), [])).toEqualTypeOf();
+	});
+});
+describe$1("Toolkit.make / compose / namespace - uniqueness", () => {
+	const Empty = Schema.Struct({});
+	const tool = (name) => make({
+		name,
+		description: "",
+		inputSchema: fromEffectSchema(Empty),
+		run: () => Effect.succeed(0)
+	});
+	it("rejects a duplicate literal name at compile time", () => {
+		make$1(tool("search"), provider({
+			name: "search",
+			description: "",
+			inputSchema: fromEffectSchema(Empty),
+			provider: "demo",
+			config: {}
+		}));
+	});
+	it("fails compose with DuplicateToolName naming the colliding sources (dynamic)", async () => {
+		const github = fromArray([tool("search")]);
+		const linear = fromArray([tool("search")]);
+		const exit = await Effect.runPromiseExit(compose(github, linear));
+		globalExpect(exit._tag).toBe("Failure");
+		if (exit._tag === "Failure") {
+			const json = JSON.stringify(exit.cause);
+			globalExpect(json).toContain("DuplicateToolName");
+			globalExpect(json).toContain("toolkit-0");
+			globalExpect(json).toContain("toolkit-1");
+		}
+	});
+	it("namespaces names so generic names from two sources compose cleanly", async () => {
+		const github = namespace("github", fromArray([tool("search")]));
+		const linear = namespace("linear", fromArray([tool("search")]));
+		const composed = await Effect.runPromise(compose(github, linear));
+		globalExpect(Object.keys(composed).sort()).toEqual(["github__search", "linear__search"]);
+	});
+	it("preserves each tool's R through compose", () => {
+		(0, import_dist.expectTypeOf)(Effect.gen(function* () {
+			return run(yield* compose(make$1(tool("a")), make$1(tool("b"))), []);
+		})).toEqualTypeOf();
+	});
+});
+describe$1("Toolkit.wrap - middleware", () => {
+	const Empty = Schema.Struct({});
+	class Audit extends Context.Service()("test/Audit") {}
+	const getWeather = make({
+		name: "get_weather",
+		description: "",
+		inputSchema: fromEffectSchema(Empty),
+		run: () => Effect.succeed({ tempC: 18 })
+	});
+	const escalate = signal({
+		name: "escalate",
+		description: "",
+		inputSchema: fromEffectSchema(Empty)
+	});
+	const audited = (run, name) => (input, emit) => Effect.gen(function* () {
+		yield* (yield* Audit).record(name);
+		return yield* run(input, emit);
+	});
+	const call = (name, id) => ({
+		type: "function_call",
+		call_id: id,
+		name,
+		arguments: "{}"
+	});
+	it("unions the middleware's R2 into the toolkit's requirements", () => {
+		const wrapped = wrap(make$1(getWeather), audited);
+		(0, import_dist.expectTypeOf)(run(wrapped, [])).toEqualTypeOf();
+	});
+	it("runs the wrapped handler and leaves non-local kinds untouched", async () => {
+		const recorded = [];
+		const wrapped = pipe(make$1(getWeather, escalate), wrap(audited));
+		const events = await Effect.runPromise(run(wrapped, [call("get_weather", "w1"), call("escalate", "s1")]).pipe(Stream.runCollect, Effect.provideService(Audit, { record: (n) => Effect.sync(() => void recorded.push(n)) })));
+		const byCall = new Map(Array.from(events).filter(isOutput).map((e) => [e.result.call_id, e.result]));
+		globalExpect(recorded).toEqual(["get_weather"]);
+		const w = byCall.get("w1");
+		globalExpect(w !== void 0 && isOk(w) && w.value).toEqual({ tempC: 18 });
+		const s = byCall.get("s1");
+		globalExpect(s?._tag === "Failure" && s.kind).toBe("non_local_tool");
+	});
+});
+describe$1("Toolkit.run - executor outcomes", () => {
+	const plain = (name, out) => make({
+		name,
+		description: "",
+		inputSchema: fromEffectSchema(Empty),
+		run: () => Effect.succeed(out)
+	});
+	it("absorbs a bare string failure as a tool_failed result", async () => {
+		const t = make({
+			name: "t",
+			description: "",
+			inputSchema: fromEffectSchema(Empty),
+			run: () => Effect.fail("nope")
+		});
+		const result = (await Effect.runPromise(runToArray(make$1(t), [toolCall("t", "1")]))).filter(isOutput)[0]?.result;
+		globalExpect(result).toMatchObject({
+			_tag: "Failure",
+			kind: "tool_failed",
+			reason: "nope"
+		});
+	});
+	it("absorbs Tool.fail with a custom kind", async () => {
+		const t = make({
+			name: "t",
+			description: "",
+			inputSchema: fromEffectSchema(Empty),
+			run: () => fail("missing", { kind: "not_found" })
+		});
+		const result = (await Effect.runPromise(runToArray(make$1(t), [toolCall("t", "1")]))).filter(isOutput)[0]?.result;
+		globalExpect(result).toMatchObject({
+			_tag: "Failure",
+			kind: "not_found",
+			reason: "missing"
+		});
+	});
+	it("propagates a typed non-sentinel failure on the stream", async () => {
+		const t = make({
+			name: "t",
+			description: "",
+			inputSchema: fromEffectSchema(Empty),
+			run: () => Effect.fail(new RateLimited({
+				provider: "x",
+				raw: null
+			}))
+		});
+		globalExpect((await Effect.runPromiseExit(runToArray(make$1(t), [toolCall("t", "1")])))._tag).toBe("Failure");
+	});
+	it("dies on a defect instead of masking it as a result", async () => {
+		const t = make({
+			name: "t",
+			description: "",
+			inputSchema: fromEffectSchema(Empty),
+			run: () => Effect.die(/* @__PURE__ */ new Error("boom"))
+		});
+		globalExpect((await Effect.runPromiseExit(runToArray(make$1(t), [toolCall("t", "1")])))._tag).toBe("Failure");
+	});
+	it("streams progress events strictly before the terminal output", async () => {
+		const t = make({
+			name: "t",
+			description: "",
+			inputSchema: fromEffectSchema(Empty),
+			run: (_input, emit) => emit("a").pipe(Effect.andThen(emit("b")), Effect.andThen(Effect.succeed("done")))
+		});
+		const events = await Effect.runPromise(runToArray(make$1(t), [toolCall("t", "1")]));
+		globalExpect(events.map((e) => e._tag)).toEqual([
+			"Progress",
+			"Progress",
+			"Output"
+		]);
+		globalExpect(events.filter(isProgress).map((p) => p.data)).toEqual(["a", "b"]);
+	});
+	it("reports input validation failures as a result carrying the issue detail", async () => {
+		const t = make({
+			name: "t",
+			description: "",
+			inputSchema: fromEffectSchema(Schema.Struct({ x: Schema.Number })),
+			run: () => Effect.succeed(1)
+		});
+		const result = (await Effect.runPromise(runToArray(make$1(t), [toolCall("t", "1", "{\"x\":\"nope\"}")]))).filter(isOutput)[0]?.result;
+		globalExpect(result).toMatchObject({
+			_tag: "Failure",
+			kind: "input_validation_error"
+		});
+		globalExpect(result !== void 0 && isFailure(result) && result.reason).toBeTruthy();
+	});
+	it("normalizes empty arguments to {} for a zero-arg tool", async () => {
+		const result = (await Effect.runPromise(runToArray(make$1(plain("t", "ok")), [toolCall("t", "1", "")]))).filter(isOutput)[0]?.result;
+		globalExpect(result).toMatchObject({
+			_tag: "Ok",
+			value: "ok"
+		});
+	});
+	it("reports unparseable arguments as input_validation_error", async () => {
+		const result = (await Effect.runPromise(runToArray(make$1(plain("t", "ok")), [toolCall("t", "1", "not json")]))).filter(isOutput)[0]?.result;
+		globalExpect(result).toMatchObject({
+			_tag: "Failure",
+			kind: "input_validation_error"
+		});
+	});
+	it("a call named constructor is unknown_tool, not non_local_tool", async () => {
+		const result = (await Effect.runPromise(runToArray(make$1(plain("t", "ok")), [toolCall("constructor", "1")]))).filter(isOutput)[0]?.result;
+		globalExpect(result).toMatchObject({
+			_tag: "Failure",
+			kind: "unknown_tool"
+		});
+	});
+	it("serializes an undefined output as \"null\" on the wire", async () => {
+		const t = make({
+			name: "t",
+			description: "",
+			inputSchema: fromEffectSchema(Empty),
+			run: () => Effect.void
+		});
+		const result = (await Effect.runPromise(runToArray(make$1(t), [toolCall("t", "1")]))).filter(isOutput)[0]?.result;
+		globalExpect(result !== void 0 && toToolCallOutput(result).output).toBe("null");
+	});
+	it("preserves call order with concurrency 1", async () => {
+		const kit = make$1(plain("a", "A"), plain("b", "B"));
+		globalExpect((await Effect.runPromise(runToArray(kit, [toolCall("a", "a1"), toolCall("b", "b1")], { concurrency: 1 }))).filter(isOutput).map((e) => e.result.call_id)).toEqual(["a1", "b1"]);
+	});
+	it("type: run of a describeFailures toolkit has no stream error", () => {
+		const kit = describeFailures(make$1(make({
+			name: "t",
+			description: "",
+			inputSchema: fromEffectSchema(Empty),
+			run: () => Effect.fail(new RateLimited({
+				provider: "x",
+				raw: null
+			}))
+		})), describe);
+		(0, import_dist.expectTypeOf)(run(kit, [])).toEqualTypeOf();
+	});
+	it("type: run of a typed toolkit propagates the tool's E", () => {
+		const t = make({
+			name: "t",
+			description: "",
+			inputSchema: fromEffectSchema(Empty),
+			run: () => Effect.fail(new RateLimited({
+				provider: "x",
+				raw: null
+			}))
+		});
+		(0, import_dist.expectTypeOf)(run(make$1(t), [])).toEqualTypeOf();
 	});
 });
 //#endregion

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

@@ -1 +1 @@
-{"version":3,"file":"Toolkit.test.mjs","names":["Tool.make","Tool.fromEffectSchema","Tool.toDescriptors","Toolkit.run"],"sources":["../../src/tool/Toolkit.test.ts"],"sourcesContent":["import { Context, Effect, Layer, Schema, Stream } from \"effect\"\nimport { describe, expect, expectTypeOf, it } from \"vitest\"\nimport type { ToolCall } from \"../domain/Items.js\"\nimport { isOutput } from \"./ToolEvent.js\"\nimport { isOk } from \"./ToolResult.js\"\nimport * as Tool from \"./Tool.js\"\nimport * as Toolkit from \"./Toolkit.js\"\n\ndescribe(\"Tool.toDescriptors\", () => {\n  const GetWeatherInput = Schema.Struct({ city: Schema.String })\n\n  const getWeather = Tool.make({\n    name: \"get_weather\",\n    description: \"Look up the current temperature for a city.\",\n    inputSchema: Tool.fromEffectSchema(GetWeatherInput),\n    run: ({ city }) => Effect.succeed({ city, tempC: 18 }),\n  })\n\n  it(\"renders the input schema as a JSON Schema document\", () => {\n    const [desc] = Tool.toDescriptors([getWeather])\n    expect(desc?.name).toBe(\"get_weather\")\n    expect(desc?.description).toBe(\"Look up the current temperature for a city.\")\n    expect(desc?.inputSchema).toMatchObject({\n      type: \"object\",\n      properties: { city: { type: \"string\" } },\n      required: [\"city\"],\n    })\n  })\n\n  it(\"includes strict flag only when set on the tool\", () => {\n    const strictTool = Tool.make({\n      name: \"strict_one\",\n      description: \"\",\n      inputSchema: Tool.fromEffectSchema(GetWeatherInput),\n      run: () => Effect.succeed({}),\n      strict: true,\n    })\n    const looseTool = Tool.make({\n      name: \"loose_one\",\n      description: \"\",\n      inputSchema: Tool.fromEffectSchema(GetWeatherInput),\n      run: () => Effect.succeed({}),\n    })\n    const [s, l] = Tool.toDescriptors([strictTool, looseTool])\n    expect(s?.strict).toBe(true)\n    expect(l).not.toHaveProperty(\"strict\")\n  })\n})\n\ndescribe(\"Toolkit.run - tools with R requirements\", () => {\n  // Two distinct services, modelling the \"typed per-tool context\" use case\n  // (cf. AI SDK 7's `toolsContext`). In Effect each tool declares its R, the\n  // compiler enforces it, and `run` surfaces the union for the caller\n  // to provide via Layer.\n  type WeatherApiKeyShape = { readonly key: string }\n  class WeatherApiKey extends Context.Service<WeatherApiKey, WeatherApiKeyShape>()(\n    \"test/WeatherApiKey\",\n  ) {}\n\n  type GeoApiKeyShape = { readonly key: string }\n  class GeoApiKey extends Context.Service<GeoApiKey, GeoApiKeyShape>()(\"test/GeoApiKey\") {}\n\n  const Empty = Schema.Struct({})\n\n  const getWeather = Tool.make({\n    name: \"get_weather\",\n    description: \"\",\n    inputSchema: Tool.fromEffectSchema(Empty),\n    run: () =>\n      Effect.gen(function* () {\n        const { key } = yield* WeatherApiKey\n        return { source: \"weather\", key }\n      }),\n  })\n\n  const getCoords = Tool.make({\n    name: \"get_coords\",\n    description: \"\",\n    inputSchema: Tool.fromEffectSchema(Empty),\n    run: () =>\n      Effect.gen(function* () {\n        const { key } = yield* GeoApiKey\n        return { source: \"geo\", key }\n      }),\n  })\n\n  const call = (name: string, id: string): ToolCall => ({\n    type: \"function_call\",\n    call_id: id,\n    name,\n    arguments: \"{}\",\n  })\n\n  it(\"propagates each tool's R into the resulting Stream's requirements\", () => {\n    const stream = Toolkit.run([getWeather, getCoords], [])\n    expectTypeOf(stream).toEqualTypeOf<\n      Stream.Stream<import(\"./ToolEvent.js\").ToolEvent, never, WeatherApiKey | GeoApiKey>\n    >()\n  })\n\n  it(\"runs each tool with its own service injected\", async () => {\n    const layer = Layer.mergeAll(\n      Layer.succeed(WeatherApiKey, { key: \"weather-123\" }),\n      Layer.succeed(GeoApiKey, { key: \"geo-456\" }),\n    )\n\n    const program = Toolkit.run(\n      [getWeather, getCoords],\n      [call(\"get_weather\", \"c1\"), call(\"get_coords\", \"c2\")],\n    ).pipe(Stream.runCollect, Effect.provide(layer))\n\n    const events = await Effect.runPromise(program)\n    const outputs = Array.from(events).filter(isOutput)\n    const byCall = new Map(outputs.map((e) => [e.result.call_id, e.result]))\n\n    const w = byCall.get(\"c1\")\n    const g = byCall.get(\"c2\")\n    expect(w !== undefined && isOk(w) && w.value).toEqual({\n      source: \"weather\",\n      key: \"weather-123\",\n    })\n    expect(g !== undefined && isOk(g) && g.value).toEqual({\n      source: \"geo\",\n      key: \"geo-456\",\n    })\n  })\n\n  it(\"with no service-needing tools, R is never\", () => {\n    const plain = Tool.make({\n      name: \"plain\",\n      description: \"\",\n      inputSchema: Tool.fromEffectSchema(Empty),\n      run: () => Effect.succeed(0),\n    })\n    const stream = Toolkit.run([plain], [])\n    expectTypeOf(stream).toEqualTypeOf<\n      Stream.Stream<import(\"./ToolEvent.js\").ToolEvent, never, never>\n    >()\n  })\n})\n"],"mappings":"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"}
+{"version":3,"file":"Toolkit.test.mjs","names":["Toolkit.run","describe","Tool.make","Tool.fromEffectSchema","Tool.toDescriptors","Toolkit.make","Tool.signal","Tool.provider","Toolkit.fromArray","Toolkit.compose","Toolkit.namespace","Toolkit.wrap","Tool.fail","AiError.RateLimited","Toolkit.describeFailures","AiError.describe"],"sources":["../../src/tool/Toolkit.test.ts"],"sourcesContent":["import { Context, Effect, Layer, pipe, Schema, Stream } from \"effect\"\nimport { describe, expect, expectTypeOf, it } from \"vitest\"\nimport * as AiError from \"../domain/AiError.js\"\nimport type { ToolCall } from \"../domain/Items.js\"\nimport { type ToolEvent, isOutput, isProgress } from \"./ToolEvent.js\"\nimport { isFailure, isOk, toToolCallOutput } from \"./ToolResult.js\"\nimport * as Tool from \"./Tool.js\"\nimport * as Toolkit from \"./Toolkit.js\"\n\nconst Empty = Schema.Struct({})\nconst toolCall = (name: string, id: string, args = \"{}\"): ToolCall => ({\n  type: \"function_call\",\n  call_id: id,\n  name,\n  arguments: args,\n})\nconst runToArray = <T extends Toolkit.Toolkit>(\n  toolkit: T,\n  calls: ReadonlyArray<ToolCall>,\n  options?: Toolkit.ExecuteOptions,\n) =>\n  Toolkit.run(toolkit, calls, options).pipe(\n    Stream.runCollect,\n    Effect.map((events): ReadonlyArray<ToolEvent> => Array.from(events)),\n  )\n\ndescribe(\"Tool.toDescriptors\", () => {\n  const GetWeatherInput = Schema.Struct({ city: Schema.String })\n\n  const getWeather = Tool.make({\n    name: \"get_weather\",\n    description: \"Look up the current temperature for a city.\",\n    inputSchema: Tool.fromEffectSchema(GetWeatherInput),\n    run: ({ city }) => Effect.succeed({ city, tempC: 18 }),\n  })\n\n  it(\"renders the input schema as a JSON Schema document\", () => {\n    const [desc] = Tool.toDescriptors([getWeather])\n    expect(desc?.name).toBe(\"get_weather\")\n    expect(desc?.description).toBe(\"Look up the current temperature for a city.\")\n    expect(desc?.inputSchema).toMatchObject({\n      type: \"object\",\n      properties: { city: { type: \"string\" } },\n      required: [\"city\"],\n    })\n  })\n\n  it(\"includes strict flag only when set on the tool\", () => {\n    const strictTool = Tool.make({\n      name: \"strict_one\",\n      description: \"\",\n      inputSchema: Tool.fromEffectSchema(GetWeatherInput),\n      run: () => Effect.succeed({}),\n      strict: true,\n    })\n    const looseTool = Tool.make({\n      name: \"loose_one\",\n      description: \"\",\n      inputSchema: Tool.fromEffectSchema(GetWeatherInput),\n      run: () => Effect.succeed({}),\n    })\n    const [s, l] = Tool.toDescriptors([strictTool, looseTool])\n    expect(s?.strict).toBe(true)\n    expect(l).not.toHaveProperty(\"strict\")\n  })\n})\n\ndescribe(\"Toolkit.run - tools with R requirements\", () => {\n  // Two distinct services, modelling the \"typed per-tool context\" use case\n  // (cf. AI SDK 7's `toolsContext`). In Effect each tool declares its R, the\n  // compiler enforces it, and `run` surfaces the union for the caller\n  // to provide via Layer.\n  type WeatherApiKeyShape = { readonly key: string }\n  class WeatherApiKey extends Context.Service<WeatherApiKey, WeatherApiKeyShape>()(\n    \"test/WeatherApiKey\",\n  ) {}\n\n  type GeoApiKeyShape = { readonly key: string }\n  class GeoApiKey extends Context.Service<GeoApiKey, GeoApiKeyShape>()(\"test/GeoApiKey\") {}\n\n  const Empty = Schema.Struct({})\n\n  const getWeather = Tool.make({\n    name: \"get_weather\",\n    description: \"\",\n    inputSchema: Tool.fromEffectSchema(Empty),\n    run: () =>\n      Effect.gen(function* () {\n        const { key } = yield* WeatherApiKey\n        return { source: \"weather\", key }\n      }),\n  })\n\n  const getCoords = Tool.make({\n    name: \"get_coords\",\n    description: \"\",\n    inputSchema: Tool.fromEffectSchema(Empty),\n    run: () =>\n      Effect.gen(function* () {\n        const { key } = yield* GeoApiKey\n        return { source: \"geo\", key }\n      }),\n  })\n\n  const call = (name: string, id: string): ToolCall => ({\n    type: \"function_call\",\n    call_id: id,\n    name,\n    arguments: \"{}\",\n  })\n\n  it(\"propagates each tool's R into the resulting Stream's requirements\", () => {\n    const stream = Toolkit.run(Toolkit.make(getWeather, getCoords), [])\n    expectTypeOf(stream).toEqualTypeOf<\n      Stream.Stream<import(\"./ToolEvent.js\").ToolEvent, never, WeatherApiKey | GeoApiKey>\n    >()\n  })\n\n  it(\"runs each tool with its own service injected\", async () => {\n    const layer = Layer.mergeAll(\n      Layer.succeed(WeatherApiKey, { key: \"weather-123\" }),\n      Layer.succeed(GeoApiKey, { key: \"geo-456\" }),\n    )\n\n    const program = Toolkit.run(Toolkit.make(getWeather, getCoords), [\n      call(\"get_weather\", \"c1\"),\n      call(\"get_coords\", \"c2\"),\n    ]).pipe(Stream.runCollect, Effect.provide(layer))\n\n    const events = await Effect.runPromise(program)\n    const outputs = Array.from(events).filter(isOutput)\n    const byCall = new Map(outputs.map((e) => [e.result.call_id, e.result]))\n\n    const w = byCall.get(\"c1\")\n    const g = byCall.get(\"c2\")\n    expect(w !== undefined && isOk(w) && w.value).toEqual({\n      source: \"weather\",\n      key: \"weather-123\",\n    })\n    expect(g !== undefined && isOk(g) && g.value).toEqual({\n      source: \"geo\",\n      key: \"geo-456\",\n    })\n  })\n\n  it(\"reports non-local kinds as non_local_tool while local calls in the same turn still run\", async () => {\n    const escalate = Tool.signal({\n      name: \"escalate\",\n      description: \"\",\n      inputSchema: Tool.fromEffectSchema(Empty),\n    })\n    const localPlain = Tool.make({\n      name: \"plain\",\n      description: \"\",\n      inputSchema: Tool.fromEffectSchema(Empty),\n      run: () => Effect.succeed({ ok: true }),\n    })\n\n    const events = await Effect.runPromise(\n      Toolkit.run(Toolkit.make(localPlain, escalate), [\n        call(\"escalate\", \"s1\"),\n        call(\"plain\", \"p1\"),\n        call(\"ghost\", \"g1\"),\n      ]).pipe(Stream.runCollect),\n    )\n    const byCall = new Map(\n      Array.from(events)\n        .filter(isOutput)\n        .map((e) => [e.result.call_id, e.result] as const),\n    )\n\n    // Signal tool: model-visible but no local executor.\n    const s = byCall.get(\"s1\")\n    expect(s?._tag === \"Failure\" && s.kind).toBe(\"non_local_tool\")\n    // Unknown tool stays distinct from non-local.\n    const g = byCall.get(\"g1\")\n    expect(g?._tag === \"Failure\" && g.kind).toBe(\"unknown_tool\")\n    // The local call still executed despite the non-local sibling.\n    const p = byCall.get(\"p1\")\n    expect(p !== undefined && isOk(p) && p.value).toEqual({ ok: true })\n  })\n\n  it(\"with no service-needing tools, R is never\", () => {\n    const plain = Tool.make({\n      name: \"plain\",\n      description: \"\",\n      inputSchema: Tool.fromEffectSchema(Empty),\n      run: () => Effect.succeed(0),\n    })\n    const stream = Toolkit.run(Toolkit.make(plain), [])\n    expectTypeOf(stream).toEqualTypeOf<\n      Stream.Stream<import(\"./ToolEvent.js\").ToolEvent, never, never>\n    >()\n  })\n})\n\ndescribe(\"Toolkit.make / compose / namespace - uniqueness\", () => {\n  const Empty = Schema.Struct({})\n  const tool = (name: string) =>\n    Tool.make({\n      name,\n      description: \"\",\n      inputSchema: Tool.fromEffectSchema(Empty),\n      run: () => Effect.succeed(0),\n    })\n\n  it(\"rejects a duplicate literal name at compile time\", () => {\n    const a = tool(\"search\")\n    const b = Tool.provider({\n      name: \"search\",\n      description: \"\",\n      inputSchema: Tool.fromEffectSchema(Empty),\n      provider: \"demo\",\n      config: {},\n    })\n    // @ts-expect-error Duplicate tool name: search\n    Toolkit.make(a, b)\n  })\n\n  it(\"fails compose with DuplicateToolName naming the colliding sources (dynamic)\", async () => {\n    const github = Toolkit.fromArray([tool(\"search\")])\n    const linear = Toolkit.fromArray([tool(\"search\")])\n    const exit = await Effect.runPromiseExit(Toolkit.compose(github, linear))\n    expect(exit._tag).toBe(\"Failure\")\n    if (exit._tag === \"Failure\") {\n      const json = JSON.stringify(exit.cause)\n      expect(json).toContain(\"DuplicateToolName\")\n      expect(json).toContain(\"toolkit-0\")\n      expect(json).toContain(\"toolkit-1\")\n    }\n  })\n\n  it(\"namespaces names so generic names from two sources compose cleanly\", async () => {\n    const github = Toolkit.namespace(\"github\", Toolkit.fromArray([tool(\"search\")]))\n    const linear = Toolkit.namespace(\"linear\", Toolkit.fromArray([tool(\"search\")]))\n    const composed = await Effect.runPromise(Toolkit.compose(github, linear))\n    expect(Object.keys(composed).sort()).toEqual([\"github__search\", \"linear__search\"])\n  })\n\n  it(\"preserves each tool's R through compose\", () => {\n    const stream = Effect.gen(function* () {\n      const composed = yield* Toolkit.compose(Toolkit.make(tool(\"a\")), Toolkit.make(tool(\"b\")))\n      return Toolkit.run(composed, [])\n    })\n    // No service-needing tools here -> R stays never (compose didn't poison it).\n    expectTypeOf(stream).toEqualTypeOf<\n      Effect.Effect<\n        Stream.Stream<import(\"./ToolEvent.js\").ToolEvent, never, never>,\n        Toolkit.DuplicateToolName\n      >\n    >()\n  })\n})\n\ndescribe(\"Toolkit.wrap - middleware\", () => {\n  const Empty = Schema.Struct({})\n  type AuditShape = { readonly record: (name: string) => Effect.Effect<void> }\n  class Audit extends Context.Service<Audit, AuditShape>()(\"test/Audit\") {}\n\n  const getWeather = Tool.make({\n    name: \"get_weather\",\n    description: \"\",\n    inputSchema: Tool.fromEffectSchema(Empty),\n    run: () => Effect.succeed({ tempC: 18 }),\n  })\n  const escalate = Tool.signal({\n    name: \"escalate\",\n    description: \"\",\n    inputSchema: Tool.fromEffectSchema(Empty),\n  })\n\n  // A middleware that needs the Audit service -> R2 = Audit.\n  const audited: Toolkit.Middleware<Audit> = (run, name) => (input, emit) =>\n    Effect.gen(function* () {\n      const a = yield* Audit\n      yield* a.record(name)\n      return yield* run(input, emit)\n    })\n\n  const call = (name: string, id: string): ToolCall => ({\n    type: \"function_call\",\n    call_id: id,\n    name,\n    arguments: \"{}\",\n  })\n\n  it(\"unions the middleware's R2 into the toolkit's requirements\", () => {\n    const wrapped = Toolkit.wrap(Toolkit.make(getWeather), audited)\n    const stream = Toolkit.run(wrapped, [])\n    expectTypeOf(stream).toEqualTypeOf<\n      Stream.Stream<import(\"./ToolEvent.js\").ToolEvent, never, Audit>\n    >()\n  })\n\n  it(\"runs the wrapped handler and leaves non-local kinds untouched\", async () => {\n    const recorded: Array<string> = []\n    const wrapped = pipe(Toolkit.make(getWeather, escalate), Toolkit.wrap(audited))\n\n    const events = await Effect.runPromise(\n      Toolkit.run(wrapped, [call(\"get_weather\", \"w1\"), call(\"escalate\", \"s1\")]).pipe(\n        Stream.runCollect,\n        Effect.provideService(Audit, { record: (n) => Effect.sync(() => void recorded.push(n)) }),\n      ),\n    )\n    const byCall = new Map(\n      Array.from(events)\n        .filter(isOutput)\n        .map((e) => [e.result.call_id, e.result] as const),\n    )\n\n    // Local tool ran through the middleware (audit fired).\n    expect(recorded).toEqual([\"get_weather\"])\n    const w = byCall.get(\"w1\")\n    expect(w !== undefined && isOk(w) && w.value).toEqual({ tempC: 18 })\n    // Signal kind is left alone by wrap -> still reported non-local.\n    const s = byCall.get(\"s1\")\n    expect(s?._tag === \"Failure\" && s.kind).toBe(\"non_local_tool\")\n  })\n})\n\ndescribe(\"Toolkit.run - executor outcomes\", () => {\n  const plain = <N extends string>(name: N, out: unknown) =>\n    Tool.make({\n      name,\n      description: \"\",\n      inputSchema: Tool.fromEffectSchema(Empty),\n      run: () => Effect.succeed(out),\n    })\n\n  it(\"absorbs a bare string failure as a tool_failed result\", async () => {\n    const t = Tool.make({\n      name: \"t\",\n      description: \"\",\n      inputSchema: Tool.fromEffectSchema(Empty),\n      run: () => Effect.fail(\"nope\"),\n    })\n    const events = await Effect.runPromise(runToArray(Toolkit.make(t), [toolCall(\"t\", \"1\")]))\n    const result = events.filter(isOutput)[0]?.result\n    expect(result).toMatchObject({ _tag: \"Failure\", kind: \"tool_failed\", reason: \"nope\" })\n  })\n\n  it(\"absorbs Tool.fail with a custom kind\", async () => {\n    const t = Tool.make({\n      name: \"t\",\n      description: \"\",\n      inputSchema: Tool.fromEffectSchema(Empty),\n      run: () => Tool.fail(\"missing\", { kind: \"not_found\" }),\n    })\n    const events = await Effect.runPromise(runToArray(Toolkit.make(t), [toolCall(\"t\", \"1\")]))\n    const result = events.filter(isOutput)[0]?.result\n    expect(result).toMatchObject({ _tag: \"Failure\", kind: \"not_found\", reason: \"missing\" })\n  })\n\n  it(\"propagates a typed non-sentinel failure on the stream\", async () => {\n    const t = Tool.make({\n      name: \"t\",\n      description: \"\",\n      inputSchema: Tool.fromEffectSchema(Empty),\n      run: () => Effect.fail(new AiError.RateLimited({ provider: \"x\", raw: null })),\n    })\n    const exit = await Effect.runPromiseExit(runToArray(Toolkit.make(t), [toolCall(\"t\", \"1\")]))\n    expect(exit._tag).toBe(\"Failure\")\n  })\n\n  it(\"dies on a defect instead of masking it as a result\", async () => {\n    const t = Tool.make({\n      name: \"t\",\n      description: \"\",\n      inputSchema: Tool.fromEffectSchema(Empty),\n      run: () => Effect.die(new Error(\"boom\")),\n    })\n    const exit = await Effect.runPromiseExit(runToArray(Toolkit.make(t), [toolCall(\"t\", \"1\")]))\n    expect(exit._tag).toBe(\"Failure\")\n  })\n\n  it(\"streams progress events strictly before the terminal output\", async () => {\n    const t = Tool.make({\n      name: \"t\",\n      description: \"\",\n      inputSchema: Tool.fromEffectSchema(Empty),\n      run: (_input, emit) =>\n        emit(\"a\").pipe(Effect.andThen(emit(\"b\")), Effect.andThen(Effect.succeed(\"done\"))),\n    })\n    const events = await Effect.runPromise(runToArray(Toolkit.make(t), [toolCall(\"t\", \"1\")]))\n    expect(events.map((e) => e._tag)).toEqual([\"Progress\", \"Progress\", \"Output\"])\n    expect(events.filter(isProgress).map((p) => p.data)).toEqual([\"a\", \"b\"])\n  })\n\n  it(\"reports input validation failures as a result carrying the issue detail\", async () => {\n    const t = Tool.make({\n      name: \"t\",\n      description: \"\",\n      inputSchema: Tool.fromEffectSchema(Schema.Struct({ x: Schema.Number })),\n      run: () => Effect.succeed(1),\n    })\n    const events = await Effect.runPromise(\n      runToArray(Toolkit.make(t), [toolCall(\"t\", \"1\", '{\"x\":\"nope\"}')]),\n    )\n    const result = events.filter(isOutput)[0]?.result\n    expect(result).toMatchObject({ _tag: \"Failure\", kind: \"input_validation_error\" })\n    expect(result !== undefined && isFailure(result) && result.reason).toBeTruthy()\n  })\n\n  it(\"normalizes empty arguments to {} for a zero-arg tool\", async () => {\n    const events = await Effect.runPromise(\n      runToArray(Toolkit.make(plain(\"t\", \"ok\")), [toolCall(\"t\", \"1\", \"\")]),\n    )\n    const result = events.filter(isOutput)[0]?.result\n    expect(result).toMatchObject({ _tag: \"Ok\", value: \"ok\" })\n  })\n\n  it(\"reports unparseable arguments as input_validation_error\", async () => {\n    const events = await Effect.runPromise(\n      runToArray(Toolkit.make(plain(\"t\", \"ok\")), [toolCall(\"t\", \"1\", \"not json\")]),\n    )\n    const result = events.filter(isOutput)[0]?.result\n    expect(result).toMatchObject({ _tag: \"Failure\", kind: \"input_validation_error\" })\n  })\n\n  it(\"a call named constructor is unknown_tool, not non_local_tool\", async () => {\n    const events = await Effect.runPromise(\n      runToArray(Toolkit.make(plain(\"t\", \"ok\")), [toolCall(\"constructor\", \"1\")]),\n    )\n    const result = events.filter(isOutput)[0]?.result\n    expect(result).toMatchObject({ _tag: \"Failure\", kind: \"unknown_tool\" })\n  })\n\n  it('serializes an undefined output as \"null\" on the wire', async () => {\n    const t = Tool.make({\n      name: \"t\",\n      description: \"\",\n      inputSchema: Tool.fromEffectSchema(Empty),\n      run: () => Effect.void,\n    })\n    const events = await Effect.runPromise(runToArray(Toolkit.make(t), [toolCall(\"t\", \"1\")]))\n    const result = events.filter(isOutput)[0]?.result\n    expect(result !== undefined && toToolCallOutput(result).output).toBe(\"null\")\n  })\n\n  it(\"preserves call order with concurrency 1\", async () => {\n    const kit = Toolkit.make(plain(\"a\", \"A\"), plain(\"b\", \"B\"))\n    const events = await Effect.runPromise(\n      runToArray(kit, [toolCall(\"a\", \"a1\"), toolCall(\"b\", \"b1\")], { concurrency: 1 }),\n    )\n    expect(events.filter(isOutput).map((e) => e.result.call_id)).toEqual([\"a1\", \"b1\"])\n  })\n\n  it(\"type: run of a describeFailures toolkit has no stream error\", () => {\n    const t = Tool.make({\n      name: \"t\",\n      description: \"\",\n      inputSchema: Tool.fromEffectSchema(Empty),\n      run: () => Effect.fail(new AiError.RateLimited({ provider: \"x\", raw: null })),\n    })\n    const kit = Toolkit.describeFailures(Toolkit.make(t), AiError.describe)\n    const stream = Toolkit.run(kit, [])\n    expectTypeOf(stream).toEqualTypeOf<Stream.Stream<ToolEvent, never, never>>()\n  })\n\n  it(\"type: run of a typed toolkit propagates the tool's E\", () => {\n    const t = Tool.make({\n      name: \"t\",\n      description: \"\",\n      inputSchema: Tool.fromEffectSchema(Empty),\n      run: () => Effect.fail(new AiError.RateLimited({ provider: \"x\", raw: null })),\n    })\n    const stream = Toolkit.run(Toolkit.make(t), [])\n    expectTypeOf(stream).toEqualTypeOf<Stream.Stream<ToolEvent, AiError.RateLimited, never>>()\n  })\n})\n"],"mappings":"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"}

package/dist/transcriber/Transcriber.d.mts

@@ -1,5 +1,5 @@
-import { t as AiError } from "../AiError-CAX_48RU.mjs";
-import { a as AudioSource, r as AudioFormat } from "../Audio-DPlTsNdz.mjs";
+import { t as AiError } from "../AiError-Bf1pq4BB.mjs";
+import { a as AudioSource, r as AudioFormat } from "../Audio-CR7CSljJ.mjs";
 import { TranscriptEvent, TranscriptResult } from "../domain/Transcript.mjs";
 import { Context, Effect, Stream } from "effect";
 

package/dist/transcriber/Transcriber.test.mjs

@@ -1,5 +1,5 @@
 import { streamTranscriptionFrom, transcribe } from "./Transcriber.mjs";
-import { i as it, n as globalExpect, r as describe, t as import_dist } from "../dist-DV5ISja1.mjs";
+import { a as describe, n as globalExpect, o as it, t as import_dist } from "../dist-B04dlFHg.mjs";
 import { layer, layerSyncOnly } from "../testing/MockTranscriber.mjs";
 import { Duration, Effect, Stream } from "effect";
 //#region src/transcriber/Transcriber.test.ts

package/dist/web-read/WebRead.d.mts

@@ -0,0 +1,44 @@
+import { t as AiError } from "../AiError-Bf1pq4BB.mjs";
+import { Context, Duration, Effect } from "effect";
+
+//#region src/web-read/WebRead.d.ts
+declare namespace WebRead_d_exports {
+  export { CommonReadRequest, ReadFormat, ReadResponse, WebRead, WebReadService, read };
+}
+/** Representation to return for a page. `markdown` is the default. */
+type ReadFormat = "markdown" | "html";
+/**
+ * Cross-provider read request: one URL in, clean content out. Provider-specific
+ * knobs live on the provider-typed request.
+ */
+type CommonReadRequest = {
+  /** The page to read. */readonly url: string; /** Output representation. Defaults to `markdown`. See {@link ReadFormat}. */
+  readonly format?: ReadFormat; /** Upper bound on time spent fetching the page. */
+  readonly timeout?: Duration.Duration;
+};
+/** One normalized read result. */
+type ReadResponse = {
+  /** The URL that was read. */readonly url: string; /** Extracted content in the requested {@link ReadFormat}. */
+  readonly content: string; /** Page title, when reported. */
+  readonly title?: string; /** Links discovered on the page, when returned. */
+  readonly links?: ReadonlyArray<string>; /** The provider-native response. */
+  readonly raw: unknown;
+};
+/**
+ * The portable read surface: one operation, `read`. Every implementor can
+ * answer, so this capability needs no marker tags.
+ */
+type WebReadService = {
+  readonly read: (request: CommonReadRequest) => Effect.Effect<ReadResponse, AiError>;
+};
+declare const WebRead_base: Context.ServiceClass<WebRead, "@betalyra/effect-uai/WebRead", WebReadService>;
+/**
+ * Generic read service tag. Yield this for provider-portable code; yield a
+ * provider tag for provider-specific knobs. A provider `layer` registers both.
+ */
+declare class WebRead extends WebRead_base {}
+/** Read one URL against whichever provider Layer is in scope. */
+declare const read: (request: CommonReadRequest) => Effect.Effect<ReadResponse, AiError, WebRead>;
+//#endregion
+export { CommonReadRequest, ReadFormat, ReadResponse, WebRead, WebReadService, read, WebRead_d_exports as t };
+//# sourceMappingURL=WebRead.d.mts.map

package/dist/web-read/WebRead.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebRead.d.mts","names":[],"sources":["../../src/web-read/WebRead.ts"],"mappings":";;;;;;;;KAQY,UAAA;;;;;KAUA,iBAAA;mCAED,GAAA;WAEA,MAAA,GAAS,UAAA,EAdR;EAAA,SAgBD,OAAA,GAAU,QAAA,CAAS,QAAA;AAAA;;KAQlB,YAAA;EAdA,sCAgBD,GAAA;WAEA,OAAA,UAhBA;EAAA,SAkBA,KAAA,WAhBS;EAAA,SAkBT,KAAA,GAAQ,aAAA,UAhBE;EAAA,SAkBV,GAAA;AAAA;;AAVX;;;KAqBY,cAAA;EAAA,SACD,IAAA,GAAO,OAAA,EAAS,iBAAA,KAAsB,MAAA,CAAO,MAAA,CAAO,YAAA,EAAc,OAAA;AAAA;AAAA,cAC5E,YAAA;;;;;cAMY,OAAA,SAAgB,YAAA;;cAKhB,IAAA,GACX,OAAA,EAAS,iBAAA,KACR,MAAA,CAAO,MAAA,CAAO,YAAA,EAAc,OAAA,EAAiB,OAAA"}

package/dist/web-read/WebRead.mjs

@@ -0,0 +1,18 @@
+import { n as __exportAll } from "../chunk-uyGKjUfl.mjs";
+import { Context, Effect } from "effect";
+//#region src/web-read/WebRead.ts
+var WebRead_exports = /* @__PURE__ */ __exportAll({
+	WebRead: () => WebRead,
+	read: () => read
+});
+/**
+* Generic read service tag. Yield this for provider-portable code; yield a
+* provider tag for provider-specific knobs. A provider `layer` registers both.
+*/
+var WebRead = class extends Context.Service()("@betalyra/effect-uai/WebRead") {};
+/** Read one URL against whichever provider Layer is in scope. */
+const read = (request) => Effect.flatMap(WebRead.asEffect(), (s) => s.read(request));
+//#endregion
+export { WebRead, read, WebRead_exports as t };
+
+//# sourceMappingURL=WebRead.mjs.map

package/dist/web-read/WebRead.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebRead.mjs","names":[],"sources":["../../src/web-read/WebRead.ts"],"sourcesContent":["import { Context, type Duration, Effect } from \"effect\"\nimport type * as AiError from \"../domain/AiError.js\"\n\n// ---------------------------------------------------------------------------\n// Format\n// ---------------------------------------------------------------------------\n\n/** Representation to return for a page. `markdown` is the default. */\nexport type ReadFormat = \"markdown\" | \"html\"\n\n// ---------------------------------------------------------------------------\n// Request\n// ---------------------------------------------------------------------------\n\n/**\n * Cross-provider read request: one URL in, clean content out. Provider-specific\n * knobs live on the provider-typed request.\n */\nexport type CommonReadRequest = {\n  /** The page to read. */\n  readonly url: string\n  /** Output representation. Defaults to `markdown`. See {@link ReadFormat}. */\n  readonly format?: ReadFormat\n  /** Upper bound on time spent fetching the page. */\n  readonly timeout?: Duration.Duration\n}\n\n// ---------------------------------------------------------------------------\n// Response\n// ---------------------------------------------------------------------------\n\n/** One normalized read result. */\nexport type ReadResponse = {\n  /** The URL that was read. */\n  readonly url: string\n  /** Extracted content in the requested {@link ReadFormat}. */\n  readonly content: string\n  /** Page title, when reported. */\n  readonly title?: string\n  /** Links discovered on the page, when returned. */\n  readonly links?: ReadonlyArray<string>\n  /** The provider-native response. */\n  readonly raw: unknown\n}\n\n// ---------------------------------------------------------------------------\n// Service + helper\n// ---------------------------------------------------------------------------\n\n/**\n * The portable read surface: one operation, `read`. Every implementor can\n * answer, so this capability needs no marker tags.\n */\nexport type WebReadService = {\n  readonly read: (request: CommonReadRequest) => Effect.Effect<ReadResponse, AiError.AiError>\n}\n\n/**\n * Generic read service tag. Yield this for provider-portable code; yield a\n * provider tag for provider-specific knobs. A provider `layer` registers both.\n */\nexport class WebRead extends Context.Service<WebRead, WebReadService>()(\n  \"@betalyra/effect-uai/WebRead\",\n) {}\n\n/** Read one URL against whichever provider Layer is in scope. */\nexport const read = (\n  request: CommonReadRequest,\n): Effect.Effect<ReadResponse, AiError.AiError, WebRead> =>\n  Effect.flatMap(WebRead.asEffect(), (s) => s.read(request))\n"],"mappings":";;;;;;;;;;;AA6DA,IAAa,UAAb,cAA6B,QAAQ,SAAkC,CACrE,+BACD,CAAC;;AAGF,MAAa,QACX,YAEA,OAAO,QAAQ,QAAQ,UAAU,GAAG,MAAM,EAAE,KAAK,QAAQ,CAAC"}

package/dist/web-read/WebReadTool.d.mts

@@ -0,0 +1,57 @@
+import { l as Tool } from "../Tool-2lC_XMth.mjs";
+import { t as AiError } from "../AiError-Bf1pq4BB.mjs";
+import { ReadFormat, ReadResponse, WebRead } from "./WebRead.mjs";
+import { Schema } from "effect";
+
+//#region src/web-read/WebReadTool.d.ts
+declare namespace WebReadTool_d_exports {
+  export { WebReadToolArgs, WebReadToolOptions, webReadTool };
+}
+/**
+ * Model-facing argument schema. Deliberately narrow: the URL is the only
+ * thing that is genuinely the model's call. Output format and the content
+ * cost ceiling are app policy, pinned on the constructor instead, so they
+ * are guaranteed rather than left to the model to remember each call.
+ */
+declare const WebReadToolArgs: Schema.Struct<{
+  readonly url: Schema.String;
+}>;
+type WebReadToolArgs = typeof WebReadToolArgs.Type;
+type WebReadToolOptions = {
+  /** Tool name the model sees. Default `"web_read"`. */readonly name?: string;
+  /**
+   * App-fixed representation for every read - a policy choice, not a model
+   * knob. Default `"markdown"` (what models read best).
+   */
+  readonly format?: ReadFormat;
+  /**
+   * App-fixed ceiling on rendered content characters per call - a context
+   * cost guard, not exposed to the model. Default `20000`.
+   */
+  readonly maxChars?: number;
+  /**
+   * Override how a read response is rendered into the model-facing string.
+   * Default: `title / url` header plus the content, truncated at `maxChars`.
+   */
+  readonly render?: (response: ReadResponse) => string;
+};
+/**
+ * The canonical web-read tool. Its `R` is just `WebRead`, so providing any
+ * read-provider Layer satisfies it and the model-facing contract (name,
+ * description, schema) is identical no matter which backend answers - swap
+ * `FirecrawlRead.layer` for `JinaRead.layer` and the tool the model sees
+ * does not change. Drops straight into a `Toolkit` next to `webSearchTool`
+ * (search finds the URLs, read fetches the ones worth reading in full).
+ *
+ * `Output` is the rendered page; failures stay typed on the `AiError`
+ * channel. To let the model recover from a failed read, wrap the toolkit in
+ * `Toolkit.describeFailures(AiError.describe)`.
+ *
+ * This is a simple default implementation for quick use. For more elaborate
+ * cases (a different output contract, more model-facing knobs), build your
+ * own tool with `Tool.make` over the same `read` helper.
+ */
+declare const webReadTool: (options?: WebReadToolOptions) => Tool<string, WebReadToolArgs, never, string, AiError, WebRead>;
+//#endregion
+export { WebReadToolArgs, WebReadToolOptions, WebReadTool_d_exports as t, webReadTool };
+//# sourceMappingURL=WebReadTool.d.mts.map

package/dist/web-read/WebReadTool.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebReadTool.d.mts","names":[],"sources":["../../src/web-read/WebReadTool.ts"],"mappings":";;;;;;;;;;;;;;;cAWM,eAAA,EAAe,MAAA,CAAA,MAAA;EAAA,cAInB,MAAA,CAAA,MAAA;AAAA;AAAA,KAEU,eAAA,UAAyB,eAAA,CAAgB,IAAA;AAAA,KAYzC,kBAAA;EAlBS,+DAoBV,IAAA;EApBU;;;;EAAA,SAyBV,MAAA,GAAS,UAAA;;AAnBpB;;;WAwBW,QAAA;EAxB8C;AAYzD;;;EAZyD,SA6B9C,MAAA,IAAU,QAAA,EAAU,YAAA;AAAA;;;;;;;;;AAmB/B;;;;;;;;cAAa,WAAA,GACX,OAAA,GAAU,kBAAA,KACT,IAAA,SAAkB,eAAA,iBAAgC,OAAA,EAAiB,OAAA"}

package/dist/web-read/WebReadTool.mjs

@@ -0,0 +1,59 @@
+import { n as __exportAll } from "../chunk-uyGKjUfl.mjs";
+import { fromEffectSchema, make } from "../tool/Tool.mjs";
+import { read } from "./WebRead.mjs";
+import { Effect, Schema } from "effect";
+//#region src/web-read/WebReadTool.ts
+var WebReadTool_exports = /* @__PURE__ */ __exportAll({ webReadTool: () => webReadTool });
+/**
+* Model-facing argument schema. Deliberately narrow: the URL is the only
+* thing that is genuinely the model's call. Output format and the content
+* cost ceiling are app policy, pinned on the constructor instead, so they
+* are guaranteed rather than left to the model to remember each call.
+*/
+const WebReadToolArgs = Schema.Struct({ url: Schema.String.annotate({ description: "Absolute URL of the page to read." }) });
+/** `title / url` header plus the extracted content - what a model reads best. */
+const defaultRender = (response, maxChars) => {
+	return `${response.title === void 0 ? response.url : `${response.title}\n${response.url}`}\n\n${response.content.length > maxChars ? `${response.content.slice(0, maxChars)}\n[content truncated at ${maxChars} characters]` : response.content}`;
+};
+/**
+* The canonical web-read tool. Its `R` is just `WebRead`, so providing any
+* read-provider Layer satisfies it and the model-facing contract (name,
+* description, schema) is identical no matter which backend answers - swap
+* `FirecrawlRead.layer` for `JinaRead.layer` and the tool the model sees
+* does not change. Drops straight into a `Toolkit` next to `webSearchTool`
+* (search finds the URLs, read fetches the ones worth reading in full).
+*
+* `Output` is the rendered page; failures stay typed on the `AiError`
+* channel. To let the model recover from a failed read, wrap the toolkit in
+* `Toolkit.describeFailures(AiError.describe)`.
+*
+* This is a simple default implementation for quick use. For more elaborate
+* cases (a different output contract, more model-facing knobs), build your
+* own tool with `Tool.make` over the same `read` helper.
+*/
+const webReadTool = (options) => {
+	const name = options?.name ?? "web_read";
+	const format = options?.format ?? "markdown";
+	const maxChars = options?.maxChars ?? 2e4;
+	const render = options?.render ?? ((response) => defaultRender(response, maxChars));
+	return make({
+		name,
+		description: "Read a web page and return its content as clean text. Use it to read a promising URL in full (e.g. one found via search).",
+		inputSchema: fromEffectSchema(WebReadToolArgs),
+		run: (args) => read({
+			url: args.url,
+			format
+		}).pipe(Effect.tap((r) => Effect.annotateCurrentSpan("web_read.content_chars", r.content.length)), Effect.map(render), Effect.withSpan(name, {
+			kind: "client",
+			attributes: {
+				"web_read.url": args.url,
+				"web_read.format": format,
+				"web_read.max_chars": maxChars
+			}
+		}))
+	});
+};
+//#endregion
+export { WebReadTool_exports as t, webReadTool };
+
+//# sourceMappingURL=WebReadTool.mjs.map

package/dist/web-read/WebReadTool.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebReadTool.mjs","names":["Tool.make","Tool.fromEffectSchema"],"sources":["../../src/web-read/WebReadTool.ts"],"sourcesContent":["import { Effect, Schema } from \"effect\"\nimport type * as AiError from \"../domain/AiError.js\"\nimport * as Tool from \"../tool/Tool.js\"\nimport { read, type ReadFormat, type ReadResponse, WebRead } from \"./WebRead.js\"\n\n/**\n * Model-facing argument schema. Deliberately narrow: the URL is the only\n * thing that is genuinely the model's call. Output format and the content\n * cost ceiling are app policy, pinned on the constructor instead, so they\n * are guaranteed rather than left to the model to remember each call.\n */\nconst WebReadToolArgs = Schema.Struct({\n  url: Schema.String.annotate({\n    description: \"Absolute URL of the page to read.\",\n  }),\n})\n\nexport type WebReadToolArgs = typeof WebReadToolArgs.Type\n\n/** `title / url` header plus the extracted content - what a model reads best. */\nconst defaultRender = (response: ReadResponse, maxChars: number): string => {\n  const header = response.title === undefined ? response.url : `${response.title}\\n${response.url}`\n  const body =\n    response.content.length > maxChars\n      ? `${response.content.slice(0, maxChars)}\\n[content truncated at ${maxChars} characters]`\n      : response.content\n  return `${header}\\n\\n${body}`\n}\n\nexport type WebReadToolOptions = {\n  /** Tool name the model sees. Default `\"web_read\"`. */\n  readonly name?: string\n  /**\n   * App-fixed representation for every read - a policy choice, not a model\n   * knob. Default `\"markdown\"` (what models read best).\n   */\n  readonly format?: ReadFormat\n  /**\n   * App-fixed ceiling on rendered content characters per call - a context\n   * cost guard, not exposed to the model. Default `20000`.\n   */\n  readonly maxChars?: number\n  /**\n   * Override how a read response is rendered into the model-facing string.\n   * Default: `title / url` header plus the content, truncated at `maxChars`.\n   */\n  readonly render?: (response: ReadResponse) => string\n}\n\n/**\n * The canonical web-read tool. Its `R` is just `WebRead`, so providing any\n * read-provider Layer satisfies it and the model-facing contract (name,\n * description, schema) is identical no matter which backend answers - swap\n * `FirecrawlRead.layer` for `JinaRead.layer` and the tool the model sees\n * does not change. Drops straight into a `Toolkit` next to `webSearchTool`\n * (search finds the URLs, read fetches the ones worth reading in full).\n *\n * `Output` is the rendered page; failures stay typed on the `AiError`\n * channel. To let the model recover from a failed read, wrap the toolkit in\n * `Toolkit.describeFailures(AiError.describe)`.\n *\n * This is a simple default implementation for quick use. For more elaborate\n * cases (a different output contract, more model-facing knobs), build your\n * own tool with `Tool.make` over the same `read` helper.\n */\nexport const webReadTool = (\n  options?: WebReadToolOptions,\n): Tool.Tool<string, WebReadToolArgs, never, string, AiError.AiError, WebRead> => {\n  const name = options?.name ?? \"web_read\"\n  const format = options?.format ?? \"markdown\"\n  const maxChars = options?.maxChars ?? 20_000\n  const render = options?.render ?? ((response: ReadResponse) => defaultRender(response, maxChars))\n  return Tool.make({\n    name,\n    description:\n      \"Read a web page and return its content as clean text. Use it to read a promising URL in full (e.g. one found via search).\",\n    inputSchema: Tool.fromEffectSchema(WebReadToolArgs),\n    // The call is wrapped in a tracing span so agent traces show the tool\n    // invocation (url, format, content length) nested under the model turn.\n    // `withSpan` is a no-op until a Tracer is installed, so this is free by\n    // default and adds nothing to the requirements.\n    run: (args) =>\n      read({ url: args.url, format }).pipe(\n        Effect.tap((r) => Effect.annotateCurrentSpan(\"web_read.content_chars\", r.content.length)),\n        Effect.map(render),\n        Effect.withSpan(name, {\n          kind: \"client\",\n          attributes: {\n            \"web_read.url\": args.url,\n            \"web_read.format\": format,\n            \"web_read.max_chars\": maxChars,\n          },\n        }),\n      ),\n  })\n}\n"],"mappings":";;;;;;;;;;;;AAWA,MAAM,kBAAkB,OAAO,OAAO,EACpC,KAAK,OAAO,OAAO,SAAS,EAC1B,aAAa,qCACd,CAAC,EACH,CAAC;;AAKF,MAAM,iBAAiB,UAAwB,aAA6B;AAM1E,QAAO,GALQ,SAAS,UAAU,KAAA,IAAY,SAAS,MAAM,GAAG,SAAS,MAAM,IAAI,SAAS,MAK3E,MAHf,SAAS,QAAQ,SAAS,WACtB,GAAG,SAAS,QAAQ,MAAM,GAAG,SAAS,CAAC,0BAA0B,SAAS,gBAC1E,SAAS;;;;;;;;;;;;;;;;;;AAwCjB,MAAa,eACX,YACgF;CAChF,MAAM,OAAO,SAAS,QAAQ;CAC9B,MAAM,SAAS,SAAS,UAAU;CAClC,MAAM,WAAW,SAAS,YAAY;CACtC,MAAM,SAAS,SAAS,YAAY,aAA2B,cAAc,UAAU,SAAS;AAChG,QAAOA,KAAU;EACf;EACA,aACE;EACF,aAAaC,iBAAsB,gBAAgB;EAKnD,MAAM,SACJ,KAAK;GAAE,KAAK,KAAK;GAAK;GAAQ,CAAC,CAAC,KAC9B,OAAO,KAAK,MAAM,OAAO,oBAAoB,0BAA0B,EAAE,QAAQ,OAAO,CAAC,EACzF,OAAO,IAAI,OAAO,EAClB,OAAO,SAAS,MAAM;GACpB,MAAM;GACN,YAAY;IACV,gBAAgB,KAAK;IACrB,mBAAmB;IACnB,sBAAsB;IACvB;GACF,CAAC,CACH;EACJ,CAAC"}

package/dist/web-search/WebSearch.d.mts

@@ -1,4 +1,4 @@
-import { t as AiError } from "../AiError-CAX_48RU.mjs";
+import { t as AiError } from "../AiError-Bf1pq4BB.mjs";
 import { Context, DateTime, Effect, Schema } from "effect";
 
 //#region src/web-search/WebSearch.d.ts