@ouro.bot/cli 0.1.0-alpha.55 → 0.1.0-alpha.550

package/dist/heart/providers/github-copilot.js

@@ -0,0 +1,145 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyGithubCopilotError = classifyGithubCopilotError;
+exports.createGithubCopilotProviderRuntime = createGithubCopilotProviderRuntime;
+const openai_1 = __importDefault(require("openai"));
+const config_1 = require("../config");
+const runtime_1 = require("../../nerves/runtime");
+const streaming_1 = require("../streaming");
+const model_capabilities_1 = require("../model-capabilities");
+const error_classification_1 = require("./error-classification");
+function classifyGithubCopilotError(error) {
+    return (0, error_classification_1.classifyHttpError)(error);
+}
+function createGithubCopilotProviderRuntime(model, config = (0, config_1.getGithubCopilotConfig)()) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.provider_init",
+        message: "github-copilot provider init",
+        meta: { provider: "github-copilot" },
+    });
+    if (!config.githubToken) {
+        throw new Error("provider 'github-copilot' is selected but github-copilot.githubToken is missing in the agent vault. Run `ouro auth --agent <agent> --provider github-copilot`.");
+    }
+    if (!config.baseUrl) {
+        throw new Error("provider 'github-copilot' is selected but github-copilot.baseUrl is missing in the agent vault. Run `ouro auth --agent <agent> --provider github-copilot`.");
+    }
+    const isCompletionsModel = model.startsWith("claude");
+    const modelCaps = (0, model_capabilities_1.getModelCapabilities)(model);
+    const capabilities = new Set();
+    /* v8 ignore next -- branch: capability detection tested via unit test @preserve */
+    if (modelCaps.reasoningEffort)
+        capabilities.add("reasoning-effort");
+    const client = new openai_1.default({
+        apiKey: config.githubToken,
+        baseURL: config.baseUrl,
+        maxRetries: 0,
+    });
+    if (isCompletionsModel) {
+        // Chat completions path (Claude models via Copilot)
+        return {
+            id: "github-copilot",
+            model,
+            client,
+            capabilities,
+            supportedReasoningEfforts: modelCaps.reasoningEffort,
+            resetTurnState(_messages) {
+                // No provider-owned turn state for chat-completions path.
+            },
+            appendToolOutput(_callId, _output) {
+                // Chat-completions providers rely on canonical messages only.
+            },
+            /* v8 ignore start -- streamTurn: tested via mock assertions in github-copilot.test.ts @preserve */
+            async streamTurn(request) {
+                const params = {
+                    messages: request.messages,
+                    tools: request.activeTools,
+                    stream: true,
+                };
+                if (this.model)
+                    params.model = this.model;
+                if (request.traceId)
+                    params.metadata = { trace_id: request.traceId };
+                if (request.toolChoiceRequired)
+                    params.tool_choice = "required";
+                try {
+                    return await (0, streaming_1.streamChatCompletion)(this.client, params, request.callbacks, request.signal, request.eagerSettleStreaming);
+                }
+                catch (error) {
+                    throw error instanceof Error ? error : new Error(String(error));
+                }
+            },
+            /* v8 ignore stop */
+            /* v8 ignore start -- ping: tested via provider-ping.test.ts @preserve */
+            async ping(signal) {
+                await this.client.chat.completions.create({ model: this.model, max_tokens: 1, messages: [{ role: "user", content: "ping" }] }, { signal });
+            },
+            /* v8 ignore stop */
+            /* v8 ignore next 3 -- delegation: classification logic tested via classifyGithubCopilotError @preserve */
+            classifyError(error) {
+                return classifyGithubCopilotError(error);
+            },
+        };
+    }
+    // Responses API path (GPT models via Copilot)
+    let nativeInput = null;
+    let nativeInstructions = "";
+    return {
+        id: "github-copilot",
+        model,
+        client,
+        capabilities,
+        supportedReasoningEfforts: modelCaps.reasoningEffort,
+        /* v8 ignore start -- responses path: tested via mock assertions in github-copilot.test.ts @preserve */
+        resetTurnState(messages) {
+            const { instructions, input } = (0, streaming_1.toResponsesInput)(messages);
+            nativeInput = input;
+            nativeInstructions = instructions;
+        },
+        appendToolOutput(callId, output) {
+            if (!nativeInput)
+                return;
+            nativeInput.push({ type: "function_call_output", call_id: callId, output: (0, streaming_1.truncateResponsesFunctionCallOutput)(output) });
+        },
+        async streamTurn(request) {
+            if (!nativeInput)
+                this.resetTurnState(request.messages);
+            const params = {
+                model: this.model,
+                input: nativeInput,
+                instructions: nativeInstructions,
+                tools: (0, streaming_1.toResponsesTools)(request.activeTools),
+                reasoning: { effort: request.reasoningEffort ?? "medium", summary: "detailed" },
+                stream: true,
+                store: false,
+                include: ["reasoning.encrypted_content"],
+            };
+            if (request.traceId)
+                params.metadata = { trace_id: request.traceId };
+            if (request.toolChoiceRequired)
+                params.tool_choice = "required";
+            try {
+                const result = await (0, streaming_1.streamResponsesApi)(this.client, params, request.callbacks, request.signal, request.eagerSettleStreaming);
+                for (const item of result.outputItems)
+                    nativeInput.push(item);
+                return result;
+            }
+            catch (error) {
+                throw error instanceof Error ? error : new Error(String(error));
+            }
+        },
+        /* v8 ignore stop */
+        /* v8 ignore start -- ping: tested via provider-ping.test.ts @preserve */
+        async ping(signal) {
+            await this.client.responses.create({ model: this.model, input: "ping", max_output_tokens: 16 }, { signal });
+        },
+        /* v8 ignore stop */
+        /* v8 ignore next 3 -- delegation: classification logic tested via classifyGithubCopilotError @preserve */
+        classifyError(error) {
+            return classifyGithubCopilotError(error);
+        },
+    };
+}

package/dist/heart/providers/minimax-vlm.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.minimaxVlmDescribe = minimaxVlmDescribe;
+const runtime_1 = require("../../nerves/runtime");
+const error_classification_1 = require("./error-classification");
+// No default timeout — if the caller doesn't pass `timeoutMs`, we don't
+// layer an AbortSignal on top of fetch, which means undici's own defaults
+// (headersTimeout and bodyTimeout, both 5 minutes in the current Node) are
+// the ceiling. That's the right ceiling: long enough to tolerate any
+// legitimate MiniMax VLM slow window, short enough to eventually give up on
+// a dead endpoint, and — unlike a number we picked — it's the stack's
+// actual default rather than a harness-imposed fiction.
+//
+// Tests that want to exercise the timeout branch pass an explicit
+// `timeoutMs`; production callers omit it and get undici's behavior.
+//
+// Same reasoning as PR #322 (dropped the 30s SDK timeout from the LLM
+// providers): the harness shouldn't impose artificially tight request
+// ceilings when the underlying stack already has correct defaults.
+const MODEL_NAME = "minimax-vlm";
+const SUPPORTED_DATA_URL_PATTERN = /^data:image\/(png|jpeg|webp);base64,/i;
+function buildVlmUrl(baseURL) {
+    const stripped = baseURL.replace(/\/v1\/?$/, "").replace(/\/$/, "");
+    return `${stripped}/v1/coding_plan/vlm`;
+}
+function extractMimeType(imageDataUrl) {
+    const match = /^data:([^;,]+)[;,]/.exec(imageDataUrl);
+    return match?.[1]?.toLowerCase();
+}
+function emitStart(params) {
+    (0, runtime_1.emitNervesEvent)({
+        level: "warn",
+        component: "senses",
+        event: "senses.bluebubbles_vlm_describe_start",
+        message: "minimax vlm describe start",
+        meta: {
+            attachmentGuid: params.attachmentGuid,
+            mimeType: params.mimeType,
+            promptLength: params.prompt.length,
+            model: MODEL_NAME,
+            chatModel: params.chatModel,
+        },
+    });
+}
+function emitEnd(params, descriptionLength, latencyMs) {
+    (0, runtime_1.emitNervesEvent)({
+        level: "warn",
+        component: "senses",
+        event: "senses.bluebubbles_vlm_describe_end",
+        message: "minimax vlm describe end",
+        meta: {
+            attachmentGuid: params.attachmentGuid,
+            descriptionLength,
+            latencyMs,
+            model: MODEL_NAME,
+        },
+    });
+}
+function emitError(params, reason, status, traceId) {
+    (0, runtime_1.emitNervesEvent)({
+        level: "warn",
+        component: "senses",
+        event: "senses.bluebubbles_vlm_describe_error",
+        message: "minimax vlm describe error",
+        meta: {
+            attachmentGuid: params.attachmentGuid,
+            mimeType: params.mimeType,
+            model: MODEL_NAME,
+            reason,
+            status,
+            traceId,
+        },
+    });
+}
+function throwAndEmit(params, message, status, traceId) {
+    emitError(params, message, status, traceId);
+    const err = new Error(message);
+    if (status !== undefined)
+        err.status = status;
+    if (traceId)
+        err.traceId = traceId;
+    throw err;
+}
+async function minimaxVlmDescribe(params) {
+    if (!params.apiKey) {
+        // We deliberately do NOT emit _start for param-validation errors — there's
+        // no meaningful "started a request" to pair with. Only the _error fires.
+        emitError(params, "minimax VLM: API key is empty — run `ouro auth --agent <agent> --provider minimax`");
+        throw new Error("minimax VLM: API key is empty — run `ouro auth --agent <agent> --provider minimax`");
+    }
+    if (!params.prompt) {
+        emitError(params, "minimax VLM: missing prompt — supply a targeted question (e.g. 'what's the flight number in the bottom-right?') and retry");
+        throw new Error("minimax VLM: missing prompt — supply a targeted question (e.g. 'what's the flight number in the bottom-right?') and retry");
+    }
+    if (!params.imageDataUrl) {
+        emitError(params, "minimax VLM: missing image data URL — verify the attachment downloaded OK or ask the user to resend the image");
+        throw new Error("minimax VLM: missing image data URL — verify the attachment downloaded OK or ask the user to resend the image");
+    }
+    if (!SUPPORTED_DATA_URL_PATTERN.test(params.imageDataUrl)) {
+        const mime = extractMimeType(params.imageDataUrl) ?? "unknown";
+        const msg = `minimax VLM: image must be a data:image/(png|jpeg|webp);base64,... URL but got ${mime} — ask the user to resend as a screenshot (png or jpeg)`;
+        emitError({ ...params, mimeType: params.mimeType ?? mime }, msg);
+        throw new Error(msg);
+    }
+    const fetchImpl = params.fetchImpl ?? fetch;
+    const url = buildVlmUrl(params.baseURL);
+    emitStart(params);
+    const startTs = Date.now();
+    // Only layer an AbortSignal if the caller explicitly asked for one.
+    // Omitting it lets undici's defaults (headersTimeout + bodyTimeout = 5min
+    // each in current Node) act as the ceiling — see the long comment on
+    // DEFAULT_TIMEOUT_MS above for the rationale.
+    const fetchOptions = {
+        method: "POST",
+        headers: {
+            "Authorization": `Bearer ${params.apiKey}`,
+            "Content-Type": "application/json",
+            "MM-API-Source": "Ouroboros",
+        },
+        body: JSON.stringify({
+            prompt: params.prompt,
+            image_url: params.imageDataUrl,
+        }),
+    };
+    if (typeof params.timeoutMs === "number" && params.timeoutMs > 0) {
+        fetchOptions.signal = AbortSignal.timeout(params.timeoutMs);
+    }
+    let response;
+    try {
+        response = await fetchImpl(url, fetchOptions);
+    }
+    catch (error) {
+        const err = (error instanceof Error ? error : new Error(String(error)));
+        if (err.name === "AbortError" || err.name === "TimeoutError") {
+            const seconds = typeof params.timeoutMs === "number" ? Math.round(params.timeoutMs / 1000) : null;
+            const hint = seconds !== null
+                ? `request timed out after ${seconds}s — retry or ask the user to resend the image`
+                : `request timed out (underlying stack default) — retry or ask the user to resend the image`;
+            throwAndEmit(params, `minimax VLM: ${hint}`);
+        }
+        if ((0, error_classification_1.isNetworkError)(err)) {
+            throwAndEmit(params, `minimax VLM: network error talking to the vlm endpoint (${err.message}) — retry in a moment`);
+        }
+        throwAndEmit(params, `minimax VLM: unexpected transport error (${err.message}) — retry, and if it persists surface 'image understanding is unavailable' to the user`);
+    }
+    const traceId = response.headers.get("Trace-Id") ?? response.headers.get("trace-id") ?? undefined;
+    const status = response.status;
+    if (status === 401 || status === 403) {
+        throwAndEmit(params, `minimax VLM: rejected credentials (HTTP ${status}) — the minimax key for this agent is invalid, re-run credential setup or rotate the key`, status, traceId);
+    }
+    if (status === 429) {
+        throwAndEmit(params, `minimax VLM: rate limited (HTTP 429) — wait and retry in a moment`, status, traceId);
+    }
+    if (status >= 500) {
+        throwAndEmit(params, `minimax VLM: server error (HTTP ${status}) — retry, and if it persists surface 'image understanding is unavailable' to the user`, status, traceId);
+    }
+    if (!response.ok) {
+        throwAndEmit(params, `minimax VLM: unexpected HTTP ${status} — retry, and if it persists surface 'image understanding is unavailable' to the user`, status, traceId);
+    }
+    let body;
+    try {
+        body = await response.json();
+    }
+    catch (error) {
+        const err = error;
+        throwAndEmit(params, `minimax VLM: malformed response (not JSON: ${err.message}) — this is a provider bug, retry or surface 'image understanding is unavailable' to the user`, status, traceId);
+    }
+    const parsed = body;
+    const providerStatus = parsed?.base_resp?.status_code ?? 0;
+    if (providerStatus !== 0) {
+        const providerMsg = parsed?.base_resp?.status_msg ?? "unknown";
+        throwAndEmit(params, `minimax VLM: provider returned status_code=${providerStatus} (${providerMsg}) — check the minimax account or retry, and if it persists surface 'image understanding is unavailable' to the user`, status, traceId);
+    }
+    const content = parsed?.content;
+    if (typeof content !== "string" || content.length === 0) {
+        throwAndEmit(params, `minimax VLM: returned no description (empty content field) — this is a provider bug, retry or surface 'image understanding is unavailable' to the user`, status, traceId);
+    }
+    const latencyMs = Date.now() - startTs;
+    emitEnd(params, content.length, latencyMs);
+    return content;
+}
+/* v8 ignore start — module-level observability event */
+(0, runtime_1.emitNervesEvent)({
+    component: "engine",
+    event: "engine.minimax_vlm_loaded",
+    message: "minimax vlm client loaded",
+    meta: {},
+});
+/* v8 ignore stop */

package/dist/heart/providers/minimax.js

@@ -3,34 +3,44 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.MINIMAX_PROVIDER_BASE_URL = void 0;
+exports.classifyMinimaxError = classifyMinimaxError;
 exports.createMinimaxProviderRuntime = createMinimaxProviderRuntime;
 const openai_1 = __importDefault(require("openai"));
 const config_1 = require("../config");
 const runtime_1 = require("../../nerves/runtime");
+const error_classification_1 = require("./error-classification");
+/**
+ * Canonical MiniMax chat-completions base URL. Exported so the BlueBubbles
+ * VLM fallback (which targets a sibling endpoint under the same host) can
+ * derive its URL from one source of truth instead of hard-coding.
+ */
+exports.MINIMAX_PROVIDER_BASE_URL = "https://api.minimaxi.chat/v1";
+function classifyMinimaxError(error) {
+    return (0, error_classification_1.classifyHttpError)(error);
+}
 const streaming_1 = require("../streaming");
 const model_capabilities_1 = require("../model-capabilities");
-function createMinimaxProviderRuntime() {
+function createMinimaxProviderRuntime(model, minimaxConfig = (0, config_1.getMinimaxConfig)()) {
     (0, runtime_1.emitNervesEvent)({
         component: "engine",
         event: "engine.provider_init",
         message: "minimax provider init",
         meta: { provider: "minimax" },
     });
-    const minimaxConfig = (0, config_1.getMinimaxConfig)();
     if (!minimaxConfig.apiKey) {
-        throw new Error("provider 'minimax' is selected in agent.json but providers.minimax.apiKey is missing in secrets.json.");
+        throw new Error("provider 'minimax' is selected but minimax.apiKey is missing in the agent vault. Run `ouro auth --agent <agent> --provider minimax`.");
     }
     // Registry consulted; MiniMax models return empty defaults (no capabilities to derive)
-    (0, model_capabilities_1.getModelCapabilities)(minimaxConfig.model);
+    (0, model_capabilities_1.getModelCapabilities)(model);
     const client = new openai_1.default({
         apiKey: minimaxConfig.apiKey,
-        baseURL: "https://api.minimaxi.chat/v1",
-        timeout: 30000,
+        baseURL: exports.MINIMAX_PROVIDER_BASE_URL,
         maxRetries: 0,
     });
     return {
         id: "minimax",
-        model: minimaxConfig.model,
+        model,
         client,
         capabilities: new Set(),
         resetTurnState(_messages) {
@@ -51,7 +61,15 @@ function createMinimaxProviderRuntime() {
                 params.metadata = { trace_id: request.traceId };
             if (request.toolChoiceRequired)
                 params.tool_choice = "required";
-            return (0, streaming_1.streamChatCompletion)(this.client, params, request.callbacks, request.signal);
+            return (0, streaming_1.streamChatCompletion)(this.client, params, request.callbacks, request.signal, request.eagerSettleStreaming);
+        },
+        /* v8 ignore start -- ping: tested via provider-ping.test.ts @preserve */
+        async ping(signal) {
+            await this.client.chat.completions.create({ model: this.model, max_tokens: 1, messages: [{ role: "user", content: "ping" }] }, { signal });
+        },
+        /* v8 ignore stop */
+        classifyError(error) {
+            return classifyMinimaxError(error);
         },
     };
 }

package/dist/heart/providers/openai-codex.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyOpenAICodexError = classifyOpenAICodexError;
 exports.createOpenAICodexProviderRuntime = createOpenAICodexProviderRuntime;
 const openai_1 = __importDefault(require("openai"));
 const config_1 = require("../config");
@@ -10,6 +11,7 @@ const identity_1 = require("../identity");
 const runtime_1 = require("../../nerves/runtime");
 const streaming_1 = require("../streaming");
 const model_capabilities_1 = require("../model-capabilities");
+const error_classification_1 = require("./error-classification");
 const OPENAI_CODEX_AUTH_FAILURE_MARKERS = [
     "authentication failed",
     "unauthorized",
@@ -18,9 +20,16 @@ const OPENAI_CODEX_AUTH_FAILURE_MARKERS = [
     "invalid bearer token",
 ];
 const OPENAI_CODEX_BACKEND_BASE_URL = "https://chatgpt.com/backend-api/codex";
-function getOpenAICodexSecretsPathForGuidance() {
-    return (0, identity_1.getAgentSecretsPath)();
-}
+const OPENAI_CODEX_PING_INPUT = [{ role: "user", content: "ping" }];
+const OPENAI_CODEX_PING_CALLBACKS = {
+    onModelStart() { },
+    onModelStreamStart() { },
+    onTextChunk() { },
+    onReasoningChunk() { },
+    onToolStart() { },
+    onToolEnd() { },
+    onError() { },
+};
 function getOpenAICodexAgentNameForGuidance() {
     return (0, identity_1.getAgentName)();
 }
@@ -28,11 +37,9 @@ function getOpenAICodexOAuthInstructions() {
     const agentName = getOpenAICodexAgentNameForGuidance();
     return [
         "Fix:",
-        `  1. Run \`npm run auth:openai-codex -- --agent ${agentName}\``,
-        "     (or run `codex login` and set the OAuth token manually)",
-        `  2. Open ${getOpenAICodexSecretsPathForGuidance()}`,
-        "  3. Confirm providers.openai-codex.oauthAccessToken is set",
-        "  4. This provider uses chatgpt.com/backend-api/codex/responses (not api.openai.com/responses).",
+        `  1. Run \`ouro auth --agent ${agentName} --provider openai-codex\``,
+        "  2. This provider uses chatgpt.com/backend-api/codex/responses (not api.openai.com/responses).",
+        "  3. After reauth, retry the failed ouro command or reconnect this session.",
     ].join("\n");
 }
 function getOpenAICodexReauthGuidance(reason) {
@@ -42,22 +49,19 @@ function getOpenAICodexReauthGuidance(reason) {
         getOpenAICodexOAuthInstructions(),
     ].join("\n");
 }
+function classifyOpenAICodexError(error) {
+    return (0, error_classification_1.classifyHttpError)(error, {
+        isAuthFailure: isOpenAICodexAuthFailure,
+        isUsageLimit: (e) => {
+            const lower = e.message.toLowerCase();
+            return lower.includes("usage") || lower.includes("quota") || lower.includes("exceeded your");
+        },
+    });
+}
 function isOpenAICodexAuthFailure(error) {
-    if (!(error instanceof Error))
-        return false;
-    const status = error.status;
-    if (status === 401 || status === 403)
-        return true;
     const lower = error.message.toLowerCase();
     return OPENAI_CODEX_AUTH_FAILURE_MARKERS.some((marker) => lower.includes(marker));
 }
-function withOpenAICodexAuthGuidance(error) {
-    const base = error instanceof Error ? error.message : String(error);
-    if (isOpenAICodexAuthFailure(error)) {
-        return new Error(getOpenAICodexReauthGuidance(`OpenAI Codex authentication failed (${base}).`));
-    }
-    return error instanceof Error ? error : new Error(String(error));
-}
 function decodeJwtPayload(token) {
     const parts = token.split(".");
     if (parts.length < 2)
@@ -88,16 +92,27 @@ function getChatGPTAccountIdFromToken(token) {
         return "";
     return accountId.trim();
 }
-function createOpenAICodexProviderRuntime() {
+function createOpenAICodexResponsesParams(input, instructions, model, reasoningEffort) {
+    return {
+        model,
+        input,
+        instructions,
+        tools: [],
+        reasoning: { effort: reasoningEffort, summary: "detailed" },
+        stream: true,
+        store: false,
+        include: ["reasoning.encrypted_content"],
+    };
+}
+function createOpenAICodexProviderRuntime(model, codexConfig = (0, config_1.getOpenAICodexConfig)()) {
     (0, runtime_1.emitNervesEvent)({
         component: "engine",
         event: "engine.provider_init",
         message: "openai-codex provider init",
         meta: { provider: "openai-codex" },
     });
-    const codexConfig = (0, config_1.getOpenAICodexConfig)();
-    if (!(codexConfig.model && codexConfig.oauthAccessToken)) {
-        throw new Error(getOpenAICodexReauthGuidance("provider 'openai-codex' is selected in agent.json but providers.openai-codex.model/oauthAccessToken is incomplete in secrets.json."));
+    if (!codexConfig.oauthAccessToken) {
+        throw new Error(getOpenAICodexReauthGuidance("provider 'openai-codex' is selected but openai-codex.oauthAccessToken is missing in the agent vault."));
     }
     const token = codexConfig.oauthAccessToken.trim();
     if (!token) {
@@ -107,7 +122,7 @@ function createOpenAICodexProviderRuntime() {
     if (!chatgptAccountId) {
         throw new Error(getOpenAICodexReauthGuidance("OpenAI Codex OAuth access token is missing a chatgpt_account_id claim required for chatgpt.com/backend-api/codex."));
     }
-    const modelCaps = (0, model_capabilities_1.getModelCapabilities)(codexConfig.model);
+    const modelCaps = (0, model_capabilities_1.getModelCapabilities)(model);
     const capabilities = new Set();
     if (modelCaps.reasoningEffort)
         capabilities.add("reasoning-effort");
@@ -121,14 +136,13 @@ function createOpenAICodexProviderRuntime() {
             "OpenAI-Beta": "responses=experimental",
             originator: "ouroboros",
         },
-        timeout: 30000,
         maxRetries: 0,
     });
     let nativeInput = null;
     let nativeInstructions = "";
     return {
         id: "openai-codex",
-        model: codexConfig.model,
+        model,
         client,
         capabilities,
         supportedReasoningEfforts: modelCaps.reasoningEffort,
@@ -140,32 +154,33 @@ function createOpenAICodexProviderRuntime() {
         appendToolOutput(callId, output) {
             if (!nativeInput)
                 return;
-            nativeInput.push({ type: "function_call_output", call_id: callId, output });
+            nativeInput.push({ type: "function_call_output", call_id: callId, output: (0, streaming_1.truncateResponsesFunctionCallOutput)(output) });
         },
         async streamTurn(request) {
             if (!nativeInput)
                 this.resetTurnState(request.messages);
-            const params = {
-                model: this.model,
-                input: nativeInput,
-                instructions: nativeInstructions,
-                tools: (0, streaming_1.toResponsesTools)(request.activeTools),
-                reasoning: { effort: request.reasoningEffort ?? "medium", summary: "detailed" },
-                stream: true,
-                store: false,
-                include: ["reasoning.encrypted_content"],
-            };
+            const params = createOpenAICodexResponsesParams(nativeInput, nativeInstructions, this.model, request.reasoningEffort ?? "medium");
+            params.tools = (0, streaming_1.toResponsesTools)(request.activeTools);
             if (request.toolChoiceRequired)
                 params.tool_choice = "required";
             try {
-                const result = await (0, streaming_1.streamResponsesApi)(this.client, params, request.callbacks, request.signal);
+                const result = await (0, streaming_1.streamResponsesApi)(this.client, params, request.callbacks, request.signal, request.eagerSettleStreaming);
                 for (const item of result.outputItems)
                     nativeInput.push(item);
                 return result;
             }
             catch (error) {
-                throw withOpenAICodexAuthGuidance(error);
+                throw error instanceof Error ? error : new Error(String(error));
             }
         },
+        /* v8 ignore start -- ping: tested via provider-ping.test.ts @preserve */
+        async ping(signal) {
+            await (0, streaming_1.streamResponsesApi)(this.client, createOpenAICodexResponsesParams(OPENAI_CODEX_PING_INPUT, "", this.model, "medium"), OPENAI_CODEX_PING_CALLBACKS, signal);
+        },
+        /* v8 ignore stop */
+        /* v8 ignore next 3 -- delegation: classification logic tested via classifyOpenAICodexError @preserve */
+        classifyError(error) {
+            return classifyOpenAICodexError(error);
+        },
     };
 }