maka-agent 0.2.0-dev.43.20260919 → 0.2.0-dev.45.20260921

package/node_modules/@maka/runtime/dist/commandcode-cli-language-model.js

@@ -1,837 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-/**
- * Command Code CLI transport: the `/alpha/generate` wire, exposed as an AI SDK
- * language model. The Go plan's keys are answered by
- * `/provider/v1/chat/completions` with `403 upgrade_required`, so this is the
- * wire that serves them.
- *
- * Shape (see also the MIT-licensed `pi-commandcode-provider` and
- * `dsh-commandcode-provider`):
- *   POST {apiBase}/alpha/generate
- *   body   { config, memory, taste, skills, params: { model, messages, tools,
- *            system, max_tokens, temperature, stream, reasoning_effort? }, threadId }
- *   events SSE `data:` lines carrying AI SDK stream parts: `text-delta`,
- *          `reasoning-start|delta|end`, `tool-call`, `finish`, `error`.
- *   errors 403 `upgrade_required` is a plan gate, not a bad key.
- */
-import { randomUUID } from 'node:crypto';
-import { APICallError, } from '@ai-sdk/provider';
-/** The official CLI release whose wire this mirrors; sent as its version header. */
-export const COMMANDCODE_CLI_VERSION = '1.54.0';
-const DEFAULT_MAX_TOKENS = 64_000;
-const DEFAULT_TEMPERATURE = 0.3;
-/** The gateway rejects `call_id` values longer than this. */
-const MAX_WIRE_TOOL_CALL_ID_LENGTH = 64;
-const SCHEMA_NORMALIZE_MAX_DEPTH = 8;
-export function commandCodeCliGenerateUrl(apiBase) {
-    return `${apiBase.replace(/\/+$/u, '')}/alpha/generate`;
-}
-/** The identity headers the official CLI sends; the gateway keys plan gating on them. */
-export function commandCodeCliHeaders(apiKey, workingDir) {
-    return {
-        'content-type': 'application/json',
-        authorization: `Bearer ${apiKey}`,
-        'x-command-code-version': COMMANDCODE_CLI_VERSION,
-        'x-cli-environment': 'production',
-        'x-project-slug': projectSlugFromPath(workingDir),
-        'x-taste-learning': 'true',
-        'x-co-flag': 'false',
-    };
-}
-export function projectSlugFromPath(pathName) {
-    const slug = pathName
-        .toLowerCase()
-        .replace(/^[a-z]:/iu, '')
-        .replace(/[^a-z0-9]+/gu, '-')
-        .replace(/^-+|(?<!-)-+$/gu, '');
-    return slug || 'project';
-}
-export class CommandCodeCliLanguageModel {
-    specificationVersion = 'v4';
-    provider = 'commandcode-cli';
-    modelId;
-    supportedUrls = {};
-    #config;
-    constructor(config) {
-        this.#config = config;
-        this.modelId = config.modelId;
-    }
-    async doGenerate(options) {
-        const { stream, request, response } = await this.doStream(options);
-        const content = [];
-        const warnings = [];
-        let finishReason = { unified: 'other', raw: undefined };
-        let usage = emptyUsage();
-        let openText;
-        let openReasoning;
-        const reader = stream.getReader();
-        for (;;) {
-            const { done, value: part } = await reader.read();
-            if (done)
-                break;
-            switch (part.type) {
-                case 'stream-start':
-                    warnings.push(...part.warnings);
-                    break;
-                case 'text-start':
-                    openText = { id: part.id, text: '' };
-                    break;
-                case 'text-delta':
-                    if (openText)
-                        openText.text += part.delta;
-                    break;
-                case 'text-end':
-                    if (openText)
-                        content.push({ type: 'text', text: openText.text });
-                    openText = undefined;
-                    break;
-                case 'reasoning-start':
-                    openReasoning = { id: part.id, text: '' };
-                    break;
-                case 'reasoning-delta':
-                    if (openReasoning)
-                        openReasoning.text += part.delta;
-                    break;
-                case 'reasoning-end':
-                    if (openReasoning)
-                        content.push({ type: 'reasoning', text: openReasoning.text });
-                    openReasoning = undefined;
-                    break;
-                case 'tool-call':
-                    content.push(part);
-                    break;
-                case 'finish':
-                    finishReason = part.finishReason;
-                    usage = part.usage;
-                    break;
-                case 'error':
-                    throw part.error;
-                default:
-                    break;
-            }
-        }
-        return {
-            content,
-            finishReason,
-            usage,
-            warnings,
-            request,
-            response: { headers: response?.headers },
-        };
-    }
-    async doStream(options) {
-        const { body, warnings } = buildCommandCodeCliRequest(options, this.#config);
-        const url = commandCodeCliGenerateUrl(this.#config.apiBase);
-        const fetchFn = this.#config.fetch ?? globalThis.fetch;
-        const headers = {
-            ...commandCodeCliHeaders(this.#config.apiKey, this.#config.workingDir ?? DEFAULT_WORKING_DIR),
-            ...definedHeaders(options.headers),
-        };
-        let response;
-        try {
-            response = await fetchFn(url, {
-                method: 'POST',
-                headers,
-                body: JSON.stringify(body),
-                signal: options.abortSignal,
-            });
-        }
-        catch (error) {
-            if (options.abortSignal?.aborted)
-                throw error;
-            throw new APICallError({
-                message: `Command Code GO request failed: ${errorMessage(error)}`,
-                url,
-                requestBodyValues: body,
-                cause: error,
-                isRetryable: true,
-            });
-        }
-        const responseHeaders = headersToRecord(response.headers);
-        if (!response.ok) {
-            const responseBody = await response.text().catch(() => '');
-            throw new APICallError({
-                message: `Command Code GO rejected the request (${response.status}): ${responseBody.slice(0, 500)}`,
-                url,
-                requestBodyValues: body,
-                statusCode: response.status,
-                responseHeaders,
-                responseBody,
-                isRetryable: response.status === 429 || response.status >= 500,
-            });
-        }
-        if (!response.body) {
-            throw new APICallError({
-                message: 'Command Code GO returned no body',
-                url,
-                requestBodyValues: body,
-                statusCode: response.status,
-                responseHeaders,
-                isRetryable: true,
-            });
-        }
-        const stream = response.body
-            .pipeThrough(new TextDecoderStream())
-            .pipeThrough(sseDataLines())
-            .pipeThrough(cliEventsToStreamParts({ warnings, url, body, modelId: this.modelId }));
-        return { stream, request: { body }, response: { headers: responseHeaders } };
-    }
-}
-const DEFAULT_WORKING_DIR = 'maka';
-// ---------------------------------------------------------------------------
-// Request
-// ---------------------------------------------------------------------------
-export function buildCommandCodeCliRequest(options, config) {
-    const warnings = [];
-    const unsupported = [
-        ['topP', options.topP],
-        ['topK', options.topK],
-        ['presencePenalty', options.presencePenalty],
-        ['frequencyPenalty', options.frequencyPenalty],
-        ['stopSequences', options.stopSequences],
-        ['seed', options.seed],
-    ];
-    for (const [setting, value] of unsupported) {
-        if (value !== undefined)
-            warnings.push({ type: 'unsupported', feature: setting });
-    }
-    if (options.responseFormat && options.responseFormat.type !== 'text') {
-        warnings.push({ type: 'unsupported', feature: 'responseFormat' });
-    }
-    if (options.toolChoice && options.toolChoice.type !== 'auto') {
-        warnings.push({
-            type: 'unsupported',
-            feature: 'toolChoice',
-            details: 'Command Code GO always lets the model choose',
-        });
-    }
-    const { system, messages } = convertPrompt(options.prompt, warnings);
-    const tools = (options.tools ?? []).flatMap((tool) => {
-        if (tool.type !== 'function') {
-            warnings.push({ type: 'unsupported', feature: `provider tool ${tool.name}` });
-            return [];
-        }
-        return [
-            {
-                type: 'function',
-                name: tool.name,
-                description: tool.description,
-                input_schema: toolParametersSchema(tool.inputSchema),
-            },
-        ];
-    });
-    const reasoningEffort = resolveReasoningEffort(options);
-    const now = config.now?.() ?? new Date();
-    const body = {
-        config: {
-            workingDir: config.workingDir ?? DEFAULT_WORKING_DIR,
-            date: now.toISOString().split('T')[0],
-            environment: `${process.platform}-${process.arch}, Node.js ${process.version}`,
-            structure: [],
-            isGitRepo: false,
-            currentBranch: '',
-            mainBranch: '',
-            gitStatus: '',
-            recentCommits: [],
-        },
-        memory: null,
-        taste: null,
-        skills: null,
-        params: {
-            model: config.modelId,
-            messages,
-            tools,
-            system,
-            max_tokens: options.maxOutputTokens ?? DEFAULT_MAX_TOKENS,
-            temperature: options.temperature ?? DEFAULT_TEMPERATURE,
-            stream: true,
-            ...(reasoningEffort ? { reasoning_effort: reasoningEffort } : {}),
-        },
-        threadId: config.threadId?.() ?? randomUUID(),
-    };
-    return { body, warnings };
-}
-function resolveReasoningEffort(options) {
-    const override = options.providerOptions?.['commandcode-cli']?.reasoningEffort;
-    if (typeof override === 'string' && override !== '')
-        return override;
-    const level = options.reasoning;
-    if (level === undefined || level === 'provider-default' || level === 'none')
-        return undefined;
-    return level;
-}
-/**
- * The CLI wire's message shape, converted from the AI SDK prompt. System
- * messages fold into `params.system`; only tool calls with a paired result
- * are replayed; assistant reasoning IS replayed (the gateway rebuilds the
- * upstream request from these blocks and DeepSeek thinking mode rejects a
- * tool loop whose history lacks it).
- */
-function convertPrompt(prompt, warnings) {
-    const systemParts = [];
-    const callIds = new Set();
-    const callNames = new Map();
-    const resultIds = new Set();
-    for (const message of prompt) {
-        if (message.role === 'assistant') {
-            for (const part of message.content) {
-                if (part.type === 'tool-call') {
-                    callIds.add(part.toolCallId);
-                    callNames.set(part.toolCallId, part.toolName);
-                }
-            }
-        }
-        if (message.role === 'tool') {
-            for (const part of message.content) {
-                if (part.type === 'tool-result')
-                    resultIds.add(part.toolCallId);
-            }
-        }
-    }
-    const paired = new Set([...callIds].filter((id) => resultIds.has(id)));
-    const wireIds = wireToolCallIds(paired);
-    const messages = [];
-    for (const message of prompt) {
-        switch (message.role) {
-            case 'system':
-                systemParts.push(message.content);
-                break;
-            case 'user': {
-                const parts = [];
-                for (const part of message.content) {
-                    if (part.type === 'text') {
-                        parts.push({ type: 'text', text: part.text });
-                        continue;
-                    }
-                    const image = imagePart(part, warnings);
-                    if (image)
-                        parts.push(image);
-                }
-                if (parts.length > 0)
-                    messages.push({ role: 'user', content: parts });
-                break;
-            }
-            case 'assistant': {
-                const parts = [];
-                for (const part of message.content) {
-                    if (part.type === 'text')
-                        parts.push({ type: 'text', text: part.text });
-                    else if (part.type === 'reasoning')
-                        parts.push({ type: 'reasoning', text: part.text });
-                    else if (part.type === 'tool-call' && paired.has(part.toolCallId)) {
-                        parts.push({
-                            type: 'tool-call',
-                            toolCallId: wireIds.get(part.toolCallId) ?? part.toolCallId,
-                            toolName: part.toolName,
-                            input: recordOrEmpty(part.input),
-                        });
-                    }
-                }
-                if (parts.length > 0)
-                    messages.push({ role: 'assistant', content: parts });
-                break;
-            }
-            case 'tool': {
-                for (const part of message.content) {
-                    if (part.type !== 'tool-result' || !paired.has(part.toolCallId))
-                        continue;
-                    const { text, isError } = toolResultText(part.output, warnings);
-                    messages.push({
-                        role: 'tool',
-                        content: [
-                            {
-                                type: 'tool-result',
-                                toolCallId: wireIds.get(part.toolCallId) ?? part.toolCallId,
-                                toolName: callNames.get(part.toolCallId) || part.toolName || 'unknown',
-                                output: isError
-                                    ? { type: 'error-text', value: text }
-                                    : { type: 'text', value: text },
-                            },
-                        ],
-                    });
-                }
-                break;
-            }
-            default:
-                break;
-        }
-    }
-    return { system: systemParts.join('\n\n'), messages };
-}
-function imagePart(part, warnings) {
-    if (!part.mediaType.startsWith('image/')) {
-        warnings.push({ type: 'unsupported', feature: `file input ${part.mediaType}` });
-        return undefined;
-    }
-    if (part.data.type !== 'data') {
-        warnings.push({
-            type: 'unsupported',
-            feature: `image ${part.data.type} input`,
-            details: 'Command Code GO carries images inline only',
-        });
-        return undefined;
-    }
-    const encoded = typeof part.data.data === 'string'
-        ? part.data.data
-        : Buffer.from(part.data.data).toString('base64');
-    // The pinned CLI serializes an image block in the AI SDK message shape it
-    // builds its request from — a data URL under `image`, beside `mimeType` —
-    // not Anthropic's `source` object. The rest of this wire is AI SDK shaped
-    // too (`toolCallId`, `toolName`, `input`), and for an unpublished endpoint
-    // the pinned CLI is the protocol authority.
-    return {
-        type: 'image',
-        image: encoded.startsWith('data:') ? encoded : `data:${part.mediaType};base64,${encoded}`,
-        mimeType: part.mediaType,
-    };
-}
-function toolResultText(output, warnings) {
-    switch (output.type) {
-        case 'text':
-            return { text: output.value, isError: false };
-        case 'error-text':
-            return { text: output.value, isError: true };
-        case 'json':
-            return { text: JSON.stringify(output.value), isError: false };
-        case 'error-json':
-            return { text: JSON.stringify(output.value), isError: true };
-        case 'execution-denied':
-            return { text: output.reason ?? 'Tool execution was denied.', isError: true };
-        case 'content': {
-            const texts = [];
-            for (const item of output.value) {
-                if (item.type === 'text')
-                    texts.push(item.text);
-                else
-                    warnings.push({ type: 'unsupported', feature: `tool result ${item.type}` });
-            }
-            return { text: texts.join('\n'), isError: false };
-        }
-        default:
-            return { text: '', isError: false };
-    }
-}
-/** Overlong paired ids get a per-request `cc-<n>` alias; the pair resolves through one map. */
-export function wireToolCallIds(paired) {
-    const wire = new Map();
-    const taken = new Set();
-    for (const id of paired) {
-        if (id.length <= MAX_WIRE_TOOL_CALL_ID_LENGTH) {
-            wire.set(id, id);
-            taken.add(id);
-        }
-    }
-    let seq = 1;
-    for (const id of paired) {
-        if (wire.has(id))
-            continue;
-        let alias = `cc-${seq++}`;
-        while (taken.has(alias))
-            alias = `cc-${seq++}`;
-        wire.set(id, alias);
-        taken.add(alias);
-    }
-    return wire;
-}
-/**
- * The gateway validates a tool schema's root `type` against the literal
- * string "object". Schemas generators emit as `["object","null"]`, a bare
- * `$ref`, or a combinator get the declared type they mean.
- */
-export function toolParametersSchema(parameters, depth = 0) {
-    if (!isRecord(parameters))
-        return { type: 'object', properties: {}, additionalProperties: true };
-    if (parameters.type === 'object')
-        return parameters;
-    if (Array.isArray(parameters.type) && parameters.type.includes('object')) {
-        return { ...parameters, type: 'object' };
-    }
-    if (parameters.type === undefined || parameters.type === null) {
-        if (typeof parameters.$ref === 'string' && depth < SCHEMA_NORMALIZE_MAX_DEPTH) {
-            const target = resolveLocalRef(parameters, parameters.$ref);
-            if (target !== undefined) {
-                const { $ref: _ref, ...rest } = parameters;
-                return toolParametersSchema({ ...target, ...rest }, depth + 1);
-            }
-        }
-        if (isRecord(parameters.properties) || parameters.additionalProperties !== undefined) {
-            return { ...parameters, type: 'object' };
-        }
-        for (const key of ['allOf', 'anyOf', 'oneOf']) {
-            const branches = parameters[key];
-            if (Array.isArray(branches) && depth < SCHEMA_NORMALIZE_MAX_DEPTH) {
-                const merged = branches.map((branch) => toolParametersSchema(branch, depth + 1));
-                const properties = Object.assign({}, ...merged.map((b) => b.properties ?? {}));
-                const required = [
-                    ...new Set(merged.flatMap((b) => (Array.isArray(b.required) ? b.required : []))),
-                ];
-                return {
-                    type: 'object',
-                    properties,
-                    ...(required.length > 0 ? { required } : {}),
-                    additionalProperties: true,
-                };
-            }
-        }
-        if (typeof parameters.$ref === 'string')
-            return { ...parameters, type: 'object' };
-    }
-    return { type: 'object', properties: {}, additionalProperties: true };
-}
-function resolveLocalRef(root, ref) {
-    if (!ref.startsWith('#/'))
-        return undefined;
-    let current = root;
-    for (const segment of ref.slice(2).split('/')) {
-        if (!isRecord(current))
-            return undefined;
-        current = current[segment.replace(/~1/gu, '/').replace(/~0/gu, '~')];
-    }
-    return isRecord(current) ? current : undefined;
-}
-// ---------------------------------------------------------------------------
-// Response
-// ---------------------------------------------------------------------------
-/** Splits SSE text into the JSON payload of each `data:` line, dropping comments and `[DONE]`. */
-/** One SSE line's event payload, or undefined when the line carries none. */
-export function parseCommandCodeCliEventLine(line) {
-    let trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith(':') || trimmed.startsWith('event:'))
-        return undefined;
-    if (trimmed.startsWith('data:'))
-        trimmed = trimmed.slice(5).trim();
-    if (!trimmed || trimmed === '[DONE]')
-        return undefined;
-    try {
-        return JSON.parse(trimmed);
-    }
-    catch {
-        // A non-JSON line is not an event on this wire.
-        return undefined;
-    }
-}
-/**
- * Reads one complete CLI stream body the way {@link CommandCodeCliLanguageModel}
- * reads it incrementally. HTTP 200 is only the handshake on this wire, so a
- * caller that stops at the status (the connection probe) would accept a body
- * whose first event is a rejection.
- */
-export function summarizeCommandCodeCliStream(body) {
-    for (const line of body.split('\n')) {
-        const event = parseCommandCodeCliEventLine(line);
-        if (!isRecord(event))
-            continue;
-        if (event.type === 'error') {
-            const { message, statusCode } = streamErrorFacts(event);
-            return {
-                finished: false,
-                error: { message, ...(statusCode === undefined ? {} : { statusCode }) },
-            };
-        }
-        if (event.type === 'finish')
-            return { finished: true };
-    }
-    return { finished: false };
-}
-function sseDataLines() {
-    let buffer = '';
-    const emit = (line, controller) => {
-        const event = parseCommandCodeCliEventLine(line);
-        if (event !== undefined)
-            controller.enqueue(event);
-    };
-    return new TransformStream({
-        transform(chunk, controller) {
-            buffer += chunk;
-            const lines = buffer.split('\n');
-            buffer = lines.pop() ?? '';
-            for (const line of lines)
-                emit(line, controller);
-        },
-        flush(controller) {
-            if (buffer)
-                emit(buffer, controller);
-        },
-    });
-}
-function cliEventsToStreamParts(input) {
-    let textId;
-    let reasoningId;
-    let nextId = 0;
-    let finished = false;
-    // The wire splits one call's usage across two events: `finish-step` carries
-    // the provider's OWN body (`prompt_tokens`, `prompt_cache_hit_tokens`, …)
-    // under `usage.raw`, and `finish` carries only the normalized totals. The
-    // provider keys are what telemetry's cache accounting reads, so keep the
-    // body here until the finish event can carry it out.
-    let providerUsageRaw;
-    const closeText = (controller) => {
-        if (textId === undefined)
-            return;
-        controller.enqueue({ type: 'text-end', id: textId });
-        textId = undefined;
-    };
-    const closeReasoning = (controller) => {
-        if (reasoningId === undefined)
-            return;
-        controller.enqueue({ type: 'reasoning-end', id: reasoningId });
-        reasoningId = undefined;
-    };
-    return new TransformStream({
-        start(controller) {
-            controller.enqueue({ type: 'stream-start', warnings: input.warnings });
-            controller.enqueue({ type: 'response-metadata', modelId: input.modelId });
-        },
-        transform(event, controller) {
-            if (!isRecord(event) || finished)
-                return;
-            switch (event.type) {
-                case 'text-delta': {
-                    closeReasoning(controller);
-                    if (textId === undefined) {
-                        textId = `text-${nextId++}`;
-                        controller.enqueue({ type: 'text-start', id: textId });
-                    }
-                    controller.enqueue({
-                        type: 'text-delta',
-                        id: textId,
-                        delta: stringValue(event.text) ?? '',
-                    });
-                    break;
-                }
-                case 'text-end':
-                    closeText(controller);
-                    break;
-                case 'reasoning-start':
-                    closeText(controller);
-                    break;
-                case 'reasoning-delta': {
-                    closeText(controller);
-                    if (reasoningId === undefined) {
-                        reasoningId = `reasoning-${nextId++}`;
-                        controller.enqueue({ type: 'reasoning-start', id: reasoningId });
-                    }
-                    controller.enqueue({
-                        type: 'reasoning-delta',
-                        id: reasoningId,
-                        delta: stringValue(event.text) ?? '',
-                    });
-                    break;
-                }
-                case 'reasoning-end':
-                    closeReasoning(controller);
-                    break;
-                case 'tool-call': {
-                    closeText(controller);
-                    closeReasoning(controller);
-                    const id = stringValue(event.toolCallId) ?? randomUUID();
-                    const toolName = stringValue(event.toolName) ?? '';
-                    const args = JSON.stringify(recordOrEmpty(event.input ?? event.args ?? event.arguments));
-                    controller.enqueue({ type: 'tool-input-start', id, toolName });
-                    controller.enqueue({ type: 'tool-input-delta', id, delta: args });
-                    controller.enqueue({ type: 'tool-input-end', id });
-                    controller.enqueue({ type: 'tool-call', toolCallId: id, toolName, input: args });
-                    break;
-                }
-                case 'finish-step': {
-                    // Carries the provider's own usage body; `finish` normalizes it away.
-                    const usage = isRecord(event.usage) ? event.usage : undefined;
-                    if (isRecord(usage?.raw))
-                        providerUsageRaw = usage.raw;
-                    break;
-                }
-                case 'finish': {
-                    closeText(controller);
-                    closeReasoning(controller);
-                    finished = true;
-                    controller.enqueue({
-                        type: 'finish',
-                        usage: usageFromEvent(event.totalUsage, providerUsageRaw),
-                        finishReason: mapFinishReason(event.finishReason),
-                    });
-                    break;
-                }
-                case 'error': {
-                    closeText(controller);
-                    closeReasoning(controller);
-                    finished = true;
-                    controller.enqueue({ type: 'error', error: streamErrorToApiCallError(event, input) });
-                    break;
-                }
-                default:
-                    break;
-            }
-        },
-        flush(controller) {
-            closeText(controller);
-            closeReasoning(controller);
-            if (!finished) {
-                // The connection closed before the wire said it was done: report the
-                // truncation instead of a clean stop so the caller can retry.
-                controller.enqueue({
-                    type: 'error',
-                    error: new APICallError({
-                        message: 'Command Code GO stream ended without a finish event',
-                        url: input.url,
-                        requestBodyValues: input.body,
-                        isRetryable: true,
-                    }),
-                });
-            }
-        },
-    });
-}
-function usageFromEvent(value, providerRaw) {
-    if (!isRecord(value))
-        return emptyUsage();
-    const inputDetails = isRecord(value.inputTokenDetails) ? value.inputTokenDetails : undefined;
-    const outputDetails = isRecord(value.outputTokenDetails) ? value.outputTokenDetails : undefined;
-    const total = numberValue(value.inputTokens);
-    const cacheRead = numberValue(inputDetails?.cacheReadTokens);
-    const cacheWrite = numberValue(inputDetails?.cacheWriteTokens);
-    const noCache = numberValue(inputDetails?.noCacheTokens) ??
-        (total === undefined ? undefined : Math.max(0, total - (cacheRead ?? 0) - (cacheWrite ?? 0)));
-    return {
-        inputTokens: { total, noCache, cacheRead, cacheWrite },
-        outputTokens: {
-            total: numberValue(value.outputTokens),
-            text: undefined,
-            reasoning: numberValue(outputDetails?.reasoningTokens),
-        },
-        // `raw` must stay the PROVIDER's own usage body, which is where the
-        // OpenAI/Anthropic cache keys live (`prompt_tokens`,
-        // `prompt_tokens_details.cached_tokens`, `cache_read_input_tokens`, …).
-        // Only `finish-step` carries that body; `finish.totalUsage` is already
-        // normalized, so carrying the envelope here left telemetry's strict reader
-        // looking for `prompt_tokens` on an object that had only `inputTokens` —
-        // every attempt settled as `usageBasis: 'missing'` and the composer's
-        // context gauge never moved.
-        //
-        // The fallback keeps a body-less event readable on the normalized keys
-        // rather than handing telemetry `undefined`.
-        raw: (providerRaw ?? value),
-    };
-}
-function emptyUsage() {
-    return {
-        inputTokens: {
-            total: undefined,
-            noCache: undefined,
-            cacheRead: undefined,
-            cacheWrite: undefined,
-        },
-        outputTokens: { total: undefined, text: undefined, reasoning: undefined },
-    };
-}
-export function mapFinishReason(reason) {
-    const raw = stringValue(reason);
-    if (raw === 'tool-calls' || raw === 'tool_calls')
-        return { unified: 'tool-calls', raw };
-    if (raw === 'length' ||
-        raw === 'max_tokens' ||
-        raw === 'max-tokens' ||
-        raw === 'max_output_tokens') {
-        return { unified: 'length', raw };
-    }
-    if (raw === 'content-filter' || raw === 'content_filter')
-        return { unified: 'content-filter', raw };
-    if (raw === 'error')
-        return { unified: 'error', raw };
-    return { unified: 'stop', raw };
-}
-/**
- * An in-band `error` event becomes the same error shape a rejected HTTP
- * response produces, so the runtime's provider-error classification reads
- * status and structured code from one place.
- */
-/** What one in-band `error` event states, shared by the stream and the probe. */
-function streamErrorFacts(event) {
-    const detail = isRecord(event.error) ? event.error : undefined;
-    const message = stringValue(detail?.message) ??
-        stringValue(event.message) ??
-        (detail ? JSON.stringify(detail) : stringValue(event.error)) ??
-        'Stream error';
-    const statusCode = numberValue(detail?.statusCode) ?? numberValue(detail?.status);
-    return {
-        message,
-        ...(statusCode !== undefined ? { statusCode } : {}),
-        ...(detail !== undefined ? { detail } : {}),
-        ...(typeof detail?.isRetryable === 'boolean' ? { explicitRetryable: detail.isRetryable } : {}),
-    };
-}
-function streamErrorToApiCallError(event, input) {
-    const { message, statusCode, detail, explicitRetryable } = streamErrorFacts(event);
-    const isRetryable = explicitRetryable ??
-        (statusCode !== undefined ? statusCode === 429 || statusCode >= 500 : false);
-    return new APICallError({
-        message: `Command Code GO stream error: ${message}`,
-        url: input.url,
-        requestBodyValues: input.body,
-        ...(statusCode !== undefined ? { statusCode } : {}),
-        responseBody: JSON.stringify({ error: detail ?? { message } }),
-        isRetryable,
-        data: detail,
-    });
-}
-// ---------------------------------------------------------------------------
-// Small helpers
-// ---------------------------------------------------------------------------
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-function stringValue(value) {
-    return typeof value === 'string' ? value : undefined;
-}
-function numberValue(value) {
-    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
-}
-function recordOrEmpty(value) {
-    if (isRecord(value))
-        return value;
-    if (typeof value === 'string') {
-        try {
-            const parsed = JSON.parse(value);
-            if (isRecord(parsed))
-                return parsed;
-        }
-        catch {
-            // Not JSON: the model produced no usable arguments.
-        }
-    }
-    return {};
-}
-function definedHeaders(headers) {
-    const out = {};
-    for (const [key, value] of Object.entries(headers ?? {})) {
-        if (value !== undefined)
-            out[key] = value;
-    }
-    return out;
-}
-function headersToRecord(headers) {
-    const out = {};
-    headers.forEach((value, key) => {
-        out[key] = value;
-    });
-    return out;
-}
-function errorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
-}