@ouro.bot/cli 0.1.0-alpha.327 → 0.1.0-alpha.328

package/changelog.json

@@ -1,6 +1,13 @@
 {
   "_note": "This changelog is maintained as part of the PR/version-bump workflow. Agent-curated, not auto-generated. Agents read this file directly via read_file to understand what changed between versions.",
   "versions": [
+    {
+      "version": "0.1.0-alpha.328",
+      "changes": [
+        "fix(auth): keep provider switches model-aware so changing providers updates incompatible model pairings to safe provider defaults instead of carrying stale model names across OpenAI Codex, Anthropic, MiniMax, Azure, and GitHub Copilot.",
+        "fix(auth): rewrite provider auth/failover guidance into multiline actionable sections with provider error details, model-mismatch repair commands, and ready-provider switch prompts."
+      ]
+    },
     {
       "version": "0.1.0-alpha.327",
       "changes": [

package/dist/heart/auth/auth-flow.js

@@ -48,33 +48,29 @@ const path = __importStar(require("path"));
 const runtime_1 = require("../../nerves/runtime");
 const identity_1 = require("../identity");
 const migrate_config_1 = require("../migrate-config");
+const provider_models_1 = require("../provider-models");
 const ANTHROPIC_SETUP_TOKEN_PREFIX = "sk-ant-oat01-";
 const ANTHROPIC_SETUP_TOKEN_MIN_LENGTH = 80;
 const DEFAULT_SECRETS_TEMPLATE = {
     providers: {
         azure: {
-            modelName: "gpt-4o-mini",
             apiKey: "",
             endpoint: "",
             deployment: "",
             apiVersion: "2025-04-01-preview",
         },
         minimax: {
-            model: "MiniMax-M2.7",
             apiKey: "",
         },
         anthropic: {
-            model: "claude-opus-4-6",
             setupToken: "",
             refreshToken: "",
             expiresAt: 0,
         },
         "openai-codex": {
-            model: "gpt-5.4",
             oauthAccessToken: "",
         },
         "github-copilot": {
-            model: "claude-sonnet-4.6",
             githubToken: "",
             baseUrl: "",
         },
@@ -176,16 +172,27 @@ function readAgentConfigForAgent(agentName, bundlesRoot = (0, identity_1.getAgen
 function writeAgentProviderSelection(agentName, facing, provider, bundlesRoot = (0, identity_1.getAgentBundlesRoot)()) {
     const { configPath, config } = readAgentConfigForAgent(agentName, bundlesRoot);
     const facingKey = facing === "human" ? "humanFacing" : "agentFacing";
+    const previousFacing = config[facingKey];
+    const resolved = (0, provider_models_1.resolveModelForProviderSelection)(provider, previousFacing.model);
     const nextConfig = {
         ...config,
-        [facingKey]: { ...config[facingKey], provider },
+        [facingKey]: { ...previousFacing, provider, model: resolved.model },
     };
     fs.writeFileSync(configPath, `${JSON.stringify(nextConfig, null, 2)}\n`, "utf8");
     (0, runtime_1.emitNervesEvent)({
         component: "daemon",
         event: "daemon.auth_provider_selected",
         message: "updated agent provider selection after auth flow",
-        meta: { agentName, facing, provider, configPath },
+        meta: {
+            agentName,
+            facing,
+            provider,
+            previousProvider: previousFacing.provider,
+            previousModel: previousFacing.model,
+            model: resolved.model,
+            preservedModel: resolved.preserved,
+            configPath,
+        },
     });
     return configPath;
 }

package/dist/heart/core.js

@@ -32,6 +32,7 @@ const obligations_1 = require("../arc/obligations");
 const tool_loop_1 = require("./tool-loop");
 const packets_1 = require("../arc/packets");
 const tool_friction_1 = require("./tool-friction");
+const provider_models_1 = require("./provider-models");
 const _providerRuntimes = {
     human: null,
     agent: null,
@@ -405,6 +406,33 @@ const RETRY_LABELS = {
     "network-error": "network error",
     "unknown": "error",
 };
+function buildAuthFailureGuidance(provider, model, agentName, detail) {
+    const mismatch = (0, provider_models_1.getProviderModelMismatchMessage)(provider, model);
+    const modelLabel = model
+        ? mismatch
+            ? `${provider} [configured model: ${model}]`
+            : `${provider} (${model})`
+        : provider;
+    const lines = [`${modelLabel} authentication failed.`];
+    const cleanDetail = detail.replace(/\s+/g, " ").trim();
+    if (cleanDetail)
+        lines.push(`provider detail: ${cleanDetail.length > 300 ? `${cleanDetail.slice(0, 297)}...` : cleanDetail}`);
+    lines.push("");
+    lines.push("To keep using this provider:");
+    lines.push(`  1. Run \`ouro auth --agent ${agentName} --provider ${provider}\``);
+    if (mismatch) {
+        const defaultModel = (0, provider_models_1.getDefaultModelForProvider)(provider);
+        lines.push("");
+        lines.push("Config warning:");
+        lines.push(`  - ${mismatch}`);
+        lines.push("  - Repair the configured model with:");
+        lines.push(`    \`ouro config model --agent ${agentName} --facing human ${defaultModel}\``);
+        lines.push(`    \`ouro config model --agent ${agentName} --facing agent ${defaultModel}\``);
+    }
+    lines.push("");
+    lines.push(`To use another configured provider instead, run \`ouro auth switch --agent ${agentName} --provider <provider>\`.`);
+    return lines.join("\n");
+}
 async function runAgent(messages, callbacks, channel, signal, options) {
     const facing = (0, channel_1.channelToFacing)(channel);
     const providerRuntime = getProviderRuntime(facing);
@@ -1025,9 +1053,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
             if (terminalErrorClassification === "auth-failure") {
                 const agentName = (0, identity_2.getAgentName)();
                 const currentProvider = providerRuntime.id;
-                callbacks.onError(new Error(`${currentProvider} (${providerRuntime.model}) encountered an error. ` +
-                    `Run \`ouro auth --agent ${agentName} --provider ${currentProvider}\` to refresh credentials, ` +
-                    `or \`ouro auth switch --agent ${agentName} --provider <other>\` to switch providers.`), "terminal");
+                callbacks.onError(new Error(buildAuthFailureGuidance(currentProvider, providerRuntime.model, agentName, terminalError.message)), "terminal");
             }
             else {
                 callbacks.onError(terminalError, "terminal");

package/dist/heart/daemon/cli-defaults.js

@@ -70,6 +70,7 @@ const launchd_1 = require("./launchd");
 const socket_client_1 = require("./socket-client");
 const session_activity_1 = require("../session-activity");
 const auth_flow_1 = require("../auth/auth-flow");
+const provider_models_1 = require("../provider-models");
 const cli_parse_1 = require("./cli-parse");
 const provider_discovery_1 = require("./provider-discovery");
 // ── Default implementations ──
@@ -305,13 +306,7 @@ async function defaultRunSerpentGuide() {
         const existingBundleCount = (0, specialist_orchestrator_1.listExistingBundles)((0, identity_1.getAgentBundlesRoot)()).length;
         const hatchVerb = existingBundleCount > 0 ? "let's hatch a new agent." : "let's hatch your first agent.";
         // Default models per provider (used when entering new credentials)
-        const defaultModels = {
-            anthropic: "claude-opus-4-6",
-            minimax: "MiniMax-M2.7",
-            "openai-codex": "gpt-5.4",
-            "github-copilot": "claude-sonnet-4.6",
-            azure: "",
-        };
+        const defaultModels = provider_models_1.DEFAULT_PROVIDER_MODELS;
         // Scan environment variables for API keys using the shared helper
         const envCreds = (0, provider_discovery_1.scanEnvVarCredentials)(process.env);
         const envDiscovered = [];

package/dist/heart/daemon/cli-exec.js

@@ -1776,7 +1776,16 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
             (0, auth_flow_1.writeAgentProviderSelection)(command.agent, "human", command.provider, deps.bundlesRoot);
             (0, auth_flow_1.writeAgentProviderSelection)(command.agent, "agent", command.provider, deps.bundlesRoot);
         }
-        const message = `switched ${command.agent} to ${command.provider} (verified working)`;
+        const { config: updatedConfig } = (0, auth_flow_1.readAgentConfigForAgent)(command.agent, deps.bundlesRoot);
+        const facingSummary = command.facing
+            ? (() => {
+                const facingConfig = command.facing === "human" ? updatedConfig.humanFacing : updatedConfig.agentFacing;
+                return `${command.facing} model: ${facingConfig.model}`;
+            })()
+            : updatedConfig.humanFacing.model === updatedConfig.agentFacing.model
+                ? `model: ${updatedConfig.humanFacing.model}`
+                : `human model: ${updatedConfig.humanFacing.model}; agent model: ${updatedConfig.agentFacing.model}`;
+        const message = `switched ${command.agent} to ${command.provider} (${facingSummary}; verified working)`;
         deps.writeStdout(message);
         return message;
     }

package/dist/heart/hatch/hatch-flow.js

@@ -42,6 +42,7 @@ const identity_1 = require("../identity");
 const config_1 = require("../config");
 const runtime_1 = require("../../nerves/runtime");
 const auth_flow_1 = require("../auth/auth-flow");
+const provider_models_1 = require("../provider-models");
 const habit_parser_1 = require("../habits/habit-parser");
 const hatch_specialist_1 = require("./hatch-specialist");
 function requiredCredentialKeys(provider) {
@@ -124,9 +125,10 @@ function writeDiaryScaffold(bundleRoot) {
 }
 function writeHatchlingAgentConfig(bundleRoot, input) {
     const template = (0, identity_1.buildDefaultAgentTemplate)(input.agentName);
+    const model = (0, provider_models_1.getDefaultModelForProvider)(input.provider);
     template.provider = input.provider;
-    template.humanFacing = { provider: input.provider, model: template.humanFacing.model };
-    template.agentFacing = { provider: input.provider, model: template.agentFacing.model };
+    template.humanFacing = { provider: input.provider, model };
+    template.agentFacing = { provider: input.provider, model };
     template.enabled = true;
     fs.writeFileSync(path.join(bundleRoot, "agent.json"), `${JSON.stringify(template, null, 2)}\n`, "utf-8");
 }

package/dist/heart/provider-failover.js

@@ -2,15 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildFailoverContext = buildFailoverContext;
 exports.handleFailoverReply = handleFailoverReply;
+const provider_models_1 = require("./provider-models");
 const runtime_1 = require("../nerves/runtime");
-const FAILING_PROVIDER_LABELS = {
-    "auth-failure": "its credentials need to be refreshed",
-    "usage-limit": "has also hit its usage limit",
-    "rate-limit": "is also being rate limited",
-    "server-error": "is also experiencing an outage",
-    "network-error": "could not be reached",
-    "unknown": "could not be reached",
-};
 const CLASSIFICATION_LABELS = {
     "auth-failure": "authentication failed",
     "usage-limit": "hit its usage limit",
@@ -19,10 +12,43 @@ const CLASSIFICATION_LABELS = {
     "network-error": "is unreachable (network error)",
     "unknown": "encountered an error",
 };
-function buildFailoverContext(_errorMessage, classification, currentProvider, currentModel, agentName, inventory, providerModels) {
+function formatProviderWithModel(provider, model) {
+    if (!model)
+        return provider;
+    if ((0, provider_models_1.getProviderModelMismatchMessage)(provider, model)) {
+        return `${provider} [configured model: ${model}]`;
+    }
+    return `${provider} (${model})`;
+}
+function formatErrorDetail(errorMessage, errorSummary) {
+    const detail = errorMessage.replace(/\s+/g, " ").trim();
+    if (!detail || detail === errorSummary)
+        return "";
+    return detail.length > 300 ? `${detail.slice(0, 297)}...` : detail;
+}
+function formatFailingProviderLine(provider, classification, agentName) {
+    const authCommand = `ouro auth --agent ${agentName} --provider ${provider}`;
+    switch (classification) {
+        case "auth-failure":
+            return `  - ${provider}: credentials need to be refreshed. Run \`${authCommand}\`.`;
+        case "network-error":
+            return `  - ${provider}: could not be reached. Check network/provider availability; if credentials may be stale, run \`${authCommand}\`.`;
+        case "server-error":
+            return `  - ${provider}: provider outage or server error. Retry later; if it keeps failing, run \`${authCommand}\`.`;
+        case "rate-limit":
+            return `  - ${provider}: rate limited. Wait and retry, or switch to a ready provider below.`;
+        case "usage-limit":
+            return `  - ${provider}: usage limit hit. Wait for quota reset, raise quota, or switch to a ready provider below.`;
+        case "unknown":
+            return `  - ${provider}: could not be reached. Run \`${authCommand}\` if credentials may be stale.`;
+    }
+}
+function buildFailoverContext(errorMessage, classification, currentProvider, currentModel, agentName, inventory, providerModels) {
     const label = CLASSIFICATION_LABELS[classification];
-    const providerWithModel = currentModel ? `${currentProvider} (${currentModel})` : currentProvider;
+    const providerWithModel = formatProviderWithModel(currentProvider, currentModel);
     const errorSummary = `${providerWithModel} ${label}`;
+    const errorDetail = formatErrorDetail(errorMessage, errorSummary);
+    const modelMismatch = (0, provider_models_1.getProviderModelMismatchMessage)(currentProvider, currentModel);
     const workingProviders = [];
     const unconfiguredProviders = [];
     const failingProviders = [];
@@ -39,27 +65,48 @@ function buildFailoverContext(_errorMessage, classification, currentProvider, cu
         }
     }
     const lines = [`${errorSummary}.`];
+    if (errorDetail) {
+        lines.push(`provider detail: ${errorDetail}`);
+    }
+    if (classification === "auth-failure") {
+        lines.push("");
+        lines.push("To keep using the current provider:");
+        lines.push(`  1. Run \`ouro auth --agent ${agentName} --provider ${currentProvider}\``);
+    }
+    if (modelMismatch) {
+        const defaultModel = (0, provider_models_1.getDefaultModelForProvider)(currentProvider);
+        lines.push("");
+        lines.push("Config warning:");
+        lines.push(`  - ${modelMismatch}`);
+        lines.push("  - Repair the configured model with:");
+        lines.push(`    \`ouro config model --agent ${agentName} --facing human ${defaultModel}\``);
+        lines.push(`    \`ouro config model --agent ${agentName} --facing agent ${defaultModel}\``);
+    }
     if (workingProviders.length > 0) {
-        const switchDescriptions = workingProviders.map((p) => {
-            const model = providerModels[p];
-            return model ? `${p} (${model})` : /* v8 ignore next -- defensive: model always present in secrets @preserve */ p;
-        });
-        const switchOptions = workingProviders.map((p) => `"switch to ${p}"`).join(" or ");
-        lines.push(`these providers are ready to go: ${switchDescriptions.join(", ")}.`);
-        lines.push(`reply ${switchOptions} to continue.`);
+        lines.push("");
+        lines.push("Ready providers:");
+        for (const provider of workingProviders) {
+            const model = (0, provider_models_1.resolveModelForProviderDisplay)(provider, providerModels[provider]);
+            lines.push(`  - ${provider} (${model}): reply "switch to ${provider}"`);
+        }
     }
     if (failingProviders.length > 0) {
+        lines.push("");
+        lines.push("Configured but unavailable:");
         for (const { provider, classification } of failingProviders) {
-            /* v8 ignore next -- defensive: all classifications have labels @preserve */
-            const detail = FAILING_PROVIDER_LABELS[classification] ?? "could not be reached";
-            lines.push(`${provider} is configured but ${detail}. run \`ouro auth --agent ${agentName} --provider ${provider}\` to refresh.`);
+            lines.push(formatFailingProviderLine(provider, classification, agentName));
         }
     }
     if (unconfiguredProviders.length > 0) {
-        lines.push(`to set up ${unconfiguredProviders.join(", ")}, run \`ouro auth --agent ${agentName}\` in terminal.`);
+        lines.push("");
+        lines.push("Not configured:");
+        for (const provider of unconfiguredProviders) {
+            lines.push(`  - ${provider}: run \`ouro auth --agent ${agentName} --provider ${provider}\``);
+        }
     }
     if (workingProviders.length === 0 && unconfiguredProviders.length === 0 && failingProviders.length === 0) {
-        lines.push(`no other providers are available. run \`ouro auth --agent ${agentName}\` in terminal to configure one.`);
+        lines.push("");
+        lines.push(`No other providers are available. Run \`ouro auth --agent ${agentName}\` in terminal to configure one.`);
     }
     (0, runtime_1.emitNervesEvent)({
         component: "engine",
@@ -74,7 +121,7 @@ function buildFailoverContext(_errorMessage, classification, currentProvider, cu
         agentName,
         workingProviders,
         unconfiguredProviders,
-        userMessage: lines.join(" "),
+        userMessage: lines.join("\n"),
     };
 }
 function handleFailoverReply(reply, context) {

package/dist/heart/provider-models.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PROVIDER_MODELS = void 0;
+exports.getProviderDisplayName = getProviderDisplayName;
+exports.getDefaultModelForProvider = getDefaultModelForProvider;
+exports.isModelClearlyIncompatibleWithProvider = isModelClearlyIncompatibleWithProvider;
+exports.resolveModelForProviderSelection = resolveModelForProviderSelection;
+exports.resolveModelForProviderDisplay = resolveModelForProviderDisplay;
+exports.getProviderModelMismatchMessage = getProviderModelMismatchMessage;
+const runtime_1 = require("../nerves/runtime");
+exports.DEFAULT_PROVIDER_MODELS = {
+    anthropic: "claude-opus-4-6",
+    azure: "gpt-4o-mini",
+    minimax: "MiniMax-M2.7",
+    "openai-codex": "gpt-5.4",
+    "github-copilot": "claude-sonnet-4.6",
+};
+const PROVIDER_NAMES = {
+    anthropic: "Anthropic",
+    azure: "Azure OpenAI",
+    minimax: "MiniMax",
+    "openai-codex": "OpenAI Codex",
+    "github-copilot": "GitHub Copilot",
+};
+function normalized(model) {
+    return model.trim().toLowerCase();
+}
+function getProviderDisplayName(provider) {
+    return PROVIDER_NAMES[provider];
+}
+function getDefaultModelForProvider(provider) {
+    return exports.DEFAULT_PROVIDER_MODELS[provider];
+}
+function isModelClearlyIncompatibleWithProvider(provider, model) {
+    const value = normalized(model);
+    if (!value)
+        return true;
+    switch (provider) {
+        case "anthropic":
+            return !value.startsWith("claude-");
+        case "minimax":
+            return !value.startsWith("minimax");
+        case "openai-codex":
+            return value.startsWith("claude-") || value.startsWith("minimax");
+        case "azure":
+            return value.startsWith("claude-") || value.startsWith("minimax");
+        case "github-copilot":
+            return false;
+    }
+}
+function resolveModelForProviderSelection(provider, currentModel) {
+    const trimmed = currentModel.trim();
+    if (trimmed && !isModelClearlyIncompatibleWithProvider(provider, trimmed)) {
+        return { model: trimmed, preserved: true };
+    }
+    const model = getDefaultModelForProvider(provider);
+    (0, runtime_1.emitNervesEvent)({
+        component: "config/identity",
+        event: "config_identity.provider_model_defaulted",
+        message: "defaulted provider model during provider selection",
+        meta: { provider, previousModel: currentModel, model },
+    });
+    return { model, preserved: false };
+}
+function resolveModelForProviderDisplay(provider, modelHint) {
+    const hint = modelHint?.trim() ?? "";
+    if (hint && !isModelClearlyIncompatibleWithProvider(provider, hint))
+        return hint;
+    return getDefaultModelForProvider(provider);
+}
+function getProviderModelMismatchMessage(provider, model) {
+    const trimmed = model.trim();
+    if (!isModelClearlyIncompatibleWithProvider(provider, trimmed))
+        return null;
+    const providerName = getProviderDisplayName(provider);
+    const defaultModel = getDefaultModelForProvider(provider);
+    if (!trimmed) {
+        return `${providerName} has no model set. Suggested model: ${defaultModel}.`;
+    }
+    return `${providerName} is currently paired with ${trimmed}, which does not look like a model for ${providerName}. Suggested model: ${defaultModel}.`;
+}

package/dist/senses/pipeline.js

@@ -54,6 +54,7 @@ const obligations_1 = require("../arc/obligations");
 const provider_failover_1 = require("../heart/provider-failover");
 const provider_ping_1 = require("../heart/provider-ping");
 const auth_flow_1 = require("../heart/auth/auth-flow");
+const provider_models_1 = require("../heart/provider-models");
 const tempo_1 = require("../heart/tempo");
 const temporal_view_1 = require("../heart/temporal-view");
 const start_of_turn_packet_1 = require("../heart/start-of-turn-packet");
@@ -162,14 +163,15 @@ async function handleInboundTurn(input) {
                     try {
                         const { secrets } = (0, auth_flow_1.loadAgentSecrets)(failoverAgentName);
                         const cfg = secrets.providers[failoverAction.provider];
-                        return cfg?.model ?? cfg?.modelName ?? "";
+                        const hint = cfg?.model ?? cfg?.modelName;
+                        return (0, provider_models_1.resolveModelForProviderDisplay)(failoverAction.provider, typeof hint === "string" ? hint : "");
                         /* v8 ignore next 2 -- defensive: secrets read failure @preserve */
                     }
                     catch {
-                        return "";
+                        return (0, provider_models_1.resolveModelForProviderDisplay)(failoverAction.provider);
                     }
                 })();
-                const newProviderLabel = newProviderSecrets ? `${failoverAction.provider} (${newProviderSecrets})` : failoverAction.provider;
+                const newProviderLabel = `${failoverAction.provider} (${newProviderSecrets})`;
                 input.messages = [{
                         role: "user",
                         content: `[provider switch: ${pendingContext.errorSummary}. switched to ${newProviderLabel}. your conversation history is intact — respond to the user's last message.]`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.327",
+  "version": "0.1.0-alpha.328",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",
@@ -31,6 +31,7 @@
     "test:coverage": "node scripts/run-coverage-gate.cjs",
     "build": "tsc && (cd packages/outlook-ui && npm install --ignore-scripts 2>/dev/null && npm run build && cp -r dist ../../dist/outlook-ui) || echo 'outlook-ui build skipped'",
     "lint": "eslint src/",
+    "release:smoke": "node scripts/release-smoke.cjs",
     "audit:nerves": "npm run build && node dist/nerves/coverage/cli-main.js"
   },
   "dependencies": {