@effect-uai/core 0.17.0 → 0.19.0-dev-20261109183959

package/dist/tool/Tool.test.mjs

@@ -1,16 +1,16 @@
-import { decodeArgs, descriptorsOf, fromEffectSchema, fromStandardSchema, isProviderTool, make, noInput, provider, providerToolsOf, signal, toDescriptors, withRun } from "./Tool.mjs";
-import { m as it, o as describe } from "../utils-CiH_DjFW.mjs";
-import { n as globalExpect } from "../test.DNmyFkvJ-YPzDR0Co.mjs";
-import { t as import_dist } from "../dist-BaenoU1A.mjs";
-import { Context, Effect, Schema } from "effect";
+import { ToolFailed, declare, decodeArgs, descriptorsOf, fromEffectSchema, fromStandardSchema, make, noInput, provider, providerToolsOf, toDescriptors, toStream, withFailures, withRun } from "./Tool.mjs";
+import { Value, image } from "./Content.mjs";
+import { make as make$1, run } from "./Toolkit.mjs";
+import { m as describe } from "../dist-DzeSyeYF.mjs";
+import { n as globalExpect } from "../index.C4tKZ0yW-LuFnBtmu.mjs";
+import { t as import_dist } from "../dist-DNeuh84d.mjs";
+import { t as it } from "../dist-B5K-y4Be.mjs";
+import { Context, Effect, Exit, Result, Schema, Stream } from "effect";
 //#region src/tool/Tool.test.ts
-const emailRecipientSchema = { "~standard": {
+const recipientSchema = { "~standard": {
 	version: 1,
 	vendor: "test-fixture",
-	validate: (value) => {
-		if (typeof value === "object" && value !== null && "to" in value && typeof value.to === "string") return { value };
-		return { issues: [{ message: "expected { to: string }" }] };
-	},
+	validate: (value) => typeof value === "object" && value !== null && "to" in value && typeof value.to === "string" ? { value: { to: value.to } } : { issues: [{ message: "expected { to: string }" }] },
 	jsonSchema: {
 		input: () => ({
 			type: "object",
@@ -24,214 +24,258 @@ const emailRecipientSchema = { "~standard": {
 		})
 	}
 } };
-const standardOnly = { "~standard": {
-	version: 1,
-	vendor: "test-fixture",
-	validate: () => ({ value: { to: "" } })
-} };
-describe("Tool.fromStandardSchema", () => {
-	it("returns the schema (structurally) typed as ToolInputSchema<Output>", () => {
-		const adapted = fromStandardSchema(emailRecipientSchema);
-		globalExpect(adapted).toBe(emailRecipientSchema);
-		const valid = adapted["~standard"].validate({ to: "hi@example.com" });
-		globalExpect(valid).toEqual({ value: { to: "hi@example.com" } });
-		const json = adapted["~standard"].jsonSchema.input({ target: "draft-2020-12" });
-		globalExpect(json).toEqual({
-			type: "object",
-			properties: { to: { type: "string" } },
-			required: ["to"]
-		});
-	});
-	it("composes with Tool.make so Input is inferred from the schema's Output", async () => {
-		const sendEmail = make({
+const callWith = (name, args) => ({
+	type: "function_call",
+	call_id: "call_1",
+	name,
+	arguments: args
+});
+describe("Tool.make", () => {
+	const Recipient = Schema.Struct({ to: Schema.String });
+	it("type: infers Input from an Effect Schema or a Standard Schema, and keeps the name literal", () => {
+		const effect = make({
 			name: "send_email",
-			description: "Send an email to a single recipient.",
-			inputSchema: fromStandardSchema(emailRecipientSchema),
-			run: ({ to }) => Effect.succeed(`queued: ${to}`)
+			description: "",
+			inputSchema: Recipient,
+			outputSchema: Schema.String,
+			run: ({ to }) => Effect.succeed(to)
 		});
-		const result = await Effect.runPromise(sendEmail.run({ to: "x@y.z" }, () => Effect.void));
-		globalExpect(result).toBe("queued: x@y.z");
-	});
-	it("type: rejects schemas missing the Standard JSON Schema half at compile time", () => {
-		fromStandardSchema(standardOnly);
-	});
-	it("type: Output type flows through fromStandardSchema into Tool.make", () => {
-		make({
+		const standard = make({
 			name: "send_email",
-			description: "send",
-			inputSchema: fromStandardSchema(emailRecipientSchema),
-			run: (input) => Effect.succeed(input)
+			description: "",
+			inputSchema: fromStandardSchema(recipientSchema),
+			outputSchema: Schema.String,
+			run: ({ to }) => Effect.succeed(to)
 		});
-		(0, import_dist.expectTypeOf)().toEqualTypeOf();
-	});
-});
-describe("Tool.withRun", () => {
-	const sendEmail = make({
-		name: "send_email",
-		description: "Send an email to a single recipient.",
-		inputSchema: fromStandardSchema(emailRecipientSchema),
-		run: ({ to }) => Effect.succeed(`sent: ${to}`)
-	});
-	it("swaps run while keeping the model-facing descriptor identical", async () => {
-		const dryRun = withRun(sendEmail, ({ to }) => Effect.succeed(`dry-run: ${to}`));
-		globalExpect(toDescriptors([dryRun])).toEqual(toDescriptors([sendEmail]));
-		const out = await Effect.runPromise(dryRun.run({ to: "x@y.z" }, () => Effect.void));
-		globalExpect(out).toBe("dry-run: x@y.z");
-	});
-});
-describe("Tool.decodeArgs", () => {
-	const sendEmail = make({
-		name: "send_email",
-		description: "Send an email to a single recipient.",
-		inputSchema: fromStandardSchema(emailRecipientSchema),
-		run: ({ to }) => Effect.succeed(`queued: ${to}`)
+		(0, import_dist.expectTypeOf)(effect).toEqualTypeOf();
+		(0, import_dist.expectTypeOf)(standard).toEqualTypeOf();
 	});
-	const callWith = (args) => ({
-		type: "function_call",
-		call_id: "call_1",
-		name: "send_email",
-		arguments: args
-	});
-	it("decodes valid JSON arguments to the typed input", async () => {
-		const input = await Effect.runPromise(decodeArgs(sendEmail, callWith("{\"to\":\"x@y.z\"}")));
-		globalExpect(input).toEqual({ to: "x@y.z" });
-		(0, import_dist.expectTypeOf)(input).toEqualTypeOf();
-	});
-	it("fails with ToolError when the arguments aren't valid JSON", async () => {
-		const exit = await Effect.runPromiseExit(decodeArgs(sendEmail, callWith("not json")));
-		globalExpect(exit._tag).toBe("Failure");
-	});
-	it("fails with ToolError when the arguments don't satisfy the schema", async () => {
-		const exit = await Effect.runPromiseExit(decodeArgs(sendEmail, callWith("{\"to\":42}")));
-		globalExpect(exit._tag).toBe("Failure");
-	});
-});
-describe("Effect Schema inputSchema", () => {
-	const Recipient = Schema.Struct({ to: Schema.String });
-	const sendEmail = make({
-		name: "send_email",
-		description: "Send an email to a single recipient.",
-		inputSchema: Recipient,
-		run: ({ to }) => Effect.succeed(`queued: ${to}`)
-	});
-	const callWith = (args) => ({
-		type: "function_call",
-		call_id: "call_1",
-		name: "send_email",
-		arguments: args
-	});
-	it("runs with the input inferred from the schema's Type", async () => {
-		const result = await Effect.runPromise(sendEmail.run({ to: "x@y.z" }, () => Effect.void));
-		globalExpect(result).toBe("queued: x@y.z");
-	});
-	it("type: Input is the schema's Type", () => {
-		(0, import_dist.expectTypeOf)().toEqualTypeOf();
-	});
-	it("type: E and R are inferred from run through the Effect Schema overload", () => {
+	it("type: Output from outputSchema; Failure, E and R from failureSchema and run", () => {
+		class NotFound extends Schema.TaggedError()("NotFound", { to: Schema.String }) {}
 		class Mailer extends Context.Service()("test/Mailer") {}
 		make({
 			name: "send_email",
-			description: "send",
+			description: "",
 			inputSchema: Recipient,
+			outputSchema: Schema.Struct({ id: Schema.String }),
+			failureSchema: NotFound,
 			run: ({ to }) => Effect.gen(function* () {
-				const mailer = yield* Mailer;
-				if (to === "") return yield* Effect.fail("empty");
-				return yield* mailer.send(to);
+				if (to === "") return yield* new NotFound({ to });
+				if (to === "boom") return yield* Effect.fail("crashed");
+				return yield* (yield* Mailer).send(to);
 			})
 		});
 		(0, import_dist.expectTypeOf)().toEqualTypeOf();
 		(0, import_dist.expectTypeOf)().toEqualTypeOf();
+		(0, import_dist.expectTypeOf)().toEqualTypeOf();
+		(0, import_dist.expectTypeOf)().toEqualTypeOf();
 	});
-	it("decodes valid JSON arguments to the typed input", async () => {
-		const input = await Effect.runPromise(decodeArgs(sendEmail, callWith("{\"to\":\"x@y.z\"}")));
-		globalExpect(input).toEqual({ to: "x@y.z" });
-		(0, import_dist.expectTypeOf)(input).toEqualTypeOf();
+	it("type: a Stream run returns outputSchema's type like an Effect run", () => {
+		make({
+			name: "count",
+			description: "",
+			inputSchema: noInput,
+			outputSchema: Schema.Number,
+			run: () => Stream.fromIterable([
+				1,
+				2,
+				3
+			])
+		});
+		(0, import_dist.expectTypeOf)().toEqualTypeOf();
 	});
-	it("fails with ToolValidationError when the arguments don't satisfy the schema", async () => {
-		const exit = await Effect.runPromiseExit(decodeArgs(sendEmail, callWith("{\"to\":42}")));
-		globalExpect(exit._tag).toBe("Failure");
+	it("type: a tool with run declares outputSchema; Content.Value is the explicit anything", () => {
+		make({
+			name: "shot",
+			description: "",
+			inputSchema: noInput,
+			outputSchema: Value,
+			run: () => Effect.succeed([{ title: "Home" }, image({
+				_tag: "url",
+				url: "u"
+			})])
+		});
+		make({
+			name: "shot",
+			description: "",
+			inputSchema: noInput,
+			run: () => Effect.succeed("ok")
+		});
 	});
-	it("renders a JSON Schema descriptor from the wrapped schema", () => {
-		const [descriptor] = toDescriptors([sendEmail]);
-		globalExpect(descriptor?.name).toBe("send_email");
-		globalExpect(descriptor?.inputSchema).toMatchObject({
-			type: "object",
-			properties: { to: { type: "string" } },
-			required: ["to"]
+	it("type: with outputSchema, the encoded side must be JSON", () => {
+		const Observed = Schema.Struct({ at: Schema.DateFromString });
+		make({
+			name: "when",
+			description: "",
+			inputSchema: noInput,
+			outputSchema: Observed,
+			run: () => Effect.succeed({ at: /* @__PURE__ */ new Date() })
+		});
+		(0, import_dist.expectTypeOf)().toEqualTypeOf();
+		make({
+			name: "when",
+			description: "",
+			inputSchema: noInput,
+			outputSchema: Schema.Struct({ at: Schema.Date }),
+			run: () => Effect.succeed({ at: /* @__PURE__ */ new Date() })
 		});
 	});
-	it("accepts an already-wrapped fromEffectSchema value unchanged", async () => {
-		const wrapped = make({
-			name: "send_email",
-			description: "Send an email to a single recipient.",
-			inputSchema: fromEffectSchema(Recipient),
-			run: ({ to }) => Effect.succeed(`queued: ${to}`)
+	it("type: make requires run", () => {
+		make({
+			name: "escalate",
+			description: "",
+			inputSchema: noInput,
+			outputSchema: Schema.String
 		});
-		globalExpect(toDescriptors([wrapped])).toEqual(toDescriptors([sendEmail]));
-		const input = await Effect.runPromise(decodeArgs(wrapped, callWith("{\"to\":\"x@y.z\"}")));
-		(0, import_dist.expectTypeOf)(input).toEqualTypeOf();
 	});
-	it("signal: decode-only kinds accept an Effect Schema directly", async () => {
-		const escalate = signal({
+	it("type: a declared tool is a signal, or a call answered elsewhere typed by outputSchema", () => {
+		const escalate = declare({
 			name: "escalate",
-			description: "Escalate to a human.",
+			description: "",
 			inputSchema: Schema.Struct({ reason: Schema.String })
 		});
-		const input = await Effect.runPromise(decodeArgs(escalate, {
-			type: "function_call",
-			call_id: "call_2",
-			name: "escalate",
-			arguments: "{\"reason\":\"stuck\"}"
-		}));
+		declare({
+			name: "ask_user",
+			description: "",
+			inputSchema: Schema.Struct({ question: Schema.String }),
+			outputSchema: Schema.Struct({ answer: Schema.String })
+		});
+		globalExpect(escalate._tag).toBe("DeclaredTool");
+		(0, import_dist.expectTypeOf)().toEqualTypeOf();
+		(0, import_dist.expectTypeOf)().toEqualTypeOf();
+	});
+	it("renders the same descriptor from an Effect Schema and its fromEffectSchema form", () => {
+		const direct = make({
+			name: "send_email",
+			description: "Send.",
+			inputSchema: Recipient,
+			outputSchema: Schema.String,
+			run: () => Effect.succeed("ok"),
+			strict: true
+		});
+		const wrapped = make({
+			name: "send_email",
+			description: "Send.",
+			inputSchema: fromEffectSchema(Recipient),
+			outputSchema: Schema.String,
+			run: () => Effect.succeed("ok"),
+			strict: true
+		});
+		globalExpect(toDescriptors([direct])).toEqual(toDescriptors([wrapped]));
+		globalExpect(toDescriptors([direct])[0]).toMatchObject({
+			inputSchema: {
+				type: "object",
+				properties: { to: { type: "string" } },
+				required: ["to"]
+			},
+			strict: true
+		});
+	});
+});
+describe("Tool.decodeArgs", () => {
+	const escalate = declare({
+		name: "escalate",
+		description: "Escalate to a human.",
+		inputSchema: Schema.Struct({ reason: Schema.String })
+	});
+	it.effect("decodes the arguments of a tool without run to its typed input", () => Effect.gen(function* () {
+		const input = yield* decodeArgs(escalate, callWith("escalate", "{\"reason\":\"stuck\"}"));
 		globalExpect(input).toEqual({ reason: "stuck" });
 		(0, import_dist.expectTypeOf)(input).toEqualTypeOf();
+	}));
+	it.effect("tells bad JSON (ToolError) apart from a schema violation (ToolValidationError)", () => Effect.gen(function* () {
+		const notJson = yield* Effect.flip(decodeArgs(escalate, callWith("escalate", "nope")));
+		const invalid = yield* Effect.flip(decodeArgs(escalate, callWith("escalate", "{\"reason\":1}")));
+		globalExpect(notJson._tag).toBe("ToolError");
+		globalExpect(invalid._tag).toBe("ToolValidationError");
+	}));
+	it.effect("fails, rather than throws, when a Standard Schema validator throws", () => Effect.gen(function* () {
+		const throwing = declare({
+			name: "t",
+			description: "",
+			inputSchema: { "~standard": {
+				...recipientSchema["~standard"],
+				validate: () => {
+					throw new Error("bug");
+				}
+			} }
+		});
+		const exit = yield* Effect.exit(decodeArgs(throwing, callWith("t", "{}")));
+		globalExpect(Exit.isFailure(exit)).toBe(true);
+	}));
+});
+describe("Tool.withRun", () => {
+	const Weather = Schema.Struct({ at: Schema.DateFromString });
+	const at = /* @__PURE__ */ new Date("2026-01-01T00:00:00.000Z");
+	const weather = make({
+		name: "weather",
+		description: "Weather now.",
+		inputSchema: noInput,
+		outputSchema: Weather,
+		run: () => Effect.succeed({ at: /* @__PURE__ */ new Date() })
+	});
+	it.effect("keeps the descriptor and schemas, replaces run", () => Effect.gen(function* () {
+		const mocked = withRun(weather, () => Effect.succeed({ at }));
+		globalExpect(toDescriptors([mocked])).toEqual(toDescriptors([weather]));
+		globalExpect(mocked.outputSchema).toBe(Weather);
+		globalExpect(yield* Stream.runCollect(toStream(mocked.run({})))).toEqual([{ at }]);
+	}));
+	it("type: the new run returns the same output type", () => {
+		withRun(weather, () => Effect.succeed("sunny"));
+	});
+	it.effect("implements a declared tool, keeping its schemas", () => Effect.gen(function* () {
+		const spec = declare({
+			name: "weather",
+			description: "Weather now.",
+			inputSchema: noInput,
+			outputSchema: Weather
+		});
+		const implemented = withRun(spec, () => Effect.succeed({ at }));
+		globalExpect(implemented._tag).toBe("LocalTool");
+		globalExpect(implemented.outputSchema).toBe(Weather);
+		const events = yield* Stream.runCollect(run(make$1(implemented), [callWith("weather", "{}")]));
+		globalExpect(events.map((e) => e._tag === "Output" && e.result)).toEqual([Result.succeed({ at })]);
+	}));
+	it("type: withFailures keeps the tool's kind", () => {
+		const declared = withFailures(declare({
+			name: "a",
+			description: "",
+			inputSchema: noInput
+		}), ToolFailed);
+		const local = withFailures(weather, ToolFailed);
+		(0, import_dist.expectTypeOf)(declared._tag).toEqualTypeOf();
+		(0, import_dist.expectTypeOf)(local._tag).toEqualTypeOf();
+		(0, import_dist.expectTypeOf)().toEqualTypeOf();
 	});
 });
 describe("provider-hosted tools", () => {
-	const localTool = make({
+	const local = make({
 		name: "send_email",
-		description: "Send an email.",
-		inputSchema: fromEffectSchema(Schema.Struct({ to: Schema.String })),
-		run: ({ to }) => Effect.succeed(`sent: ${to}`)
+		description: "",
+		inputSchema: noInput,
+		outputSchema: Schema.String,
+		run: () => Effect.succeed("sent")
 	});
-	const signalTool = signal({
+	const signal = declare({
 		name: "escalate",
-		description: "Escalate to a human.",
-		inputSchema: Schema.Struct({ reason: Schema.String })
+		description: "",
+		inputSchema: noInput
 	});
-	const hostedTool = provider({
+	const hosted = provider({
 		name: "web_search",
-		description: "Search the web.",
+		description: "",
 		inputSchema: noInput,
 		provider: "gemini",
 		config: { kind: "google_search" }
 	});
 	const toolkit = {
-		send_email: localTool,
-		escalate: signalTool,
-		web_search: hostedTool
+		send_email: local,
+		escalate: signal,
+		web_search: hosted
 	};
-	it("descriptorsOf excludes provider-hosted tools", () => {
-		const descriptors = descriptorsOf(toolkit);
-		globalExpect(descriptors.map((d) => d.name)).toEqual(["send_email", "escalate"]);
-	});
-	it("toDescriptors drops a ProviderTool from a mixed array", () => {
-		globalExpect(toDescriptors([localTool, hostedTool]).map((d) => d.name)).toEqual(["send_email"]);
-	});
-	it("providerToolsOf returns only the provider-hosted tools", () => {
-		const provider = providerToolsOf(toolkit);
-		globalExpect(provider).toHaveLength(1);
-		globalExpect(provider[0]?.name).toBe("web_search");
-		globalExpect(provider[0]?.provider).toBe("gemini");
-		globalExpect(provider[0]?.config).toEqual({ kind: "google_search" });
-	});
-	it("providerToolsOf on an absent toolkit is empty", () => {
-		globalExpect(providerToolsOf(void 0)).toEqual([]);
-	});
-	it("isProviderTool narrows the tool kind", () => {
-		globalExpect(isProviderTool(hostedTool)).toBe(true);
-		globalExpect(isProviderTool(localTool)).toBe(false);
-		globalExpect(isProviderTool(signalTool)).toBe(false);
+	it("are rendered by the provider, never as function descriptors", () => {
+		globalExpect(descriptorsOf(toolkit).map((d) => d.name)).toEqual(["send_email", "escalate"]);
+		globalExpect(providerToolsOf(toolkit)).toEqual([hosted]);
 	});
 });
 //#endregion

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

@@ -1 +1 @@
-{"version":3,"file":"Tool.test.mjs","names":["Tool.fromStandardSchema","Tool.make","Tool.withRun","Tool.toDescriptors","Tool.decodeArgs","Tool.fromEffectSchema","Tool.signal","Tool.provider","Tool.noInput","Tool.descriptorsOf","Tool.providerToolsOf","Tool.isProviderTool"],"sources":["../../src/tool/Tool.test.ts"],"sourcesContent":["import type { StandardJSONSchemaV1, StandardSchemaV1 } from \"@standard-schema/spec\"\nimport { Context, Effect, Schema } from \"effect\"\nimport { describe, expect, expectTypeOf, it } from \"vitest\"\nimport type * as Items from \"../domain/Items.js\"\nimport * as Tool from \"./Tool.js\"\n\n// ---------------------------------------------------------------------------\n// Minimal dual-standard schema for testing — no need to pull Zod / Valibot /\n// ArkType as devDeps. This is the smallest possible object satisfying both\n// `StandardSchemaV1` and `StandardJSONSchemaV1` per their published specs.\n// ---------------------------------------------------------------------------\n\ntype EmailRecipient = { readonly to: string }\n\nconst emailRecipientSchema: StandardSchemaV1<unknown, EmailRecipient> &\n  StandardJSONSchemaV1<unknown, EmailRecipient> = {\n  \"~standard\": {\n    version: 1,\n    vendor: \"test-fixture\",\n    validate: (value) => {\n      if (\n        typeof value === \"object\" &&\n        value !== null &&\n        \"to\" in value &&\n        typeof (value as { to: unknown }).to === \"string\"\n      ) {\n        return { value: value as EmailRecipient }\n      }\n      return { issues: [{ message: \"expected { to: string }\" }] }\n    },\n    jsonSchema: {\n      input: () => ({\n        type: \"object\",\n        properties: { to: { type: \"string\" } },\n        required: [\"to\"],\n      }),\n      output: () => ({\n        type: \"object\",\n        properties: { to: { type: \"string\" } },\n        required: [\"to\"],\n      }),\n    },\n  },\n}\n\n// A schema that satisfies StandardSchemaV1 only (no JSON Schema). Used to\n// verify the helper's compile-time guard.\nconst standardOnly: StandardSchemaV1<unknown, EmailRecipient> = {\n  \"~standard\": {\n    version: 1,\n    vendor: \"test-fixture\",\n    validate: () => ({ value: { to: \"\" } }),\n  },\n}\n\ndescribe(\"Tool.fromStandardSchema\", () => {\n  it(\"returns the schema (structurally) typed as ToolInputSchema<Output>\", () => {\n    const adapted = Tool.fromStandardSchema(emailRecipientSchema)\n\n    // Same object — helper is a type-narrowing identity at runtime.\n    expect(adapted).toBe(emailRecipientSchema)\n\n    // Both interfaces accessible through the same `~standard` key.\n    const valid = adapted[\"~standard\"].validate({ to: \"hi@example.com\" })\n    expect(valid).toEqual({ value: { to: \"hi@example.com\" } })\n\n    const json = adapted[\"~standard\"].jsonSchema.input({ target: \"draft-2020-12\" })\n    expect(json).toEqual({\n      type: \"object\",\n      properties: { to: { type: \"string\" } },\n      required: [\"to\"],\n    })\n  })\n\n  it(\"composes with Tool.make so Input is inferred from the schema's Output\", async () => {\n    const sendEmail = Tool.make({\n      name: \"send_email\",\n      description: \"Send an email to a single recipient.\",\n      inputSchema: Tool.fromStandardSchema(emailRecipientSchema),\n      run: ({ to }) => Effect.succeed(`queued: ${to}`),\n    })\n\n    // `run`'s parameter is typed as { to: string } via the schema's Output —\n    // this property access compiles without annotation.\n    const result = await Effect.runPromise(sendEmail.run({ to: \"x@y.z\" }, () => Effect.void))\n    expect(result).toBe(\"queued: x@y.z\")\n  })\n\n  it(\"type: rejects schemas missing the Standard JSON Schema half at compile time\", () => {\n    // @ts-expect-error — `standardOnly` lacks `jsonSchema`; helper's\n    // intersection constraint refuses it.\n    Tool.fromStandardSchema(standardOnly)\n  })\n\n  it(\"type: Output type flows through fromStandardSchema into Tool.make\", () => {\n    const tool = Tool.make({\n      name: \"send_email\",\n      description: \"send\",\n      inputSchema: Tool.fromStandardSchema(emailRecipientSchema),\n      run: (input) => Effect.succeed(input),\n    })\n\n    type InputOf<T> = T extends Tool.Tool<string, infer I, any, any, any> ? I : never\n    expectTypeOf<InputOf<typeof tool>>().toEqualTypeOf<EmailRecipient>()\n  })\n})\n\ndescribe(\"Tool.withRun\", () => {\n  const sendEmail = Tool.make({\n    name: \"send_email\",\n    description: \"Send an email to a single recipient.\",\n    inputSchema: Tool.fromStandardSchema(emailRecipientSchema),\n    run: ({ to }) => Effect.succeed(`sent: ${to}`),\n  })\n\n  it(\"swaps run while keeping the model-facing descriptor identical\", async () => {\n    const dryRun = Tool.withRun(sendEmail, ({ to }) => Effect.succeed(`dry-run: ${to}`))\n\n    // Definition (name/description/schema) is byte-identical -> same descriptor.\n    expect(Tool.toDescriptors([dryRun])).toEqual(Tool.toDescriptors([sendEmail]))\n    // input is typed from the original tool, no annotation needed.\n    const out = await Effect.runPromise(dryRun.run({ to: \"x@y.z\" }, () => Effect.void))\n    expect(out).toBe(\"dry-run: x@y.z\")\n  })\n})\n\ndescribe(\"Tool.decodeArgs\", () => {\n  const sendEmail = Tool.make({\n    name: \"send_email\",\n    description: \"Send an email to a single recipient.\",\n    inputSchema: Tool.fromStandardSchema(emailRecipientSchema),\n    run: ({ to }) => Effect.succeed(`queued: ${to}`),\n  })\n\n  const callWith = (args: string): Items.ToolCall => ({\n    type: \"function_call\",\n    call_id: \"call_1\",\n    name: \"send_email\",\n    arguments: args,\n  })\n\n  it(\"decodes valid JSON arguments to the typed input\", async () => {\n    const input = await Effect.runPromise(Tool.decodeArgs(sendEmail, callWith('{\"to\":\"x@y.z\"}')))\n    expect(input).toEqual({ to: \"x@y.z\" })\n    // The return type is the tool's Input, no annotation needed.\n    expectTypeOf(input).toEqualTypeOf<EmailRecipient>()\n  })\n\n  it(\"fails with ToolError when the arguments aren't valid JSON\", async () => {\n    const exit = await Effect.runPromiseExit(Tool.decodeArgs(sendEmail, callWith(\"not json\")))\n    expect(exit._tag).toBe(\"Failure\")\n  })\n\n  it(\"fails with ToolError when the arguments don't satisfy the schema\", async () => {\n    const exit = await Effect.runPromiseExit(Tool.decodeArgs(sendEmail, callWith('{\"to\":42}')))\n    expect(exit._tag).toBe(\"Failure\")\n  })\n})\n\ndescribe(\"Effect Schema inputSchema\", () => {\n  const Recipient = Schema.Struct({ to: Schema.String })\n\n  const sendEmail = Tool.make({\n    name: \"send_email\",\n    description: \"Send an email to a single recipient.\",\n    inputSchema: Recipient,\n    run: ({ to }) => Effect.succeed(`queued: ${to}`),\n  })\n\n  const callWith = (args: string): Items.ToolCall => ({\n    type: \"function_call\",\n    call_id: \"call_1\",\n    name: \"send_email\",\n    arguments: args,\n  })\n\n  it(\"runs with the input inferred from the schema's Type\", async () => {\n    const result = await Effect.runPromise(sendEmail.run({ to: \"x@y.z\" }, () => Effect.void))\n    expect(result).toBe(\"queued: x@y.z\")\n  })\n\n  it(\"type: Input is the schema's Type\", () => {\n    type InputOf<T> = T extends Tool.Tool<string, infer I, any, any, any> ? I : never\n    expectTypeOf<InputOf<typeof sendEmail>>().toEqualTypeOf<{ readonly to: string }>()\n  })\n\n  it(\"type: E and R are inferred from run through the Effect Schema overload\", () => {\n    class Mailer extends Context.Service<\n      Mailer,\n      { readonly send: (to: string) => Effect.Effect<string> }\n    >()(\"test/Mailer\") {}\n\n    const tool = Tool.make({\n      name: \"send_email\",\n      description: \"send\",\n      inputSchema: Recipient,\n      run: ({ to }) =>\n        Effect.gen(function* () {\n          const mailer = yield* Mailer\n          if (to === \"\") return yield* Effect.fail(\"empty\" as const)\n          return yield* mailer.send(to)\n        }),\n    })\n\n    expectTypeOf<Tool.ToolE<typeof tool>>().toEqualTypeOf<\"empty\">()\n    expectTypeOf<Tool.ToolR<typeof tool>>().toEqualTypeOf<Mailer>()\n  })\n\n  it(\"decodes valid JSON arguments to the typed input\", async () => {\n    const input = await Effect.runPromise(Tool.decodeArgs(sendEmail, callWith('{\"to\":\"x@y.z\"}')))\n    expect(input).toEqual({ to: \"x@y.z\" })\n    expectTypeOf(input).toEqualTypeOf<{ readonly to: string }>()\n  })\n\n  it(\"fails with ToolValidationError when the arguments don't satisfy the schema\", async () => {\n    const exit = await Effect.runPromiseExit(Tool.decodeArgs(sendEmail, callWith('{\"to\":42}')))\n    expect(exit._tag).toBe(\"Failure\")\n  })\n\n  it(\"renders a JSON Schema descriptor from the wrapped schema\", () => {\n    const [descriptor] = Tool.toDescriptors([sendEmail])\n    expect(descriptor?.name).toBe(\"send_email\")\n    expect(descriptor?.inputSchema).toMatchObject({\n      type: \"object\",\n      properties: { to: { type: \"string\" } },\n      required: [\"to\"],\n    })\n  })\n\n  it(\"accepts an already-wrapped fromEffectSchema value unchanged\", async () => {\n    const wrapped = Tool.make({\n      name: \"send_email\",\n      description: \"Send an email to a single recipient.\",\n      inputSchema: Tool.fromEffectSchema(Recipient),\n      run: ({ to }) => Effect.succeed(`queued: ${to}`),\n    })\n    expect(Tool.toDescriptors([wrapped])).toEqual(Tool.toDescriptors([sendEmail]))\n    const input = await Effect.runPromise(Tool.decodeArgs(wrapped, callWith('{\"to\":\"x@y.z\"}')))\n    expectTypeOf(input).toEqualTypeOf<{ readonly to: string }>()\n  })\n\n  it(\"signal: decode-only kinds accept an Effect Schema directly\", async () => {\n    const escalate = Tool.signal({\n      name: \"escalate\",\n      description: \"Escalate to a human.\",\n      inputSchema: Schema.Struct({ reason: Schema.String }),\n    })\n    const input = await Effect.runPromise(\n      Tool.decodeArgs(escalate, {\n        type: \"function_call\",\n        call_id: \"call_2\",\n        name: \"escalate\",\n        arguments: '{\"reason\":\"stuck\"}',\n      }),\n    )\n    expect(input).toEqual({ reason: \"stuck\" })\n    expectTypeOf(input).toEqualTypeOf<{ readonly reason: string }>()\n  })\n})\n\ndescribe(\"provider-hosted tools\", () => {\n  const localTool = Tool.make({\n    name: \"send_email\",\n    description: \"Send an email.\",\n    inputSchema: Tool.fromEffectSchema(Schema.Struct({ to: Schema.String })),\n    run: ({ to }) => Effect.succeed(`sent: ${to}`),\n  })\n  const signalTool = Tool.signal({\n    name: \"escalate\",\n    description: \"Escalate to a human.\",\n    inputSchema: Schema.Struct({ reason: Schema.String }),\n  })\n  const hostedTool = Tool.provider({\n    name: \"web_search\",\n    description: \"Search the web.\",\n    inputSchema: Tool.noInput,\n    provider: \"gemini\",\n    config: { kind: \"google_search\" },\n  })\n  const toolkit = { send_email: localTool, escalate: signalTool, web_search: hostedTool }\n\n  it(\"descriptorsOf excludes provider-hosted tools\", () => {\n    const descriptors = Tool.descriptorsOf(toolkit)\n    expect(descriptors.map((d) => d.name)).toEqual([\"send_email\", \"escalate\"])\n  })\n\n  it(\"toDescriptors drops a ProviderTool from a mixed array\", () => {\n    expect(Tool.toDescriptors([localTool, hostedTool]).map((d) => d.name)).toEqual([\"send_email\"])\n  })\n\n  it(\"providerToolsOf returns only the provider-hosted tools\", () => {\n    const provider = Tool.providerToolsOf(toolkit)\n    expect(provider).toHaveLength(1)\n    expect(provider[0]?.name).toBe(\"web_search\")\n    expect(provider[0]?.provider).toBe(\"gemini\")\n    expect(provider[0]?.config).toEqual({ kind: \"google_search\" })\n  })\n\n  it(\"providerToolsOf on an absent toolkit is empty\", () => {\n    expect(Tool.providerToolsOf(undefined)).toEqual([])\n  })\n\n  it(\"isProviderTool narrows the tool kind\", () => {\n    expect(Tool.isProviderTool(hostedTool)).toBe(true)\n    expect(Tool.isProviderTool(localTool)).toBe(false)\n    expect(Tool.isProviderTool(signalTool)).toBe(false)\n  })\n})\n"],"mappings":"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"}
+{"version":3,"file":"Tool.test.mjs","names":["Tool.make","Tool.fromStandardSchema","Tool.noInput","Content.Value","Content.image","Tool.declare","Tool.fromEffectSchema","Tool.toDescriptors","Tool.decodeArgs","Tool.withRun","Tool.toStream","Toolkit.run","Toolkit.make","Tool.withFailures","Tool.ToolFailed","Tool.provider","Tool.descriptorsOf","Tool.providerToolsOf"],"sources":["../../src/tool/Tool.test.ts"],"sourcesContent":["import { describe, expect, expectTypeOf, it } from \"@effect/vitest\"\nimport type { StandardJSONSchemaV1, StandardSchemaV1 } from \"@standard-schema/spec\"\nimport { Context, Effect, Exit, Result, Schema, Stream } from \"effect\"\nimport type * as Items from \"../domain/Items.js\"\nimport * as Content from \"./Content.js\"\nimport * as Tool from \"./Tool.js\"\nimport * as Toolkit from \"./Toolkit.js\"\n\n// The smallest object satisfying both Standard Schema and Standard JSON Schema.\ntype Recipient = { readonly to: string }\n\nconst recipientSchema: StandardSchemaV1<unknown, Recipient> &\n  StandardJSONSchemaV1<unknown, Recipient> = {\n  \"~standard\": {\n    version: 1,\n    vendor: \"test-fixture\",\n    validate: (value) =>\n      typeof value === \"object\" && value !== null && \"to\" in value && typeof value.to === \"string\"\n        ? { value: { to: value.to } }\n        : { issues: [{ message: \"expected { to: string }\" }] },\n    jsonSchema: {\n      input: () => ({ type: \"object\", properties: { to: { type: \"string\" } }, required: [\"to\"] }),\n      output: () => ({ type: \"object\", properties: { to: { type: \"string\" } }, required: [\"to\"] }),\n    },\n  },\n}\n\nconst callWith = (name: string, args: string): Items.ToolCall => ({\n  type: \"function_call\",\n  call_id: \"call_1\",\n  name,\n  arguments: args,\n})\n\ndescribe(\"Tool.make\", () => {\n  const Recipient = Schema.Struct({ to: Schema.String })\n\n  it(\"type: infers Input from an Effect Schema or a Standard Schema, and keeps the name literal\", () => {\n    const effect = Tool.make({\n      name: \"send_email\",\n      description: \"\",\n      inputSchema: Recipient,\n      outputSchema: Schema.String,\n      run: ({ to }) => Effect.succeed(to),\n    })\n    const standard = Tool.make({\n      name: \"send_email\",\n      description: \"\",\n      inputSchema: Tool.fromStandardSchema(recipientSchema),\n      outputSchema: Schema.String,\n      run: ({ to }) => Effect.succeed(to),\n    })\n    expectTypeOf(effect).toEqualTypeOf<Tool.Tool<\"send_email\", { readonly to: string }, string>>()\n    expectTypeOf(standard).toEqualTypeOf<Tool.Tool<\"send_email\", Recipient, string>>()\n  })\n\n  it(\"type: Output from outputSchema; Failure, E and R from failureSchema and run\", () => {\n    class NotFound extends Schema.TaggedError<NotFound>()(\"NotFound\", { to: Schema.String }) {}\n    class Mailer extends Context.Service<\n      Mailer,\n      { readonly send: (to: string) => Effect.Effect<{ readonly id: string }> }\n    >()(\"test/Mailer\") {}\n\n    const tool = Tool.make({\n      name: \"send_email\",\n      description: \"\",\n      inputSchema: Recipient,\n      outputSchema: Schema.Struct({ id: Schema.String }),\n      failureSchema: NotFound,\n      run: ({ to }) =>\n        Effect.gen(function* () {\n          if (to === \"\") return yield* new NotFound({ to })\n          if (to === \"boom\") return yield* Effect.fail(\"crashed\" as const)\n          return yield* (yield* Mailer).send(to)\n        }),\n    })\n    expectTypeOf<Tool.ToolOutput<typeof tool>>().toEqualTypeOf<{ readonly id: string }>()\n    expectTypeOf<Tool.ToolFailure<typeof tool>>().toEqualTypeOf<NotFound>()\n    expectTypeOf<Tool.ToolUnhandled<typeof tool>>().toEqualTypeOf<\"crashed\">()\n    expectTypeOf<Tool.ToolR<typeof tool>>().toEqualTypeOf<Mailer>()\n  })\n\n  it(\"type: a Stream run returns outputSchema's type like an Effect run\", () => {\n    const tool = Tool.make({\n      name: \"count\",\n      description: \"\",\n      inputSchema: Tool.noInput,\n      outputSchema: Schema.Number,\n      run: () => Stream.fromIterable([1, 2, 3]),\n    })\n    expectTypeOf<Tool.ToolOutput<typeof tool>>().toEqualTypeOf<number>()\n  })\n\n  it(\"type: a tool with run declares outputSchema; Content.Value is the explicit anything\", () => {\n    Tool.make({\n      name: \"shot\",\n      description: \"\",\n      inputSchema: Tool.noInput,\n      outputSchema: Content.Value,\n      run: () => Effect.succeed([{ title: \"Home\" }, Content.image({ _tag: \"url\", url: \"u\" })]),\n    })\n    // @ts-expect-error a tool with run needs an outputSchema\n    Tool.make({\n      name: \"shot\",\n      description: \"\",\n      inputSchema: Tool.noInput,\n      run: () => Effect.succeed(\"ok\"),\n    })\n  })\n\n  it(\"type: with outputSchema, the encoded side must be JSON\", () => {\n    const Observed = Schema.Struct({ at: Schema.DateFromString })\n    const tool = Tool.make({\n      name: \"when\",\n      description: \"\",\n      inputSchema: Tool.noInput,\n      outputSchema: Observed,\n      run: () => Effect.succeed({ at: new Date() }),\n    })\n    expectTypeOf<Tool.ToolOutput<typeof tool>>().toEqualTypeOf<{ readonly at: Date }>()\n\n    Tool.make({\n      name: \"when\",\n      description: \"\",\n      inputSchema: Tool.noInput,\n      // @ts-expect-error Schema.Date encodes to a Date, not JSON\n      outputSchema: Schema.Struct({ at: Schema.Date }),\n      run: () => Effect.succeed({ at: new Date() }),\n    })\n  })\n\n  it(\"type: make requires run\", () => {\n    // @ts-expect-error run is missing: a tool without run is Tool.declare\n    Tool.make({\n      name: \"escalate\",\n      description: \"\",\n      inputSchema: Tool.noInput,\n      outputSchema: Schema.String,\n    })\n  })\n\n  it(\"type: a declared tool is a signal, or a call answered elsewhere typed by outputSchema\", () => {\n    const escalate = Tool.declare({\n      name: \"escalate\",\n      description: \"\",\n      inputSchema: Schema.Struct({ reason: Schema.String }),\n    })\n    const askUser = Tool.declare({\n      name: \"ask_user\",\n      description: \"\",\n      inputSchema: Schema.Struct({ question: Schema.String }),\n      outputSchema: Schema.Struct({ answer: Schema.String }),\n    })\n    expect(escalate._tag).toBe(\"DeclaredTool\")\n    expectTypeOf<Tool.ToolOutput<typeof escalate>>().toEqualTypeOf<never>()\n    expectTypeOf<Tool.ToolOutput<typeof askUser>>().toEqualTypeOf<{ readonly answer: string }>()\n  })\n\n  it(\"renders the same descriptor from an Effect Schema and its fromEffectSchema form\", () => {\n    const direct = Tool.make({\n      name: \"send_email\",\n      description: \"Send.\",\n      inputSchema: Recipient,\n      outputSchema: Schema.String,\n      run: () => Effect.succeed(\"ok\"),\n      strict: true,\n    })\n    const wrapped = Tool.make({\n      name: \"send_email\",\n      description: \"Send.\",\n      inputSchema: Tool.fromEffectSchema(Recipient),\n      outputSchema: Schema.String,\n      run: () => Effect.succeed(\"ok\"),\n      strict: true,\n    })\n    expect(Tool.toDescriptors([direct])).toEqual(Tool.toDescriptors([wrapped]))\n    expect(Tool.toDescriptors([direct])[0]).toMatchObject({\n      inputSchema: { type: \"object\", properties: { to: { type: \"string\" } }, required: [\"to\"] },\n      strict: true,\n    })\n  })\n})\n\ndescribe(\"Tool.decodeArgs\", () => {\n  const escalate = Tool.declare({\n    name: \"escalate\",\n    description: \"Escalate to a human.\",\n    inputSchema: Schema.Struct({ reason: Schema.String }),\n  })\n\n  it.effect(\"decodes the arguments of a tool without run to its typed input\", () =>\n    Effect.gen(function* () {\n      const input = yield* Tool.decodeArgs(escalate, callWith(\"escalate\", '{\"reason\":\"stuck\"}'))\n      expect(input).toEqual({ reason: \"stuck\" })\n      expectTypeOf(input).toEqualTypeOf<{ readonly reason: string }>()\n    }),\n  )\n\n  it.effect(\"tells bad JSON (ToolError) apart from a schema violation (ToolValidationError)\", () =>\n    Effect.gen(function* () {\n      const notJson = yield* Effect.flip(Tool.decodeArgs(escalate, callWith(\"escalate\", \"nope\")))\n      const invalid = yield* Effect.flip(\n        Tool.decodeArgs(escalate, callWith(\"escalate\", '{\"reason\":1}')),\n      )\n      expect(notJson._tag).toBe(\"ToolError\")\n      expect(invalid._tag).toBe(\"ToolValidationError\")\n    }),\n  )\n\n  it.effect(\"fails, rather than throws, when a Standard Schema validator throws\", () =>\n    Effect.gen(function* () {\n      const throwing = Tool.declare({\n        name: \"t\",\n        description: \"\",\n        inputSchema: {\n          \"~standard\": {\n            ...recipientSchema[\"~standard\"],\n            validate: () => {\n              throw new Error(\"bug\")\n            },\n          },\n        },\n      })\n      const exit = yield* Effect.exit(Tool.decodeArgs(throwing, callWith(\"t\", \"{}\")))\n      expect(Exit.isFailure(exit)).toBe(true)\n    }),\n  )\n})\n\ndescribe(\"Tool.withRun\", () => {\n  const Weather = Schema.Struct({ at: Schema.DateFromString })\n  const at = new Date(\"2026-01-01T00:00:00.000Z\")\n  const weather = Tool.make({\n    name: \"weather\",\n    description: \"Weather now.\",\n    inputSchema: Tool.noInput,\n    outputSchema: Weather,\n    run: () => Effect.succeed({ at: new Date() }),\n  })\n\n  it.effect(\"keeps the descriptor and schemas, replaces run\", () =>\n    Effect.gen(function* () {\n      const mocked = Tool.withRun(weather, () => Effect.succeed({ at }))\n      expect(Tool.toDescriptors([mocked])).toEqual(Tool.toDescriptors([weather]))\n      expect(mocked.outputSchema).toBe(Weather)\n      expect(yield* Stream.runCollect(Tool.toStream(mocked.run({})))).toEqual([{ at }])\n    }),\n  )\n\n  it(\"type: the new run returns the same output type\", () => {\n    // @ts-expect-error a string is not the tool's output\n    Tool.withRun(weather, () => Effect.succeed(\"sunny\"))\n  })\n\n  it.effect(\"implements a declared tool, keeping its schemas\", () =>\n    Effect.gen(function* () {\n      const spec = Tool.declare({\n        name: \"weather\",\n        description: \"Weather now.\",\n        inputSchema: Tool.noInput,\n        outputSchema: Weather,\n      })\n      const implemented = Tool.withRun(spec, () => Effect.succeed({ at }))\n      expect(implemented._tag).toBe(\"LocalTool\")\n      expect(implemented.outputSchema).toBe(Weather)\n      const events = yield* Stream.runCollect(\n        Toolkit.run(Toolkit.make(implemented), [callWith(\"weather\", \"{}\")]),\n      )\n      expect(events.map((e) => e._tag === \"Output\" && e.result)).toEqual([Result.succeed({ at })])\n    }),\n  )\n\n  it(\"type: withFailures keeps the tool's kind\", () => {\n    const declared = Tool.withFailures(\n      Tool.declare({ name: \"a\", description: \"\", inputSchema: Tool.noInput }),\n      Tool.ToolFailed,\n    )\n    const local = Tool.withFailures(weather, Tool.ToolFailed)\n    expectTypeOf(declared._tag).toEqualTypeOf<\"DeclaredTool\">()\n    expectTypeOf(local._tag).toEqualTypeOf<\"LocalTool\">()\n    expectTypeOf<Tool.ToolFailure<typeof local>>().toEqualTypeOf<Tool.ToolFailed>()\n  })\n})\n\ndescribe(\"provider-hosted tools\", () => {\n  const local = Tool.make({\n    name: \"send_email\",\n    description: \"\",\n    inputSchema: Tool.noInput,\n    outputSchema: Schema.String,\n    run: () => Effect.succeed(\"sent\"),\n  })\n  const signal = Tool.declare({ name: \"escalate\", description: \"\", inputSchema: Tool.noInput })\n  const hosted = Tool.provider({\n    name: \"web_search\",\n    description: \"\",\n    inputSchema: Tool.noInput,\n    provider: \"gemini\",\n    config: { kind: \"google_search\" },\n  })\n  const toolkit = { send_email: local, escalate: signal, web_search: hosted }\n\n  it(\"are rendered by the provider, never as function descriptors\", () => {\n    expect(Tool.descriptorsOf(toolkit).map((d) => d.name)).toEqual([\"send_email\", \"escalate\"])\n    expect(Tool.providerToolsOf(toolkit)).toEqual([hosted])\n  })\n})\n"],"mappings":"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"}