toolnexus 0.23.0 → 0.25.0

package/src/agents/loop.ts

@@ -141,6 +141,7 @@ export async function runGated(
   }
 
   let accumulated: RunResult["toolCalls"] = []
+  let accFiles: RunResult["files"] = []
   let last: RunResult | undefined
   let reason = ""
   for (let attempt = 1; attempt <= maxAttempts; attempt++) {
@@ -149,7 +150,9 @@ export async function runGated(
     // The gate judges the ACCUMULATED work, so an agent cannot escape it by
     // declining to re-declare its plan on a retry.
     accumulated = [...accumulated, ...r.toolCalls]
-    const judged: RunResult = { ...r, toolCalls: accumulated }
+    // RunResult.files is derived from toolCalls, so it accumulates with them (§8).
+    accFiles = [...accFiles, ...(r.files ?? [])]
+    const judged: RunResult = { ...r, toolCalls: accumulated, files: accFiles }
     last = judged
 
     if (r.status && r.status !== "done") {

package/src/agents/runtime.ts

@@ -1012,7 +1012,7 @@ export class AgentRuntime {
     const team = [...(parent.def.team ?? [])].sort()
     const advertised = team.map((n) => (this.registry[n] ? `${n}: ${this.registry[n].does}` : n)).join("; ")
     const rt = this
-    return defineTool({
+    const tool = defineTool({
       name: "task",
       description: `Delegate a subtask to an isolated subagent (it runs on a fresh transcript and returns only its final answer). Available agents — ${advertised}`,
       inputSchema: {
@@ -1068,5 +1068,8 @@ export class AgentRuntime {
         }
       },
     })
+    // Each subagent is isolated and the runtime's own gate schedules the children,
+    // so a fan-out of task calls runs concurrently (SPEC §8 "Tool scheduling").
+    return { ...tool, concurrencySafe: () => true }
   }
 }

package/src/client.ts

@@ -10,6 +10,7 @@ import { toOpenAI, toAnthropic } from "./adapters.js"
 import { applyPromptCache, type PromptCacheOptions } from "./promptcache.js"
 import { buildToolPlan, toolSearch, unwrapCallTool, type ToolPlan, type ToolTier, type ToolTierOptions } from "./tooltiers.js"
 import { isRetryableStatus, retryAfterMs } from "./retry.js"
+import { isConcurrencySafe, resolveMaxToolConcurrency, scheduleCalls } from "./toolconcurrency.js"
 import type { ContentPart, PromptInput, UnsupportedPartMode } from "./content.js"
 import { toOpenAIWire, toAnthropicWire, checkPromptParts, type WireOptions } from "./wire.js"
 import type { TranslateRequest, TranslateResult, TranslatedToolCall } from "./translate.js"
@@ -41,6 +42,10 @@ export interface ClientOptions {
   headers?: Record<string, string>
   systemPrompt?: string
   maxTurns?: number
+  /** Cap on concurrency-safe tool calls of one response running at once (SPEC §8 "Tool
+   * scheduling"). Absent ⇒ env `TOOLNEXUS_MAX_TOOL_CONCURRENCY` when a positive integer, else 10.
+   * Unsafe calls (anything not read-only) always run alone. */
+  maxToolConcurrency?: number
   hooks?: Hooks
   /** Retries on transient LLM errors (`429`/`500`/`502`/`503`/`504`/`529` + network). Default 2.
    * Widen the status set with `retryableStatuses`. */
@@ -318,6 +323,26 @@ export interface ToolCallRecord {
   output: string
   isError: boolean
   metadata?: Record<string, unknown>
+  /** §8: the ToolResult's parts — present iff the result had parts. */
+  parts?: ContentPart[]
+}
+
+/** §8 RunResult.files entry: a non-text part a tool call produced this run. */
+export type RunFile = { type: "image" | "file" | "audio"; mimeType: string; url?: string; data?: string; name?: string; from: string; callId: string }
+
+/** Model tool-call id of each record, kept off the record itself (§8 shape has no id). */
+const callIds = new WeakMap<ToolCallRecord, string>()
+
+/** RunResult.files: every non-text part of every tool call, in call order (§8). */
+function runFiles(toolCalls: ToolCallRecord[]): RunFile[] {
+  const out: RunFile[] = []
+  for (const r of toolCalls) {
+    for (const p of r.parts ?? []) {
+      if (p.type === "text") continue
+      out.push({ ...p, from: r.name, callId: callIds.get(r) ?? "" })
+    }
+  }
+  return out
 }
 
 /** Token usage, summed across every LLM round trip in the run. */
@@ -340,6 +365,8 @@ export interface RunResult {
   messages: any[]
   /** Every tool call made, with its output, error flag, and metadata. */
   toolCalls: ToolCallRecord[]
+  /** Every non-text part produced by tool calls this run, in call order (§8). Always present. */
+  files: RunFile[]
   /** Total number of tool calls (= toolCalls.length). */
   toolCallCount: number
   /** Number of LLM round trips. */
@@ -361,8 +388,12 @@ export interface RunResult {
 /** Events yielded by client.stream(). */
 export type StreamEvent =
   | { type: "text"; delta: string }
-  | { type: "tool_call"; id: string; name: string; args: Record<string, unknown>; via?: "call_tool" }
-  | { type: "tool_result"; id: string; name: string; output: string; isError: boolean; metadata?: Record<string, unknown>; via?: "call_tool" }
+  /** Model reasoning narration (e.g. an ACP agent's `agent_thought_chunk`). Never part of
+   *  the answer text or the RunResult. */
+  | { type: "thought"; delta: string; via?: "acp" }
+  /** `via: "acp"` marks a tool the ACP agent ran itself: reported, never executed by the loop. */
+  | { type: "tool_call"; id: string; name: string; args: Record<string, unknown>; via?: "call_tool" | "acp" }
+  | { type: "tool_result"; id: string; name: string; output: string; isError: boolean; metadata?: Record<string, unknown>; via?: "call_tool" | "acp" }
   | { type: "usage"; usage: Usage }
   | { type: "pending"; request: Request }
   | { type: "done"; result: RunResult }
@@ -990,6 +1021,27 @@ export class Client {
     return { args: a, result }
   }
 
+  /** Runs one response's calls under the tool schedule (SPEC §8 "Tool scheduling"). */
+  private schedule<T, R>(
+    toolkit: Toolkit | undefined,
+    items: T[],
+    key: (item: T) => [string, Record<string, unknown>],
+    fn: (item: T) => Promise<R>,
+  ): Promise<R[]> {
+    return scheduleCalls(items, (item) => {
+      const [name, args] = key(item)
+      return this.callSafe(toolkit, name, args)
+    }, resolveMaxToolConcurrency(this.opts.maxToolConcurrency), fn)
+  }
+
+  /** One call's safety; looks through `call_tool` to the tool it names. Unknown ⇒ unsafe. */
+  private callSafe(toolkit: Toolkit | undefined, name: string, args: Record<string, unknown>): boolean {
+    if (this.opts.toolTiers && name === "tool_search") return true
+    const inner = this.unwrapCall(name, args ?? {})
+    const tool = toolkit?.get(inner ? inner.name : name)
+    return tool ? isConcurrencySafe(tool, inner ? inner.args : (args ?? {})) : false
+  }
+
   /** ToolTiers `call_tool {name, arguments}` -> the real call; undefined when tiers are off. */
   private unwrapCall(name: string, args: Record<string, unknown>): { name: string; args: Record<string, unknown> } | undefined {
     return this.opts.toolTiers ? unwrapCallTool(name, args) : undefined
@@ -997,9 +1049,12 @@ export class Client {
 
   /** The RunResult.toolCalls entry: a `call_tool` call is recorded as the real tool with its
    *  inner arguments, the name hooks and stream events see (the transcript keeps the wrapper). */
-  private toolCallRecord(name: string, args: Record<string, unknown>, result: ToolResult): ToolCallRecord {
+  private toolCallRecord(name: string, args: Record<string, unknown>, result: ToolResult, callId?: string): ToolCallRecord {
     const inner = this.unwrapCall(name, args)
-    return { name: inner ? inner.name : name, args: inner ? inner.args : args, output: result.output, isError: result.isError, metadata: result.metadata }
+    const rec: ToolCallRecord = { name: inner ? inner.name : name, args: inner ? inner.args : args, output: result.output, isError: result.isError, metadata: result.metadata }
+    if (result.parts?.length) rec.parts = result.parts
+    callIds.set(rec, callId ?? "")
+    return rec
   }
 
   /** The stream's tool_call event, naming the real tool for a `call_tool` call. */
@@ -1157,8 +1212,8 @@ export class Client {
         if (calls.length === 0) return this.endRun(runStart, lastModel, msg.content ?? "", messages, toolCalls, turns, usage)
         // execute all tool calls in this turn concurrently (true parallel tool calling)
         done.clear()
-        const settled = await untilAborted(signal, Promise.all(
-          calls.map(async (call: any) => {
+        const settled = await untilAborted(signal, this.schedule(toolkit,
+          calls, (call: any) => [call.function.name, safeJson(call.function.arguments)], async (call: any) => {
             let { args, result } = await this.runTool(toolkit, call.function.name, safeJson(call.function.arguments), call.id, turn, signal)
             let halted: Request | undefined
             const req = pendingOf(result)
@@ -1169,13 +1224,13 @@ export class Client {
             }
             if (!halted && call.id) done.set(call.id, result)
             return { call, args, result, halted }
-          }),
+          },
         ))
         // Record in tool-call order; on the FIRST durable halt, surface it and stop — deterministic,
         // and the later suspensions' placeholder results never enter the transcript (they re-suspend
         // on resume). Mirrors the streaming path.
         for (const s of settled) {
-          toolCalls.push(this.toolCallRecord(s.call.function.name, s.args, s.result))
+          toolCalls.push(this.toolCallRecord(s.call.function.name, s.args, s.result, s.call.id))
           messages.push(toolMessage(s.call.id, s.call.function.name, s.result))
           if (s.halted) return this.pendingRun(runStart, lastModel, s.halted, messages, toolCalls, turns, usage)
         }
@@ -1190,7 +1245,7 @@ export class Client {
 
   private result(model: string, text: string, messages: any[], toolCalls: ToolCallRecord[], turns: number, usage: Usage, exhausted = false): RunResult {
     const incomplete = exhausted && text === ""
-    const r: RunResult = { text, messages, toolCalls, toolCallCount: toolCalls.length, turns, usage, model, status: incomplete ? "incomplete" : "done" }
+    const r: RunResult = { text, messages, toolCalls, files: runFiles(toolCalls), toolCallCount: toolCalls.length, turns, usage, model, status: incomplete ? "incomplete" : "done" }
     if (incomplete) r.limit = "maxTurns"
     return r
   }
@@ -1198,7 +1253,7 @@ export class Client {
   /** §10: a run halted because a tool suspended and no `waitFor` was configured. */
   private pendingRun(runStart: number, model: string, request: Request, messages: any[], toolCalls: ToolCallRecord[], turns: number, usage: Usage): RunResult {
     this.emit({ event: "run", model, turns, toolCalls: toolCalls.length, totalTokens: usage.totalTokens, ms: Date.now() - runStart })
-    return { text: request.prompt, messages, toolCalls, toolCallCount: toolCalls.length, turns, usage, model, status: "pending", pending: request }
+    return { text: request.prompt, messages, toolCalls, files: runFiles(toolCalls), toolCallCount: toolCalls.length, turns, usage, model, status: "pending", pending: request }
   }
 
   /**
@@ -1275,8 +1330,8 @@ export class Client {
         }
         // execute all tool_use blocks in this turn concurrently (true parallel tool calling)
         done.clear()
-        const settled = await untilAborted(signal, Promise.all(
-          uses.map(async (use: any) => {
+        const settled = await untilAborted(signal, this.schedule(toolkit,
+          uses, (use: any) => [use.name, use.input ?? {}], async (use: any) => {
             let { args, result } = await this.runTool(toolkit, use.name, use.input ?? {}, use.id, turn, signal)
             let halted: Request | undefined
             const req = pendingOf(result)
@@ -1287,7 +1342,7 @@ export class Client {
             }
             if (!halted && use.id) done.set(use.id, result)
             return { use, args, result, halted }
-          }),
+          },
         ))
         // Record in tool-call order; on the FIRST durable halt, include that tool_result block, stop
         // building the content, and surface it — deterministic (G3), later suspensions re-suspend on
@@ -1295,7 +1350,7 @@ export class Client {
         const content: any[] = []
         let halted: Request | undefined
         for (const s of settled) {
-          toolCalls.push(this.toolCallRecord(s.use.name, s.args, s.result))
+          toolCalls.push(this.toolCallRecord(s.use.name, s.args, s.result, s.use.id))
           content.push(toolResultBlock(s.use.id, s.result))
           if (s.halted) { halted = s.halted; break }
         }
@@ -1356,6 +1411,13 @@ export class Client {
             const payload = line.slice(5).trim()
             if (payload === "[DONE]") break
             const j = safeParse(payload)
+            // A non-text event from an in-process streaming generate rides in-band so it keeps
+            // its order and arrives as it happens; it goes straight to the consumer and is never
+            // executed. Honoured only on the in-process sentinel URL, never from a real server.
+            if (j && j[IN_PROCESS_SIDE_KEY] && this.opts.baseUrl === IN_PROCESS_BASE_URL) {
+              yield j[IN_PROCESS_SIDE_KEY] as StreamEvent
+              continue
+            }
             if (j?.usage) addUsage(usage, j.usage, "openai")
             const choice = j?.choices?.[0]
             const d = choice?.delta
@@ -1385,11 +1447,11 @@ export class Client {
         messages.push({ role: "assistant", content: content || null, tool_calls: calls.map((c) => ({ id: c.id, type: "function", function: { name: c.name, arguments: c.args } })) })
         for (const c of calls) yield this.callEvent(c.id, c.name, safeJson(c.args))
         done.clear()
-        const settled = await untilAborted(signal, Promise.all(calls.map(async (c) => {
+        const settled = await untilAborted(signal, this.schedule(toolkit, calls, (c) => [c.name, safeJson(c.args)], async (c) => {
           const r = await this.runTool(toolkit, c.name, safeJson(c.args), c.id, turn, signal)
-          if (!pendingOf(r.result) && c.id) done.set(c.id, r.result)
+                    if (!pendingOf(r.result) && c.id) done.set(c.id, r.result)
           return r
-        })))
+        }))
         for (let i = 0; i < calls.length; i++) {
           const c = calls[i]
           let { args, result } = settled[i]
@@ -1399,13 +1461,13 @@ export class Client {
             const r = await this.resolvePending(toolkit, c.name, args, req, c.id, turn, signal)
             result = r.result
             if (r.halted) {
-              toolCalls.push(this.toolCallRecord(c.name, args, result))
+              toolCalls.push(this.toolCallRecord(c.name, args, result, c.id))
               messages.push(toolMessage(c.id, c.name, result))
               yield { type: "done", result: this.pendingRun(runStart, lastModel, r.halted, messages, toolCalls, turns, usage) }
               return
             }
           }
-          toolCalls.push(this.toolCallRecord(c.name, args, result))
+          toolCalls.push(this.toolCallRecord(c.name, args, result, c.id))
           messages.push(toolMessage(c.id, c.name, result))
           yield this.resultEvent(c.id, c.name, safeJson(c.args), result)
         }
@@ -1487,11 +1549,11 @@ export class Client {
         }
         for (const u of uses as any[]) yield this.callEvent(u.id, u.name, u.input)
         done.clear()
-        const settled = await untilAborted(signal, Promise.all((uses as any[]).map(async (u) => {
+        const settled = await untilAborted(signal, this.schedule(toolkit, uses as any[], (u: any) => [u.name, u.input ?? {}], async (u: any) => {
           const r = await this.runTool(toolkit, u.name, u.input ?? {}, u.id, turn, signal)
           if (!pendingOf(r.result) && u.id) done.set(u.id, r.result)
           return r
-        })))
+        }))
         const results: any[] = []
         for (let i = 0; i < uses.length; i++) {
           const u = uses[i] as any
@@ -1502,14 +1564,14 @@ export class Client {
             const r = await this.resolvePending(toolkit, u.name, args, req, u.id, turn, signal)
             result = r.result
             if (r.halted) {
-              toolCalls.push(this.toolCallRecord(u.name, args, result))
+              toolCalls.push(this.toolCallRecord(u.name, args, result, u.id))
               results.push(toolResultBlock(u.id, result))
               messages.push({ role: "user", content: results })
               yield { type: "done", result: this.pendingRun(runStart, lastModel, r.halted, messages, toolCalls, turns, usage) }
               return
             }
           }
-          toolCalls.push(this.toolCallRecord(u.name, args, result))
+          toolCalls.push(this.toolCallRecord(u.name, args, result, u.id))
           results.push(toolResultBlock(u.id, result))
           yield this.resultEvent(u.id, u.name, u.input, result)
         }
@@ -1560,11 +1622,27 @@ export interface InProcessResponse {
   usage?: { promptTokens?: number; completionTokens?: number; totalTokens?: number }
 }
 
+/** A streaming in-process model: `emit` each event as it happens — `text` deltas become
+ *  the streamed answer as they arrive; any other event (thought, an agent's own tool_call /
+ *  tool_result) goes straight to the stream consumer and is never executed by the loop.
+ *  Return the whole message when done (its `toolCalls`, if any, are what the loop runs). */
+export type InProcessGenerateStream = (
+  request: InProcessRequest,
+  emit: (event: StreamEvent) => void,
+) => InProcessResponse | Promise<InProcessResponse>
+
+type InProcessGenerate = (request: InProcessRequest) => InProcessResponse | Promise<InProcessResponse>
+
 /** Options for {@link createInProcessClient}: every client option EXCEPT the three
- *  that describe a wire — `baseUrl`, `apiKey` and `style` — plus `generate`. */
+ *  that describe a wire — `baseUrl`, `apiKey` and `style` — plus `generate` and/or
+ *  `generateStream` (at least one). */
 export type InProcessOptions = Omit<ClientOptions, "baseUrl" | "apiKey" | "style" | "fetch"> & {
   /** Your model. Receives the assembled request, returns one assistant message. */
-  generate: (request: InProcessRequest) => InProcessResponse | Promise<InProcessResponse>
+  generate?: InProcessGenerate
+  /** Your model, streaming for real. With it, `stream()` is incremental; without it a
+   *  `stream()` on a plain `generate` is refused. When both are set, `generate` serves
+   *  non-streaming calls; alone, it serves them too (with a no-op `emit`). */
+  generateStream?: InProcessGenerateStream
 }
 
 /** The sentinel base URL. Never dialled — the transport below answers every request
@@ -1573,6 +1651,10 @@ export type InProcessOptions = Omit<ClientOptions, "baseUrl" | "apiKey" | "style
  *  name can never resolve. */
 const IN_PROCESS_BASE_URL = "http://in-process.invalid/v1"
 
+/** The in-band SSE key that carries a non-text stream event from an in-process
+ *  streaming generate to the consumer (honoured only on {@link IN_PROCESS_BASE_URL}). */
+const IN_PROCESS_SIDE_KEY = "toolnexus_event"
+
 /**
  * Build a `fetch`-shaped adapter over a semantic `generate` function (ADR 0030):
  * the reusable piece of {@link createInProcessClient} — assembles the wire request,
@@ -1581,15 +1663,20 @@ const IN_PROCESS_BASE_URL = "http://in-process.invalid/v1"
  * or the agent runtime's `inProcess` option) goes through this ONE function, so there
  * is no second copy of the request/response assembly to drift.
  *
- * Streaming is refused rather than faked — see the thrown error.
+ * Streaming with only a plain `generate` is refused rather than faked — see the thrown
+ * error. With `generateStream` it streams for real: each text event is written to the
+ * SSE body the moment it is emitted.
  */
-export function createInProcessFetch(generate: (request: InProcessRequest) => InProcessResponse | Promise<InProcessResponse>): typeof fetch {
-  if (typeof generate !== "function") {
-    throw new Error("toolnexus: createInProcessFetch requires a `generate` function")
+export function createInProcessFetch(generate?: InProcessGenerate, generateStream?: InProcessGenerateStream): typeof fetch {
+  if (typeof generate !== "function" && typeof generateStream !== "function") {
+    throw new Error("toolnexus: createInProcessFetch requires a `generate` (or `generateStream`) function")
   }
 
   const inProcessFetch: typeof fetch = async (_url, init) => {
     const body = JSON.parse(String((init as any)?.body ?? "{}"))
+    const request: InProcessRequest = { messages: body.messages ?? [], tools: body.tools, model: body.model, body }
+
+    if (body.stream && generateStream) return inProcessStream(generateStream, request)
 
     // A generate() returns a whole answer, so a stream would be one chunk pretending
     // to be many. Content and delta-count assertions cannot tell that from a real
@@ -1601,25 +1688,11 @@ export function createInProcessFetch(generate: (request: InProcessRequest) => In
       )
     }
 
-    const answer = await generate({
-      messages: body.messages ?? [],
-      tools: body.tools,
-      model: body.model,
-      body,
-    })
+    const answer = generate ? await generate(request) : await generateStream!(request, () => {})
 
     const message: Record<string, any> = { role: "assistant" }
     if (answer.toolCalls && answer.toolCalls.length > 0) {
-      message.tool_calls = answer.toolCalls.map((c, i) => ({
-        id: c.id ?? `call_${i}`,
-        type: "function",
-        function: {
-          name: c.name,
-          // A string is already encoded; anything else is encoded here so a model
-          // author never has to think about the wire.
-          arguments: typeof c.arguments === "string" ? c.arguments : JSON.stringify(c.arguments ?? {}),
-        },
-      }))
+      message.tool_calls = wireToolCalls(answer.toolCalls, false)
     } else {
       message.content = answer.content ?? ""
     }
@@ -1643,6 +1716,77 @@ export function createInProcessFetch(generate: (request: InProcessRequest) => In
   return inProcessFetch
 }
 
+function wireToolCalls(calls: InProcessToolCall[], indexed: boolean): any[] {
+  return calls.map((c, i) => ({
+    ...(indexed ? { index: i } : {}),
+    id: c.id ?? `call_${i}`,
+    type: "function",
+    function: {
+      name: c.name,
+      // A string is already encoded; anything else is encoded here so a model
+      // author never has to think about the wire.
+      arguments: typeof c.arguments === "string" ? c.arguments : JSON.stringify(c.arguments ?? {}),
+    },
+  }))
+}
+
+/** Runs a streaming generate and answers with an OpenAI SSE body written AS EVENTS ARRIVE:
+ *  text → a content delta; any other event → an in-band side chunk for the consumer; then
+ *  (tool calls as one delta | the content as one delta when no text was emitted), the
+ *  finish_reason chunk, usage, and [DONE]. */
+function inProcessStream(generateStream: InProcessGenerateStream, request: InProcessRequest): Response {
+  const enc = new TextEncoder()
+  let open = true
+  const sse = new ReadableStream<Uint8Array>({
+    start(controller) {
+      const chunk = (v: unknown) => {
+        if (open) controller.enqueue(enc.encode(`data: ${JSON.stringify(v)}\n\n`))
+      }
+      let sawText = false
+      void (async () => {
+        try {
+          const answer = await generateStream(request, (ev) => {
+            if (!ev || typeof ev !== "object") return
+            if (ev.type === "text") {
+              if (ev.delta) {
+                sawText = true
+                chunk({ choices: [{ index: 0, delta: { content: ev.delta } }] })
+              }
+              return
+            }
+            chunk({ [IN_PROCESS_SIDE_KEY]: ev })
+          })
+          let finish = "stop"
+          if (answer.toolCalls && answer.toolCalls.length > 0) {
+            chunk({ choices: [{ index: 0, delta: { tool_calls: wireToolCalls(answer.toolCalls, true) } }] })
+            finish = "tool_calls"
+          } else if (!sawText && answer.content) {
+            chunk({ choices: [{ index: 0, delta: { content: answer.content } }] })
+          }
+          chunk({ choices: [{ index: 0, delta: {}, finish_reason: finish }] })
+          const u = answer.usage
+          if (u) {
+            const p = u.promptTokens ?? 0, c = u.completionTokens ?? 0
+            chunk({ choices: [], usage: { prompt_tokens: p, completion_tokens: c, total_tokens: u.totalTokens || p + c } })
+          }
+          if (open) controller.enqueue(enc.encode("data: [DONE]\n\n"))
+          open = false
+          controller.close()
+        } catch (e) {
+          if (open) {
+            open = false
+            controller.error(e)
+          }
+        }
+      })()
+    },
+    cancel() {
+      open = false
+    },
+  })
+  return new Response(sse, { status: 200, headers: { "content-type": "text/event-stream" } })
+}
+
 /**
  * A client backed by a model running IN THIS PROCESS — no server, no socket, and no
  * HTTP types to construct.
@@ -1653,11 +1797,15 @@ export function createInProcessFetch(generate: (request: InProcessRequest) => In
  * The `fetch`-shaped adapter itself is {@link createInProcessFetch} — this function
  * is just that adapter wired into a `Client`.
  *
- * Streaming is refused rather than faked — see {@link createInProcessFetch}.
+ * Streaming is refused rather than faked for a plain `generate`; with `generateStream`
+ * it streams for real — see {@link createInProcessFetch}.
  */
 export function createInProcessClient(opts: InProcessOptions): Client {
-  const { generate, ...rest } = opts
-  const inProcessFetch = createInProcessFetch(generate)
+  const { generate, generateStream, ...rest } = opts
+  if (typeof generate !== "function" && typeof generateStream !== "function") {
+    throw new Error("toolnexus: createInProcessClient requires a `generate` (or `generateStream`) function")
+  }
+  const inProcessFetch = createInProcessFetch(generate, generateStream)
 
   return new Client({
     // Retries default to ZERO here, unlike a network client. There is no wire, so

package/src/index.ts

@@ -10,6 +10,8 @@ export * from "./a2a.js"
 export * from "./acp.js"
 export * from "./serve.js"
 export * from "./mcpserve.js"
+export * from "./mcphandler.js"
+export * from "./mcpserverauth.js"
 export * from "./adapters.js"
 export * from "./translate.js"
 export * from "./toolkit.js"
@@ -45,5 +47,7 @@ export {
 } from "./judge.js"
 export * from "./promptcache.js"
 export * from "./tooltiers.js"
+export * from "./toolconcurrency.js"
 export * from "./models.js"
 export * from "./builtin_extras.js"
+export * from "./media.js"