agenticreplay 0.1.0 → 0.1.2

package/node_modules/@agenticreplay/providers/dist/translate/openai.d.ts

@@ -0,0 +1,60 @@
+/**
+ * OpenAI Chat Completions <-> canonical IR.
+ *
+ * The load-bearing asymmetry is tool arguments: OpenAI sends a JSON *string*, canonical holds a
+ * parsed *object*. Both directions round trip, including arguments the model truncated into
+ * invalid JSON, which are kept under `_raw` rather than thrown away or thrown on.
+ *
+ * Responses translate both ways too, in both wire forms, so a reply recorded from Anthropic can
+ * be handed to an agent that speaks this dialect. Where this dialect has no equivalent field —
+ * one content body instead of a block list, no stop-sequence finish reason, no cache-write
+ * counter — the loss is documented at the point it happens and asserted in the tests.
+ */
+import type { CanonicalChunk, CanonicalRequest, CanonicalResponse, StopReason, Usage } from '@agenticreplay/plugin-api';
+/** Unconsumed top-level request fields, parked verbatim. */
+export declare const OPENAI_EXTRA = "openai.extra";
+/** The original tool definitions by name, so `strict` and vendor extras survive. */
+export declare const OPENAI_TOOL_ORIGINALS = "openai.tool_originals";
+/** Which of `max_tokens` / `max_completion_tokens` the caller used. */
+export declare const OPENAI_MAX_TOKENS_FIELD = "openai.max_tokens_field";
+/** Whether the system prompt arrived as role `system` or role `developer`. */
+export declare const OPENAI_SYSTEM_ROLE = "openai.system_role";
+export declare function openaiToCanonicalRequest(body: unknown): CanonicalRequest;
+export declare function canonicalToOpenaiRequest(req: CanonicalRequest): Record<string, unknown>;
+export declare function openaiToCanonicalResponse(body: unknown): CanonicalResponse;
+export declare function openaiStopReason(value: unknown): StopReason;
+export declare function openaiUsage(value: unknown): Usage;
+/**
+ * The non-streamed chat-completions body for one assistant turn.
+ *
+ * This is the half of translation a cross-provider fork needs: a reply obtained from any provider
+ * has to be handed back to the agent in the dialect that agent speaks.
+ */
+export declare function canonicalToOpenaiResponse(res: CanonicalResponse): Record<string, unknown>;
+/**
+ * The `chat.completion.chunk` sequence for one assistant turn, terminated by `[DONE]`.
+ *
+ * Tool calls are announced by name in their own chunk before any argument bytes, the way the API
+ * frames them, and usage arrives in a final choice-less chunk as it does under
+ * `stream_options.include_usage` — `OpenAiStreamAssembler` reads this back unchanged.
+ */
+export declare function canonicalToOpenaiSse(res: CanonicalResponse): string;
+/** Incremental assembler for OpenAI-shaped SSE, shared by the recorder and the live provider. */
+export declare class OpenAiStreamAssembler {
+    private readonly decoder;
+    private readonly calls;
+    private id;
+    private model;
+    private text;
+    private thinking;
+    private stop;
+    private usage;
+    private errorText;
+    push(chunk: string): CanonicalChunk[];
+    flush(): CanonicalChunk[];
+    result(): CanonicalResponse;
+    private handle;
+}
+/** Assemble a complete response from a recorded OpenAI-shaped SSE stream. */
+export declare function parseOpenaiSse(chunks: string[] | string): CanonicalResponse;
+//# sourceMappingURL=openai.d.ts.map

package/node_modules/@agenticreplay/providers/dist/translate/openai.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai.d.ts","sourceRoot":"","sources":["../../src/translate/openai.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EACV,cAAc,EAGd,gBAAgB,EAChB,iBAAiB,EAEjB,UAAU,EACV,KAAK,EACN,MAAM,2BAA2B,CAAC;AAenC,4DAA4D;AAC5D,eAAO,MAAM,YAAY,iBAAiB,CAAC;AAC3C,oFAAoF;AACpF,eAAO,MAAM,qBAAqB,0BAA0B,CAAC;AAC7D,uEAAuE;AACvE,eAAO,MAAM,uBAAuB,4BAA4B,CAAC;AACjE,8EAA8E;AAC9E,eAAO,MAAM,kBAAkB,uBAAuB,CAAC;AAkBvD,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,OAAO,GAAG,gBAAgB,CAgFxE;AA2DD,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,gBAAgB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAuCvF;AA8DD,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,OAAO,GAAG,iBAAiB,CAwC1E;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,UAAU,CAY3D;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,CAajD;AAeD;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,iBAAiB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAyBzF;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,iBAAiB,GAAG,MAAM,CA8CnE;AAmED,iGAAiG;AACjG,qBAAa,qBAAqB;IAChC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAoB;IAC5C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAoC;IAC1D,OAAO,CAAC,EAAE,CAAM;IAChB,OAAO,CAAC,KAAK,CAAM;IACnB,OAAO,CAAC,IAAI,CAAM;IAClB,OAAO,CAAC,QAAQ,CAAM;IACtB,OAAO,CAAC,IAAI,CAA0B;IACtC,OAAO,CAAC,KAAK,CAAgD;IAC7D,OAAO,CAAC,SAAS,CAAqB;IAEtC,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,EAAE;IAMrC,KAAK,IAAI,cAAc,EAAE;IAMzB,MAAM,IAAI,iBAAiB;IAkB3B,OAAO,CAAC,MAAM;CAwCf;AAED,6EAA6E;AAC7E,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,GAAG,iBAAiB,CAK3E"}

package/node_modules/@agenticreplay/providers/dist/translate/openai.js

@@ -0,0 +1,577 @@
+/**
+ * OpenAI Chat Completions <-> canonical IR.
+ *
+ * The load-bearing asymmetry is tool arguments: OpenAI sends a JSON *string*, canonical holds a
+ * parsed *object*. Both directions round trip, including arguments the model truncated into
+ * invalid JSON, which are kept under `_raw` rather than thrown away or thrown on.
+ *
+ * Responses translate both ways too, in both wire forms, so a reply recorded from Anthropic can
+ * be handed to an agent that speaks this dialect. Where this dialect has no equivalent field —
+ * one content body instead of a block list, no stop-sequence finish reason, no cache-write
+ * counter — the loss is documented at the point it happens and asserted in the tests.
+ */
+import { SseDecoder, encodeSseFrame, frameJson, toChunks } from './sse.js';
+import { asArray, asBoolean, asNumber, asRecord, asString, canonicalErrorText, omitUndefined, parseToolInput, stringifyToolInput, unknownKeys, } from './util.js';
+/** Unconsumed top-level request fields, parked verbatim. */
+export const OPENAI_EXTRA = 'openai.extra';
+/** The original tool definitions by name, so `strict` and vendor extras survive. */
+export const OPENAI_TOOL_ORIGINALS = 'openai.tool_originals';
+/** Which of `max_tokens` / `max_completion_tokens` the caller used. */
+export const OPENAI_MAX_TOKENS_FIELD = 'openai.max_tokens_field';
+/** Whether the system prompt arrived as role `system` or role `developer`. */
+export const OPENAI_SYSTEM_ROLE = 'openai.system_role';
+const REQUEST_KEYS = new Set([
+    'model',
+    'messages',
+    'tools',
+    'max_tokens',
+    'max_completion_tokens',
+    'temperature',
+    'top_p',
+    'stop',
+    'stream',
+]);
+// ---------------------------------------------------------------------------
+// request: wire -> canonical
+// ---------------------------------------------------------------------------
+export function openaiToCanonicalRequest(body) {
+    const src = asRecord(body);
+    const metadata = {};
+    const systemParts = [];
+    let systemRole;
+    const messages = [];
+    let toolBatch;
+    for (const raw of asArray(src['messages'])) {
+        const msg = asRecord(raw);
+        const role = asString(msg['role']) ?? 'user';
+        if (role === 'system' || role === 'developer') {
+            systemParts.push(flattenContent(msg['content']));
+            systemRole ??= role;
+            continue;
+        }
+        if (role === 'tool' || role === 'function') {
+            const block = {
+                type: 'tool_result',
+                tool_use_id: asString(msg['tool_call_id']) ?? asString(msg['name']) ?? '',
+                content: flattenContent(msg['content']),
+            };
+            // Anthropic wants every result for a turn in one user message; canonical follows suit.
+            if (toolBatch)
+                toolBatch.content.push(block);
+            else {
+                toolBatch = { role: 'user', content: [block] };
+                messages.push(toolBatch);
+            }
+            continue;
+        }
+        toolBatch = undefined;
+        messages.push(openaiMessageToCanonical(role, msg));
+    }
+    const toolsRaw = asArray(src['tools']);
+    let tools;
+    if (toolsRaw.length > 0) {
+        const originals = {};
+        tools = toolsRaw.map((raw) => {
+            const tool = asRecord(raw);
+            const fn = asRecord(tool['function']);
+            const name = asString(fn['name']) ?? asString(tool['name']) ?? '';
+            originals[name] = raw;
+            return omitUndefined({
+                name,
+                description: asString(fn['description']) ?? asString(tool['description']),
+                input_schema: asRecord(fn['parameters'] ?? tool['parameters']),
+            });
+        });
+        metadata[OPENAI_TOOL_ORIGINALS] = originals;
+    }
+    const maxCompletion = asNumber(src['max_completion_tokens']);
+    const maxLegacy = asNumber(src['max_tokens']);
+    if (maxCompletion !== undefined)
+        metadata[OPENAI_MAX_TOKENS_FIELD] = 'max_completion_tokens';
+    else if (maxLegacy !== undefined)
+        metadata[OPENAI_MAX_TOKENS_FIELD] = 'max_tokens';
+    if (systemRole !== undefined)
+        metadata[OPENAI_SYSTEM_ROLE] = systemRole;
+    const extra = unknownKeys(src, REQUEST_KEYS);
+    if (extra)
+        metadata[OPENAI_EXTRA] = extra;
+    const stopRaw = src['stop'];
+    const stop = typeof stopRaw === 'string'
+        ? [stopRaw]
+        : asArray(stopRaw).filter((s) => typeof s === 'string');
+    return omitUndefined({
+        model: asString(src['model']) ?? '',
+        system: systemParts.length > 0 ? systemParts.join('\n\n') : undefined,
+        messages,
+        tools,
+        max_tokens: maxCompletion ?? maxLegacy,
+        temperature: asNumber(src['temperature']),
+        top_p: asNumber(src['top_p']),
+        stop: stop.length > 0 ? stop : undefined,
+        stream: asBoolean(src['stream']),
+        metadata: Object.keys(metadata).length > 0 ? metadata : undefined,
+    });
+}
+function openaiMessageToCanonical(role, msg) {
+    const content = [];
+    const raw = msg['content'];
+    if (typeof raw === 'string') {
+        if (raw !== '')
+            content.push({ type: 'text', text: raw });
+    }
+    else {
+        for (const part of asArray(raw)) {
+            const mapped = openaiPartToCanonical(part);
+            if (mapped)
+                content.push(mapped);
+        }
+    }
+    for (const call of asArray(msg['tool_calls'])) {
+        const tc = asRecord(call);
+        const fn = asRecord(tc['function']);
+        content.push({
+            type: 'tool_use',
+            id: asString(tc['id']) ?? '',
+            name: asString(fn['name']) ?? '',
+            input: parseToolInput(asString(fn['arguments']) ?? ''),
+        });
+    }
+    return { role: role === 'assistant' ? 'assistant' : 'user', content };
+}
+function openaiPartToCanonical(raw) {
+    const part = asRecord(raw);
+    const type = asString(part['type']);
+    if (type === 'text' || type === 'input_text' || type === 'output_text') {
+        return { type: 'text', text: asString(part['text']) ?? '' };
+    }
+    if (type === 'image_url' || type === 'input_image') {
+        const url = asString(asRecord(part['image_url'])['url']) ?? asString(part['image_url']) ?? '';
+        return dataUrlToImage(url);
+    }
+    // Audio and other modalities have no canonical home; the raw bytes still hold them.
+    return undefined;
+}
+function dataUrlToImage(url) {
+    const match = /^data:([^;,]+);base64,(.*)$/s.exec(url);
+    if (match)
+        return { type: 'image', media_type: match[1] ?? '', data: match[2] ?? '' };
+    return { type: 'image', media_type: '', data: url };
+}
+/** OpenAI message content may be a string or an array of parts; canonical text is a string. */
+function flattenContent(content) {
+    if (typeof content === 'string')
+        return content;
+    return asArray(content)
+        .map((part) => asString(asRecord(part)['text']) ?? '')
+        .filter((text) => text !== '')
+        .join('\n');
+}
+// ---------------------------------------------------------------------------
+// request: canonical -> wire
+// ---------------------------------------------------------------------------
+export function canonicalToOpenaiRequest(req) {
+    const metadata = asRecord(req.metadata);
+    const out = { ...asRecord(metadata[OPENAI_EXTRA]) };
+    out['model'] = req.model;
+    const messages = [];
+    if (req.system !== undefined) {
+        const role = asString(metadata[OPENAI_SYSTEM_ROLE]) ?? 'system';
+        messages.push({ role, content: req.system });
+    }
+    for (const msg of req.messages)
+        messages.push(...canonicalMessageToOpenai(msg));
+    out['messages'] = messages;
+    if (req.tools !== undefined) {
+        const originals = asRecord(metadata[OPENAI_TOOL_ORIGINALS]);
+        out['tools'] = req.tools.map((tool) => {
+            const original = asRecord(originals[tool.name]);
+            const base = { ...original };
+            const fn = { ...asRecord(original['function']) };
+            base['type'] = asString(original['type']) ?? 'function';
+            fn['name'] = tool.name;
+            if (tool.description === undefined)
+                delete fn['description'];
+            else
+                fn['description'] = tool.description;
+            const schema = tool.input_schema ?? {};
+            if ('parameters' in fn || Object.keys(schema).length > 0)
+                fn['parameters'] = schema;
+            base['function'] = fn;
+            return base;
+        });
+    }
+    if (req.max_tokens !== undefined) {
+        const field = asString(metadata[OPENAI_MAX_TOKENS_FIELD]) ?? 'max_tokens';
+        out[field] = req.max_tokens;
+    }
+    if (req.temperature !== undefined)
+        out['temperature'] = req.temperature;
+    if (req.top_p !== undefined)
+        out['top_p'] = req.top_p;
+    if (req.stop !== undefined && req.stop.length > 0)
+        out['stop'] = req.stop;
+    if (req.stream !== undefined)
+        out['stream'] = req.stream;
+    return out;
+}
+/** One canonical message can become several OpenAI messages: tool results are their own turns. */
+function canonicalMessageToOpenai(msg) {
+    const out = [];
+    const rest = [];
+    for (const block of msg.content) {
+        if (block.type === 'tool_result') {
+            out.push({ role: 'tool', tool_call_id: block.tool_use_id, content: block.content });
+        }
+        else {
+            rest.push(block);
+        }
+    }
+    const toolCalls = rest
+        .filter((b) => b.type === 'tool_use')
+        .map((b) => ({
+        id: b.id,
+        type: 'function',
+        function: { name: b.name, arguments: stringifyToolInput(b.input) },
+    }));
+    const visible = rest.filter((b) => b.type === 'text' || b.type === 'image');
+    const allText = visible.every((b) => b.type === 'text');
+    if (msg.role === 'assistant') {
+        if (visible.length === 0 && toolCalls.length === 0)
+            return out;
+        const text = visible
+            .map((b) => (b.type === 'text' ? b.text : ''))
+            .filter((t) => t !== '')
+            .join('\n');
+        const message = { role: 'assistant' };
+        message['content'] = toolCalls.length > 0 && text === '' ? null : text;
+        if (toolCalls.length > 0)
+            message['tool_calls'] = toolCalls;
+        out.push(message);
+        return out;
+    }
+    if (visible.length > 0) {
+        out.push({
+            role: 'user',
+            content: allText
+                ? visible.map((b) => (b.type === 'text' ? b.text : '')).join('\n')
+                : visible.map(canonicalPartToOpenai),
+        });
+    }
+    return out;
+}
+function canonicalPartToOpenai(block) {
+    if (block.type === 'image') {
+        const url = /^https?:\/\//.test(block.data)
+            ? block.data
+            : `data:${block.media_type};base64,${block.data}`;
+        return { type: 'image_url', image_url: { url } };
+    }
+    return { type: 'text', text: block.type === 'text' ? block.text : '' };
+}
+// ---------------------------------------------------------------------------
+// response
+// ---------------------------------------------------------------------------
+export function openaiToCanonicalResponse(body) {
+    const src = asRecord(body);
+    const error = src['error'];
+    if (error !== undefined && error !== null) {
+        const err = asRecord(error);
+        return {
+            id: asString(src['id']) ?? '',
+            model: asString(src['model']) ?? '',
+            stop_reason: 'error',
+            content: [{ type: 'text', text: asString(err['message']) ?? 'unknown provider error' }],
+            usage: { input_tokens: 0, output_tokens: 0 },
+        };
+    }
+    const choice = asRecord(asArray(src['choices'])[0]);
+    const message = asRecord(choice['message']);
+    const content = [];
+    const reasoning = asString(message['reasoning_content']) ?? asString(message['reasoning']);
+    if (reasoning !== undefined && reasoning !== '')
+        content.push({ type: 'thinking', text: reasoning });
+    const text = flattenContent(message['content']);
+    if (text !== '')
+        content.push({ type: 'text', text });
+    for (const call of asArray(message['tool_calls'])) {
+        const tc = asRecord(call);
+        const fn = asRecord(tc['function']);
+        content.push({
+            type: 'tool_use',
+            id: asString(tc['id']) ?? '',
+            name: asString(fn['name']) ?? '',
+            input: parseToolInput(asString(fn['arguments']) ?? ''),
+        });
+    }
+    return {
+        id: asString(src['id']) ?? '',
+        model: asString(src['model']) ?? '',
+        stop_reason: openaiStopReason(choice['finish_reason']),
+        content,
+        usage: openaiUsage(src['usage']),
+    };
+}
+export function openaiStopReason(value) {
+    switch (asString(value)) {
+        case 'tool_calls':
+        case 'function_call':
+            return 'tool_use';
+        case 'length':
+            return 'max_tokens';
+        default:
+            // `stop`, `content_filter`, null and anything added later: the turn is over and no tool
+            // call is pending. OpenAI has no separate stop-sequence reason.
+            return 'end_turn';
+    }
+}
+export function openaiUsage(value) {
+    const u = asRecord(value);
+    const prompt = asNumber(u['prompt_tokens']) ?? 0;
+    const cached = asNumber(asRecord(u['prompt_tokens_details'])['cached_tokens']) ??
+        asNumber(u['prompt_cache_hit_tokens']);
+    return omitUndefined({
+        // OpenAI counts cached tokens inside prompt_tokens; Anthropic does not. Canonical follows
+        // Anthropic, so cost math can add the cache tiers without double counting.
+        input_tokens: Math.max(0, prompt - (cached ?? 0)),
+        output_tokens: asNumber(u['completion_tokens']) ?? 0,
+        cache_read_tokens: cached,
+    });
+}
+// ---------------------------------------------------------------------------
+// response: canonical -> wire
+// ---------------------------------------------------------------------------
+/**
+ * The `created` timestamp every chat-completions body carries.
+ *
+ * Canonical holds no creation time, and reading the clock here would make one recorded response
+ * serialize to different bytes on every replay — the one thing a replay tool cannot afford. The
+ * field stays present because clients type it as required; they only ever display it.
+ */
+const CREATED = 0;
+/**
+ * The non-streamed chat-completions body for one assistant turn.
+ *
+ * This is the half of translation a cross-provider fork needs: a reply obtained from any provider
+ * has to be handed back to the agent in the dialect that agent speaks.
+ */
+export function canonicalToOpenaiResponse(res) {
+    const head = { id: res.id, object: 'chat.completion', created: CREATED, model: res.model };
+    if (res.stop_reason === 'error') {
+        // `error` is not a finish_reason; a failed call answers with an error envelope instead, which
+        // is exactly what `openaiToCanonicalResponse` looks for first.
+        return { ...head, error: { type: 'error', message: canonicalErrorText(res.content) } };
+    }
+    const parts = splitCanonicalContent(res.content);
+    return {
+        ...head,
+        choices: [
+            {
+                index: 0,
+                message: omitUndefined({
+                    role: 'assistant',
+                    // `null`, not `""`, is what the API sends for a turn that is only tool calls.
+                    content: parts.text === '' ? null : parts.text,
+                    reasoning_content: parts.thinking === '' ? undefined : parts.thinking,
+                    tool_calls: parts.tools.length > 0 ? parts.tools.map(openaiToolCall) : undefined,
+                }),
+                finish_reason: openaiFinishReason(res.stop_reason),
+            },
+        ],
+        usage: canonicalToOpenaiUsage(res.usage),
+    };
+}
+/**
+ * The `chat.completion.chunk` sequence for one assistant turn, terminated by `[DONE]`.
+ *
+ * Tool calls are announced by name in their own chunk before any argument bytes, the way the API
+ * frames them, and usage arrives in a final choice-less chunk as it does under
+ * `stream_options.include_usage` — `OpenAiStreamAssembler` reads this back unchanged.
+ */
+export function canonicalToOpenaiSse(res) {
+    const head = { id: res.id, object: 'chat.completion.chunk', created: CREATED, model: res.model };
+    const frames = [];
+    const emit = (body) => {
+        frames.push(encodeSseFrame({ data: JSON.stringify({ ...head, ...body }) }));
+    };
+    const delta = (d) => {
+        emit({ choices: [{ index: 0, delta: d, finish_reason: null }] });
+    };
+    delta({ role: 'assistant', content: '' });
+    if (res.stop_reason === 'error') {
+        // Usage goes out before the error frame: a reader stops at the error, so anything the failed
+        // call already accounted for has to have reached it by then.
+        emit({ choices: [], usage: canonicalToOpenaiUsage(res.usage) });
+        frames.push(encodeSseFrame({
+            data: JSON.stringify({
+                error: { type: 'error', message: canonicalErrorText(res.content) },
+            }),
+        }));
+        frames.push(encodeSseFrame({ data: '[DONE]' }));
+        return frames.join('');
+    }
+    const parts = splitCanonicalContent(res.content);
+    if (parts.thinking !== '')
+        delta({ reasoning_content: parts.thinking });
+    if (parts.text !== '')
+        delta({ content: parts.text });
+    parts.tools.forEach((block, index) => {
+        delta({
+            tool_calls: [
+                { index, id: block.id, type: 'function', function: { name: block.name, arguments: '' } },
+            ],
+        });
+        // One chunk with the whole argument string: the fragment boundaries a live stream happened to
+        // use are not canonical, and the assembler only ever sees the concatenation.
+        delta({
+            tool_calls: [{ index, function: { arguments: stringifyToolInput(block.input) } }],
+        });
+    });
+    emit({ choices: [{ index: 0, delta: {}, finish_reason: openaiFinishReason(res.stop_reason) }] });
+    emit({ choices: [], usage: canonicalToOpenaiUsage(res.usage) });
+    frames.push(encodeSseFrame({ data: '[DONE]' }));
+    return frames.join('');
+}
+/** A chat-completions message has one reasoning field, one content body and a tool_calls list. */
+function splitCanonicalContent(content) {
+    const thinking = [];
+    const text = [];
+    const tools = [];
+    for (const block of content) {
+        if (block.type === 'thinking') {
+            if (block.text !== '')
+                thinking.push(block.text);
+        }
+        else if (block.type === 'text') {
+            if (block.text !== '')
+                text.push(block.text);
+        }
+        else if (block.type === 'tool_use') {
+            tools.push(block);
+        }
+        // An assistant turn never contains a tool_result, and an assistant message cannot carry an
+        // image in this dialect at all, so neither has anywhere to go here.
+    }
+    // Joining several text blocks is lossy — the block list cannot be recovered — but the dialect
+    // has exactly one content body, and joining beats dropping everything after the first.
+    return { thinking: thinking.join('\n'), text: text.join('\n'), tools };
+}
+function openaiToolCall(block) {
+    return {
+        id: block.id,
+        type: 'function',
+        function: { name: block.name, arguments: stringifyToolInput(block.input) },
+    };
+}
+function openaiFinishReason(stop) {
+    if (stop === 'tool_use')
+        return 'tool_calls';
+    if (stop === 'max_tokens')
+        return 'length';
+    // `end_turn`, plus `stop_sequence`, which OpenAI's vocabulary cannot tell apart from it.
+    return 'stop';
+}
+function canonicalToOpenaiUsage(usage) {
+    const cached = usage.cache_read_tokens;
+    // OpenAI counts cached tokens inside prompt_tokens; canonical follows Anthropic and does not.
+    const prompt = usage.input_tokens + (cached ?? 0);
+    return omitUndefined({
+        prompt_tokens: prompt,
+        completion_tokens: usage.output_tokens,
+        total_tokens: prompt + usage.output_tokens,
+        // A cache *write* has no counter anywhere in this dialect: cache_write_tokens stops here.
+        prompt_tokens_details: cached === undefined ? undefined : { cached_tokens: cached },
+    });
+}
+/** Incremental assembler for OpenAI-shaped SSE, shared by the recorder and the live provider. */
+export class OpenAiStreamAssembler {
+    decoder = new SseDecoder();
+    calls = new Map();
+    id = '';
+    model = '';
+    text = '';
+    thinking = '';
+    stop = 'end_turn';
+    usage = { input_tokens: 0, output_tokens: 0 };
+    errorText;
+    push(chunk) {
+        const out = [];
+        for (const frame of this.decoder.push(chunk))
+            this.handle(frameJson(frame), out);
+        return out;
+    }
+    flush() {
+        const out = [];
+        for (const frame of this.decoder.flush())
+            this.handle(frameJson(frame), out);
+        return out;
+    }
+    result() {
+        const content = [];
+        if (this.thinking !== '')
+            content.push({ type: 'thinking', text: this.thinking });
+        if (this.text !== '')
+            content.push({ type: 'text', text: this.text });
+        for (const index of [...this.calls.keys()].sort((a, b) => a - b)) {
+            const call = this.calls.get(index);
+            if (!call)
+                continue;
+            content.push({
+                type: 'tool_use',
+                id: call.id,
+                name: call.name,
+                input: parseToolInput(call.args),
+            });
+        }
+        if (this.errorText !== undefined)
+            content.push({ type: 'text', text: this.errorText });
+        return { id: this.id, model: this.model, stop_reason: this.stop, content, usage: this.usage };
+    }
+    handle(data, out) {
+        if (!data)
+            return;
+        const error = data['error'];
+        if (error !== undefined && error !== null) {
+            this.errorText = asString(asRecord(error)['message']) ?? 'unknown provider error';
+            this.stop = 'error';
+            return;
+        }
+        this.id = asString(data['id']) ?? this.id;
+        this.model = asString(data['model']) ?? this.model;
+        if (data['usage'] !== undefined && data['usage'] !== null)
+            this.usage = openaiUsage(data['usage']);
+        const choice = asRecord(asArray(data['choices'])[0]);
+        if (choice['finish_reason'] !== undefined && choice['finish_reason'] !== null) {
+            this.stop = openaiStopReason(choice['finish_reason']);
+        }
+        const delta = asRecord(choice['delta']);
+        const text = typeof delta['content'] === 'string' ? delta['content'] : flattenContent(delta['content']);
+        if (text !== '') {
+            this.text += text;
+            out.push({ type: 'text_delta', text });
+        }
+        const reasoning = asString(delta['reasoning_content']) ?? asString(delta['reasoning']);
+        if (reasoning !== undefined)
+            this.thinking += reasoning;
+        for (const raw of asArray(delta['tool_calls'])) {
+            const tc = asRecord(raw);
+            const index = asNumber(tc['index']) ?? 0;
+            const call = this.calls.get(index) ?? { id: '', name: '', args: '' };
+            const fn = asRecord(tc['function']);
+            call.id = asString(tc['id']) ?? call.id;
+            call.name = asString(fn['name']) ?? call.name;
+            const partial = asString(fn['arguments']) ?? '';
+            call.args += partial;
+            this.calls.set(index, call);
+            out.push({ type: 'tool_use_delta', id: call.id, name: call.name, partial_json: partial });
+        }
+    }
+}
+/** Assemble a complete response from a recorded OpenAI-shaped SSE stream. */
+export function parseOpenaiSse(chunks) {
+    const assembler = new OpenAiStreamAssembler();
+    for (const chunk of toChunks(chunks))
+        assembler.push(chunk);
+    assembler.flush();
+    return assembler.result();
+}
+//# sourceMappingURL=openai.js.map