@ouro.bot/cli 0.1.0-alpha.34 → 0.1.0-alpha.340

package/dist/heart/outlook/readers/sessions.js

@@ -0,0 +1,231 @@
+"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.readSessionInventory = readSessionInventory;
+exports.readSessionTranscript = readSessionTranscript;
+const path = __importStar(require("path"));
+const runtime_1 = require("../../../nerves/runtime");
+const identity_1 = require("../../identity");
+const session_events_1 = require("../../session-events");
+const shared_1 = require("./shared");
+/* v8 ignore start — session envelope parsing utilities */
+function parseSessionUsage(raw) {
+    if (!raw || typeof raw !== "object")
+        return null;
+    const record = raw;
+    const inputTokens = typeof record.input_tokens === "number" ? record.input_tokens : 0;
+    const outputTokens = typeof record.output_tokens === "number" ? record.output_tokens : 0;
+    const reasoningTokens = typeof record.reasoning_tokens === "number" ? record.reasoning_tokens : 0;
+    const totalTokens = typeof record.total_tokens === "number" ? record.total_tokens : 0;
+    if (inputTokens === 0 && outputTokens === 0 && totalTokens === 0)
+        return null;
+    return { input_tokens: inputTokens, output_tokens: outputTokens, reasoning_tokens: reasoningTokens, total_tokens: totalTokens };
+}
+function parseSessionContinuity(raw) {
+    if (!raw)
+        return null;
+    if (typeof raw !== "object")
+        return null;
+    const record = raw;
+    const continuity = {
+        mustResolveBeforeHandoff: record.mustResolveBeforeHandoff === true,
+        lastFriendActivityAt: typeof record.lastFriendActivityAt === "string" ? record.lastFriendActivityAt : null,
+    };
+    if (!continuity.mustResolveBeforeHandoff && continuity.lastFriendActivityAt === null)
+        return null;
+    return continuity;
+}
+function extractContent(event) {
+    if (!event)
+        return null;
+    const text = (0, session_events_1.extractEventText)(event);
+    return text.length > 0 ? text : null;
+}
+function extractToolCallNames(event) {
+    if (!event)
+        return [];
+    return event.toolCalls
+        .map((call) => call.function.name)
+        .filter((name) => typeof name === "string" && name.length > 0);
+}
+/* v8 ignore stop */
+function estimateTokenCount(messages) {
+    let charCount = 0;
+    for (const msg of messages) {
+        const content = extractContent(msg);
+        if (content)
+            charCount += content.length;
+        if (msg.toolCalls.length > 0)
+            charCount += JSON.stringify(msg.toolCalls).length;
+    }
+    return Math.ceil(charCount / 4);
+}
+/* v8 ignore start — filesystem traversal with defensive isDirectory checks */
+function resolveAllSessionPaths(sessionsDir) {
+    const results = [];
+    if (!(0, shared_1.safeIsDirectory)(sessionsDir))
+        return results;
+    for (const friendId of (0, shared_1.safeReaddir)(sessionsDir)) {
+        const friendDir = path.join(sessionsDir, friendId);
+        if (!(0, shared_1.safeIsDirectory)(friendDir))
+            continue;
+        for (const channel of (0, shared_1.safeReaddir)(friendDir)) {
+            const channelDir = path.join(friendDir, channel);
+            if (!(0, shared_1.safeIsDirectory)(channelDir))
+                continue;
+            for (const file of (0, shared_1.safeReaddir)(channelDir)) {
+                if (!file.endsWith(".json"))
+                    continue;
+                const key = file.slice(0, -5);
+                results.push({
+                    friendId,
+                    channel,
+                    key,
+                    sessionPath: path.join(channelDir, file),
+                });
+            }
+        }
+    }
+    return results;
+}
+/* v8 ignore stop */
+/* v8 ignore start — defensive parsing */
+function readSessionInventory(agentName, options = {}) {
+    const bundlesRoot = options.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)();
+    const now = options.now?.() ?? new Date();
+    const agentRoot = path.join(bundlesRoot, `${agentName}.ouro`);
+    const sessionsDir = path.join(agentRoot, "state", "sessions");
+    const friendsDir = path.join(agentRoot, "friends");
+    const allSessions = resolveAllSessionPaths(sessionsDir);
+    const items = [];
+    for (const { friendId, channel, key, sessionPath } of allSessions) {
+        if (friendId === "self" && channel === "inner")
+            continue;
+        const envelope = (0, shared_1.readSessionEnvelope)(sessionPath);
+        const events = envelope?.events ?? [];
+        const chronology = (0, session_events_1.deriveSessionChronology)(events);
+        const lastUsage = parseSessionUsage(envelope?.lastUsage);
+        const continuity = parseSessionContinuity(envelope?.state);
+        const hasObservedEventTiming = events.some((event) => event.time.authoredAt !== null || event.time.observedAt !== null);
+        const lastActivityAt = hasObservedEventTiming
+            ? (chronology.lastActivityAt ?? continuity?.lastFriendActivityAt ?? (0, shared_1.safeFileMtime)(sessionPath) ?? now.toISOString())
+            : (continuity?.lastFriendActivityAt ?? (0, shared_1.safeFileMtime)(sessionPath) ?? now.toISOString());
+        const activitySource = hasObservedEventTiming && chronology.lastActivityAt
+            ? "event-timeline"
+            : continuity?.lastFriendActivityAt
+                ? "friend-facing"
+                : "mtime-fallback";
+        const userMessages = events.filter((m) => m.role === "user");
+        const assistantMessages = events.filter((m) => m.role === "assistant");
+        const lastUser = userMessages.length > 0 ? userMessages[userMessages.length - 1] : null;
+        const lastAssistant = assistantMessages.length > 0 ? assistantMessages[assistantMessages.length - 1] : null;
+        const latestToolCallNames = [];
+        for (let i = events.length - 1; i >= 0; i--) {
+            const names = extractToolCallNames(events[i]);
+            if (names.length > 0) {
+                latestToolCallNames.push(...names);
+                break;
+            }
+        }
+        const friendName = (0, shared_1.resolveFriendName)(friendsDir, friendId);
+        const lastMsg = events.length > 0 ? events[events.length - 1] : null;
+        const mustResolve = continuity?.mustResolveBeforeHandoff === true;
+        let replyState = "idle";
+        if (mustResolve) {
+            replyState = "on-hold";
+        }
+        else if (lastMsg?.role === "user") {
+            replyState = "needs-reply";
+        }
+        else if (events.length > 0) {
+            replyState = "monitoring";
+        }
+        items.push({
+            friendId,
+            friendName,
+            channel,
+            key,
+            sessionPath,
+            lastActivityAt,
+            activitySource,
+            replyState,
+            messageCount: events.length,
+            lastUsage,
+            continuity,
+            latestUserExcerpt: (0, shared_1.truncateExcerpt)(extractContent(lastUser)),
+            latestAssistantExcerpt: (0, shared_1.truncateExcerpt)(extractContent(lastAssistant)),
+            latestToolCallNames,
+            estimatedTokens: events.length > 0 ? estimateTokenCount(events) : null,
+        });
+    }
+    items.sort((a, b) => b.lastActivityAt.localeCompare(a.lastActivityAt));
+    const ageThreshold = now.getTime() - shared_1.STALE_THRESHOLD_MS;
+    const activeCount = items.filter((item) => Date.parse(item.lastActivityAt) >= ageThreshold).length;
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.outlook_sessions_read",
+        message: "reading outlook session inventory",
+        meta: { agentName, totalCount: items.length, activeCount },
+    });
+    return {
+        totalCount: items.length,
+        activeCount,
+        staleCount: items.length - activeCount,
+        items,
+    };
+}
+function readSessionTranscript(agentName, friendId, channel, key, options = {}) {
+    const bundlesRoot = options.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)();
+    const agentRoot = path.join(bundlesRoot, `${agentName}.ouro`);
+    const sessionPath = path.join(agentRoot, "state", "sessions", friendId, channel, `${key}.json`);
+    const envelope = (0, shared_1.readSessionEnvelope)(sessionPath);
+    if (!envelope)
+        return null;
+    const rawMessages = envelope.events;
+    const friendsDir = path.join(agentRoot, "friends");
+    const friendName = (0, shared_1.resolveFriendName)(friendsDir, friendId);
+    const messages = rawMessages;
+    return {
+        friendId,
+        friendName,
+        channel,
+        key,
+        sessionPath,
+        messageCount: messages.length,
+        lastUsage: parseSessionUsage(envelope.lastUsage),
+        continuity: parseSessionContinuity(envelope.state),
+        messages,
+    };
+}

package/dist/heart/outlook/readers/shared.js

@@ -0,0 +1,111 @@
+"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.STALE_THRESHOLD_MS = exports.BLOCKED_CODING_STATUSES = exports.ACTIVE_CODING_STATUSES = void 0;
+exports.issue = issue;
+exports.safeReaddir = safeReaddir;
+exports.safeIsDirectory = safeIsDirectory;
+exports.resolveFriendName = resolveFriendName;
+exports.safeFileMtime = safeFileMtime;
+exports.truncateExcerpt = truncateExcerpt;
+exports.readSessionEnvelope = readSessionEnvelope;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../../nerves/runtime");
+const session_events_1 = require("../../session-events");
+exports.ACTIVE_CODING_STATUSES = new Set(["spawning", "running", "waiting_input", "stalled"]);
+exports.BLOCKED_CODING_STATUSES = new Set(["waiting_input", "stalled"]);
+exports.STALE_THRESHOLD_MS = 24 * 60 * 60 * 1000;
+function issue(code, detail) {
+    return { code, detail };
+}
+function safeReaddir(dir) {
+    try {
+        return fs.readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+}
+function safeIsDirectory(filePath) {
+    try {
+        return fs.statSync(filePath).isDirectory();
+        /* v8 ignore start */
+    }
+    catch {
+        return false;
+    }
+    /* v8 ignore stop */
+}
+/* v8 ignore start — defensive friend name resolution */
+function resolveFriendName(friendsDir, friendId) {
+    try {
+        const raw = fs.readFileSync(path.join(friendsDir, `${friendId}.json`), "utf-8");
+        const parsed = JSON.parse(raw);
+        return typeof parsed.name === "string" ? parsed.name : friendId;
+    }
+    catch {
+        return friendId;
+    }
+}
+/* v8 ignore stop */
+/* v8 ignore start — utility helpers with defensive branches */
+function safeFileMtime(filePath) {
+    try {
+        return fs.statSync(filePath).mtime.toISOString();
+    }
+    catch {
+        return null;
+    }
+}
+function truncateExcerpt(content, maxLength = 200) {
+    if (!content)
+        return null;
+    if (content.length <= maxLength)
+        return content;
+    const truncated = content.slice(0, maxLength);
+    const lastSpace = truncated.lastIndexOf(" ");
+    return (lastSpace > maxLength * 0.6 ? truncated.slice(0, lastSpace) : truncated) + "…";
+}
+/* v8 ignore stop */
+function readSessionEnvelope(sessionPath) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.outlook_session_envelope_read",
+        message: "reading outlook session envelope",
+        meta: { sessionPath },
+    });
+    return (0, session_events_1.loadSessionEnvelopeFile)(sessionPath);
+}

package/dist/heart/progress-story.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildProgressStory = buildProgressStory;
+exports.renderProgressStory = renderProgressStory;
+const runtime_1 = require("../nerves/runtime");
+function labelForScope(scope) {
+    return scope === "inner-delegation" ? "inner work" : "shared work";
+}
+function compactDetail(text) {
+    if (typeof text !== "string")
+        return null;
+    const trimmed = text.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function buildProgressStory(input) {
+    const detailLines = [
+        compactDetail(input.objective),
+        compactDetail(input.outcomeText),
+        compactDetail(input.bridgeId ? `bridge: ${input.bridgeId}` : null),
+        compactDetail(input.taskName ? `task: ${input.taskName}` : null),
+    ].filter((line) => Boolean(line));
+    const story = {
+        statusLine: `${labelForScope(input.scope)}: ${input.phase}`,
+        detailLines,
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.progress_story_build",
+        message: "built shared progress story",
+        meta: {
+            scope: input.scope,
+            phase: input.phase,
+            detailLines: detailLines.length,
+            hasBridge: Boolean(input.bridgeId),
+            hasTask: Boolean(input.taskName),
+        },
+    });
+    return story;
+}
+function renderProgressStory(story) {
+    return [story.statusLine, ...story.detailLines].join("\n");
+}

package/dist/heart/provider-failover.js

@@ -0,0 +1,135 @@
+"use strict";
+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 CLASSIFICATION_LABELS = {
+    "auth-failure": "authentication failed",
+    "usage-limit": "hit its usage limit",
+    "rate-limit": "is being rate limited",
+    "server-error": "is experiencing an outage",
+    "network-error": "is unreachable (network error)",
+    "unknown": "encountered an error",
+};
+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 = 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 = [];
+    for (const [provider, result] of Object.entries(inventory)) {
+        if (result.ok) {
+            workingProviders.push(provider);
+        }
+        else if (result.classification === "auth-failure" && result.message === "no credentials configured") {
+            unconfiguredProviders.push(provider);
+        }
+        else {
+            // Configured but ping failed (expired token, provider also down, etc.)
+            failingProviders.push({ provider, classification: result.classification });
+        }
+    }
+    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) {
+        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) {
+            lines.push(formatFailingProviderLine(provider, classification, agentName));
+        }
+    }
+    if (unconfiguredProviders.length > 0) {
+        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("");
+        lines.push(`No other providers are available. Run \`ouro auth --agent ${agentName}\` in terminal to configure one.`);
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.failover_context_built",
+        message: "built provider failover context",
+        meta: { currentProvider, classification, workingProviders, unconfiguredProviders },
+    });
+    return {
+        errorSummary,
+        classification,
+        currentProvider,
+        agentName,
+        workingProviders,
+        unconfiguredProviders,
+        userMessage: lines.join("\n"),
+    };
+}
+function handleFailoverReply(reply, context) {
+    const lower = reply.toLowerCase().trim();
+    for (const provider of context.workingProviders) {
+        if (lower.includes(`switch to ${provider}`) || lower === provider) {
+            return { action: "switch", provider };
+        }
+    }
+    return { action: "dismiss" };
+}

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}.`;
+}