@andorra-labs/code 0.0.0-stage → 0.1.4

package/dist/src/opencode-provider.js

@@ -0,0 +1,525 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { andorraStream as chatStream } from '../vendor/engine/runtime/ai/api/openai-completions.js';
+import { andorraStream as responsesStream } from '../vendor/engine/runtime/ai/api/openai-responses.js';
+import { andorraStream as messagesStream } from '../vendor/engine/runtime/ai/api/anthropic-messages.js';
+import { andorraConvertMessages, andorraConvertTools } from '../vendor/engine/runtime/ai/api/google-shared.js';
+import { andorraNormalizeContext } from '../vendor/engine/runtime/ai/utils/transcript.js';
+import { andorraClampMaxTokensToContext } from '../vendor/engine/runtime/ai/api/simple-options.js';
+import { isEngineContextOverflow, toEngineMessages } from './provider-engine.js';
+import { assertRequestTimeout, assertStreamIdleTimeout, configuredContextWindow, resolveProviderApiKey, DEFAULT_REQUEST_TIMEOUT_MS, ProviderRequestError } from './providers.js';
+import { OPENCODE_GO_BASE_URL, OPENCODE_GO_MODEL_SNAPSHOT, readOpenCodeModels } from './opencode-catalog.js';
+const OUTPUT_LIMIT = 4 * 1024 * 1024;
+const paths = {
+    'openai-completions': '/openai/v1/chat/completions', 'openai-responses': '/openai/v1/responses',
+    'anthropic-messages': '/anthropic/v1/messages', 'google-generative-ai': '/google/v1beta/models/',
+};
+function malformed() { throw new Error('OpenCode Go returned an invalid or interrupted response.'); }
+function object(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return malformed();
+    return value;
+}
+function argumentsObject(value) { try {
+    object(JSON.parse(value));
+}
+catch {
+    malformed();
+} }
+function counter(value) { return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0 ? value : 0; }
+/** Validate exact wire arguments before the engine's best-effort JSON recovery can accept them. */
+function validateEvents(raw, protocol) {
+    const argumentsByIndex = new Map();
+    const closedBlocks = new Set();
+    const completeArguments = [];
+    const responsesCalls = new Map();
+    let terminalOutput;
+    let completed = false, truncated = false;
+    for (const frame of raw.replace(/\r\n|\r/g, '\n').split('\n\n')) {
+        const data = frame.split('\n').filter(line => line.startsWith('data:')).map(line => line.slice(5).trimStart()).join('\n');
+        if (!data)
+            continue;
+        if (data === '[DONE]') {
+            if (protocol === 'openai-completions')
+                completed = true;
+            continue;
+        }
+        let event;
+        try {
+            event = object(JSON.parse(data));
+        }
+        catch {
+            return malformed();
+        }
+        if (event.error || event.type === 'error' || event.type === 'response.failed')
+            malformed();
+        if (protocol === 'openai-completions') {
+            for (const choice of event.choices ?? []) {
+                if (choice.finish_reason != null)
+                    completed = true;
+                if (choice.finish_reason === 'length')
+                    truncated = true;
+                for (const call of choice.delta?.tool_calls ?? []) {
+                    if (!Number.isSafeInteger(call.index) || call.index < 0)
+                        malformed();
+                    if (call.function?.arguments !== undefined && typeof call.function.arguments !== 'string')
+                        malformed();
+                    argumentsByIndex.set(call.index, (argumentsByIndex.get(call.index) ?? '') + (call.function?.arguments ?? ''));
+                }
+            }
+        }
+        else if (protocol === 'anthropic-messages') {
+            if (event.type === 'message_stop')
+                completed = true;
+            if (event.type === 'message_delta' && event.delta?.stop_reason === 'max_tokens')
+                truncated = true;
+            if (event.type === 'content_block_start' && event.content_block?.type === 'tool_use') {
+                if (!Number.isSafeInteger(event.index) || event.index < 0 || argumentsByIndex.has(event.index))
+                    malformed();
+                object(event.content_block.input);
+                argumentsByIndex.set(event.index, '');
+            }
+            if (event.type === 'content_block_delta' && event.delta?.type === 'input_json_delta') {
+                if (!argumentsByIndex.has(event.index) || closedBlocks.has(event.index) || typeof event.delta.partial_json !== 'string')
+                    malformed();
+                argumentsByIndex.set(event.index, argumentsByIndex.get(event.index) + event.delta.partial_json);
+            }
+            if (event.type === 'content_block_stop' && argumentsByIndex.has(event.index))
+                closedBlocks.add(event.index);
+        }
+        else if (protocol === 'openai-responses') {
+            if ((event.type === 'response.output_item.added' || event.type === 'response.output_item.done') && event.item?.type === 'custom_tool_call')
+                malformed();
+            if (event.type === 'response.output_item.added' && event.item?.type === 'function_call') {
+                if (!Number.isSafeInteger(event.output_index) || event.output_index < 0 || responsesCalls.has(event.output_index)
+                    || typeof event.item.id !== 'string' || !event.item.id || typeof event.item.call_id !== 'string' || !event.item.call_id
+                    || typeof event.item.name !== 'string' || !event.item.name)
+                    malformed();
+                responsesCalls.set(event.output_index, { id: event.item.id, callId: event.item.call_id, name: event.item.name,
+                    arguments: event.item.arguments ?? '', finalized: false });
+            }
+            if (event.type === 'response.function_call_arguments.delta' || event.type === 'response.function_call_arguments.done'
+                || (event.type === 'response.output_item.done' && event.item?.type === 'function_call')) {
+                const call = responsesCalls.get(event.output_index);
+                if (!call || call.finalized || (event.item_id !== undefined && event.item_id !== call.id))
+                    malformed();
+                if (event.type === 'response.function_call_arguments.delta') {
+                    if (typeof event.delta !== 'string')
+                        malformed();
+                    call.arguments += event.delta;
+                }
+                else if (event.type === 'response.function_call_arguments.done') {
+                    if (typeof event.arguments !== 'string')
+                        malformed();
+                    call.arguments = event.arguments;
+                }
+                else {
+                    if (event.item.id !== call.id || event.item.call_id !== call.callId || event.item.name !== call.name || typeof event.item.arguments !== 'string')
+                        malformed();
+                    call.arguments = event.item.arguments;
+                    call.finalized = true;
+                }
+            }
+            if (event.type === 'response.completed' || (event.type === 'response.incomplete' && event.response?.incomplete_details?.reason === 'max_output_tokens'))
+                completed = true;
+            if (event.type === 'response.completed') {
+                if (!Array.isArray(event.response?.output))
+                    malformed();
+                terminalOutput = event.response.output;
+            }
+            if (event.type === 'response.incomplete' && event.response?.incomplete_details?.reason === 'max_output_tokens')
+                truncated = true;
+            if (event.type === 'response.function_call_arguments.done')
+                completeArguments.push(event.arguments);
+            if (event.type === 'response.output_item.done' && event.item?.type === 'function_call')
+                completeArguments.push(event.item.arguments);
+        }
+    }
+    if (!completed || argumentsByIndex.size > 100)
+        malformed();
+    if (!truncated) {
+        if (protocol === 'openai-responses') {
+            const terminalCalls = terminalOutput?.filter(item => item.type === 'function_call') ?? [];
+            if (responsesCalls.size > 100 || terminalCalls.length !== responsesCalls.size)
+                malformed();
+            const terminalIds = new Set();
+            const callIds = new Set();
+            for (const call of responsesCalls.values()) {
+                if (!call.finalized || terminalIds.has(call.id) || callIds.has(call.callId))
+                    malformed();
+                terminalIds.add(call.id);
+                callIds.add(call.callId);
+                argumentsObject(call.arguments);
+                const item = terminalCalls.find(item => item.id === call.id);
+                if (!item || item.call_id !== call.callId || item.name !== call.name || item.arguments !== call.arguments)
+                    malformed();
+            }
+        }
+        if (protocol === 'anthropic-messages' && [...argumentsByIndex.keys()].some(index => !closedBlocks.has(index)))
+            malformed();
+        for (const value of completeArguments)
+            argumentsObject(value);
+        for (const value of argumentsByIndex.values())
+            if (value || protocol === 'openai-completions')
+                argumentsObject(value);
+    }
+}
+/** Native inference only. The URL and protocol routes cannot be redirected to a paid endpoint. */
+export function createOpenCodeAdapter(config, dependencies = {}) {
+    if (config.baseUrl.replace(/\/$/, '') !== OPENCODE_GO_BASE_URL)
+        throw new Error('OpenCode Go requires its fixed HTTPS endpoint.');
+    assertRequestTimeout(config);
+    assertStreamIdleTimeout(config);
+    const transport = dependencies.fetch ?? fetch;
+    const readModels = dependencies.readModels ?? (signal => readOpenCodeModels(signal, transport, config.requestTimeoutMs));
+    const fallbackSession = randomUUID();
+    const models = new Map(OPENCODE_GO_MODEL_SNAPSHOT.map(model => [model.id, model]));
+    return {
+        async listModels(signal) { const catalog = await readModels(signal); for (const model of catalog)
+            models.set(model.id, model); return catalog.map(model => model.id); },
+        async generate(request) {
+            if (request.signal.aborted)
+                throw new Error('OpenCode Go request cancelled.');
+            let metadata = models.get(request.model);
+            if (!metadata?.protocol) {
+                const catalog = await readModels(request.signal);
+                for (const model of catalog)
+                    models.set(model.id, model);
+                metadata = models.get(request.model);
+            }
+            if (!metadata?.protocol)
+                throw new Error('This OpenCode Go model has no verified protocol metadata. Refresh the model catalog or select another Go model.');
+            if (request.messages.some(message => message.images?.length) && !metadata.image)
+                throw new Error('This OpenCode Go model does not support image input.');
+            if (request.maxTokens !== undefined && (!Number.isSafeInteger(request.maxTokens) || request.maxTokens < 1))
+                throw new Error('Invalid auxiliary output allowance.');
+            const key = resolveProviderApiKey(config);
+            if (!key)
+                throw new Error('Save an OpenCode Go API key in /providers before using this provider.');
+            const effort = request.model === config.model ? config.reasoningEffort : undefined;
+            if (effort !== undefined && !metadata.efforts?.includes(effort))
+                throw new Error('The selected OpenCode Go model does not support this reasoning effort.');
+            const session = createHash('sha256').update(`${request.context?.runId ?? fallbackSession}/${request.context?.subagentId ?? ''}`).digest('hex');
+            const protocol = metadata.protocol;
+            const model = { id: request.model, name: request.model, api: protocol, provider: config.id,
+                baseUrl: `${OPENCODE_GO_BASE_URL}/${protocol === 'anthropic-messages' ? 'anthropic/v1' : 'openai/v1'}`,
+                contextWindow: configuredContextWindow(config, request.model) ?? (request.model === config.model ? config.contextWindow : undefined)
+                    ?? metadata.contextWindow ?? 128_000, maxTokens: metadata.maxTokens ?? 8192,
+                input: metadata.image ? ['text', 'image'] : ['text'], reasoning: metadata.reasoning === true,
+                cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+                // Verified Messages effort options use adaptive thinking; the engine otherwise drops
+                // the selected effort in favor of a legacy fixed thinking budget.
+                ...(protocol === 'anthropic-messages' && effort !== undefined ? { compat: { forceAdaptiveThinking: true } } : {}),
+                ...(protocol === 'openai-completions' ? { compat: { supportsDeveloperRole: false, supportsStore: false,
+                        supportsMidConvoSystemMessages: true, requiresReasoningContentOnAssistantMessages: true } } : {}) };
+            const timeoutMs = config.streamIdleTimeoutMs ?? config.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+            const deadline = new AbortController();
+            const signal = AbortSignal.any([request.signal, deadline.signal]);
+            let timer;
+            const refresh = () => { clearTimeout(timer); if (timeoutMs > 0)
+                timer = setTimeout(() => deadline.abort(), timeoutMs); };
+            let wire = '', transportError;
+            let cancelBody = async () => { };
+            const send = async (body) => {
+                refresh();
+                request.onRequest?.();
+                const headers = { 'content-type': 'application/json', 'user-agent': 'andorra-code/0.1', 'x-opencode-session': session };
+                if (protocol === 'anthropic-messages') {
+                    headers['x-api-key'] = key;
+                    headers['anthropic-version'] = '2023-06-01';
+                }
+                else if (protocol === 'google-generative-ai')
+                    headers['x-goog-api-key'] = key;
+                else
+                    headers.authorization = `Bearer ${key}`;
+                const path = protocol === 'google-generative-ai' ? `${paths[protocol]}${encodeURIComponent(request.model)}:streamGenerateContent?alt=sse` : paths[protocol];
+                try {
+                    const response = await transport(`${OPENCODE_GO_BASE_URL}${path}`, { method: 'POST', headers,
+                        body: JSON.stringify(body), signal, redirect: 'error' });
+                    if (!response.ok) {
+                        if (response.status === 413) {
+                            await response.body?.cancel().catch(() => { });
+                            throw new ProviderRequestError('Provider input exceeds the context window.', true);
+                        }
+                        let contextOverflow = false, privacyGate = false;
+                        if ([400, 422].includes(response.status) && response.body) {
+                            const reader = response.body.getReader();
+                            const chunks = [];
+                            let size = 0;
+                            const abort = () => { void reader.cancel().catch(() => { }); };
+                            signal.addEventListener('abort', abort, { once: true });
+                            try {
+                                while (true) {
+                                    signal.throwIfAborted();
+                                    const chunk = await reader.read();
+                                    signal.throwIfAborted();
+                                    if (chunk.done)
+                                        break;
+                                    if ((size += chunk.value.byteLength) > 64 * 1024)
+                                        break;
+                                    chunks.push(chunk.value);
+                                }
+                                if (size <= 64 * 1024) {
+                                    const error = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(Buffer.concat(chunks)));
+                                    contextOverflow = isEngineContextOverflow(JSON.stringify(error));
+                                    const message = error?.error?.message ?? error?.message;
+                                    privacyGate = response.status === 400 && typeof message === 'string'
+                                        && /trains on request data/i.test(message) && /privacy settings/i.test(message);
+                                }
+                            }
+                            catch { /* Error text is never exposed; cancellation is classified by the caller. */ }
+                            finally {
+                                signal.removeEventListener('abort', abort);
+                                await reader.cancel().catch(() => { });
+                                reader.releaseLock();
+                            }
+                        }
+                        else
+                            await response.body?.cancel().catch(() => { });
+                        if (contextOverflow)
+                            throw new ProviderRequestError('Provider input exceeds the context window.', true);
+                        if (privacyGate)
+                            throw new ProviderRequestError('OpenCode Go blocked this model under your workspace privacy settings because the provider trains on request data.');
+                        throw new ProviderRequestError(`OpenCode Go request failed (HTTP ${response.status}). Check the Go API key, subscription, and model availability.`);
+                    }
+                    if (!response.body || !/text\/event-stream/i.test(response.headers.get('content-type') ?? '')) {
+                        await response.body?.cancel().catch(() => { });
+                        malformed();
+                    }
+                    const reader = response.body.getReader();
+                    let size = 0, ended = false;
+                    const decoder = new TextDecoder('utf-8', { fatal: true });
+                    let controller;
+                    const finish = () => { ended = true; clearTimeout(timer); signal.removeEventListener('abort', abort); };
+                    cancelBody = async () => { if (!ended) {
+                        finish();
+                        await reader.cancel().catch(() => { });
+                        reader.releaseLock();
+                    } };
+                    const abort = () => { if (!ended) {
+                        controller.error(new Error('OpenCode Go request ended.'));
+                        void cancelBody();
+                    } };
+                    const stream = new ReadableStream({
+                        start(value) { controller = value; signal.addEventListener('abort', abort, { once: true }); if (signal.aborted)
+                            abort(); },
+                        async pull(value) {
+                            try {
+                                const chunk = await reader.read();
+                                if (ended)
+                                    return;
+                                if (chunk.done) {
+                                    wire += decoder.decode();
+                                    finish();
+                                    reader.releaseLock();
+                                    value.close();
+                                    return;
+                                }
+                                if ((size += chunk.value.byteLength) > OUTPUT_LIMIT)
+                                    throw new Error('OpenCode Go response exceeds the 4 MiB limit.');
+                                wire += decoder.decode(chunk.value, { stream: true });
+                                refresh();
+                                value.enqueue(chunk.value);
+                            }
+                            catch (error) {
+                                if (!ended) {
+                                    transportError = error;
+                                    value.error(error);
+                                    await cancelBody();
+                                }
+                            }
+                        }, cancel() { return cancelBody(); },
+                    }, { highWaterMark: 0 });
+                    return new Response(stream, { headers: response.headers });
+                }
+                catch (error) {
+                    transportError = error;
+                    throw error;
+                }
+            };
+            try {
+                let result;
+                if (protocol === 'google-generative-ai')
+                    result = await googleResponse(request, model, send, effort);
+                else {
+                    const nativeRequest = { ...request, messages: request.messages.map(message => {
+                            const saved = message.providerContinuation;
+                            return saved && (saved.api !== model.api || saved.provider !== model.provider || saved.model !== model.id)
+                                ? { ...message, reasoningContent: undefined } : message;
+                        }) };
+                    const context = andorraNormalizeContext({ messages: toEngineMessages(nativeRequest, model), tools: request.tools });
+                    const nativeFetch = async (_url, init) => send(JSON.parse(String(init?.body)));
+                    const options = {
+                        apiKey: 'andorra-transport-owned', fetch: nativeFetch, signal, maxRetries: 0,
+                        maxTokens: andorraClampMaxTokensToContext(model, context, Math.min(request.maxTokens ?? model.maxTokens, model.maxTokens)),
+                        ...(effort !== undefined ? protocol === 'anthropic-messages' ? { thinkingEnabled: true, effort } : { reasoningEffort: effort } : {}),
+                    };
+                    const stream = protocol === 'openai-completions' ? chatStream(model, context, options)
+                        : protocol === 'openai-responses' ? responsesStream(model, context, options) : messagesStream(model, context, options);
+                    for await (const event of stream) {
+                        if (event.type === 'text_delta')
+                            request.onText?.(event.delta);
+                        if (event.type === 'thinking_delta')
+                            request.onReasoning?.(event.delta);
+                    }
+                    if (transportError)
+                        throw transportError;
+                    validateEvents(wire, protocol);
+                    const output = await stream.result();
+                    if (output.stopReason === 'error' || output.stopReason === 'aborted' || output.stopReason === 'pending')
+                        malformed();
+                    result = engineResponse(output, config.id, request.model);
+                }
+                if (transportError)
+                    throw transportError;
+                if (signal.aborted)
+                    throw new Error('OpenCode Go request ended.');
+                const ids = new Set();
+                if (result.toolCalls.length > 100)
+                    malformed();
+                for (const call of result.toolCalls) {
+                    if (!call.id || !call.name || ids.has(call.id))
+                        malformed();
+                    ids.add(call.id);
+                    argumentsObject(call.arguments);
+                }
+                return result;
+            }
+            catch (error) {
+                if (request.signal.aborted)
+                    throw new Error('OpenCode Go request cancelled.');
+                if (deadline.signal.aborted)
+                    throw new Error('OpenCode Go request timed out.');
+                if (error instanceof ProviderRequestError)
+                    throw error;
+                if (error instanceof Error && /^OpenCode Go (?:response exceeds|returned)/.test(error.message))
+                    throw error;
+                throw new Error('OpenCode Go request failed. Check the Go connection and model availability.');
+            }
+            finally {
+                clearTimeout(timer);
+                await cancelBody();
+            }
+        },
+    };
+}
+function engineResponse(output, provider, model) {
+    const thinking = output.content.filter(block => block.type === 'thinking').map(block => ({ type: 'thinking',
+        thinking: block.thinking, ...(block.thinkingSignature ? { thinkingSignature: output.api === 'openai-completions'
+                && ['reasoning', 'reasoning_text'].includes(block.thinkingSignature) ? 'reasoning_content' : block.thinkingSignature } : {}),
+        ...(block.redacted ? { redacted: true } : {}) }));
+    return { text: output.content.filter(block => block.type === 'text').map(block => block.text).join(''),
+        toolCalls: output.stopReason === 'length' ? [] : output.content.filter(block => block.type === 'toolCall').map(block => ({ id: block.id, name: block.name, arguments: JSON.stringify(block.arguments) })), stopReason: output.stopReason,
+        ...(thinking.length ? { providerContinuation: { api: output.api, provider, model, thinking },
+            ...(output.api === 'openai-completions' ? { reasoningContent: thinking.map(block => block.thinking).join('') } : {}) } : {}),
+        usage: { inputTokens: counter(output.usage.input) + counter(output.usage.cacheRead) + counter(output.usage.cacheWrite),
+            outputTokens: counter(output.usage.output), cacheRead: counter(output.usage.cacheRead), cacheWrite: counter(output.usage.cacheWrite), requests: 1 } };
+}
+/** Gemini signatures can attach to text AND tool calls; retain the exact parts as opaque replay. */
+async function googleResponse(request, model, send, effort) {
+    const engineMessages = toEngineMessages(request, model);
+    // The generic engine boundary stores only thinking blocks. Gemini's entire signed model
+    // turn is kept in that opaque slot and restored after the shared transcript conversion.
+    for (const [index, message] of engineMessages.entries())
+        if (message.role === 'assistant') {
+            message.content = message.content.filter(block => block.type !== 'thinking');
+            const continuation = request.messages[index].providerContinuation;
+            if (continuation?.api !== 'google-generative-ai' || continuation.provider !== model.provider || continuation.model !== model.id)
+                continue;
+            const saved = continuation.thinking.find(block => block.thinkingSignature)?.thinkingSignature;
+            if (!saved)
+                continue;
+            let savedParts;
+            try {
+                savedParts = JSON.parse(saved);
+            }
+            catch {
+                malformed();
+            }
+            if (!Array.isArray(savedParts))
+                malformed();
+            // Restore this exact assistant message before normalization can skip empty turns.
+            // Signatures on text and function calls survive the shared Gemini serializer too.
+            message.content = savedParts.flatMap((part) => {
+                object(part);
+                if (part.functionCall)
+                    return [{ type: 'toolCall', id: part.functionCall.id, name: part.functionCall.name,
+                            arguments: object(part.functionCall.args ?? {}), ...(part.thoughtSignature ? { thoughtSignature: part.thoughtSignature } : {}) }];
+                if (typeof part.text === 'string')
+                    return part.thought ? [{ type: 'thinking', thinking: part.text, thinkingSignature: part.thoughtSignature }]
+                        : [{ type: 'text', text: part.text, textSignature: part.thoughtSignature }];
+                return [];
+            });
+        }
+    const context = andorraNormalizeContext({ messages: engineMessages, tools: request.tools });
+    const contents = andorraConvertMessages(model, context);
+    const system = request.messages.filter(message => message.role === 'system').map(message => message.content).join('\n\n');
+    const response = await send({ contents, ...(system ? { systemInstruction: { parts: [{ text: system }] } } : {}),
+        tools: andorraConvertTools(request.tools), generationConfig: { maxOutputTokens: andorraClampMaxTokensToContext(model, context, Math.min(request.maxTokens ?? model.maxTokens, model.maxTokens)),
+            ...(effort ? { thinkingConfig: effort === 'none' ? { thinkingBudget: 0 } : { thinkingLevel: effort.toUpperCase() } } : {}) } });
+    const text = [], thoughts = [], parts = [];
+    const calls = [];
+    let usage, finish, raw = '';
+    const reader = response.body.getReader(), decoder = new TextDecoder('utf-8', { fatal: true });
+    const accept = (frame) => {
+        const data = frame.replace(/\r\n|\r/g, '\n').split('\n').filter(line => line.startsWith('data:')).map(line => line.slice(5).trimStart()).join('\n');
+        if (!data)
+            return;
+        const chunk = object(JSON.parse(data));
+        if (chunk.error)
+            malformed();
+        const candidate = chunk.candidates?.[0];
+        if (candidate?.finishReason)
+            finish = candidate.finishReason;
+        if (chunk.usageMetadata)
+            usage = chunk.usageMetadata;
+        for (const part of candidate?.content?.parts ?? []) {
+            object(part);
+            parts.push(part);
+            if (typeof part.text === 'string') {
+                if (part.thought) {
+                    thoughts.push(part.text);
+                    request.onReasoning?.(part.text);
+                }
+                else {
+                    text.push(part.text);
+                    request.onText?.(part.text);
+                }
+            }
+            if (part.functionCall) {
+                const call = object(part.functionCall);
+                const id = typeof call.id === 'string' && call.id ? call.id : randomUUID();
+                call.id = id;
+                if (typeof call.name !== 'string' || !call.name)
+                    malformed();
+                calls.push({ id, name: call.name, arguments: JSON.stringify(object(call.args ?? {})) });
+            }
+        }
+    };
+    try {
+        while (true) {
+            const chunk = await reader.read();
+            raw += chunk.done ? decoder.decode() : decoder.decode(chunk.value, { stream: true });
+            let boundary;
+            while ((boundary = /(?:\r\n|\r(?!\n)|\n){2}/.exec(raw))) {
+                accept(raw.slice(0, boundary.index));
+                raw = raw.slice(boundary.index + boundary[0].length);
+            }
+            if (chunk.done) {
+                if (raw.trim())
+                    accept(raw);
+                break;
+            }
+        }
+    }
+    finally {
+        await reader.cancel().catch(() => { });
+        reader.releaseLock();
+    }
+    if (finish !== 'STOP' && finish !== 'MAX_TOKENS')
+        malformed();
+    const continuation = { api: 'google-generative-ai', provider: model.provider, model: model.id,
+        thinking: [{ type: 'thinking', thinking: '', thinkingSignature: JSON.stringify(parts) }] };
+    return { text: text.join(''), toolCalls: finish === 'MAX_TOKENS' ? [] : calls, stopReason: finish === 'MAX_TOKENS' ? 'length' : calls.length ? 'toolUse' : 'stop',
+        providerContinuation: continuation, usage: { inputTokens: counter(usage?.promptTokenCount),
+            outputTokens: counter(usage?.candidatesTokenCount) + counter(usage?.thoughtsTokenCount), cacheRead: counter(usage?.cachedContentTokenCount), requests: 1 } };
+}

package/dist/src/paged-transcript.d.ts

@@ -0,0 +1,58 @@
+type Body = {
+    text: string;
+    detail?: string;
+};
+type Metadata<T extends Body> = Omit<T, 'text' | 'detail'>;
+/** Session-only disk transcript: bodies are paged, small ordering/timing metadata remains live. */
+export declare class PagedTranscript<T extends Body, R> {
+    private readonly options;
+    private entries;
+    private cache;
+    private cachedChars;
+    private fd?;
+    private folder?;
+    private path?;
+    private offset;
+    private diskFailed;
+    private closed;
+    private omitted;
+    constructor(options?: {
+        temporaryDirectory?: string;
+    });
+    get diagnostics(): {
+        entries: number;
+        cacheEntries: number;
+        cacheChars: number;
+        path: string | undefined;
+        omitted: boolean;
+    };
+    append(value: T): void;
+    private size;
+    private remember;
+    private materialize;
+    window(options: {
+        prefix: R[];
+        height: number;
+        scroll: number;
+        key: string;
+        render: (entry: T) => R[];
+        revision?: (metadata: Metadata<T>) => string;
+    }): {
+        rows: R[];
+        scroll: number;
+        total: number;
+    };
+    /**
+     * Drop every entry so the next render shows only the caller's prefix.
+     *
+     * This is the non-terminal counterpart of {@link close}: the spool file, its descriptor and the
+     * class's usability are all kept. Every entry is removed from the live list and the body cache,
+     * and the file itself is truncated back to zero, so the cleared bodies are not merely unreachable
+     * but gone from disk. Writes are positional `writeSync` calls at absolute offsets, so resetting
+     * the write offset together with the truncation is what keeps an entry appended after a clear
+     * from landing at a stale offset and being read back from the wrong bytes.
+     */
+    clear(): void;
+    close(): void;
+}
+export {};