@ouro.bot/cli 0.1.0-alpha.83 → 0.1.0-alpha.831

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

@@ -3,53 +3,32 @@ 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 identity_1 = require("../identity");
 const runtime_1 = require("../../nerves/runtime");
 const streaming_1 = require("../streaming");
 const model_capabilities_1 = require("../model-capabilities");
-/* v8 ignore start -- auth guidance helpers: tested via mock-driven provider tests @preserve */
-function isAuthFailure(error) {
-    if (!(error instanceof Error))
-        return false;
-    const status = error.status;
-    return status === 401 || status === 403;
+const error_classification_1 = require("./error-classification");
+function classifyGithubCopilotError(error) {
+    return (0, error_classification_1.classifyHttpError)(error);
 }
-function getReauthGuidance(reason) {
-    const agentName = (0, identity_1.getAgentName)();
-    return [
-        `provider github-copilot failed (${reason}).`,
-        `Run \`ouro auth verify --agent ${agentName}\` to check all configured providers,`,
-        `\`ouro auth switch --agent ${agentName} --provider <other>\` to switch,`,
-        `or \`ouro auth --agent ${agentName} --provider github-copilot\` to reconfigure.`,
-    ].join(" ");
-}
-function withAuthGuidance(error) {
-    const base = error instanceof Error ? error.message : String(error);
-    if (isAuthFailure(error)) {
-        return new Error(getReauthGuidance(base));
-    }
-    return error instanceof Error ? error : new Error(String(error));
-}
-/* v8 ignore stop */
-function createGithubCopilotProviderRuntime() {
+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" },
     });
-    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.");
+        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 in agent.json but providers.github-copilot.baseUrl is missing in secrets.json.");
+        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 = config.model.startsWith("claude");
-    const modelCaps = (0, model_capabilities_1.getModelCapabilities)(config.model);
+    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)
@@ -57,14 +36,13 @@ function createGithubCopilotProviderRuntime() {
     const client = new openai_1.default({
         apiKey: config.githubToken,
         baseURL: config.baseUrl,
-        timeout: 30000,
         maxRetries: 0,
     });
     if (isCompletionsModel) {
         // Chat completions path (Claude models via Copilot)
         return {
             id: "github-copilot",
-            model: config.model,
+            model,
             client,
             capabilities,
             supportedReasoningEfforts: modelCaps.reasoningEffort,
@@ -88,13 +66,22 @@ function createGithubCopilotProviderRuntime() {
                 if (request.toolChoiceRequired)
                     params.tool_choice = "required";
                 try {
-                    return await (0, streaming_1.streamChatCompletion)(this.client, params, request.callbacks, request.signal);
+                    return await (0, streaming_1.streamChatCompletion)(this.client, params, request.callbacks, request.signal, request.eagerSettleStreaming);
                 }
                 catch (error) {
-                    throw withAuthGuidance(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)
@@ -102,7 +89,7 @@ function createGithubCopilotProviderRuntime() {
     let nativeInstructions = "";
     return {
         id: "github-copilot",
-        model: config.model,
+        model,
         client,
         capabilities,
         supportedReasoningEfforts: modelCaps.reasoningEffort,
@@ -115,7 +102,7 @@ function createGithubCopilotProviderRuntime() {
         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)
@@ -135,15 +122,24 @@ function createGithubCopilotProviderRuntime() {
             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 withAuthGuidance(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);
         },
     };
 }