toolnexus 0.23.0 → 0.25.0

package/dist/client.d.ts

@@ -7,7 +7,7 @@ import type { Toolkit } from "./toolkit.js";
 import type { ToolHints, ToolResult, Request, Answer } from "./types.js";
 import { type PromptCacheOptions } from "./promptcache.js";
 import { type ToolTier, type ToolTierOptions } from "./tooltiers.js";
-import type { PromptInput, UnsupportedPartMode } from "./content.js";
+import type { ContentPart, PromptInput, UnsupportedPartMode } from "./content.js";
 import type { TranslateRequest, TranslateResult } from "./translate.js";
 export type ClientStyle = "openai" | "anthropic";
 export interface ClientOptions {
@@ -26,6 +26,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`. */
@@ -299,7 +303,19 @@ 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;
+};
 /** Token usage, summed across every LLM round trip in the run. */
 export interface Usage {
     promptTokens: number;
@@ -319,6 +335,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. */
@@ -340,12 +358,21 @@ export interface RunResult {
 export type StreamEvent = {
     type: "text";
     delta: string;
-} | {
+}
+/** 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";
+    via?: "call_tool" | "acp";
 } | {
     type: "tool_result";
     id: string;
@@ -353,7 +380,7 @@ export type StreamEvent = {
     output: string;
     isError: boolean;
     metadata?: Record<string, unknown>;
-    via?: "call_tool";
+    via?: "call_tool" | "acp";
 } | {
     type: "usage";
     usage: Usage;
@@ -491,6 +518,10 @@ export declare class Client {
     /** Run one tool through beforeTool/afterTool hooks (mutate args, short-circuit, transform result). */
     private runTool;
     private runToolDirect;
+    /** Runs one response's calls under the tool schedule (SPEC §8 "Tool scheduling"). */
+    private schedule;
+    /** One call's safety; looks through `call_tool` to the tool it names. Unknown ⇒ unsafe. */
+    private callSafe;
     /** ToolTiers `call_tool {name, arguments}` -> the real call; undefined when tiers are off. */
     private unwrapCall;
     /** The RunResult.toolCalls entry: a `call_tool` call is recorded as the real tool with its
@@ -560,11 +591,22 @@ export interface InProcessResponse {
         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;
 };
 /**
  * Build a `fetch`-shaped adapter over a semantic `generate` function (ADR 0030):
@@ -574,9 +616,11 @@ export type InProcessOptions = Omit<ClientOptions, "baseUrl" | "apiKey" | "style
  * 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 declare function createInProcessFetch(generate: (request: InProcessRequest) => InProcessResponse | Promise<InProcessResponse>): typeof fetch;
+export declare function createInProcessFetch(generate?: InProcessGenerate, generateStream?: InProcessGenerateStream): typeof fetch;
 /**
  * A client backed by a model running IN THIS PROCESS — no server, no socket, and no
  * HTTP types to construct.
@@ -587,7 +631,8 @@ export declare function createInProcessFetch(generate: (request: InProcessReques
  * 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 declare function createInProcessClient(opts: InProcessOptions): Client;
 /** Stateful multi-turn conversation: each send() continues the same transcript (memory). */
@@ -603,3 +648,4 @@ export declare class Conversation {
     /** Reset the conversation memory. */
     reset(): void;
 }
+export {};

package/dist/client.js

@@ -3,6 +3,7 @@ import { toOpenAI, toAnthropic } from "./adapters.js";
 import { applyPromptCache } from "./promptcache.js";
 import { buildToolPlan, toolSearch, unwrapCallTool } from "./tooltiers.js";
 import { isRetryableStatus, retryAfterMs } from "./retry.js";
+import { isConcurrencySafe, resolveMaxToolConcurrency, scheduleCalls } from "./toolconcurrency.js";
 import { toOpenAIWire, toAnthropicWire, checkPromptParts } from "./wire.js";
 import { finishReasonFor, argsString, openAIMessagesToAnthropic, openAIToolsToAnthropic, openAIToolChoiceToAnthropic, hasSystemMessage, } from "./translate.js";
 /**
@@ -106,6 +107,20 @@ function delay(ms, signal) {
         signal.addEventListener("abort", () => { clearTimeout(t); reject(signal.reason ?? new Error("aborted")); }, { once: true });
     });
 }
+/** Model tool-call id of each record, kept off the record itself (§8 shape has no id). */
+const callIds = new WeakMap();
+/** RunResult.files: every non-text part of every tool call, in call order (§8). */
+function runFiles(toolCalls) {
+    const out = [];
+    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;
+}
 function addUsage(acc, raw, style) {
     if (!raw)
         return;
@@ -718,15 +733,34 @@ export class Client {
         this.emitTool(name, source, result, t0);
         return { args: a, result };
     }
+    /** Runs one response's calls under the tool schedule (SPEC §8 "Tool scheduling"). */
+    schedule(toolkit, items, key, fn) {
+        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. */
+    callSafe(toolkit, name, args) {
+        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. */
     unwrapCall(name, args) {
         return this.opts.toolTiers ? unwrapCallTool(name, args) : undefined;
     }
     /** 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). */
-    toolCallRecord(name, args, result) {
+    toolCallRecord(name, args, result, callId) {
         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 = { 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. */
     callEvent(id, name, args) {
@@ -886,7 +920,7 @@ export class Client {
                     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) => {
+                const settled = await untilAborted(signal, this.schedule(toolkit, calls, (call) => [call.function.name, safeJson(call.function.arguments)], async (call) => {
                     let { args, result } = await this.runTool(toolkit, call.function.name, safeJson(call.function.arguments), call.id, turn, signal);
                     let halted;
                     const req = pendingOf(result);
@@ -898,12 +932,12 @@ 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);
@@ -919,7 +953,7 @@ export class Client {
     }
     result(model, text, messages, toolCalls, turns, usage, exhausted = false) {
         const incomplete = exhausted && text === "";
-        const r = { text, messages, toolCalls, toolCallCount: toolCalls.length, turns, usage, model, status: incomplete ? "incomplete" : "done" };
+        const r = { text, messages, toolCalls, files: runFiles(toolCalls), toolCallCount: toolCalls.length, turns, usage, model, status: incomplete ? "incomplete" : "done" };
         if (incomplete)
             r.limit = "maxTurns";
         return r;
@@ -927,7 +961,7 @@ export class Client {
     /** §10: a run halted because a tool suspended and no `waitFor` was configured. */
     pendingRun(runStart, model, request, messages, toolCalls, turns, usage) {
         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 };
     }
     /**
      * §10: resolve a suspended tool result. Calls `waitFor(request)`, and on `ok` re-executes the
@@ -1008,7 +1042,7 @@ 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) => {
+                const settled = await untilAborted(signal, this.schedule(toolkit, uses, (use) => [use.name, use.input ?? {}], async (use) => {
                     let { args, result } = await this.runTool(toolkit, use.name, use.input ?? {}, use.id, turn, signal);
                     let halted;
                     const req = pendingOf(result);
@@ -1020,14 +1054,14 @@ 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
                 // resume. Mirrors the OpenAI path and the streaming loops.
                 const content = [];
                 let halted;
                 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;
@@ -1098,6 +1132,13 @@ export class Client {
                         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];
+                            continue;
+                        }
                         if (j?.usage)
                             addUsage(usage, j.usage, "openai");
                         const choice = j?.choices?.[0];
@@ -1136,12 +1177,12 @@ export class Client {
                 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);
                     return r;
-                })));
+                }));
                 for (let i = 0; i < calls.length; i++) {
                     const c = calls[i];
                     let { args, result } = settled[i];
@@ -1151,13 +1192,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);
                 }
@@ -1256,12 +1297,12 @@ export class Client {
                 for (const u of uses)
                     yield this.callEvent(u.id, u.name, u.input);
                 done.clear();
-                const settled = await untilAborted(signal, Promise.all(uses.map(async (u) => {
+                const settled = await untilAborted(signal, this.schedule(toolkit, uses, (u) => [u.name, u.input ?? {}], async (u) => {
                     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 = [];
                 for (let i = 0; i < uses.length; i++) {
                     const u = uses[i];
@@ -1272,14 +1313,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);
                 }
@@ -1302,6 +1343,9 @@ export function createClient(opts) {
  *  it must be syntactically valid. `.invalid` is reserved by RFC 2606 precisely so a
  *  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,
@@ -1310,14 +1354,19 @@ 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) {
-    if (typeof generate !== "function") {
-        throw new Error("toolnexus: createInProcessFetch requires a `generate` function");
+export function createInProcessFetch(generate, generateStream) {
+    if (typeof generate !== "function" && typeof generateStream !== "function") {
+        throw new Error("toolnexus: createInProcessFetch requires a `generate` (or `generateStream`) function");
     }
     const inProcessFetch = async (_url, init) => {
         const body = JSON.parse(String(init?.body ?? "{}"));
+        const request = { 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
         // stream, so refuse instead of degrading silently.
@@ -1325,24 +1374,10 @@ export function createInProcessFetch(generate) {
             throw new Error("toolnexus: createInProcessClient does not support streaming — `generate` returns a " +
                 "complete answer. Use the non-streaming run, or supply a `fetch`/transport that streams.");
         }
-        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 = { 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 ?? "";
@@ -1361,6 +1396,80 @@ export function createInProcessFetch(generate) {
     };
     return inProcessFetch;
 }
+function wireToolCalls(calls, indexed) {
+    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, request) {
+    const enc = new TextEncoder();
+    let open = true;
+    const sse = new ReadableStream({
+        start(controller) {
+            const chunk = (v) => {
+                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.
@@ -1371,11 +1480,15 @@ export function createInProcessFetch(generate) {
  * 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) {
-    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
         // there is no transient failure to ride out: whatever `generate` throws will

package/dist/index.d.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";
@@ -22,5 +24,7 @@ export * from "./batteries.js";
 export { State, context, questionMap, ask, gate, decide, applyGate, applyPolicy, answersOf, staticClassifier, Tape, DEFAULT_BANDS, type NamedQuestion, type Band, type Bands, type Answers, type Rule, type GateOutcome, type Policy, } 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";

package/dist/index.js

@@ -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";
@@ -25,5 +27,7 @@ export * from "./batteries.js";
 export { State, context, questionMap, ask, gate, decide, applyGate, applyPolicy, answersOf, staticClassifier, Tape, DEFAULT_BANDS, } 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";

package/dist/mcp.d.ts

@@ -1,6 +1,11 @@
 import type { ElicitRequest, ElicitResult } from "@modelcontextprotocol/sdk/types.js";
-import { type JSONSchema, type Tool, type ToolHints, type McpStatus, type Request, type Answer } from "./types.js";
+import { type JSONSchema, type Tool, type ToolHints, type ToolResult, type McpStatus, type Request, type Answer } from "./types.js";
 import { type ContentPart } from "./content.js";
+import type { SkillDef } from "./skill.js";
+import { type AuthConfig } from "./mcp2026/source.js";
+import { type TokenStore } from "./mcp2026/auth.js";
+export { Token, MemoryTokenStore, type TokenStore } from "./mcp2026/auth.js";
+export type { AuthConfig } from "./mcp2026/source.js";
 /** Map an MCP `elicitation/create` request onto a §10 `Request`. */
 export declare function elicitationToRequest(params: ElicitRequest["params"]): Request;
 /** Map a resolved §10 `Answer` back onto an MCP `ElicitResult`. ok→accept; declined→decline; else→cancel. */
@@ -18,6 +23,10 @@ export interface LocalServer {
      * builtins/skills filter (nil/empty ⇒ all; ≥1 true ⇒ allowlist; only-false ⇒ drop-list; unknown
      * ⇒ ignore+warn). Applied to the listed defs before sanitize/prefix. */
     tools?: Record<string, boolean>;
+    /** §2.8 lazy tool search: expose `<server>_search_tools` + `<server>_call_tool` instead of every tool. */
+    toolSearch?: boolean;
+    /** §2.8 what this server is for (shown by search_tools). */
+    description?: string;
 }
 export interface RemoteServer {
     type?: "remote";
@@ -28,6 +37,11 @@ export interface RemoteServer {
     timeout?: number;
     /** §2 Gap 7. Per-server tool allowlist (see LocalServer.tools). */
     tools?: Record<string, boolean>;
+    /** §2.8 lazy tool search (see LocalServer.toolSearch). */
+    toolSearch?: boolean;
+    description?: string;
+    /** §2A OAuth 2.1 client settings. Absent ⇒ a 401 still triggers the flow (CIMD if the AS supports it). */
+    auth?: AuthConfig;
 }
 export type ServerConfig = LocalServer | RemoteServer;
 export type McpConfig = Record<string, ServerConfig>;
@@ -46,6 +60,8 @@ export declare function expandEnvHeaders(headers?: Record<string, string>): Reco
  * takes it there.
  */
 export declare function mcpContentToParts(content: unknown): ContentPart[] | undefined;
+/** §2 `tools/call` result → ToolResult (shared by the 2026 path and the frozen fallback). */
+export declare function mapCallToolResult(result: any, server: string): ToolResult;
 export interface McpSource {
     tools: Tool[];
     status: Record<string, McpStatus>;
@@ -56,6 +72,8 @@ export interface McpSource {
      * source is closed.
      */
     resourceTools(): Tool[];
+    /** §2.7 skills served by 2026 servers (skills extension); the toolkit adds them to the `skill` tool. */
+    skills: SkillDef[];
 }
 /** One server's outcome, reported by `loadMcp`'s `onServer` the moment that server finishes. */
 export interface McpServerResult {
@@ -75,12 +93,21 @@ export declare function mcpHints(a: {
     destructiveHint?: boolean;
     openWorldHint?: boolean;
 } | undefined): ToolHints | undefined;
+/** Options shared by loadMcp / listMcpTools for the 2026 path and OAuth (§2A.1a). */
+export interface McpLoadOptions {
+    waitFor?: (request: Request) => Promise<Answer>;
+    signal?: AbortSignal;
+    /** Where OAuth tokens live (default: in memory, per load). */
+    tokenStore?: TokenStore;
+    /** How `auto` OAuth mode opens the authorization URL (default: the OS opener). */
+    openUrl?: (url: string) => unknown | Promise<unknown>;
+    /** Final exposed names to drop; on a tool-search server they are also hidden from search/call. */
+    disableTools?: string[];
+}
 /** Connect to every enabled server, list + convert tools. Failures are isolated.
  *  §2 Gap 3: an optional `signal` bounds each connect/list by the server timeout and aborts the
  *  whole load promptly on parent cancellation. */
-export declare function loadMcp(input: string | object, opts?: {
-    waitFor?: (request: Request) => Promise<Answer>;
-    signal?: AbortSignal;
+export declare function loadMcp(input: string | object, opts?: McpLoadOptions & {
     /**
      * Called once per server the moment it is connected, failed or found disabled (SPEC §4C),
      * so a host can register a fast server's tools while a slow one is still connecting.
@@ -105,6 +132,4 @@ export interface McpInventory {
  * §2 Gap 6. Connect to every enabled server, list tool definitions, and DISCONNECT before
  * returning — no toolkit, no execute wiring, nothing left running. Failure isolation as in loadMcp.
  */
-export declare function listMcpTools(input: string | object, opts?: {
-    signal?: AbortSignal;
-}): Promise<McpInventory>;
+export declare function listMcpTools(input: string | object, opts?: McpLoadOptions): Promise<McpInventory>;