@theoremjs/agents 0.3.0 → 0.3.1

package/esm/src/providers/openrouter/openai/reasoning-state.js

@@ -0,0 +1,31 @@
+import { jsonObjectSchema } from '../../../kernel/json.js';
+import { isRecord } from '../../../kernel/util/record.js';
+export function collectReasoning(row, details) {
+    let content = '';
+    for (const choice of Array.isArray(row.choices) ? row.choices : []) {
+        if (!isRecord(choice))
+            continue;
+        const delta = isRecord(choice.delta)
+            ? choice.delta
+            : isRecord(choice.message)
+                ? choice.message
+                : undefined;
+        if (!delta)
+            continue;
+        if (typeof delta.reasoning === 'string')
+            content += delta.reasoning;
+        else if (typeof delta.reasoning_content === 'string')
+            content += delta.reasoning_content;
+        for (const raw of Array.isArray(delta.reasoning_details) ? delta.reasoning_details : []) {
+            const detail = jsonObjectSchema.parse(raw);
+            const key = JSON.stringify([detail.index ?? detail.id ?? details.size, detail.type]);
+            const previous = details.get(key);
+            const merged = { ...previous, ...detail };
+            for (const field of ['text', 'summary', 'data'])
+                if (previous && typeof previous[field] === 'string' && typeof detail[field] === 'string')
+                    merged[field] = previous[field] + detail[field];
+            details.set(key, merged);
+        }
+    }
+    return content;
+}

package/esm/src/providers/openrouter/protocol.d.ts

@@ -0,0 +1,8 @@
+import { type Protocol } from '../../kernel/protocols/mod.js';
+import type { CacheSpec } from '../../kernel/types.js';
+/** What an `openRouter` binding sets in `options`. */
+export interface OpenRouterOptions {
+    cache?: CacheSpec;
+}
+/** Chat Completions with OpenRouter's caching, routing, web search, citations, and reasoning. */
+export declare const openRouter: Protocol<OpenRouterOptions>;

package/esm/src/providers/openrouter/protocol.js

@@ -0,0 +1,171 @@
+import { z } from 'zod';
+import { asRecord } from '../../kernel/engine/record.js';
+import { jsonObjectSchema } from '../../kernel/json.js';
+import { extendProtocol } from '../../kernel/protocols/mod.js';
+import { CACHE_MODES, CACHE_TTLS } from '../../kernel/schema.js';
+import { openAi } from '../open-ai/protocol.js';
+import { collectReasoning } from './openai/reasoning-state.js';
+// labels-exempt: builder field description, read by the studio and docs
+const cache = z
+    .strictObject({
+    mode: z
+        .enum(CACHE_MODES)
+        .describe('What is cached: the whole request (`automatic`) or the system instruction only (`system`).'),
+    ttl: z
+        .enum(CACHE_TTLS)
+        .optional()
+        .describe('How long the cache is kept. Absent: the upstream default.'),
+})
+    .describe('Prompt caching, for models that support it.');
+/** What OpenRouter's reasoning comes back as, to be sent back word for word. */
+const reasoning = z.strictObject({
+    details: z.array(jsonObjectSchema),
+    content: z.string().optional(),
+});
+function cacheControl(spec) {
+    return spec.ttl ? { type: 'ephemeral', ttl: spec.ttl } : { type: 'ephemeral' };
+}
+function callIds(message) {
+    const calls = asRecord(message)?.tool_calls;
+    return Array.isArray(calls) ? calls.map((call) => String(asRecord(call)?.id)) : [];
+}
+/** Puts the reasoning OpenRouter wrote back on the assistant message it came with, matched by its calls. */
+function replay(messages, history) {
+    for (const message of messages) {
+        const ids = callIds(message);
+        if (message.role !== 'assistant' || !ids.length)
+            continue;
+        const source = history.find((item) => item.role === 'assistant' &&
+            JSON.stringify((item.tool_calls ?? []).map((call) => call.id)) === JSON.stringify(ids));
+        const data = (source?.reasoning ?? [])
+            .map((item) => reasoning.safeParse(item.data))
+            .find((parsed) => parsed.success);
+        if (!data?.success)
+            continue;
+        message.reasoning_details = data.data.details;
+        if (data.data.content)
+            message.reasoning = data.data.content;
+    }
+}
+function strings(value) {
+    return Array.isArray(value) ? value.filter((item) => typeof item === 'string') : [];
+}
+/** Where OpenRouter puts plain citation lists: the row, its metadata, and each choice. */
+function citedUris(row) {
+    const meta = (record) => [
+        record?.citations,
+        asRecord(record?.providerMetadata)?.citations,
+        asRecord(record?.provider_metadata)?.citations,
+    ];
+    const openrouter = asRecord(row.openrouter);
+    const choices = Array.isArray(row.choices) ? row.choices.map(asRecord) : [];
+    return [
+        ...meta(row),
+        ...meta(openrouter),
+        ...meta(asRecord(openrouter?.providerMetadata)),
+        ...meta(asRecord(openrouter?.provider_metadata)),
+        ...choices.flatMap((choice) => [
+            ...meta(asRecord(choice?.message)),
+            ...meta(asRecord(choice?.delta)),
+        ]),
+    ].flatMap(strings);
+}
+/** Annotations other than URL citations (which the base reads), from the row and its choices. */
+function otherAnnotations(row) {
+    const choices = Array.isArray(row.choices) ? row.choices.map(asRecord) : [];
+    const lists = [
+        row.annotations,
+        asRecord(row.openrouter)?.annotations,
+        ...choices.flatMap((choice) => [
+            asRecord(choice?.message)?.annotations,
+            asRecord(choice?.delta)?.annotations,
+        ]),
+    ];
+    return lists
+        .flatMap((list) => (Array.isArray(list) ? list : []))
+        .filter((item) => asRecord(item)?.type !== 'url_citation');
+}
+function thinking(row) {
+    const choices = Array.isArray(row.choices) ? row.choices : [];
+    return choices
+        .map((choice) => asRecord(asRecord(choice)?.delta)?.thinking)
+        .filter((text) => typeof text === 'string')
+        .join('');
+}
+/** Chat Completions with OpenRouter's caching, routing, web search, citations, and reasoning. */
+export const openRouter = extendProtocol(openAi, {
+    id: 'openRouter',
+    name: 'OpenRouter Chat Completions',
+    description: "Chat Completions with OpenRouter's caching, routing, web search, citations and reasoning.", // labels-exempt: builder field description, read by the studio and docs
+    options: z.strictObject({ cache: cache.optional() }),
+    reasoning,
+    body(body, at) {
+        // why: its fields are Chat Completions ones; a speech request goes as openAi sends it.
+        if (at.profileType !== 'text')
+            return { body };
+        const out = { ...body, provider: { require_parameters: true } };
+        if (out.reasoning_effort !== undefined) {
+            out.reasoning = { effort: out.reasoning_effort };
+            delete out.reasoning_effort;
+        }
+        const messages = Array.isArray(out.messages) ? out.messages : [];
+        const spec = at.options.cache;
+        if (spec?.mode === 'automatic')
+            out.cache_control = cacheControl(spec);
+        if (spec?.mode === 'system' && messages[0]?.role === 'system')
+            messages[0] = {
+                ...messages[0],
+                content: [
+                    { type: 'text', text: messages[0].content ?? '', cache_control: cacheControl(spec) },
+                ],
+            };
+        replay(messages, at.request?.history ?? []);
+        if (at.request?.sessionId)
+            out.session_id = at.request.sessionId;
+        const web = at.builtInTools.includes('webSearch');
+        if (web)
+            out.web_search_options = {};
+        return { body: { ...out, messages }, wroteTools: web ? ['webSearch'] : [] };
+    },
+    read(at) {
+        const details = new Map();
+        const cited = new Set();
+        const reported = new Set();
+        let content = '';
+        return {
+            row(row) {
+                content += collectReasoning(row, details);
+                const events = [];
+                const thought = thinking(row);
+                if (thought && at.request?.summaries !== 'none')
+                    events.push({ type: 'thought', text: thought });
+                const sources = citedUris(row)
+                    .filter((uri) => !cited.has(uri) && cited.add(uri))
+                    .map((uri) => ({ title: uri, uri, type: 'web' }));
+                if (sources.length)
+                    events.push({ type: 'citation', sources });
+                const annotations = otherAnnotations(row).filter((item) => {
+                    const key = JSON.stringify(item);
+                    return !reported.has(key) && reported.add(key);
+                });
+                if (annotations.length)
+                    events.push({
+                        type: 'evidence',
+                        evidence: {
+                            provider: 'openrouter',
+                            kind: 'provider_step',
+                            step: 'annotations',
+                            raw: { annotations },
+                        },
+                    });
+                return { events };
+            },
+            finish() {
+                if (!details.size && !content)
+                    return {};
+                const data = { details: [...details.values()], ...(content ? { content } : {}) };
+                return { events: [{ type: 'reasoning', data }] };
+            },
+        };
+    },
+});

package/esm/src/providers/openrouter/provider.d.ts

@@ -0,0 +1,10 @@
+import { type Provider } from '../../kernel/protocols/provider.js';
+/** What registering `openRouterProvider` takes as `connection`. */
+export interface OpenRouterConnection {
+    baseUrl?: string;
+    decisionUrl?: string;
+    siteUrl?: string;
+    siteName?: string;
+}
+/** OpenRouter: many labs' models behind one key. Chat, speech, images, and decisions. */
+export declare const openRouterProvider: Provider<OpenRouterConnection, string>;

package/esm/src/providers/openrouter/provider.js

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+import { bearer, defineProvider, endpointUrlSchema, } from '../../kernel/protocols/provider.js';
+import { systemOne } from '../system-one/protocol.js';
+import { openRouterEmbedding } from './embedding-protocol.js';
+import { openRouterImages } from './images-protocol.js';
+import { openRouter } from './protocol.js';
+const connection = z.strictObject({
+    baseUrl: endpointUrlSchema
+        .optional()
+        .describe('The API, by default https://openrouter.ai/api/v1.'), // labels-exempt: builder field description, read by the studio and docs
+    decisionUrl: endpointUrlSchema
+        .optional()
+        .describe('The decision API, by default https://openrouter.ai/api/alpha/decisions.'), // labels-exempt: builder field description, read by the studio and docs
+    siteUrl: z
+        .string()
+        .trim()
+        .min(1)
+        .optional()
+        .describe('Sent as HTTP-Referer, for OpenRouter rankings.'), // labels-exempt: builder field description, read by the studio and docs
+    siteName: z
+        .string()
+        .trim()
+        .min(1)
+        .optional()
+        .describe('Sent as X-Title, for OpenRouter rankings.'), // labels-exempt: builder field description, read by the studio and docs
+});
+/** OpenRouter: many labs' models behind one key. Chat, speech, images, and decisions. */
+export const openRouterProvider = defineProvider({
+    id: 'openrouter',
+    name: 'OpenRouter',
+    description: "Many labs' models behind one key.", // labels-exempt: builder field description, read by the studio and docs
+    connection: connection.default({}),
+    key: z.string().trim().min(1),
+    authorize: bearer(),
+    serves(at) {
+        const baseUrl = at.baseUrl ?? 'https://openrouter.ai/api/v1';
+        const headers = {};
+        if (at.siteUrl)
+            headers['HTTP-Referer'] = at.siteUrl;
+        if (at.siteName)
+            headers['X-Title'] = at.siteName;
+        const decisionUrl = at.decisionUrl ?? 'https://openrouter.ai/api/alpha/decisions';
+        return [
+            { protocol: openRouter, baseUrl, headers },
+            { protocol: openRouterEmbedding, baseUrl, headers },
+            { protocol: openRouterImages, baseUrl, headers },
+            { protocol: systemOne, baseUrl: decisionUrl, url: () => decisionUrl, headers },
+        ];
+    },
+});

package/esm/src/providers/shared/carried-tool-files.d.ts

@@ -0,0 +1,7 @@
+import type { InteractionPart, TurnHistoryMessage } from '../../kernel/types.js';
+/**
+ * History for a wire whose tool result holds only the `holds` part types. Every
+ * other file leaves a marker in its place and follows the run of tool results in
+ * one user message, so the results of a parallel call stay together.
+ */
+export declare function withCarriedToolFiles(messages: readonly TurnHistoryMessage[], holds: ReadonlySet<InteractionPart['type']>): TurnHistoryMessage[];

package/esm/src/providers/shared/carried-tool-files.js

@@ -0,0 +1,43 @@
+/** What stands in a tool result where a file it cannot hold was. */
+function carriedFileMarker(part) {
+    return { type: 'text', text: `[${part.type}: sent in the next message]` };
+}
+/** What leads the files of one tool result in the user message that carries them. */
+function carriedFilesLead(msg) {
+    const from = msg.name ? `the ${msg.name} result` : 'a tool result';
+    return { type: 'text', text: `Files from ${from}:` };
+}
+/**
+ * History for a wire whose tool result holds only the `holds` part types. Every
+ * other file leaves a marker in its place and follows the run of tool results in
+ * one user message, so the results of a parallel call stay together.
+ */
+export function withCarriedToolFiles(messages, holds) {
+    const out = [];
+    let carried = [];
+    const flush = () => {
+        if (carried.length === 0)
+            return;
+        out.push({ role: 'user', parts: carried });
+        carried = [];
+    };
+    for (const msg of messages) {
+        if (msg.role !== 'tool') {
+            flush();
+            out.push(msg);
+            continue;
+        }
+        const files = (msg.parts ?? []).filter((part) => !holds.has(part.type));
+        if (files.length === 0) {
+            out.push(msg);
+            continue;
+        }
+        out.push({
+            ...msg,
+            parts: (msg.parts ?? []).map((part) => holds.has(part.type) ? part : carriedFileMarker(part)),
+        });
+        carried.push(carriedFilesLead(msg), ...files);
+    }
+    flush();
+    return out;
+}

package/esm/src/providers/shared/pcm.js

@@ -1,4 +1,4 @@
-/*
+/*probed 2026-09-23:
  * Each transport states the PCM format on the wire (probes 23/09/2026):
  * - Gemini Live: `audio/pcm;rate=24000`
  * - Interactions: `audio/l16; rate=24000; channels=1` (buffered), or
@@ -58,7 +58,7 @@ export function wrapPcmAsWav(pcm, format) {
     writeAscii(view, 8, 'WAVE');
     writeAscii(view, 12, 'fmt ');
     view.setUint32(16, 16, true);
-    view.setUint16(20, 1, true); // PCM
+    view.setUint16(20, 1, true);
     view.setUint16(22, channels, true);
     view.setUint32(24, sampleRate, true);
     view.setUint32(28, byteRate, true);

package/esm/src/providers/shared/protocol-events.d.ts

@@ -0,0 +1,8 @@
+import type { ProtocolEvent } from '../../kernel/protocols/mod.js';
+import type { ModelEvent } from '../../kernel/types.js';
+/**
+ * One event from the shared Gemini and Chat Completions readers, as a protocol event: a finished
+ * call is a `tool_call`, a cancelled one a `tool_cancel`, and a broken one an error. A `done` keeps
+ * only its stop; the protocol adds its own state.
+ */
+export declare function asProtocolEvent<S>(event: ModelEvent): ProtocolEvent<S> | undefined;

package/esm/src/providers/shared/protocol-events.js

@@ -0,0 +1,20 @@
+/**
+ * One event from the shared Gemini and Chat Completions readers, as a protocol event: a finished
+ * call is a `tool_call`, a cancelled one a `tool_cancel`, and a broken one an error. A `done` keeps
+ * only its stop; the protocol adds its own state.
+ */
+export function asProtocolEvent(event) {
+    if (event.type === 'done')
+        return {
+            type: 'done',
+            stop: event.stop,
+            ...(event.interrupted === undefined ? {} : { interrupted: event.interrupted }),
+        };
+    if (event.type !== 'tool')
+        return event;
+    if (event.tool.phase === undefined)
+        return { type: 'tool_call', call: event.tool };
+    if (event.tool.phase === 'cancel')
+        return { type: 'tool_cancel', callId: event.tool.callId };
+    return event.tool.phase === 'error' ? { type: 'error', errorKind: 'bad_response' } : undefined;
+}

package/esm/src/providers/shared/response-identity.d.ts

@@ -1,11 +1,11 @@
-import type { ProviderEvent, TurnResponse } from '../../kernel/types.js';
+import type { ModelEvent, TurnResponse } from '../../kernel/types.js';
 /**
  * Emits as soon as the wire names the response and again whenever that changes, so a
  * call that fails or is cut by a guardrail still records which model served it.
  */
 export declare function foldResponse(known: TurnResponse | undefined, seen: TurnResponse | undefined): {
     known: TurnResponse | undefined;
-    event?: Extract<ProviderEvent, {
+    event?: Extract<ModelEvent, {
         type: 'response';
     }>;
 };

package/esm/src/providers/shared/retry.d.ts

@@ -0,0 +1,17 @@
+/** How a retry waits; a host or test may pass its own. The signal ends the wait early. */
+export type Wait = (ms: number, signal?: AbortSignal | null) => Promise<void>;
+/** All the waiting one call may do between tries; a wait that would pass it sends the last answer back. */
+export declare const WAIT_BUDGET_MS = 5000;
+export declare const waitDefault: Wait;
+export declare function isTransientHttp(status: number): boolean;
+export declare function isTransientThrown(err: unknown): boolean;
+export declare function backoffMs(attempt: number): number;
+/** `retry-after-ms`, else `Retry-After` in seconds or as a date; undefined when absent or unreadable. */
+export declare function retryAfterMs(headers: Headers, now?: number): number | undefined;
+/**
+ * Retries a transient status (408, 429, 5xx gateway) or a network failure while the waits stay
+ * within five seconds in all, at most four times. Each wait is the response's `Retry-After` when it gives one, else
+ * 1s, 2s, 4s then 8s; a wait that would pass the five seconds, or the call's own time left, is not
+ * taken, and the last answer or error goes back as it came. An abort ends the wait.
+ */
+export declare function retryTransient(send: typeof fetch, wait?: Wait, timeLeft?: () => number): typeof fetch;

package/esm/src/providers/shared/retry.js

@@ -0,0 +1,90 @@
+import { isAbortError, isTimeoutError } from '../../guardrails/error.js';
+const BACKOFF_MS = [1000, 2000, 4000, 8000];
+/** All the waiting one call may do between tries; a wait that would pass it sends the last answer back. */
+export const WAIT_BUDGET_MS = 5000;
+/** The most tries after the first: a `Retry-After: 0` costs no wait, so the budget alone never ends it. */
+const MAX_RETRIES = BACKOFF_MS.length;
+const MS_PER_SECOND = 1000;
+const TRANSIENT_STATUSES = new Set([408, 429, 500, 502, 503, 504]);
+const TRANSIENT_THROWN_RE = /name resolution|dns|econnreset|econnrefused|etimedout|connection (?:refused|reset)|error sending request|network|fetch failed|temporarily unavailable|socket|503|502|504/i;
+export const waitDefault = (ms, signal) => new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+        reject(abortReason(signal));
+        return;
+    }
+    const timer = setTimeout(() => {
+        signal?.removeEventListener('abort', onAbort);
+        resolve();
+    }, ms);
+    function onAbort() {
+        clearTimeout(timer);
+        reject(abortReason(signal));
+    }
+    signal?.addEventListener('abort', onAbort, { once: true });
+});
+function abortReason(signal) {
+    return signal.reason ?? new DOMException('The operation was aborted.', 'AbortError');
+}
+export function isTransientHttp(status) {
+    return TRANSIENT_STATUSES.has(status);
+}
+export function isTransientThrown(err) {
+    if (isAbortError(err) || isTimeoutError(err)) {
+        return false;
+    }
+    return TRANSIENT_THROWN_RE.test(String(err));
+}
+export function backoffMs(attempt) {
+    return BACKOFF_MS[Math.min(attempt, BACKOFF_MS.length - 1)];
+}
+/** `retry-after-ms`, else `Retry-After` in seconds or as a date; undefined when absent or unreadable. */
+export function retryAfterMs(headers, now = Date.now()) {
+    const ms = headers.get('retry-after-ms');
+    const after = headers.get('retry-after');
+    let delay;
+    if (ms !== null && ms.trim() !== '' && Number.isFinite(Number(ms))) {
+        delay = Number(ms);
+    }
+    else if (after !== null && after.trim() !== '') {
+        const seconds = Number(after);
+        delay = Number.isFinite(seconds) ? seconds * MS_PER_SECOND : Date.parse(after) - now;
+    }
+    if (delay === undefined || Number.isNaN(delay) || delay < 0) {
+        return undefined;
+    }
+    return delay;
+}
+/**
+ * Retries a transient status (408, 429, 5xx gateway) or a network failure while the waits stay
+ * within five seconds in all, at most four times. Each wait is the response's `Retry-After` when it gives one, else
+ * 1s, 2s, 4s then 8s; a wait that would pass the five seconds, or the call's own time left, is not
+ * taken, and the last answer or error goes back as it came. An abort ends the wait.
+ */
+export function retryTransient(send, wait = waitDefault, timeLeft = () => Number.POSITIVE_INFINITY) {
+    return async (url, init) => {
+        let waited = 0;
+        for (let attempt = 0;; attempt++) {
+            const left = Math.min(WAIT_BUDGET_MS - waited, timeLeft());
+            let delay;
+            try {
+                const res = await send(url, init);
+                if (!isTransientHttp(res.status)) {
+                    return res;
+                }
+                delay = retryAfterMs(res.headers) ?? backoffMs(attempt);
+                if (delay > left || attempt >= MAX_RETRIES) {
+                    return res;
+                }
+                await res.body?.cancel();
+            }
+            catch (err) {
+                delay = backoffMs(attempt);
+                if (!isTransientThrown(err) || delay > left || attempt >= MAX_RETRIES) {
+                    throw err;
+                }
+            }
+            await wait(delay, init?.signal);
+            waited += delay;
+        }
+    };
+}

package/esm/src/providers/shared/sse.d.ts

@@ -1,10 +1,6 @@
-export declare function asObject(parsed: unknown): Record<string, unknown> | undefined;
-export declare function dataRecord(raw: string, sseEvent: string): Record<string, unknown>;
 export declare function takeSsePayloads(buffer: string, pendingEvent?: string): {
     rest: string;
     payloads: Record<string, unknown>[];
     pendingEvent: string;
 };
 export declare function readSseChunks(body: ReadableStream<Uint8Array>): AsyncGenerator<Record<string, unknown>>;
-/** Silently skips malformed payloads, unlike `readSseChunks`. */
-export declare function parseSseStream(body: ReadableStream<Uint8Array>): AsyncGenerator<Record<string, unknown>>;

package/esm/src/providers/shared/sse.js

@@ -1,19 +1,17 @@
-const DATA_PREFIX = 'data: ';
-const EVENT_PREFIX = 'event: ';
 const DONE = '[DONE]';
-export function asObject(parsed) {
+function asObject(parsed) {
     if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
         return parsed;
     }
     return undefined;
 }
-export function dataRecord(raw, sseEvent) {
-    const data = raw.slice(DATA_PREFIX.length).trim();
+function dataRecord(raw, sseEvent) {
+    const data = raw.startsWith('data:') ? raw.slice(5).replace(/^ /, '') : raw;
     const row = {};
     if (sseEvent) {
         row.sseEvent = sseEvent;
     }
-    if (!data || data === DONE) {
+    if (data === DONE) {
         row.eventType = 'sse_done';
         return row;
     }
@@ -35,45 +33,61 @@ export function dataRecord(raw, sseEvent) {
 }
 export function takeSsePayloads(buffer, pendingEvent = '') {
     const payloads = [];
-    const chunks = buffer.split('\n');
-    const rest = chunks.pop() ?? '';
-    let sseEvent = pendingEvent;
-    for (const line of chunks) {
-        if (line.startsWith(EVENT_PREFIX)) {
-            sseEvent = line.slice(EVENT_PREFIX.length).trim();
+    let event = pendingEvent;
+    let data = [];
+    let hasData = false;
+    let consumed = 0;
+    const lineEnds = /\r\n|\r|\n/g;
+    let start = 0;
+    for (let match = lineEnds.exec(buffer); match; match = lineEnds.exec(buffer)) {
+        if (match[0] === '\r' && match.index === buffer.length - 1)
+            break;
+        const line = buffer.slice(start, match.index);
+        start = match.index + match[0].length;
+        if (!line) {
+            if (hasData)
+                payloads.push(dataRecord(data.join('\n'), event));
+            event = '';
+            data = [];
+            hasData = false;
+            consumed = start;
         }
-        else if (line.startsWith(DATA_PREFIX)) {
-            payloads.push(dataRecord(line, sseEvent));
-            sseEvent = '';
+        else if (!line.startsWith(':')) {
+            const colon = line.indexOf(':');
+            const field = colon < 0 ? line : line.slice(0, colon);
+            const value = colon < 0 ? '' : line.slice(colon + 1).replace(/^ /, '');
+            if (field === 'event')
+                event = value;
+            if (field === 'data') {
+                data.push(value);
+                hasData = true;
+            }
         }
     }
-    return { rest, payloads, pendingEvent: sseEvent };
+    return { rest: buffer.slice(consumed), payloads, pendingEvent: '' };
 }
 export async function* readSseChunks(body) {
     const reader = body.getReader();
     const decoder = new TextDecoder();
     let buffer = '';
-    let pendingEvent = '';
-    for (;;) {
-        const { done, value } = await reader.read();
-        if (done)
-            break;
-        buffer += decoder.decode(value, { stream: true });
-        const result = takeSsePayloads(buffer, pendingEvent);
-        buffer = result.rest;
-        pendingEvent = result.pendingEvent;
-        for (const payload of result.payloads) {
-            yield payload;
+    let ended = false;
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done) {
+                ended = true;
+                break;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            const result = takeSsePayloads(buffer);
+            buffer = result.rest;
+            for (const payload of result.payloads)
+                yield payload;
         }
     }
-}
-/** Silently skips malformed payloads, unlike `readSseChunks`. */
-export async function* parseSseStream(body) {
-    for await (const payload of readSseChunks(body)) {
-        if (payload.eventType === 'sse_done')
-            return;
-        if (payload.eventType === 'sse_unparsed')
-            continue;
-        yield payload;
+    finally {
+        if (!ended)
+            void reader.cancel().catch(() => undefined);
+        reader.releaseLock();
     }
 }

package/esm/src/providers/shared/tool-args.d.ts

@@ -1,5 +1,6 @@
 import { type ToolCallBase } from '../../kernel/tools/events.js';
-import type { ProviderEvent } from '../../kernel/types.js';
+import type { ToolCallRequest } from '../../kernel/tools/types.js';
+import type { ModelEvent } from '../../kernel/types.js';
 /**
  * Adapters never invent a history call id or name: a provider that needs a
  * missing one rejects the request, and that error is the answer.
@@ -16,10 +17,8 @@ export type ParsedToolArguments = {
 export declare function parseToolArgumentsObject(raw: unknown): ParsedToolArguments;
 export declare function historyToolArguments(raw: unknown): Record<string, unknown>;
 /** A call sent without an id gets one, so its request and failure events join. */
-export declare function toolCallEvents(call: {
+export declare function toolCallEvents(call: Pick<ToolCallRequest, 'name' | 'stepId' | 'stepCallCount'> & {
     id?: string;
-    name: string;
-    thoughtSignature?: string;
-}, rawArguments: unknown): ProviderEvent[];
-/** Keeps the thought signature: the model still reads the failed call's result back. */
-export declare function malformedToolCall(base: ToolCallBase, message: string, raw: unknown, thoughtSignature?: string): ProviderEvent[];
+}, rawArguments: unknown): ModelEvent[];
+/** The model still reads the failed call's result back. */
+export declare function malformedToolCall(base: ToolCallBase, message: string, raw: unknown, request?: Pick<ToolCallRequest, 'stepId' | 'stepCallCount'>): ModelEvent[];