@cubicecho/agent-core 2.23.0 → 2.25.0

package/dist/stream.d.ts

@@ -1,6 +1,7 @@
-import type OpenAI from "openai";
-import { type ContextBreakdown } from "./retry.ts";
-import { type Fence } from "./thinking.ts";
+import type OpenAI from 'openai';
+import { type Fence } from './thinking.ts';
+import type { ContextBreakdown } from './tokens.ts';
+import type { ToolCall } from './tool-calls.ts';
 /**
  * Reading one streamed turn back into a message.
  *
@@ -11,9 +12,32 @@ import { type Fence } from "./thinking.ts";
  * hangs the turn until somebody presses stop. `EndpointSilent` and `timeoutMs` were exported for
  * this loop long before the loop itself was.
  */
+/**
+ * What the loop changed that would explain a prompt cache that did not hold.
+ *
+ * @remarks
+ * In the order `breakReason` looks, the earliest in the prompt first, since a change there is the
+ * one that costs the rest.
+ */
+export declare const CacheBreakReason: {
+    /** The tool array is not the one the request before declared. */
+    readonly ToolsChanged: 'tools-changed';
+    /** The system messages the prompt opens with are not the ones it opened with before. */
+    readonly SystemChanged: 'system-changed';
+    /** A message the request before sent is gone or different. */
+    readonly HistoryRewritten: 'history-rewritten';
+    /**
+     * Nothing the loop can see: the server's doing — an eviction, another client on the slot — or
+     * a change made where the loop does not look.
+     */
+    readonly NoneKnown: 'none-known';
+};
+/** Any one of the reasons in `CacheBreakReason`. */
+export type CacheBreakReason = (typeof CacheBreakReason)[keyof typeof CacheBreakReason];
 /**
  * What a turn cost, and how it went. Zero throughout the four counts means the server did not say.
  *
+ * @remarks
  * The four counts are always there, as they always were. Everything after them is absent rather
  * than zero when nothing reported or measured it, because a zero cache hit and a server that says
  * nothing about its cache are different findings, and a consumer drawing one as the other is
@@ -28,6 +52,7 @@ export interface TurnUsage {
     /**
      * How much of `prompt` came from the endpoint's prompt cache — a part of it, not in addition.
      *
+     * @remarks
      * The only way a caller can tell whether the prefix it is careful to keep still is actually
      * being reused: a prefix that stops hitting the cache otherwise shows up as a bill and nothing
      * else. Zero is also what a server that does not report it sends; `uncached` is the field whose
@@ -83,12 +108,8 @@ export interface TurnUsage {
      * reported, so a server that says nothing about its cache is never accused of losing it.
      */
     cacheBroken?: boolean;
-    /**
-     * What the loop changed that would explain `cacheBroken`, the earliest in the prompt first,
-     * since a change there is the one that costs the rest. `none-known` is the server's doing — an
-     * eviction, another client on the slot — or a change the loop cannot see. Only on a broken turn.
-     */
-    cacheBreakReason?: "tools-changed" | "system-changed" | "history-rewritten" | "none-known";
+    /** What the loop changed that would explain `cacheBroken`. Only on a broken turn. */
+    cacheBreakReason?: CacheBreakReason;
     /** How many tools the request declared, filled by `runAgentLoop`. */
     toolsDeclared?: number;
     /**
@@ -100,6 +121,7 @@ export interface TurnUsage {
      * What the request was made of, as `contextTokens` cuts it, filled by `runAgentLoop`. Shares of
      * the prompt the turn's first request reported, summing to it, or an estimate where none was.
      *
+     * @remarks
      * Measured on the request as first built, with the tools as `toolSchemaTokens` measures them. A
      * continued turn's `prompt` is every request's summed, so it is larger than this `total`; and
      * where a refusal was answered with a lesser body, the prompt is that body's and the proportions
@@ -107,6 +129,28 @@ export interface TurnUsage {
      */
     context?: ContextBreakdown;
 }
+/**
+ * A usage with nothing counted yet, a fresh object each call since every caller adds into it.
+ *
+ * @returns The four counts at zero and no other field.
+ *
+ * @remarks
+ * Only the four counts every turn has: the optional fields stay absent, which is what says
+ * nothing reported them.
+ */
+export declare const noUsage: () => TurnUsage;
+/**
+ * The four token counts of two usages, added.
+ *
+ * @param a - One usage. Neither is changed.
+ * @param b - The other.
+ * @returns A new usage holding the four sums, and none of the optional fields of either.
+ *
+ * @remarks
+ * Only those: the rest are measurements a sum of would mean nothing, or would mean something only
+ * `runMetrics` knows how to weigh.
+ */
+export declare const addCounts: (a: TurnUsage, b: TurnUsage) => TurnUsage;
 /** One streamed turn, put back together into the shape a loop and a transcript work with. */
 export interface Turn {
     content: string;
@@ -116,12 +160,13 @@ export interface Turn {
      * belongs to, every caller had to narrow before it could read `.function`, to rule out a
      * custom call that this loop cannot produce. Still assignable wherever the union is wanted.
      */
-    toolCalls: OpenAI.ChatCompletionMessageFunctionToolCall[];
+    toolCalls: ToolCall[];
     usage: TurnUsage;
     /**
      * Why the model stopped, in the endpoint's own words — `stop`, `length`, `tool_calls`, or `""`
      * where it never said.
      *
+     * @remarks
      * Reported because `length` is otherwise invisible. A turn cut off at the token ceiling comes
      * back as a well-formed `Turn` with truncated `content`, or with a tool call whose `arguments`
      * stop mid-JSON — so the caller meets a parse failure with nothing to attribute it to. Being
@@ -134,6 +179,7 @@ export interface Turn {
      * The model's scratchpad, as `onThinking` was told it, `""` where it deliberated in silence or
      * not at all.
      *
+     * @remarks
      * Kept because some models want it back. gpt-oss and DeepSeek in thinking mode read the
      * analysis behind a tool call off the assistant message on the next request, so a caller
      * talking to one stores it as `reasoning_content` on that message for as long as the message
@@ -145,6 +191,7 @@ export interface Turn {
 /**
  * Whether the model has said anything a second attempt would say twice.
  *
+ * @remarks
  * A box rather than a return value because it has to be readable *while* the request is in
  * flight: the rules in `retry.ts` are built on the premise that a stream which has already
  * emitted tokens must never be replayed, and by the time a rejected promise is in hand the turn
@@ -171,8 +218,11 @@ export interface StreamTurnOptions {
      */
     idleMs?: number;
     /**
-     * Silence allowed before the first chunk, `idleMs` unless given; zero waits forever.
+     * Silence allowed before the first chunk; zero waits forever.
      *
+     * @defaultValue `idleMs`
+     *
+     * @remarks
      * The first wait is prefill, or a server loading the model, and is routinely many times the
      * gap between tokens. See `Endpoint.firstTokenSeconds` and `firstTokenMs`.
      */
@@ -180,8 +230,11 @@ export interface StreamTurnOptions {
     /** Set by the first chunk that carries anything, so a failed call knows if it can be retried. */
     produced?: Produced;
     /**
-     * The fences that mark a scratchpad written into `content`, `DEFAULT_FENCES` unless given.
+     * The fences that mark a scratchpad written into `content`.
+     *
+     * @defaultValue `DEFAULT_FENCES`
      *
+     * @remarks
      * Text inside one goes to `onThinking` and `reasoning` rather than `onOutput` and `content`.
      * `ALL_FENCES` adds `<thinking>` and `<reasoning>`, which a model can also be quoting; an
      * empty list reads `content` as all answer.
@@ -202,6 +255,14 @@ export interface StreamTurnOptions {
  * Runs one turn as a stream, reporting tokens as they arrive and assembling them back into a
  * message.
  *
+ * @param client - The pooled client for this endpoint.
+ * @param body - The request, which must set `stream: true`.
+ * @param [options] - Cancellation, the idle watchdog, and the token callbacks.
+ * @returns The assembled turn, once the stream has ended. Rejects with `EndpointSilent` where the
+ * endpoint was silent past its allowance, and with whatever the abort raised where `signal`
+ * stopped it — an aborted stream never comes back as a turn.
+ *
+ * @remarks
  * Streaming buys no speed — nothing waits on the reply but the loop itself. It is what makes a
  * run watchable: a run that stalls, loops, or reaches for the wrong tool says so while it is
  * happening instead of only in the row it leaves behind.
@@ -209,9 +270,5 @@ export interface StreamTurnOptions {
  * Two token callbacks rather than an event input, because a turn does not know which step of
  * which run it is: `step` is the caller's flow concept, and wrapping these into an `emit` is one
  * line at the call site.
- *
- * @param client The pooled client for this endpoint.
- * @param body The request, which must set `stream: true`.
- * @param options Cancellation, the idle watchdog, and the token callbacks.
  */
 export declare function streamTurn(client: OpenAI, body: OpenAI.ChatCompletionCreateParamsStreaming, { signal, idleMs, firstChunkMs, produced, fences, startInReasoning, onThinking, onOutput, }?: StreamTurnOptions): Promise<Turn>;

package/dist/stream.js

@@ -1,24 +1,205 @@
-import { EndpointSilent } from "./retry.js";
-import { DEFAULT_FENCES, FenceSplitter } from "./thinking.js";
+import { MS_PER_SECOND } from './platform.js';
+import { EndpointSilent } from './retry.js';
+import { DEFAULT_FENCES, FenceSplitter, SPLIT_REASONING } from './thinking.js';
+import { FUNCTION_TOOL } from './wire.js';
+/**
+ * Reading one streamed turn back into a message.
+ *
+ * The rest of a request is the caller's — which model, which tools, which transcript — but the
+ * reading of the answer is the same everywhere, and it is fiddly in ways the API does not
+ * advertise: tool calls arrive in pieces, an aborted stream ends rather than throws, reasoning
+ * has two spellings and is in no published type, and an endpoint that stops answering mid-stream
+ * hangs the turn until somebody presses stop. `EndpointSilent` and `timeoutMs` were exported for
+ * this loop long before the loop itself was.
+ */
+/**
+ * What the loop changed that would explain a prompt cache that did not hold.
+ *
+ * @remarks
+ * In the order `breakReason` looks, the earliest in the prompt first, since a change there is the
+ * one that costs the rest.
+ */
+export const CacheBreakReason = {
+    /** The tool array is not the one the request before declared. */
+    ToolsChanged: 'tools-changed',
+    /** The system messages the prompt opens with are not the ones it opened with before. */
+    SystemChanged: 'system-changed',
+    /** A message the request before sent is gone or different. */
+    HistoryRewritten: 'history-rewritten',
+    /**
+     * Nothing the loop can see: the server's doing — an eviction, another client on the slot — or
+     * a change made where the loop does not look.
+     */
+    NoneKnown: 'none-known',
+};
+/**
+ * A usage with nothing counted yet, a fresh object each call since every caller adds into it.
+ *
+ * @returns The four counts at zero and no other field.
+ *
+ * @remarks
+ * Only the four counts every turn has: the optional fields stay absent, which is what says
+ * nothing reported them.
+ */
+export const noUsage = () => ({ prompt: 0, completion: 0, total: 0, cached: 0 });
+/**
+ * The four token counts of two usages, added.
+ *
+ * @param a - One usage. Neither is changed.
+ * @param b - The other.
+ * @returns A new usage holding the four sums, and none of the optional fields of either.
+ *
+ * @remarks
+ * Only those: the rest are measurements a sum of would mean nothing, or would mean something only
+ * `runMetrics` knows how to weigh.
+ */
+export const addCounts = (a, b) => ({
+    prompt: a.prompt + b.prompt,
+    completion: a.completion + b.completion,
+    total: a.total + b.total,
+    cached: a.cached + b.cached,
+});
 /**
  * The fields of `timings` a turn reports, under the names `TurnUsage` gives them. A value that is
  * not a finite number is left out rather than guessed at.
  */
 const TIMINGS = [
-    ["prompt_ms", "promptMs"],
-    ["prompt_per_second", "promptTokensPerSecond"],
-    ["predicted_ms", "predictedMs"],
-    ["predicted_per_second", "tokensPerSecond"],
-    ["draft_n", "draftTotal"],
-    ["draft_n_accepted", "draftAccepted"],
+    ['prompt_ms', 'promptMs'],
+    ['prompt_per_second', 'promptTokensPerSecond'],
+    ['predicted_ms', 'predictedMs'],
+    ['predicted_per_second', 'tokensPerSecond'],
+    ['draft_n', 'draftTotal'],
+    ['draft_n_accepted', 'draftAccepted'],
 ];
-const isCount = (value) => typeof value === "number" && Number.isFinite(value);
+/**
+ * Whether a value is a finite number, which is what a count or a timing off the wire has to be.
+ *
+ * @param value - Whatever a server put in a numeric field.
+ * @returns True for a number that is neither `NaN` nor infinite. Zero and a negative pass.
+ */
+const isCount = (value) => typeof value === 'number' && Number.isFinite(value);
+/**
+ * Reads a chunk's usage block and its `timings`, either of which most chunks carry neither of.
+ *
+ * @param chunk - One chunk of the stream. Not written to.
+ * @returns Only what this chunk said. `counts` is empty for a chunk with neither block; a usage
+ * block always sets the three token counts, zero for one it left out; and a cache count, a
+ * reasoning count or a timing is there only where the server sent a finite number.
+ */
+function chunkReport(chunk) {
+    const counts = {};
+    const report = { counts };
+    if (chunk.usage) {
+        counts.prompt = chunk.usage.prompt_tokens ?? 0;
+        counts.completion = chunk.usage.completion_tokens ?? 0;
+        counts.total = chunk.usage.total_tokens ?? 0;
+        const reported = chunk.usage;
+        const hit = reported.prompt_tokens_details?.cached_tokens ?? reported.prompt_cache_hit_tokens;
+        if (isCount(hit)) {
+            report.cacheReport = hit;
+        }
+        const reasoned = reported.completion_tokens_details?.reasoning_tokens;
+        if (isCount(reasoned)) {
+            counts.reasoningTokens = reasoned;
+        }
+    }
+    const { timings } = chunk;
+    if (timings) {
+        for (const [from, to] of TIMINGS) {
+            const value = timings[from];
+            if (isCount(value)) {
+                counts[to] = value;
+            }
+        }
+        if (isCount(timings.cache_n)) {
+            report.cacheTimings = timings.cache_n;
+        }
+    }
+    return report;
+}
+/**
+ * The position a fragment says its call is at, where the server sent a number.
+ *
+ * @param part - One tool-call fragment of a delta.
+ * @returns Its `index`, or `undefined` where the server sent none or something not a number.
+ */
+const fragmentIndex = (part) => typeof part.index === 'number' ? part.index : undefined;
+/**
+ * The call a fragment belongs to, of those begun so far, or none where it opens a new one.
+ *
+ * @param calls - The calls begun so far, in arrival order. Not written to.
+ * @param part - The fragment to place.
+ * @returns The call to add the fragment to — the object in `calls`, not a copy — or `undefined`
+ * where the caller is to begin a new one.
+ *
+ * @remarks
+ * By `index` where the server sent a number, which the SDK types as required and servers have
+ * nonetheless left out: keyed on `undefined`, every call joined into one whose name and
+ * arguments were all of theirs run together. Without one, by `id`; failing that, a fragment
+ * naming a function opens a call and a bare run of arguments continues the latest. A server
+ * that sends whole calls one per chunk at index `0` makes the same mistake the other way, so
+ * a different id, or a name after arguments have begun, opens a new call under that index.
+ */
+function ownerOf(calls, part) {
+    const index = fragmentIndex(part);
+    const name = part.function?.name;
+    let known;
+    if (index !== undefined) {
+        known = calls.findLast((call) => call.index === index);
+    }
+    else if (part.id) {
+        known = calls.find((call) => call.id === part.id);
+    }
+    else if (!name) {
+        known = calls.at(-1);
+    }
+    const another = known && ((part.id && known.id && part.id !== known.id) || (name && known.arguments));
+    return another ? undefined : known;
+}
+/**
+ * A turn's calls as they are handed back: in the order their indexes give, arrival order where a
+ * server sent none, each under an id of its own.
+ *
+ * @param calls - The calls as the stream left them, in arrival order. Not written to or reordered.
+ * @returns One function call per entry. An id is made up for a call the server gave none, and for
+ * one whose id an earlier call in the result already has.
+ */
+function assembledCalls(calls) {
+    const ordered = calls
+        .map((call, order) => ({ call, order }))
+        .sort((a, b) => (a.call.index ?? a.order) - (b.call.index ?? b.order) || a.order - b.order);
+    const minted = new Set();
+    const assembled = [];
+    for (const [position, { call }] of ordered.entries()) {
+        // A server that streams a call without an id still needs one for the result to answer,
+        // and two calls it put under one index must not be answered as one.
+        let id = call.id || `call_${call.index ?? position}`;
+        if (minted.has(id)) {
+            id = `call_${position}_${minted.size}`;
+        }
+        minted.add(id);
+        assembled.push({
+            id,
+            type: FUNCTION_TOOL,
+            function: { name: call.name, arguments: call.arguments },
+        });
+    }
+    return assembled;
+}
 /** The largest delay a timer takes, which is as close to none as the SDK's timeout option goes. */
-const NO_SDK_TIMEOUT = 2 ** 31 - 1;
+const NO_SDK_TIMEOUT = 2_147_483_647;
 /**
  * Runs one turn as a stream, reporting tokens as they arrive and assembling them back into a
  * message.
  *
+ * @param client - The pooled client for this endpoint.
+ * @param body - The request, which must set `stream: true`.
+ * @param [options] - Cancellation, the idle watchdog, and the token callbacks.
+ * @returns The assembled turn, once the stream has ended. Rejects with `EndpointSilent` where the
+ * endpoint was silent past its allowance, and with whatever the abort raised where `signal`
+ * stopped it — an aborted stream never comes back as a turn.
+ *
+ * @remarks
  * Streaming buys no speed — nothing waits on the reply but the loop itself. It is what makes a
  * run watchable: a run that stalls, loops, or reaches for the wrong tool says so while it is
  * happening instead of only in the row it leaves behind.
@@ -26,10 +207,6 @@ const NO_SDK_TIMEOUT = 2 ** 31 - 1;
  * Two token callbacks rather than an event input, because a turn does not know which step of
  * which run it is: `step` is the caller's flow concept, and wrapping these into an `emit` is one
  * line at the call site.
- *
- * @param client The pooled client for this endpoint.
- * @param body The request, which must set `stream: true`.
- * @param options Cancellation, the idle watchdog, and the token callbacks.
  */
 export async function streamTurn(client, body, { signal, idleMs, firstChunkMs, produced, fences = DEFAULT_FENCES, startInReasoning, onThinking, onOutput, } = {}) {
     // Silence, not duration: the timer is rearmed on every chunk, so a model that is still
@@ -48,8 +225,9 @@ export async function streamTurn(client, body, { signal, idleMs, firstChunkMs, p
         talking ||= carried;
         const ms = talking ? idleMs : first;
         clearTimeout(idle);
-        if (ms)
+        if (ms) {
             idle = setTimeout(() => watchdog.abort(), ms);
+        }
     };
     try {
         rearm(false);
@@ -63,8 +241,8 @@ export async function streamTurn(client, body, { signal, idleMs, firstChunkMs, p
         // they read the row and disbelieve it.
         if (watchdog.signal.aborted && !signal?.aborted) {
             const waited = talking ? idleMs : first;
-            const before = talking || first === idleMs ? "" : " before its first token";
-            throw new EndpointSilent(`the model endpoint sent nothing for ${(waited ?? 0) / 1000}s${before}`);
+            const before = talking || first === idleMs ? '' : ' before its first token';
+            throw new EndpointSilent(`the model endpoint sent nothing for ${(waited ?? 0) / MS_PER_SECOND}s${before}`);
         }
         throw error;
     }
@@ -85,18 +263,19 @@ export async function streamTurn(client, body, { signal, idleMs, firstChunkMs, p
         const reasoning = [];
         const splitter = new FenceSplitter(fences, { startInside: startInReasoning });
         const report = (parts) => {
-            for (const part of parts)
-                (part.kind === "reasoning" ? onThinking : onOutput)?.(part.text);
+            for (const part of parts) {
+                (part.kind === SPLIT_REASONING ? onThinking : onOutput)?.(part.text);
+            }
         };
         // In arrival order, sorted by index at the end; a call from a server that sent none keeps
         // its place in the order they arrived.
         const calls = [];
-        const usage = { prompt: 0, completion: 0, total: 0, cached: 0 };
+        const usage = noUsage();
         // The usage block's own cache count wins over llama.cpp's, which is the same number in the
         // servers that send both; kept apart so the order the two arrive in does not decide.
         let cacheReport;
         let cacheTimings;
-        let finishReason = "";
+        let finishReason = '';
         for await (const chunk of stream) {
             // Rearmed on every chunk, latched below on only some: a priming chunk is the endpoint
             // being alive, which is all the watchdog is asking about. Which allowance it rearms with
@@ -106,40 +285,24 @@ export async function streamTurn(client, body, { signal, idleMs, firstChunkMs, p
             // and the two agree there, but a server that reports cumulatively per chunk makes a sum
             // of sums out of an accumulator — and a token count wrong by a factor of the chunk count
             // is not a number anyone would attribute to the stream reader.
-            if (chunk.usage) {
-                usage.prompt = chunk.usage.prompt_tokens ?? 0;
-                usage.completion = chunk.usage.completion_tokens ?? 0;
-                usage.total = chunk.usage.total_tokens ?? 0;
-                const reported = chunk.usage;
-                const hit = reported.prompt_tokens_details?.cached_tokens ?? reported.prompt_cache_hit_tokens;
-                if (isCount(hit))
-                    cacheReport = hit;
-                const reasoned = reported.completion_tokens_details?.reasoning_tokens;
-                if (isCount(reasoned))
-                    usage.reasoningTokens = reasoned;
-            }
-            const { timings } = chunk;
-            if (timings) {
-                for (const [from, to] of TIMINGS) {
-                    const value = timings[from];
-                    if (isCount(value))
-                        usage[to] = value;
-                }
-                if (isCount(timings.cache_n))
-                    cacheTimings = timings.cache_n;
-            }
+            const reported = chunkReport(chunk);
+            Object.assign(usage, reported.counts);
+            cacheReport = reported.cacheReport ?? cacheReport;
+            cacheTimings = reported.cacheTimings ?? cacheTimings;
             // One choice, because that is what an agent loop asks for. A body with `n` above one
             // keeps only the first; nothing here is built to reassemble several at once.
             const choice = chunk.choices[0];
             // Read before the delta guard rather than beside the content. The chunk that carries the
             // reason usually carries an empty delta, and some servers send it with no delta at all —
             // either of which the guard below skips, taking the reason with it.
-            if (choice?.finish_reason)
+            if (choice?.finish_reason) {
                 finishReason = choice.finish_reason;
+            }
             const delta = choice?.delta;
-            if (!delta)
+            if (!delta) {
                 continue;
-            const thinking = delta.reasoning_content || delta.reasoning || "";
+            }
+            const thinking = delta.reasoning_content || delta.reasoning || '';
             // Latched on what the chunk carried, not on its having arrived. Most OpenAI-compatible
             // servers open a stream with a content-free `{"role":"assistant"}` before the first
             // token; latching on that made an endpoint that primes and then wedges unrepeatable,
@@ -152,53 +315,35 @@ export async function streamTurn(client, body, { signal, idleMs, firstChunkMs, p
                 rearm(true);
                 usage.firstTokenMs = Date.now() - started;
             }
-            if (produced && carried)
+            if (produced && carried) {
                 produced.any = true;
+            }
             if (thinking) {
                 reasoning.push(thinking);
                 onThinking?.(thinking);
             }
-            if (delta.content)
+            if (delta.content) {
                 report(splitter.push(delta.content));
+            }
             // Tool calls arrive in pieces, keyed by position: the id in one chunk, the name in
             // another, the arguments spread across the next several.
             for (const part of delta.tool_calls ?? []) {
-                const call = fragmentOf(part);
-                if (part.id)
+                let call = ownerOf(calls, part);
+                if (!call) {
+                    call = { index: fragmentIndex(part), id: '', name: '', arguments: '' };
+                    calls.push(call);
+                }
+                if (part.id) {
                     call.id = part.id;
-                if (part.function?.name)
+                }
+                if (part.function?.name) {
                     call.name += part.function.name;
-                if (part.function?.arguments)
+                }
+                if (part.function?.arguments) {
                     call.arguments += part.function.arguments;
+                }
             }
         }
-        /**
-         * The call a fragment belongs to.
-         *
-         * By `index` where the server sent a number, which the SDK types as required and servers have
-         * nonetheless left out: keyed on `undefined`, every call joined into one whose name and
-         * arguments were all of theirs run together. Without one, by `id`; failing that, a fragment
-         * naming a function opens a call and a bare run of arguments continues the latest. A server
-         * that sends whole calls one per chunk at index `0` makes the same mistake the other way, so
-         * a different id, or a name after arguments have begun, opens a new call under that index.
-         */
-        function fragmentOf(part) {
-            const index = typeof part.index === "number" ? part.index : undefined;
-            const name = part.function?.name;
-            const known = index !== undefined
-                ? calls.findLast((call) => call.index === index)
-                : part.id
-                    ? calls.find((call) => call.id === part.id)
-                    : name
-                        ? undefined
-                        : calls.at(-1);
-            const another = known && ((part.id && known.id && part.id !== known.id) || (name && known.arguments));
-            if (known && !another)
-                return known;
-            const call = { index, id: "", name: "", arguments: "" };
-            calls.push(call);
-            return call;
-        }
         // An aborted stream ends its iteration rather than throwing, so without this a turn cut off
         // halfway — by the watchdog or by someone stopping the run — comes back looking like a
         // complete one, and a truncated answer is recorded as the output. Nothing about the API
@@ -211,31 +356,16 @@ export async function streamTurn(client, body, { signal, idleMs, firstChunkMs, p
         const cached = cacheReport ?? cacheTimings;
         if (cached !== undefined) {
             usage.cached = cached;
-            if (usage.prompt > 0)
+            if (usage.prompt > 0) {
                 usage.uncached = Math.max(0, usage.prompt - cached);
+            }
         }
-        const minted = new Set();
         return {
             content: splitter.output,
-            toolCalls: calls
-                .map((call, order) => ({ call, order }))
-                .sort((a, b) => (a.call.index ?? a.order) - (b.call.index ?? b.order) || a.order - b.order)
-                .map(({ call }, position) => {
-                // A server that streams a call without an id still needs one for the result to answer,
-                // and two calls it put under one index must not be answered as one.
-                let id = call.id || `call_${call.index ?? position}`;
-                if (minted.has(id))
-                    id = `call_${position}_${minted.size}`;
-                minted.add(id);
-                return {
-                    id,
-                    type: "function",
-                    function: { name: call.name, arguments: call.arguments },
-                };
-            }),
+            toolCalls: assembledCalls(calls),
             usage,
             finishReason,
-            reasoning: reasoning.join("") + splitter.reasoning,
+            reasoning: reasoning.join('') + splitter.reasoning,
         };
     }
 }