@ouro.bot/cli 0.1.0-alpha.32 → 0.1.0-alpha.321

package/dist/heart/providers/error-classification.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNetworkError = isNetworkError;
+exports.classifyHttpError = classifyHttpError;
+const runtime_1 = require("../../nerves/runtime");
+// Node socket / DNS error codes that indicate a transient network failure.
+const NETWORK_ERROR_CODES = new Set([
+    "ECONNRESET",
+    "ECONNREFUSED",
+    "ENOTFOUND",
+    "ETIMEDOUT",
+    "EPIPE",
+    "EAI_AGAIN",
+    "EHOSTUNREACH",
+    "ENETUNREACH",
+    "ECONNABORTED",
+]);
+// Substrings the OpenAI/Anthropic SDKs use when wrapping fetch/socket failures
+// into Error.message instead of an err.code.
+const NETWORK_ERROR_MESSAGE_PATTERNS = [
+    "fetch failed",
+    "socket hang up",
+    "getaddrinfo",
+    "request timed out", // OpenAI SDK timeout — see SDK source
+    "request timeout",
+    "connection error",
+];
+// True if the error looks like a transient network issue (no HTTP status, just
+// a socket/DNS/timeout failure from the underlying transport).
+function isNetworkError(error) {
+    const code = error.code || "";
+    if (NETWORK_ERROR_CODES.has(code))
+        return true;
+    const msg = (error.message || "").toLowerCase();
+    return NETWORK_ERROR_MESSAGE_PATTERNS.some((pat) => msg.includes(pat));
+}
+// Standard HTTP error → ProviderErrorClassification mapping. Providers wrap
+// this with their own overrides.
+function classifyHttpError(error, overrides) {
+    const status = error.status;
+    if (overrides?.isAuthFailure?.(error) || status === 401 || status === 403) {
+        return "auth-failure";
+    }
+    if (status === 429) {
+        if (overrides?.isUsageLimit?.(error))
+            return "usage-limit";
+        return "rate-limit";
+    }
+    if (overrides?.isServerError?.(error) || (status !== undefined && status >= 500)) {
+        return "server-error";
+    }
+    if (isNetworkError(error))
+        return "network-error";
+    return "unknown";
+}
+/* v8 ignore start — module-level observability event */
+(0, runtime_1.emitNervesEvent)({
+    component: "engine",
+    event: "engine.error_classification_loaded",
+    message: "shared provider error classification loaded",
+    meta: {},
+});
+/* v8 ignore stop */

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

@@ -0,0 +1,136 @@
+"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) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.provider_init",
+        message: "github-copilot provider init",
+        meta: { provider: "github-copilot" },
+    });
+    const config = (0, config_1.getGithubCopilotConfig)();
+    if (!config.githubToken) {
+        throw new Error("provider 'github-copilot' is selected in agent.json but providers.github-copilot.githubToken is missing in secrets.json.");
+    }
+    if (!config.baseUrl) {
+        throw new Error("provider 'github-copilot' is selected in agent.json but providers.github-copilot.baseUrl is missing in secrets.json.");
+    }
+    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 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 });
+        },
+        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 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 — re-run credential setup or add a minimax key to secrets.json");
+        throw new Error("minimax VLM: API key is empty — re-run credential setup or add a minimax key to secrets.json");
+    }
+    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,12 +3,25 @@ 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");
-function createMinimaxProviderRuntime() {
+const model_capabilities_1 = require("../model-capabilities");
+function createMinimaxProviderRuntime(model) {
     (0, runtime_1.emitNervesEvent)({
         component: "engine",
         event: "engine.provider_init",
@@ -19,16 +32,18 @@ function createMinimaxProviderRuntime() {
     if (!minimaxConfig.apiKey) {
         throw new Error("provider 'minimax' is selected in agent.json but providers.minimax.apiKey is missing in secrets.json.");
     }
+    // Registry consulted; MiniMax models return empty defaults (no capabilities to derive)
+    (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) {
             // No provider-owned turn state for chat-completions providers.
         },
@@ -47,7 +62,10 @@ 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);
+        },
+        classifyError(error) {
+            return classifyMinimaxError(error);
         },
     };
 }

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

@@ -3,12 +3,15 @@ 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");
 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",
@@ -27,11 +30,11 @@ 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)",
+        `  1. Run \`ouro auth --agent ${agentName}\``,
         `  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).",
+        "  5. After reauth, retry the failed ouro command or reconnect this session.",
     ].join("\n");
 }
 function getOpenAICodexReauthGuidance(reason) {
@@ -41,22 +44,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)
@@ -87,7 +87,7 @@ function getChatGPTAccountIdFromToken(token) {
         return "";
     return accountId.trim();
 }
-function createOpenAICodexProviderRuntime() {
+function createOpenAICodexProviderRuntime(model) {
     (0, runtime_1.emitNervesEvent)({
         component: "engine",
         event: "engine.provider_init",
@@ -95,8 +95,8 @@ function createOpenAICodexProviderRuntime() {
         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 in agent.json but providers.openai-codex.oauthAccessToken is missing in secrets.json."));
     }
     const token = codexConfig.oauthAccessToken.trim();
     if (!token) {
@@ -106,6 +106,12 @@ 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)(model);
+    const capabilities = new Set();
+    if (modelCaps.reasoningEffort)
+        capabilities.add("reasoning-effort");
+    if (modelCaps.phase)
+        capabilities.add("phase-annotation");
     const client = new openai_1.default({
         apiKey: token,
         baseURL: OPENAI_CODEX_BACKEND_BASE_URL,
@@ -114,15 +120,16 @@ 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,
         resetTurnState(messages) {
             const { instructions, input } = (0, streaming_1.toResponsesInput)(messages);
             nativeInput = input;
@@ -141,7 +148,7 @@ function createOpenAICodexProviderRuntime() {
                 input: nativeInput,
                 instructions: nativeInstructions,
                 tools: (0, streaming_1.toResponsesTools)(request.activeTools),
-                reasoning: { effort: "medium", summary: "detailed" },
+                reasoning: { effort: request.reasoningEffort ?? "medium", summary: "detailed" },
                 stream: true,
                 store: false,
                 include: ["reasoning.encrypted_content"],
@@ -149,14 +156,18 @@ function createOpenAICodexProviderRuntime() {
             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 next 3 -- delegation: classification logic tested via classifyOpenAICodexError @preserve */
+        classifyError(error) {
+            return classifyOpenAICodexError(error);
+        },
     };
 }