@ouro.bot/cli 0.1.0-alpha.33 → 0.1.0-alpha.330

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);
+        },
     };
 }

package/dist/heart/session-activity.js

@@ -0,0 +1,190 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listSessionActivity = listSessionActivity;
+exports.findFreshestFriendSession = findFreshestFriendSession;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../nerves/runtime");
+const config_1 = require("./config");
+const session_events_1 = require("./session-events");
+const DEFAULT_ACTIVE_THRESHOLD_MS = 24 * 60 * 60 * 1000;
+function activityPriority(source) {
+    return source === "friend-facing" ? 0 : 1;
+}
+function resolveFriendName(friendId, friendsDir, agentName) {
+    if (friendId === "self")
+        return agentName;
+    try {
+        const raw = fs.readFileSync(path.join(friendsDir, `${friendId}.json`), "utf-8");
+        const parsed = JSON.parse(raw);
+        return parsed.name ?? friendId;
+    }
+    catch {
+        return friendId;
+    }
+}
+function parseFriendActivity(sessionPath) {
+    let mtimeMs;
+    try {
+        mtimeMs = fs.statSync(sessionPath).mtimeMs;
+    }
+    catch {
+        return null;
+    }
+    const envelope = (0, session_events_1.loadSessionEnvelopeFile)(sessionPath);
+    const chronology = envelope ? (0, session_events_1.deriveSessionChronology)(envelope.events) : null;
+    const explicit = envelope?.state.lastFriendActivityAt;
+    if (typeof explicit === "string") {
+        const parsedMs = Date.parse(explicit);
+        if (Number.isFinite(parsedMs)) {
+            return {
+                lastActivityMs: parsedMs,
+                lastActivityAt: new Date(parsedMs).toISOString(),
+                activitySource: "friend-facing",
+                lastInboundAt: chronology?.lastInboundAt ?? null,
+                lastOutboundAt: chronology?.lastOutboundAt ?? null,
+                unansweredInboundCount: chronology?.unansweredInboundCount ?? 0,
+            };
+        }
+    }
+    if (chronology?.lastInboundAt) {
+        const parsedMs = Date.parse(chronology.lastInboundAt);
+        if (Number.isFinite(parsedMs)) {
+            return {
+                lastActivityMs: parsedMs,
+                lastActivityAt: new Date(parsedMs).toISOString(),
+                activitySource: "friend-facing",
+                lastInboundAt: chronology.lastInboundAt,
+                lastOutboundAt: chronology.lastOutboundAt,
+                unansweredInboundCount: chronology.unansweredInboundCount,
+            };
+        }
+    }
+    return {
+        lastActivityMs: mtimeMs,
+        lastActivityAt: new Date(mtimeMs).toISOString(),
+        activitySource: "mtime-fallback",
+        lastInboundAt: chronology?.lastInboundAt ?? null,
+        lastOutboundAt: chronology?.lastOutboundAt ?? null,
+        unansweredInboundCount: chronology?.unansweredInboundCount ?? 0,
+    };
+}
+function listSessionActivity(query) {
+    const { sessionsDir, friendsDir, agentName, activeThresholdMs = DEFAULT_ACTIVE_THRESHOLD_MS, nowMs = Date.now(), currentSession = null, } = query;
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.session_activity_scan",
+        message: "scanning session activity",
+        meta: {
+            sessionsDir,
+            currentSession: currentSession ? `${currentSession.friendId}/${currentSession.channel}/${currentSession.key}` : null,
+        },
+    });
+    if (!fs.existsSync(sessionsDir))
+        return [];
+    const results = [];
+    let friendDirs;
+    try {
+        friendDirs = fs.readdirSync(sessionsDir);
+    }
+    catch {
+        return [];
+    }
+    for (const friendId of friendDirs) {
+        const friendPath = path.join(sessionsDir, friendId);
+        let channels;
+        try {
+            channels = fs.readdirSync(friendPath);
+        }
+        catch {
+            continue;
+        }
+        for (const channel of channels) {
+            const channelPath = path.join(friendPath, channel);
+            let keys;
+            try {
+                keys = fs.readdirSync(channelPath);
+            }
+            catch {
+                continue;
+            }
+            for (const keyFile of keys) {
+                if (!keyFile.endsWith(".json"))
+                    continue;
+                const key = keyFile.replace(/\.json$/, "");
+                // Compare with sanitizeKey on both sides — session keys from the filesystem
+                // are already sanitized (colons → underscores), but the canonical key from
+                // the pipeline may still have colons (e.g. "chat:any" vs "chat_any").
+                if (currentSession && friendId === currentSession.friendId && channel === currentSession.channel && (0, config_1.sanitizeKey)(key) === (0, config_1.sanitizeKey)(currentSession.key)) {
+                    continue;
+                }
+                const sessionPath = path.join(channelPath, keyFile);
+                const activity = parseFriendActivity(sessionPath);
+                if (!activity)
+                    continue;
+                if (nowMs - activity.lastActivityMs > activeThresholdMs)
+                    continue;
+                results.push({
+                    friendId,
+                    friendName: resolveFriendName(friendId, friendsDir, agentName),
+                    channel,
+                    key,
+                    sessionPath,
+                    lastActivityAt: activity.lastActivityAt,
+                    lastActivityMs: activity.lastActivityMs,
+                    activitySource: activity.activitySource,
+                    lastInboundAt: activity.lastInboundAt,
+                    lastOutboundAt: activity.lastOutboundAt,
+                    unansweredInboundCount: activity.unansweredInboundCount,
+                });
+            }
+        }
+    }
+    return results.sort((a, b) => {
+        const sourceDiff = activityPriority(a.activitySource) - activityPriority(b.activitySource);
+        if (sourceDiff !== 0)
+            return sourceDiff;
+        return b.lastActivityMs - a.lastActivityMs;
+    });
+}
+function findFreshestFriendSession(query) {
+    const { activeOnly = false, activeThresholdMs = DEFAULT_ACTIVE_THRESHOLD_MS, nowMs, ...rest } = query;
+    const currentSession = rest.currentSession ?? null;
+    const all = activeOnly
+        ? listSessionActivity({ ...rest, activeThresholdMs, nowMs, currentSession })
+        : listSessionActivity({ ...rest, activeThresholdMs: Number.MAX_SAFE_INTEGER, nowMs, currentSession });
+    return all.find((entry) => entry.friendId === query.friendId) ?? null;
+}