@cleocode/core 2026.6.14 → 2026.6.17

package/dist/llm/transports/codex-responses.js

@@ -1,55 +1,65 @@
 /**
- * CodexResponsesTransport — OpenAI Responses API transport.
+ * CodexResponsesTransport — OpenAI Responses API transport (raw-fetch variant).
  *
- * Implements {@link LlmTransport} for providers that expose the OpenAI
- * Responses API (`openai.responses.create`), including:
- * - OpenAI (Codex CLI models, GPT-4.1, o-series)
- * - xAI (grok-* models via Responses-compatible endpoints)
+ * Implements {@link LlmTransport} for the ChatGPT Codex backend
+ * (`https://chatgpt.com/backend-api/codex/responses`) and any provider that
+ * speaks a compatible Responses-API SSE protocol (xAI grok-via-responses).
  *
- * Key behavioral differences from ChatCompletionsTransport:
- * - Input uses the `input` array of ResponseInputItem (not `messages`).
- * - Tools use `{type: 'function', name, description, parameters}` shape.
- * - Tool results use `{type: 'function_call_output', call_id, output}` items.
- * - The system prompt goes in `instructions`, not a system message.
- * - Response text is extracted from `output_text` shortcut or by scanning
- *   `output` for `{type: 'message'}` items.
- * - Tool calls come from `output` items of `{type: 'function_call'}`.
- * - Usage is in `response.usage.input_tokens` / `output_tokens`.
+ * ## Wire shape (mirrored from @earendil-works/pi-ai 0.78.x — imports banned)
  *
- * Parity gaps vs ChatCompletions are documented inline with:
- * `// PARITY GAP: <feature> not yet supported by OpenAI Responses API`
+ * Unlike the previous OpenAI-SDK-based implementation, this transport uses
+ * **raw `fetch`** to control every request header.  The Codex backend rejects
+ * requests that carry the SDK's default `Accept: application/json` header or
+ * that omit `store: false` in the body.
+ *
+ * Mandatory request headers:
+ * - `Authorization: Bearer <token>`
+ * - `chatgpt-account-id: <jwt claim>`
+ * - `originator: codex_cli_rs` (set by buildCodexOAuthHeaders)
+ * - `OpenAI-Beta: responses=experimental`
+ * - `accept: text/event-stream`  (always — backend mandates stream:true on every request)
+ * - `content-type: application/json`
+ *
+ * Mandatory body fields:
+ * - `model`, `input`, `instructions`
+ * - `store: false`                 (codex backend rejects store:true or absent)
+ * - `stream: true`                (always — the Codex backend rejects stream:false)
  *
  * @module llm/transports/codex-responses
+ * @task T11985
  * @task T9311
  * @epic T9261 (T-LLM-CRED-CENTRALIZATION Phase 5)
  * @see ADR-072 §LlmTransport — pure wire level
  */
-import { OpenAI as OpenAIClient } from 'openai';
 // ---------------------------------------------------------------------------
 // CodexResponsesTransport
 // ---------------------------------------------------------------------------
 /**
- * Transport for providers that expose the OpenAI Responses API.
+ * Transport for providers that expose the OpenAI Responses API via raw fetch.
  *
- * Wraps `openai.responses.create()` and normalizes requests/responses to/from
- * the provider-neutral {@link LlmTransport} interface.
+ * Uses native `fetch` (not the OpenAI SDK) so that the `Accept` header,
+ * `store: false` body field, and `OpenAI-Beta` header can all be set
+ * explicitly — the OpenAI SDK hardcodes `Accept: application/json` and omits
+ * `store`, both of which cause the Codex ChatGPT backend to return a 400.
  *
- * Input items are built by {@link _buildInputItems}, which converts
- * {@link TransportMessage} arrays into the Responses API `input` format.
- * Multi-turn tool replay is handled by injecting `function_call_output`
- * items when a prior `assistant` turn carries tool calls.
+ * SSE stream parsing mirrors the pi-ai 0.78.x reference implementation
+ * (`@earendil-works/pi-ai/dist/providers/openai-codex-responses.js`) —
+ * imports from that package are banned; the wire shape is transcribed here.
  *
  * @example
  * ```ts
  * const transport = new CodexResponsesTransport({
  *   provider: 'openai',
- *   apiKey: process.env.OPENAI_API_KEY!,
- * });
- * const response = await transport.complete({
- *   model: 'codex-mini-latest',
- *   messages: [{ role: 'user', content: 'Write a fizzbuzz.' }],
- *   maxTokens: 1024,
+ *   apiKey: process.env.CODEX_OAUTH_TOKEN!,
+ *   defaultHeaders: buildCodexOAuthHeaders(process.env.CODEX_OAUTH_TOKEN!),
  * });
+ * for await (const delta of transport.stream({
+ *   model: 'gpt-5.5',
+ *   messages: [{ role: 'user', content: 'Reply with exactly: pong' }],
+ *   maxTokens: 64,
+ * }, {})) {
+ *   process.stdout.write(delta.text);
+ * }
  * ```
  */
 export class CodexResponsesTransport {
@@ -64,117 +74,211 @@ export class CodexResponsesTransport {
      * @see ADR-072 §Type lock-in
      */
     apiMode = 'codex_responses';
-    /** Underlying OpenAI SDK client. */
-    _client;
+    /** API key / OAuth bearer token. */
+    _apiKey;
+    /**
+     * Resolved endpoint URL (the full `/codex/responses` path).
+     * Derived once at construction so the URL normalisation runs once.
+     */
+    _endpointUrl;
+    /** Extra headers merged into every request (auth, originator, etc.). */
+    _defaultHeaders;
     /**
      * Construct a CodexResponsesTransport.
      *
-     * @param opts - Construction options including provider, API key, and
-     *   optional base URL / default headers.
+     * @param opts - Construction options: provider, API key, optional base URL
+     *   and default headers (auth + Cloudflare-bypass headers for OAuth callers).
      */
     constructor(opts) {
         this.provider = opts.provider;
-        this._client = new OpenAIClient({
-            apiKey: opts.apiKey,
-            baseURL: opts.baseUrl,
-            defaultHeaders: opts.defaultHeaders,
-        });
+        this._apiKey = opts.apiKey;
+        this._endpointUrl = resolveCodexUrl(opts.baseUrl);
+        this._defaultHeaders = opts.defaultHeaders ?? {};
     }
+    // ---------------------------------------------------------------------------
+    // LlmTransport — complete()
+    // ---------------------------------------------------------------------------
     /**
-     * Execute a single completion using the OpenAI Responses API.
+     * Execute a single (non-streaming) completion using the Responses API.
      *
-     * Maps the provider-neutral {@link TransportRequest} to
-     * `openai.responses.create()` and normalizes the {@link Response} into a
-     * {@link NormalizedResponse}.
+     * The Codex ChatGPT backend mandates `stream: true` on every request and
+     * returns `400 {"detail":"Stream must be set to true"}` for `stream: false`.
+     * This method therefore always sends `stream: true` with
+     * `Accept: text/event-stream`, internally consumes the SSE stream, and
+     * aggregates text deltas + tool calls + usage into a {@link NormalizedResponse}
+     * — identical to calling `stream()` and collecting all chunks.
      *
      * @param request - Provider-neutral request parameters.
      * @param _ctx - Transport context (unused; `request.signal` handles abort).
      * @returns Normalized response envelope.
      */
     async complete(request, _ctx) {
-        const input = this._buildInputItems(request);
-        const tools = this._buildTools(request.tools);
-        const params = {
-            model: request.model,
-            input,
-            max_output_tokens: request.maxTokens,
-            temperature: request.temperature ?? 0.7,
+        const body = this._buildBody(request, true);
+        const headers = this._buildHeaders(true);
+        const res = await fetch(this._endpointUrl, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(body),
+            signal: request.signal,
+        });
+        if (!res.ok) {
+            throw new Error(await buildHttpError(res));
+        }
+        if (!res.body) {
+            throw new Error('codex_responses: response body is null (no SSE stream)');
+        }
+        // Aggregate SSE stream into a single NormalizedResponse.
+        const textParts = [];
+        const toolCalls = [];
+        let finalUsage = null;
+        let finishReason = null;
+        let responseId = null;
+        let responseModel = null;
+        for await (const event of parseSSE(res.body, request.signal)) {
+            const evType = event['type'];
+            if (evType === 'response.output_text.delta') {
+                const delta = event['delta'];
+                if (delta)
+                    textParts.push(delta);
+                continue;
+            }
+            if (evType === 'response.output_item.done') {
+                // Capture function_call items emitted per-output-item.
+                const item = event['item'];
+                if (item?.['type'] === 'function_call') {
+                    toolCalls.push({
+                        id: typeof item['call_id'] === 'string' ? item['call_id'] : null,
+                        name: typeof item['name'] === 'string' ? item['name'] : 'unknown',
+                        arguments: typeof item['arguments'] === 'string' ? item['arguments'] : '{}',
+                        providerData: {
+                            call_id: item['call_id'],
+                            response_item_id: item['id'],
+                        },
+                    });
+                }
+                continue;
+            }
+            if (evType === 'response.completed') {
+                const completedResponse = event['response'];
+                if (completedResponse) {
+                    finishReason = completedResponse['status'] ?? 'completed';
+                    responseId = completedResponse['id'] ?? null;
+                    responseModel = completedResponse['model'] ?? null;
+                    const usage = completedResponse['usage'];
+                    if (usage)
+                        finalUsage = normalizeUsage(usage);
+                    // Also capture tool calls embedded in the completed output array.
+                    const output = completedResponse['output'] ?? [];
+                    const embeddedCalls = extractToolCallsFromOutput(output);
+                    if (embeddedCalls.length > 0 && toolCalls.length === 0) {
+                        toolCalls.push(...embeddedCalls);
+                    }
+                }
+                break;
+            }
+            if (evType === 'response.failed' || evType === 'response.incomplete') {
+                const failedResponse = event['response'];
+                if (failedResponse) {
+                    finishReason = failedResponse['status'] ?? evType;
+                    const usage = failedResponse['usage'];
+                    if (usage)
+                        finalUsage = normalizeUsage(usage);
+                }
+                break;
+            }
+            if (evType === 'error') {
+                const code = event['code'];
+                const message = event['message'];
+                throw new Error(`Codex error: ${message ?? code ?? JSON.stringify(event)}`);
+            }
+        }
+        const content = textParts.join('') || null;
+        return {
+            id: responseId ?? `resp-${Date.now().toString(36)}`,
+            model: responseModel ?? request.model,
+            content,
+            toolCalls: toolCalls.length > 0 ? toolCalls : null,
+            stopReason: finishReason ?? 'completed',
+            usage: finalUsage ?? { inputTokens: 0, outputTokens: 0 },
+            providerData: {
+                codex_response_id: responseId,
+            },
+            raw: {},
         };
-        if (request.system)
-            params['instructions'] = request.system;
-        if (tools.length > 0)
-            params['tools'] = tools;
-        // PARITY GAP: cacheStrategy (system_and_3 / prefix_and_2) not yet supported
-        // by OpenAI Responses API — it has its own `prompt_cache_retention` parameter
-        // but no equivalent to Anthropic's cache-breakpoint injection.
-        const response = (await this._client.responses.create(params, { signal: request.signal }));
-        return this._normalize(response, request.model);
     }
+    // ---------------------------------------------------------------------------
+    // LlmTransport — stream()
+    // ---------------------------------------------------------------------------
     /**
-     * Stream a completion using the OpenAI Responses API SSE stream.
+     * Stream a completion using the Responses API SSE stream.
      *
      * Yields {@link NormalizedDelta} chunks from `response.output_text.delta`
-     * events. The final delta is emitted when `response.completed` fires and
-     * carries `stopReason` and `usage`.
+     * events parsed from the raw SSE stream.  The final delta carries
+     * `stopReason` and `usage` from `response.completed`.
+     *
+     * Wire shape:
+     * - `store: false` (required — codex backend rejects absent or true)
+     * - `stream: true`
+     * - `Accept: text/event-stream`
+     * - `OpenAI-Beta: responses=experimental`
      *
      * @param request - Provider-neutral request parameters.
      * @param _ctx - Transport context (unused; `request.signal` handles abort).
      * @returns Async iterable of normalized delta chunks.
      */
     async *stream(request, _ctx) {
-        const input = this._buildInputItems(request);
-        const tools = this._buildTools(request.tools);
-        const params = {
-            model: request.model,
-            input,
-            max_output_tokens: request.maxTokens,
-            temperature: request.temperature ?? 0.7,
-            stream: true,
-        };
-        if (request.system)
-            params['instructions'] = request.system;
-        if (tools.length > 0)
-            params['tools'] = tools;
-        // PARITY GAP: stream_options.include_usage not available in Responses API stream
-        // — usage arrives in the response.completed event, not a dedicated usage chunk.
-        const responseStream = (await this._client.responses.create(params, { signal: request.signal }));
+        const body = this._buildBody(request, true);
+        const headers = this._buildHeaders(true);
+        const res = await fetch(this._endpointUrl, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(body),
+            signal: request.signal,
+        });
+        if (!res.ok) {
+            throw new Error(await buildHttpError(res));
+        }
+        if (!res.body) {
+            throw new Error('codex_responses: response body is null (no SSE stream)');
+        }
         let finishReason = null;
         let finalUsage = null;
-        for await (const event of responseStream) {
-            const ev = event;
-            const evType = ev['type'];
+        for await (const event of parseSSE(res.body, request.signal)) {
+            const evType = event['type'];
             if (evType === 'response.output_text.delta') {
-                const delta = ev['delta'];
+                const delta = event['delta'];
                 if (delta) {
                     yield { text: delta, reasoning: '', stopReason: null, usage: null };
                 }
                 continue;
             }
-            // PARITY GAP: reasoning_summary_text.delta not mapped to delta.reasoning
-            // because the Responses API streams reasoning summary separately.
-            // Once the API stabilizes reasoning streaming, wire this through.
             if (evType === 'response.completed') {
-                const completedResponse = ev['response'] ?? null;
+                const completedResponse = event['response'];
                 if (completedResponse) {
-                    finishReason = completedResponse.status ?? 'completed';
-                    const usage = completedResponse.usage;
+                    finishReason = completedResponse['status'] ?? 'completed';
+                    const usage = completedResponse['usage'];
                     if (usage) {
-                        finalUsage = this._normalizeUsage(usage);
+                        finalUsage = normalizeUsage(usage);
                     }
                 }
                 break;
             }
             if (evType === 'response.failed' || evType === 'response.incomplete') {
-                const failedResponse = ev['response'] ?? null;
+                const failedResponse = event['response'];
                 if (failedResponse) {
-                    finishReason = failedResponse.status ?? evType;
-                    const usage = failedResponse.usage;
+                    finishReason = failedResponse['status'] ?? evType;
+                    const usage = failedResponse['usage'];
                     if (usage) {
-                        finalUsage = this._normalizeUsage(usage);
+                        finalUsage = normalizeUsage(usage);
                     }
                 }
                 break;
             }
+            if (evType === 'error') {
+                const code = event['code'];
+                const message = event['message'];
+                throw new Error(`Codex error: ${message ?? code ?? JSON.stringify(event)}`);
+            }
         }
         yield {
             text: '',
@@ -184,146 +288,191 @@ export class CodexResponsesTransport {
         };
     }
     // ---------------------------------------------------------------------------
-    // Input items construction
+    // Private helpers
     // ---------------------------------------------------------------------------
     /**
-     * Convert provider-neutral messages to the Responses API `input` array.
+     * Build the HTTP headers for a Codex request.
      *
-     * Mapping rules:
-     * - `user` / `assistant` string messages → `EasyInputMessage` with `type:'message'`.
-     * - `user` / `assistant` multimodal blocks → content list with `input_text` /
-     *   `input_image` items.
-     * - `tool` messages (role=`'tool'`) → `function_call_output` items using
-     *   `toolUseId` as `call_id`.
+     * Merges the auth/cloudflare headers from `_defaultHeaders` with the
+     * mandatory Codex-specific headers:
+     * - `OpenAI-Beta: responses=experimental`
+     * - `content-type: application/json`
+     * - `accept: text/event-stream` (always — both complete() and stream() use SSE)
      *
-     * Multi-turn tool replay: when an assistant message's raw content is a
-     * `function_call` JSON envelope (injected by the agent loop after a tool
-     * call round-trip), the item is converted to a `function_call` input item
-     * so the Responses API can continue the conversation.
+     * The Authorization header is injected only if not already present in
+     * `_defaultHeaders` (OAuth callers pre-set it via buildCodexOAuthHeaders).
      *
-     * @param request - Full transport request.
-     * @returns Responses API input items array.
+     * @param streaming - Whether this is a streaming (SSE) or completion call.
+     * @returns Plain string record of all request headers.
      */
-    _buildInputItems(request) {
-        const items = [];
-        for (const msg of request.messages) {
-            if (msg.role === 'tool') {
-                // Tool result: convert to function_call_output
-                items.push({
-                    type: 'function_call_output',
-                    call_id: msg.toolUseId ?? `call_${Date.now().toString(36)}`,
-                    output: typeof msg.content === 'string' ? msg.content : extractTextContent(msg),
-                });
-                continue;
-            }
-            // user or assistant messages
-            const contentItems = buildContentList(msg);
-            if (contentItems.length === 1 && contentItems[0]?.['type'] === 'input_text') {
-                // Simple text — use the EasyInputMessage shorthand
-                items.push({
-                    type: 'message',
-                    role: msg.role === 'assistant' ? 'assistant' : 'user',
-                    content: contentItems[0]['text'],
-                });
-            }
-            else {
-                items.push({
-                    type: 'message',
-                    role: msg.role === 'assistant' ? 'assistant' : 'user',
-                    content: contentItems,
-                });
-            }
+    _buildHeaders(streaming) {
+        const headers = {
+            ...this._defaultHeaders,
+            'OpenAI-Beta': 'responses=experimental',
+            'content-type': 'application/json',
+            accept: streaming ? 'text/event-stream' : 'application/json',
+        };
+        // Inject Authorization only when callers haven't pre-set it.
+        const hasAuth = Object.keys(headers).some((k) => k.toLowerCase() === 'authorization');
+        if (!hasAuth) {
+            headers['Authorization'] = `Bearer ${this._apiKey}`;
         }
-        return items;
-    }
-    // ---------------------------------------------------------------------------
-    // Tool conversion
-    // ---------------------------------------------------------------------------
-    /**
-     * Convert provider-neutral tool definitions to the Responses API
-     * `{type: 'function', name, description, parameters, strict}` shape.
-     *
-     * @param tools - Provider-neutral tool definitions (may be undefined).
-     * @returns Responses API tool objects, or empty array.
-     */
-    _buildTools(tools) {
-        if (!tools || tools.length === 0)
-            return [];
-        return tools.map((t) => ({
-            type: 'function',
-            name: t.name,
-            description: t.description,
-            parameters: t.inputSchema,
-            strict: false,
-        }));
+        return headers;
     }
-    // ---------------------------------------------------------------------------
-    // Response normalization
-    // ---------------------------------------------------------------------------
     /**
-     * Normalize an OpenAI Responses API {@link Response} into a
-     * {@link NormalizedResponse}.
+     * Build the JSON request body for a Codex Responses API call.
      *
-     * Mapping rules:
-     * - `content` — from `response.output_text` shortcut (SDK convenience
-     *   property that aggregates all output_text parts).
-     * - `toolCalls` — from `output` items of `type: 'function_call'`.
-     * - `stopReason` — from `response.status` (completed / failed / incomplete).
-     * - `usage` — `input_tokens` → `inputTokens`, `output_tokens` → `outputTokens`.
-     * - `cachedTokens` — from `usage.input_tokens_details.cached_tokens`.
-     * - `raw` — unmodified SDK response.
-     *
-     * @param response - Raw Responses API response object.
-     * @param requestedModel - Model string from the originating request.
-     * @returns Normalized response envelope.
-     */
-    _normalize(response, requestedModel) {
-        const content = response.output_text && response.output_text.length > 0
-            ? response.output_text
-            : extractTextFromOutput(response.output);
-        const toolCalls = extractToolCallsFromOutput(response.output);
-        const usage = this._normalizeUsage(response.usage ?? null);
-        return {
-            id: response.id ?? `resp-${Date.now().toString(36)}`,
-            model: String(response.model ?? requestedModel),
-            content: content || null,
-            toolCalls: toolCalls.length > 0 ? toolCalls : null,
-            stopReason: response.status ?? 'completed',
-            usage,
-            providerData: {
-                codex_response_id: response.id,
-            },
-            raw: response,
-        };
-    }
-    /**
-     * Normalize OpenAI Responses API usage into {@link NormalizedUsage}.
+     * Mandatory fields per the Codex backend:
+     * - `store: false`   — backend rejects absent or `true`.
+     * - `instructions`   — system prompt (defaulting to empty string when absent).
+     * - `input`          — array of Responses API input items.
      *
-     * @param usage - Raw usage object (may be null when the API omits it).
-     * @returns Normalized usage with optional `cachedTokens`.
+     * @param request - Provider-neutral request.
+     * @param streaming - Whether to enable SSE streaming.
+     * @returns Serialisable request body.
      */
-    _normalizeUsage(usage) {
-        if (!usage)
-            return { inputTokens: 0, outputTokens: 0 };
-        const normalized = {
-            inputTokens: usage.input_tokens ?? 0,
-            outputTokens: usage.output_tokens ?? 0,
+    _buildBody(request, streaming) {
+        const body = {
+            model: request.model,
+            input: buildInputItems(request),
+            instructions: request.system ?? '',
+            store: false,
+            stream: streaming,
         };
-        const cached = usage.input_tokens_details?.cached_tokens;
-        if (typeof cached === 'number' && cached > 0) {
-            normalized.cachedTokens = cached;
-        }
-        return normalized;
+        // NOTE: the Codex ChatGPT backend rejects `max_output_tokens` with a 400
+        // ("Unsupported parameter: max_output_tokens"). pi-ai 0.78.x omits it too.
+        // Only set temperature when explicitly provided by the caller.
+        if (request.temperature != null)
+            body.temperature = request.temperature;
+        const tools = buildTools(request.tools);
+        if (tools.length > 0)
+            body.tools = tools;
+        return body;
     }
 }
 // ---------------------------------------------------------------------------
 // Module-private helpers
 // ---------------------------------------------------------------------------
 /**
- * Extract plain text content from a {@link TransportMessage}.
+ * Resolve the full Responses API endpoint URL from an optional base URL.
+ *
+ * Mirrors the `resolveCodexUrl` logic from pi-ai 0.78.x so the same base URL
+ * variants work:
+ * - `https://chatgpt.com/backend-api`           → `.../codex/responses`
+ * - `https://chatgpt.com/backend-api/codex`     → `.../codex/responses`
+ * - `https://chatgpt.com/backend-api/codex/responses` → unchanged
+ * - `undefined` (no override)                   → ChatGPT Codex default
+ *
+ * For non-ChatGPT providers (xAI, custom shims) the raw baseUrl is
+ * appended with `/responses` when it doesn't already end with `/responses`.
+ *
+ * @param baseUrl - Optional override base URL (no trailing slash).
+ * @returns The fully resolved endpoint URL.
+ */
+export function resolveCodexUrl(baseUrl) {
+    const DEFAULT_BASE = 'https://chatgpt.com/backend-api';
+    const raw = baseUrl?.trim() ? baseUrl.trim() : DEFAULT_BASE;
+    const normalized = raw.replace(/\/+$/, '');
+    if (normalized.endsWith('/codex/responses'))
+        return normalized;
+    if (normalized.endsWith('/codex'))
+        return `${normalized}/responses`;
+    return `${normalized}/codex/responses`;
+}
+/**
+ * Consume an HTTP error response and build a descriptive error message.
+ *
+ * Reads the response body (if present) and attempts to extract a
+ * `{error.message}` payload from JSON.  Falls back to the raw body text when
+ * JSON parsing fails, or to the HTTP status text when the body is empty.
+ *
+ * This replaces the previous "(no body)" message that appeared whenever the
+ * Codex backend returned a structured error (e.g. `{"error":{"message":"…"}}`).
+ *
+ * @param res - The failed fetch Response.
+ * @returns A descriptive error string including status code and body detail.
+ */
+async function buildHttpError(res) {
+    let bodyDetail = '';
+    try {
+        const text = await res.text();
+        if (text) {
+            try {
+                const parsed = JSON.parse(text);
+                const err = parsed['error'];
+                bodyDetail = err?.['message'] ?? text;
+            }
+            catch {
+                bodyDetail = text;
+            }
+        }
+    }
+    catch {
+        // Body read failed — fall through to status-only message.
+    }
+    return bodyDetail ? `${res.status} ${bodyDetail}` : `${res.status} status code (no body)`;
+}
+/**
+ * Convert provider-neutral messages to the Responses API `input` array.
+ *
+ * Mapping rules:
+ * - `user` / `assistant` string messages → `{type:'message', role, content}`.
+ * - `user` / `assistant` multimodal blocks → content list with `input_text` /
+ *   `input_image` items.
+ * - `tool` messages (role=`'tool'`) → `function_call_output` items.
+ *
+ * @param request - Full transport request.
+ * @returns Responses API input items array.
+ */
+function buildInputItems(request) {
+    const items = [];
+    for (const msg of request.messages) {
+        if (msg.role === 'tool') {
+            items.push({
+                type: 'function_call_output',
+                call_id: msg.toolUseId ?? `call_${Date.now().toString(36)}`,
+                output: extractTextContent(msg),
+            });
+            continue;
+        }
+        const contentItems = buildContentList(msg);
+        if (contentItems.length === 1 && contentItems[0]?.['type'] === 'input_text') {
+            items.push({
+                type: 'message',
+                role: msg.role === 'assistant' ? 'assistant' : 'user',
+                content: contentItems[0]['text'],
+            });
+        }
+        else {
+            items.push({
+                type: 'message',
+                role: msg.role === 'assistant' ? 'assistant' : 'user',
+                content: contentItems,
+            });
+        }
+    }
+    return items;
+}
+/**
+ * Convert provider-neutral tool definitions to the Responses API
+ * `{type: 'function', name, description, parameters, strict}` shape.
  *
- * When `content` is a plain string, returns it as-is. When it is a multimodal
- * block array, concatenates all `text` blocks and drops `image` blocks.
+ * @param tools - Provider-neutral tool definitions (may be undefined).
+ * @returns Responses API tool objects, or empty array.
+ */
+function buildTools(tools) {
+    if (!tools || tools.length === 0)
+        return [];
+    return tools.map((t) => ({
+        type: 'function',
+        name: t.name,
+        description: t.description,
+        parameters: t.inputSchema,
+        strict: false,
+    }));
+}
+/**
+ * Extract plain text content from a {@link TransportMessage}.
  *
  * @param message - Transport message to extract text from.
  * @returns Plain text string.
@@ -339,9 +488,6 @@ function extractTextContent(message) {
 /**
  * Build a Responses API content list from a {@link TransportMessage}.
  *
- * Each text block becomes `{type: 'input_text', text}`.
- * Each image block becomes `{type: 'input_image', image_url, detail: 'auto'}`.
- *
  * @param message - Transport message to convert.
  * @returns Array of Responses API content items.
  */
@@ -353,67 +499,119 @@ function buildContentList(message) {
         if (block.type === 'text') {
             return { type: 'input_text', text: block.text };
         }
-        // image block
         const source = block.source;
         const imageUrl = source.type === 'base64' ? `data:${source.mediaType};base64,${source.data}` : source.data;
         return { type: 'input_image', image_url: imageUrl, detail: 'auto' };
     });
 }
-/**
- * Extract plain text from a Responses API `output` item array.
- *
- * Scans for `{type: 'message'}` output items and concatenates all
- * `{type: 'output_text'}` content parts.
- *
- * @param output - Array of ResponseOutputItem objects (typed as unknown[]).
- * @returns Concatenated text content, or empty string.
- */
-function extractTextFromOutput(output) {
-    const parts = [];
-    for (const item of output) {
-        const it = item;
-        if (it['type'] !== 'message')
-            continue;
-        const content = it['content'];
-        if (!Array.isArray(content))
-            continue;
-        for (const part of content) {
-            if (part['type'] === 'output_text' && typeof part['text'] === 'string') {
-                parts.push(part['text']);
-            }
-        }
-    }
-    return parts.join('');
-}
 /**
  * Extract tool calls from a Responses API `output` item array.
  *
- * Scans for `{type: 'function_call'}` items and maps them to
- * {@link NormalizedToolCall}.
- *
- * The Responses API uses `call_id` as the stable tool-call identifier (not `id`).
- * Both are stored: `NormalizedToolCall.id` is set to `call_id` (the replay key),
- * and `providerData.response_item_id` carries the item's `id` field for tracing.
- *
- * @param output - Array of ResponseOutputItem objects (typed as unknown[]).
+ * @param output - Array of ResponseOutputItem objects.
  * @returns Array of normalized tool calls.
  */
 function extractToolCallsFromOutput(output) {
     const calls = [];
     for (const item of output) {
-        const it = item;
-        if (it['type'] !== 'function_call')
+        if (item['type'] !== 'function_call')
             continue;
         calls.push({
-            id: typeof it['call_id'] === 'string' ? it['call_id'] : null,
-            name: typeof it['name'] === 'string' ? it['name'] : 'unknown',
-            arguments: typeof it['arguments'] === 'string' ? it['arguments'] : '{}',
+            id: typeof item['call_id'] === 'string' ? item['call_id'] : null,
+            name: typeof item['name'] === 'string' ? item['name'] : 'unknown',
+            arguments: typeof item['arguments'] === 'string' ? item['arguments'] : '{}',
             providerData: {
-                call_id: it['call_id'],
-                response_item_id: it['id'],
+                call_id: item['call_id'],
+                response_item_id: item['id'],
             },
         });
     }
     return calls;
 }
+/**
+ * Normalize raw Responses API usage into {@link NormalizedUsage}.
+ *
+ * @param usage - Raw usage object (may be empty or undefined fields).
+ * @returns Normalized usage with optional `cachedTokens`.
+ */
+function normalizeUsage(usage) {
+    const inputTokens = usage['input_tokens'] ?? 0;
+    const outputTokens = usage['output_tokens'] ?? 0;
+    const normalized = { inputTokens, outputTokens };
+    const details = usage['input_tokens_details'];
+    const cached = details?.['cached_tokens'];
+    if (typeof cached === 'number' && cached > 0) {
+        normalized.cachedTokens = cached;
+    }
+    return normalized;
+}
+/**
+ * Parse a raw SSE (Server-Sent Events) stream and yield JSON event objects.
+ *
+ * Reads chunks from a ReadableStream, splits on `\n\n` event boundaries,
+ * and parses each `data:` line as JSON.  `[DONE]` terminates the loop.
+ *
+ * Mirrors the `parseSSE` function from pi-ai 0.78.x
+ * (`@earendil-works/pi-ai/dist/providers/openai-codex-responses.js`).
+ *
+ * @param body - The ReadableStream from the fetch response.
+ * @param signal - Optional AbortSignal for early termination.
+ * @returns Async iterable of parsed JSON event objects.
+ */
+async function* parseSSE(body, signal) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    const onAbort = () => {
+        void reader.cancel().catch(() => undefined);
+    };
+    signal?.addEventListener('abort', onAbort, { once: true });
+    try {
+        while (true) {
+            if (signal?.aborted)
+                throw new Error('Request was aborted');
+            const { done, value } = await reader.read();
+            if (signal?.aborted)
+                throw new Error('Request was aborted');
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            let idx = buffer.indexOf('\n\n');
+            while (idx !== -1) {
+                const chunk = buffer.slice(0, idx);
+                buffer = buffer.slice(idx + 2);
+                const dataLines = chunk
+                    .split('\n')
+                    .filter((l) => l.startsWith('data:'))
+                    .map((l) => l.slice(5).trim());
+                if (dataLines.length > 0) {
+                    const data = dataLines.join('\n').trim();
+                    if (data && data !== '[DONE]') {
+                        try {
+                            yield JSON.parse(data);
+                        }
+                        catch {
+                            // Malformed SSE JSON — skip event; don't crash the stream.
+                        }
+                    }
+                }
+                idx = buffer.indexOf('\n\n');
+            }
+        }
+    }
+    finally {
+        signal?.removeEventListener('abort', onAbort);
+        try {
+            await reader.cancel();
+        }
+        catch {
+            // ignore
+        }
+        try {
+            reader.releaseLock();
+        }
+        catch {
+            // ignore
+        }
+    }
+}
 //# sourceMappingURL=codex-responses.js.map