@effect-uai/core 0.10.0 → 0.12.0

package/src/streaming/SSE.test.ts

@@ -1,4 +1,4 @@
-import { Effect, Stream } from "effect"
+import { Cause, Deferred, Effect, Exit, Fiber, Result, Stream } from "effect"
 import { describe, expect, it } from "vitest"
 import * as SSE from "./SSE.js"
 
@@ -8,6 +8,21 @@ const bytesOf = (...chunks: ReadonlyArray<string>) =>
 
 const collect = <A, E>(s: Stream.Stream<A, E>) => Effect.runPromise(Stream.runCollect(s))
 
+const runUntilEnd = <A, E>(s: Stream.Stream<A, E>) =>
+  Effect.runPromise(
+    s.pipe(
+      Stream.result,
+      Stream.runCollect,
+      Effect.map((results) => ({
+        seen: results.filter(Result.isSuccess).map((r) => r.success),
+        failures: results.filter(Result.isFailure).map((r) => r.failure),
+      })),
+    ),
+  )
+
+const failuresOf = (exit: Exit.Exit<unknown, unknown>): ReadonlyArray<unknown> =>
+  Exit.isFailure(exit) ? exit.cause.reasons.filter(Cause.isFailReason).map((r) => r.error) : []
+
 describe("SSE.fromBytes", () => {
   it("parses a single complete event", async () => {
     const out = await collect(SSE.fromBytes(bytesOf("event: foo\ndata: hello\n\n")))
@@ -39,9 +54,77 @@ describe("SSE.fromBytes", () => {
     expect(out).toEqual([{ id: "42", data: "x" }])
   })
 
-  it("flushes a trailing event without a closing blank line", async () => {
+  it("parses a data field with no space after the colon", async () => {
+    const out = await collect(SSE.fromBytes(bytesOf("data:x\n\n")))
+    expect(out).toEqual([{ data: "x" }])
+  })
+
+  it("ignores an id containing a NUL character", async () => {
+    const out = await collect(SSE.fromBytes(bytesOf("id: a\u0000b\ndata: x\n\n")))
+    expect(out).toEqual([{ data: "x" }])
+  })
+
+  it("discards a trailing event without a closing blank line", async () => {
     const out = await collect(SSE.fromBytes(bytesOf("data: tail")))
-    expect(out).toEqual([{ data: "tail" }])
+    expect(out).toEqual([])
+  })
+
+  it("discards buffered partial data when the upstream fails mid-stream", async () => {
+    const failing = Stream.concat(
+      bytesOf("data: good\n\ndata: partial-tr"),
+      Stream.fail("boom" as const),
+    )
+    const { seen, failures } = await runUntilEnd(SSE.fromBytes(failing))
+    expect(seen).toEqual([{ data: "good" }])
+    expect(failures).toEqual(["boom"])
+  })
+
+  it("discards a partial multi-byte char in the text decoder when the upstream fails", async () => {
+    const partialSquid = enc.encode("data: 🦑\n\n").slice(0, 8)
+    const failing = Stream.concat(
+      Stream.fromIterable([enc.encode("data: ok\n\n"), partialSquid]),
+      Stream.fail("boom" as const),
+    )
+    const { seen, failures } = await runUntilEnd(SSE.fromBytes(failing))
+    expect(seen).toEqual([{ data: "ok" }])
+    expect(failures).toEqual(["boom"])
+  })
+
+  it("discards buffered partial data when the stream is interrupted", async () => {
+    const { seen, exit } = await Effect.runPromise(
+      Effect.gen(function* () {
+        const seen: Array<SSE.Event> = []
+        const latch = yield* Deferred.make<void>()
+        const hanging = Stream.concat(bytesOf("data: good\n\ndata: partial"), Stream.never)
+        const fiber = yield* Stream.runForEach(SSE.fromBytes(hanging), (e) =>
+          Effect.sync(() => {
+            seen.push(e)
+          }).pipe(Effect.andThen(Deferred.succeed(latch, void 0))),
+        ).pipe(Effect.forkChild)
+        yield* Deferred.await(latch)
+        yield* Fiber.interrupt(fiber)
+        const exit = yield* Fiber.await(fiber)
+        return { seen, exit }
+      }),
+    )
+    expect(seen).toEqual([{ data: "good" }])
+    expect(Exit.isFailure(exit)).toBe(true)
+    expect(failuresOf(exit)).toEqual([])
+  })
+
+  it("ignores retry directives", async () => {
+    const out = await collect(SSE.fromBytes(bytesOf("retry: 3000\n\ndata: a\n\n")))
+    expect(out).toEqual([{ data: "a" }])
+  })
+
+  it("treats an explicit 'event: message' as the default event", async () => {
+    const out = await collect(SSE.fromBytes(bytesOf("event: message\ndata: x\n\n")))
+    expect(out).toEqual([{ data: "x" }])
+  })
+
+  it("does not dispatch events with no data", async () => {
+    const out = await collect(SSE.fromBytes(bytesOf("event: ping\n\ndata: x\n\n")))
+    expect(out).toEqual([{ data: "x" }])
   })
 
   it("ignores empty blocks between events", async () => {

package/src/streaming/SSE.ts

@@ -1,8 +1,9 @@
 import { Stream } from "effect"
+import { Sse } from "effect/unstable/encoding"
 
 /**
  * One Server-Sent Event. Fields per the WHATWG spec:
- * - `event`: optional event name (default "message" on the wire)
+ * - `event`: optional event name (absent for the default "message")
  * - `data`: payload, with multiple `data:` lines joined by `\n`
  * - `id`: optional last-event id
  */
@@ -12,98 +13,44 @@ export type Event = {
   readonly id?: string
 }
 
-// ---------------------------------------------------------------------------
-// Generic stream helpers (kept module-local for now; promote to a shared
-// Stream module once a third caller appears).
-// ---------------------------------------------------------------------------
+const toEvent = (wire: Sse.Event): Event => ({
+  data: wire.data,
+  ...(wire.event !== "message" && { event: wire.event }),
+  ...(wire.id !== undefined && { id: wire.id }),
+})
 
-/** Decode `Uint8Array` chunks as UTF-8, handling multi-byte boundaries. */
-const decodeText = <E, R>(self: Stream.Stream<Uint8Array, E, R>): Stream.Stream<string, E, R> =>
-  self.pipe(
-    Stream.mapAccum(
-      (): TextDecoder => new TextDecoder("utf-8"),
-      (decoder, chunk: Uint8Array) => [decoder, [decoder.decode(chunk, { stream: true })]] as const,
-      {
-        onHalt: (decoder: TextDecoder) => {
-          const tail = decoder.decode()
-          return tail.length > 0 ? [tail] : []
-        },
-      },
-    ),
-  )
-
-/** Split a text stream on a separator, buffering across chunk boundaries. */
-const splitOn =
-  (separator: string) =>
-  <E, R>(self: Stream.Stream<string, E, R>): Stream.Stream<string, E, R> =>
-    self.pipe(
-      Stream.mapAccum(
-        (): string => "",
-        (buffer, chunk: string) => {
-          const parts = (buffer + chunk).split(separator)
-          const tail = parts[parts.length - 1] ?? ""
-          return [tail, parts.slice(0, -1)] as const
-        },
-        { onHalt: (tail: string) => (tail.length > 0 ? [tail] : []) },
-      ),
-    )
-
-// ---------------------------------------------------------------------------
-// Parser
-// ---------------------------------------------------------------------------
-
-const parseField = (line: string): readonly [string, string] => {
-  const colon = line.indexOf(":")
-  if (colon < 0) return [line, ""]
-  const value = line.slice(colon + 1)
-  return [line.slice(0, colon), value.startsWith(" ") ? value.slice(1) : value]
+type ParserState = {
+  readonly parser: Sse.Parser
+  readonly out: Array<Event>
 }
 
-const parseBlock = (block: string): Event | null => {
-  const lines = block.split("\n").filter((l) => l.length > 0 && !l.startsWith(":"))
-  if (lines.length === 0) return null
-
-  const fields = lines.map(parseField)
-  const dataLines = fields.filter(([f]) => f === "data").map(([, v]) => v)
-  const event = fields.find(([f]) => f === "event")?.[1]
-  const id = fields.find(([f]) => f === "id")?.[1]
-
-  const out: { event?: string; data: string; id?: string } = {
-    data: dataLines.join("\n"),
-  }
-  if (event !== undefined) out.event = event
-  if (id !== undefined) out.id = id
-  return out as Event
+const makeParserState = (): ParserState => {
+  const out: Array<Event> = []
+  const parser = Sse.makeParser((event) => {
+    // `retry:` reconnection hints have no representation in `Event`
+    if (event._tag === "Event") out.push(toEvent(event))
+  })
+  return { parser, out }
 }
 
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-
 /**
  * Decode a `Stream<Uint8Array>` (e.g. an HTTP response body) into a
- * `Stream<SSE.Event>`. Handles partial UTF-8 sequences, CRLF/LF line
- * endings, and events split across chunk boundaries.
+ * `Stream<SSE.Event>`, using the spec parser from `effect/unstable/encoding`.
+ * An event is dispatched only once its terminating blank line arrives, so a
+ * partial event at stream end (clean or failed) is discarded per the spec
+ * rather than surfaced as a truncated frame.
  */
 export const fromBytes = <E, R>(
   self: Stream.Stream<Uint8Array, E, R>,
 ): Stream.Stream<Event, E, R> =>
   self.pipe(
-    decodeText,
-    Stream.map((s) => s.replace(/\r/g, "")), // SSE allows CRLF; normalize to LF
-    splitOn("\n\n"),
-    Stream.map(parseBlock),
-    Stream.filter((ev): ev is Event => ev !== null),
+    Stream.decodeText,
+    Stream.mapAccum(makeParserState, (state, text: string) => {
+      state.parser.feed(text)
+      return [state, state.out.splice(0)] as const
+    }),
   )
 
-const eventToString = (ev: Event): string => {
-  const parts: string[] = []
-  if (ev.event !== undefined) parts.push(`event: ${ev.event}`)
-  if (ev.id !== undefined) parts.push(`id: ${ev.id}`)
-  for (const line of ev.data.split("\n")) parts.push(`data: ${line}`)
-  return parts.join("\n") + "\n\n"
-}
-
 const encoder = new TextEncoder()
 
 /**
@@ -111,4 +58,13 @@ const encoder = new TextEncoder()
  * HTTP response with `Content-Type: text/event-stream`.
  */
 export const toBytes = <E, R>(self: Stream.Stream<Event, E, R>): Stream.Stream<Uint8Array, E, R> =>
-  Stream.map(self, (ev) => encoder.encode(eventToString(ev)))
+  Stream.map(self, (ev) =>
+    encoder.encode(
+      Sse.encoder.write({
+        _tag: "Event",
+        event: ev.event ?? "message",
+        id: ev.id,
+        data: ev.data,
+      }),
+    ),
+  )

package/src/tool/Tool.test.ts

@@ -1,5 +1,5 @@
 import type { StandardJSONSchemaV1, StandardSchemaV1 } from "@standard-schema/spec"
-import { Effect } from "effect"
+import { Context, Effect, Schema } from "effect"
 import { describe, expect, expectTypeOf, it } from "vitest"
 import type * as Items from "../domain/Items.js"
 import * as Tool from "./Tool.js"
@@ -156,3 +156,153 @@ describe("Tool.decodeArgs", () => {
     expect(exit._tag).toBe("Failure")
   })
 })
+
+describe("Effect Schema inputSchema", () => {
+  const Recipient = Schema.Struct({ to: Schema.String })
+
+  const sendEmail = Tool.make({
+    name: "send_email",
+    description: "Send an email to a single recipient.",
+    inputSchema: Recipient,
+    run: ({ to }) => Effect.succeed(`queued: ${to}`),
+  })
+
+  const callWith = (args: string): Items.ToolCall => ({
+    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))
+    expect(result).toBe("queued: x@y.z")
+  })
+
+  it("type: Input is the schema's Type", () => {
+    type InputOf<T> = T extends Tool.Tool<string, infer I, any, any, any> ? I : never
+    expectTypeOf<InputOf<typeof sendEmail>>().toEqualTypeOf<{ readonly to: string }>()
+  })
+
+  it("type: E and R are inferred from run through the Effect Schema overload", () => {
+    class Mailer extends Context.Service<
+      Mailer,
+      { readonly send: (to: string) => Effect.Effect<string> }
+    >()("test/Mailer") {}
+
+    const tool = Tool.make({
+      name: "send_email",
+      description: "send",
+      inputSchema: Recipient,
+      run: ({ to }) =>
+        Effect.gen(function* () {
+          const mailer = yield* Mailer
+          if (to === "") return yield* Effect.fail("empty" as const)
+          return yield* mailer.send(to)
+        }),
+    })
+
+    expectTypeOf<Tool.ToolE<typeof tool>>().toEqualTypeOf<"empty">()
+    expectTypeOf<Tool.ToolR<typeof tool>>().toEqualTypeOf<Mailer>()
+  })
+
+  it("decodes valid JSON arguments to the typed input", async () => {
+    const input = await Effect.runPromise(Tool.decodeArgs(sendEmail, callWith('{"to":"x@y.z"}')))
+    expect(input).toEqual({ to: "x@y.z" })
+    expectTypeOf(input).toEqualTypeOf<{ readonly to: string }>()
+  })
+
+  it("fails with ToolValidationError when the arguments don't satisfy the schema", async () => {
+    const exit = await Effect.runPromiseExit(Tool.decodeArgs(sendEmail, callWith('{"to":42}')))
+    expect(exit._tag).toBe("Failure")
+  })
+
+  it("renders a JSON Schema descriptor from the wrapped schema", () => {
+    const [descriptor] = Tool.toDescriptors([sendEmail])
+    expect(descriptor?.name).toBe("send_email")
+    expect(descriptor?.inputSchema).toMatchObject({
+      type: "object",
+      properties: { to: { type: "string" } },
+      required: ["to"],
+    })
+  })
+
+  it("accepts an already-wrapped fromEffectSchema value unchanged", async () => {
+    const wrapped = Tool.make({
+      name: "send_email",
+      description: "Send an email to a single recipient.",
+      inputSchema: Tool.fromEffectSchema(Recipient),
+      run: ({ to }) => Effect.succeed(`queued: ${to}`),
+    })
+    expect(Tool.toDescriptors([wrapped])).toEqual(Tool.toDescriptors([sendEmail]))
+    const input = await Effect.runPromise(Tool.decodeArgs(wrapped, callWith('{"to":"x@y.z"}')))
+    expectTypeOf(input).toEqualTypeOf<{ readonly to: string }>()
+  })
+
+  it("signal: decode-only kinds accept an Effect Schema directly", async () => {
+    const escalate = Tool.signal({
+      name: "escalate",
+      description: "Escalate to a human.",
+      inputSchema: Schema.Struct({ reason: Schema.String }),
+    })
+    const input = await Effect.runPromise(
+      Tool.decodeArgs(escalate, {
+        type: "function_call",
+        call_id: "call_2",
+        name: "escalate",
+        arguments: '{"reason":"stuck"}',
+      }),
+    )
+    expect(input).toEqual({ reason: "stuck" })
+    expectTypeOf(input).toEqualTypeOf<{ readonly reason: string }>()
+  })
+})
+
+describe("provider-hosted tools", () => {
+  const localTool = Tool.make({
+    name: "send_email",
+    description: "Send an email.",
+    inputSchema: Tool.fromEffectSchema(Schema.Struct({ to: Schema.String })),
+    run: ({ to }) => Effect.succeed(`sent: ${to}`),
+  })
+  const signalTool = Tool.signal({
+    name: "escalate",
+    description: "Escalate to a human.",
+    inputSchema: Schema.Struct({ reason: Schema.String }),
+  })
+  const hostedTool = Tool.provider({
+    name: "web_search",
+    description: "Search the web.",
+    inputSchema: Tool.noInput,
+    provider: "gemini",
+    config: { kind: "google_search" },
+  })
+  const toolkit = { send_email: localTool, escalate: signalTool, web_search: hostedTool }
+
+  it("descriptorsOf excludes provider-hosted tools", () => {
+    const descriptors = Tool.descriptorsOf(toolkit)
+    expect(descriptors.map((d) => d.name)).toEqual(["send_email", "escalate"])
+  })
+
+  it("toDescriptors drops a ProviderTool from a mixed array", () => {
+    expect(Tool.toDescriptors([localTool, hostedTool]).map((d) => d.name)).toEqual(["send_email"])
+  })
+
+  it("providerToolsOf returns only the provider-hosted tools", () => {
+    const provider = Tool.providerToolsOf(toolkit)
+    expect(provider).toHaveLength(1)
+    expect(provider[0]?.name).toBe("web_search")
+    expect(provider[0]?.provider).toBe("gemini")
+    expect(provider[0]?.config).toEqual({ kind: "google_search" })
+  })
+
+  it("providerToolsOf on an absent toolkit is empty", () => {
+    expect(Tool.providerToolsOf(undefined)).toEqual([])
+  })
+
+  it("isProviderTool narrows the tool kind", () => {
+    expect(Tool.isProviderTool(hostedTool)).toBe(true)
+    expect(Tool.isProviderTool(localTool)).toBe(false)
+    expect(Tool.isProviderTool(signalTool)).toBe(false)
+  })
+})

package/src/tool/Tool.ts

@@ -244,37 +244,114 @@ export type ToolDescriptor = {
   readonly strict?: boolean
 }
 
+const resolveInputSchema = (
+  schema: ToolInputSchema<any> | Schema.Codec<any, any, never, any>,
+): ToolInputSchema<any> =>
+  Schema.isSchema(schema)
+    ? fromEffectSchema(schema as Schema.Codec<any, any, never, any>)
+    : (schema as ToolInputSchema<any>)
+
 /** A model-visible tool with a local `Effect` executor. */
-export const make = <Name extends string, Input, Event, Output, E = never, R = never>(
-  spec: Omit<Tool<Name, Input, Event, Output, E, R>, "_tag">,
-): Tool<Name, Input, Event, Output, E, R> => ({ _tag: "LocalTool", ...spec })
+export const make: {
+  <
+    Name extends string,
+    S extends Schema.Codec<any, any, never, any>,
+    Event,
+    Output,
+    E = never,
+    R = never,
+  >(
+    spec: Omit<Tool<Name, S["Type"], Event, Output, E, R>, "_tag" | "inputSchema"> & {
+      readonly inputSchema: S
+    },
+  ): Tool<Name, S["Type"], Event, Output, E, R>
+  <Name extends string, Input, Event, Output, E = never, R = never>(
+    spec: Omit<Tool<Name, Input, Event, Output, E, R>, "_tag">,
+  ): Tool<Name, Input, Event, Output, E, R>
+} = (
+  spec: Omit<AnyLocalTool, "_tag" | "inputSchema"> & {
+    readonly inputSchema: ToolInputSchema<any> | Schema.Codec<any, any, never, any>
+  },
+): AnyLocalTool => ({
+  _tag: "LocalTool",
+  ...spec,
+  inputSchema: resolveInputSchema(spec.inputSchema),
+})
 
 /**
  * A provider-hosted tool (native web search, code execution, RAG grounding).
  * No local executor — `provider`/`config` drive the provider adapter's
  * rendering. The model sees it; `Toolkit.run` reports it as `non_local_tool`.
  */
-export const provider = <Name extends string, Input, Provider extends string, Config>(
-  spec: Omit<ProviderTool<Name, Input, Provider, Config>, "_tag">,
-): ProviderTool<Name, Input, Provider, Config> => ({ _tag: "ProviderTool", ...spec })
+export const provider: {
+  <
+    Name extends string,
+    S extends Schema.Codec<any, any, never, any>,
+    Provider extends string,
+    Config,
+  >(
+    spec: Omit<ProviderTool<Name, S["Type"], Provider, Config>, "_tag" | "inputSchema"> & {
+      readonly inputSchema: S
+    },
+  ): ProviderTool<Name, S["Type"], Provider, Config>
+  <Name extends string, Input, Provider extends string, Config>(
+    spec: Omit<ProviderTool<Name, Input, Provider, Config>, "_tag">,
+  ): ProviderTool<Name, Input, Provider, Config>
+} = (
+  spec: Omit<ProviderTool<string, any, string, any>, "_tag" | "inputSchema"> & {
+    readonly inputSchema: ToolInputSchema<any> | Schema.Codec<any, any, never, any>
+  },
+): ProviderTool<string, any, string, any> => ({
+  _tag: "ProviderTool",
+  ...spec,
+  inputSchema: resolveInputSchema(spec.inputSchema),
+})
 
 /**
  * A typed control-flow signal to the agent loop (escalate, pause, schedule,
  * hand off). Decode-only: the loop interprets the call rather than executing a
  * handler, so there is no `run`.
  */
-export const signal = <Name extends string, Input>(
-  spec: Omit<SignalTool<Name, Input>, "_tag">,
-): SignalTool<Name, Input> => ({ _tag: "SignalTool", ...spec })
+export const signal: {
+  <Name extends string, S extends Schema.Codec<any, any, never, any>>(
+    spec: Omit<SignalTool<Name, S["Type"]>, "_tag" | "inputSchema"> & {
+      readonly inputSchema: S
+    },
+  ): SignalTool<Name, S["Type"]>
+  <Name extends string, Input>(spec: Omit<SignalTool<Name, Input>, "_tag">): SignalTool<Name, Input>
+} = (
+  spec: Omit<SignalTool<string, any>, "_tag" | "inputSchema"> & {
+    readonly inputSchema: ToolInputSchema<any> | Schema.Codec<any, any, never, any>
+  },
+): SignalTool<string, any> => ({
+  _tag: "SignalTool",
+  ...spec,
+  inputSchema: resolveInputSchema(spec.inputSchema),
+})
 
 /**
  * A typed request for an external actor to respond before the loop resumes
  * (frontend, Telegram, CLI prompt). Decode-only; the loop stops/pauses and
  * resumes by appending the actor's `function_call_output`.
  */
-export const interaction = <Name extends string, Input>(
-  spec: Omit<InteractionTool<Name, Input>, "_tag">,
-): InteractionTool<Name, Input> => ({ _tag: "InteractionTool", ...spec })
+export const interaction: {
+  <Name extends string, S extends Schema.Codec<any, any, never, any>>(
+    spec: Omit<InteractionTool<Name, S["Type"]>, "_tag" | "inputSchema"> & {
+      readonly inputSchema: S
+    },
+  ): InteractionTool<Name, S["Type"]>
+  <Name extends string, Input>(
+    spec: Omit<InteractionTool<Name, Input>, "_tag">,
+  ): InteractionTool<Name, Input>
+} = (
+  spec: Omit<InteractionTool<string, any>, "_tag" | "inputSchema"> & {
+    readonly inputSchema: ToolInputSchema<any> | Schema.Codec<any, any, never, any>
+  },
+): InteractionTool<string, any> => ({
+  _tag: "InteractionTool",
+  ...spec,
+  inputSchema: resolveInputSchema(spec.inputSchema),
+})
 
 /**
  * Return a copy of a tool under a new `name`. Useful for resolving a name
@@ -312,18 +389,39 @@ export const withRun = <
   run: (input: Input, emit: Emit<Event>) => Effect.Effect<Output2, E2, R2>,
 ): Tool<Name, Input, Event, Output2, E2, R2> => ({ ...tool, run })
 
-/** Render tools to provider-agnostic descriptors. Every kind is model-visible. */
+/** True for provider-hosted tools — the kind a provider renders natively. */
+export const isProviderTool = (tool: AnyTool): tool is ProviderTool<string, any, string, any> =>
+  tool._tag === "ProviderTool"
+
+/**
+ * The `ProviderTool`s in a toolkit, for a provider adapter to render as its
+ * native hosted-tool entries (web search, code execution, grounding). The other
+ * kinds render as function declarations via `descriptorsOf`.
+ */
+export const providerToolsOf = (
+  toolkit?: Readonly<Record<string, AnyTool>>,
+): ReadonlyArray<ProviderTool<string, any, string, any>> =>
+  toolkit === undefined ? [] : Object.values(toolkit).filter(isProviderTool)
+
+/**
+ * Render tools to provider-agnostic descriptors. `ProviderTool`s are excluded:
+ * they are provider-hosted and must never leak into the function-declaration
+ * list — each adapter renders them natively via `providerToolsOf`. Every other
+ * kind is model-visible as a declaration.
+ */
 export const toDescriptors = (tools: ReadonlyArray<AnyTool>): ReadonlyArray<ToolDescriptor> =>
-  tools.map((tool) => {
-    const inputSchema = tool.inputSchema["~standard"].jsonSchema.input({
-      target: "draft-2020-12",
+  tools
+    .filter((tool) => !isProviderTool(tool))
+    .map((tool) => {
+      const inputSchema = tool.inputSchema["~standard"].jsonSchema.input({
+        target: "draft-2020-12",
+      })
+      // `strict` only exists on local/provider kinds; signals/interactions omit it.
+      const strict = "strict" in tool ? tool.strict : undefined
+      return strict !== undefined
+        ? { name: tool.name, description: tool.description, inputSchema, strict }
+        : { name: tool.name, description: tool.description, inputSchema }
     })
-    // `strict` only exists on local/provider kinds; signals/interactions omit it.
-    const strict = "strict" in tool ? tool.strict : undefined
-    return strict !== undefined
-      ? { name: tool.name, description: tool.description, inputSchema, strict }
-      : { name: tool.name, description: tool.description, inputSchema }
-  })
 
 /**
  * Render a `Toolkit` (a name-indexed record of tools) to descriptors, treating

package/src/tool/Toolkit.test.ts

@@ -252,6 +252,66 @@ describe("Toolkit.make / compose / namespace - uniqueness", () => {
   })
 })
 
+describe("Toolkit.namespace - typed toolkits", () => {
+  const Query = Schema.Struct({ q: Schema.String })
+  type GeoShape = { readonly lookup: (q: string) => Effect.Effect<string> }
+  class Geo extends Context.Service<Geo, GeoShape>()("test/Geo") {}
+
+  const search = Tool.make({
+    name: "search",
+    description: "",
+    inputSchema: Tool.fromEffectSchema(Query),
+    run: ({ q }) =>
+      Effect.gen(function* () {
+        const geo = yield* Geo
+        if (q === "") return yield* Effect.fail("empty_query" as const)
+        return yield* geo.lookup(q)
+      }),
+  })
+
+  const kit = Toolkit.namespace("geo", Toolkit.make(search))
+
+  it("type: prefixes the name literal of a service-requiring tool", () => {
+    expectTypeOf(kit.geo__search.name).toEqualTypeOf<"geo__search">()
+  })
+
+  it("type: preserves E and R through namespace", () => {
+    expectTypeOf<Toolkit.ToolkitE<typeof kit>>().toEqualTypeOf<"empty_query">()
+    expectTypeOf<Toolkit.ToolkitR<typeof kit>>().toEqualTypeOf<Geo>()
+  })
+
+  it("type: preserves E and R through makeNamespaced", () => {
+    const namespaced = Toolkit.makeNamespaced("geo", search)
+    expectTypeOf(namespaced.geo__search.name).toEqualTypeOf<"geo__search">()
+    expectTypeOf<Toolkit.ToolkitE<typeof namespaced>>().toEqualTypeOf<"empty_query">()
+    expectTypeOf<Toolkit.ToolkitR<typeof namespaced>>().toEqualTypeOf<Geo>()
+  })
+
+  it("type: Toolkit.run surfaces the namespaced tool's R (string E is absorbed)", () => {
+    const stream = Toolkit.run(kit, [])
+    expectTypeOf(stream).toEqualTypeOf<
+      Stream.Stream<import("./ToolEvent.js").ToolEvent, never, Geo>
+    >()
+  })
+
+  it("runtime: renames the tool and executes it under the prefixed name", async () => {
+    const call: ToolCall = {
+      type: "function_call",
+      call_id: "call_1",
+      name: "geo__search",
+      arguments: '{"q":"lisbon"}',
+    }
+    const events = await Effect.runPromise(
+      Stream.runCollect(Toolkit.run(kit, [call])).pipe(
+        Effect.provide(Layer.succeed(Geo, { lookup: (q) => Effect.succeed(`geo:${q}`) })),
+      ),
+    )
+    const outputs = events.filter(isOutput).map((e) => e.result)
+    expect(outputs).toHaveLength(1)
+    expect(outputs[0]).toMatchObject({ _tag: "Ok", tool: "geo__search", value: "geo:lisbon" })
+  })
+})
+
 describe("Toolkit.wrap - middleware", () => {
   const Empty = Schema.Struct({})
   type AuditShape = { readonly record: (name: string) => Effect.Effect<void> }

package/src/tool/Toolkit.ts

@@ -186,8 +186,8 @@ export class DuplicateToolName extends Data.TaggedError("DuplicateToolName")<{
 type PrefixName<Prefix extends string, Name extends string> = `${Prefix}__${Name}`
 
 type PrefixTool<Prefix extends string, T extends AnyTool> =
-  T extends Tool<infer N, infer I, infer Ev, infer O, infer R>
-    ? Tool<PrefixName<Prefix, N>, I, Ev, O, R>
+  T extends Tool<infer N, infer I, infer Ev, infer O, infer E, infer R>
+    ? Tool<PrefixName<Prefix, N>, I, Ev, O, E, R>
     : T extends ProviderTool<infer N, infer I, infer P, infer C>
       ? ProviderTool<PrefixName<Prefix, N>, I, P, C>
       : T extends SignalTool<infer N, infer I>