@intent-systems/nexus 2026.1.5-3

package/dist/auto-reply/reply/dispatch-from-config.js

@@ -0,0 +1,23 @@
+import { getReplyFromConfig } from "../reply.js";
+export async function dispatchReplyFromConfig(params) {
+    const replyResult = await (params.replyResolver ?? getReplyFromConfig)(params.ctx, {
+        ...params.replyOptions,
+        onToolResult: (payload) => {
+            params.dispatcher.sendToolResult(payload);
+        },
+        onBlockReply: (payload) => {
+            params.dispatcher.sendBlockReply(payload);
+        },
+    }, params.cfg);
+    const replies = replyResult
+        ? Array.isArray(replyResult)
+            ? replyResult
+            : [replyResult]
+        : [];
+    let queuedFinal = false;
+    for (const reply of replies) {
+        queuedFinal = params.dispatcher.sendFinalReply(reply) || queuedFinal;
+    }
+    await params.dispatcher.waitForIdle();
+    return { queuedFinal, counts: params.dispatcher.getQueuedCounts() };
+}

package/dist/auto-reply/reply/followup-runner.js

@@ -0,0 +1,181 @@
+import crypto from "node:crypto";
+import { lookupContextTokens } from "../../agents/context.js";
+import { DEFAULT_CONTEXT_TOKENS } from "../../agents/defaults.js";
+import { runWithModelFallback } from "../../agents/model-fallback.js";
+import { runEmbeddedPiAgent } from "../../agents/pi-embedded.js";
+import { hasNonzeroUsage } from "../../agents/usage.js";
+import { saveSessionStore } from "../../config/sessions.js";
+import { logVerbose } from "../../globals.js";
+import { registerAgentRunContext } from "../../infra/agent-events.js";
+import { defaultRuntime } from "../../runtime.js";
+import { stripHeartbeatToken } from "../heartbeat.js";
+import { SILENT_REPLY_TOKEN } from "../tokens.js";
+import { extractReplyToTag } from "./reply-tags.js";
+import { incrementCompactionCount } from "./session-updates.js";
+export function createFollowupRunner(params) {
+    const { opts, typing, sessionEntry, sessionStore, sessionKey, storePath, defaultModel, agentCfgContextTokens, } = params;
+    const sendFollowupPayloads = async (payloads) => {
+        if (!opts?.onBlockReply) {
+            logVerbose("followup queue: no onBlockReply handler; dropping payloads");
+            return;
+        }
+        for (const payload of payloads) {
+            if (!payload?.text && !payload?.mediaUrl && !payload?.mediaUrls?.length) {
+                continue;
+            }
+            if (payload.text?.trim() === SILENT_REPLY_TOKEN &&
+                !payload.mediaUrl &&
+                !payload.mediaUrls?.length) {
+                continue;
+            }
+            await typing.startTypingOnText(payload.text);
+            await opts.onBlockReply(payload);
+        }
+    };
+    return async (queued) => {
+        try {
+            const runId = crypto.randomUUID();
+            if (queued.run.sessionKey) {
+                registerAgentRunContext(runId, { sessionKey: queued.run.sessionKey });
+            }
+            let autoCompactionCompleted = false;
+            let runResult;
+            let fallbackProvider = queued.run.provider;
+            let fallbackModel = queued.run.model;
+            try {
+                const fallbackResult = await runWithModelFallback({
+                    cfg: queued.run.config,
+                    provider: queued.run.provider,
+                    model: queued.run.model,
+                    run: (provider, model) => runEmbeddedPiAgent({
+                        sessionId: queued.run.sessionId,
+                        sessionKey: queued.run.sessionKey,
+                        messageProvider: queued.run.messageProvider,
+                        sessionFile: queued.run.sessionFile,
+                        workspaceDir: queued.run.workspaceDir,
+                        config: queued.run.config,
+                        skillsSnapshot: queued.run.skillsSnapshot,
+                        prompt: queued.prompt,
+                        extraSystemPrompt: queued.run.extraSystemPrompt,
+                        ownerNumbers: queued.run.ownerNumbers,
+                        enforceFinalTag: queued.run.enforceFinalTag,
+                        provider,
+                        model,
+                        authProfileId: queued.run.authProfileId,
+                        thinkLevel: queued.run.thinkLevel,
+                        verboseLevel: queued.run.verboseLevel,
+                        bashElevated: queued.run.bashElevated,
+                        timeoutMs: queued.run.timeoutMs,
+                        runId,
+                        blockReplyBreak: queued.run.blockReplyBreak,
+                        onAgentEvent: (evt) => {
+                            if (evt.stream !== "compaction")
+                                return;
+                            const phase = typeof evt.data.phase === "string" ? evt.data.phase : "";
+                            const willRetry = Boolean(evt.data.willRetry);
+                            if (phase === "end" && !willRetry) {
+                                autoCompactionCompleted = true;
+                            }
+                        },
+                    }),
+                });
+                runResult = fallbackResult.result;
+                fallbackProvider = fallbackResult.provider;
+                fallbackModel = fallbackResult.model;
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                defaultRuntime.error?.(`Followup agent failed before reply: ${message}`);
+                return;
+            }
+            const payloadArray = runResult.payloads ?? [];
+            if (payloadArray.length === 0)
+                return;
+            const sanitizedPayloads = payloadArray.flatMap((payload) => {
+                const text = payload.text;
+                if (!text || !text.includes("HEARTBEAT_OK"))
+                    return [payload];
+                const stripped = stripHeartbeatToken(text, { mode: "message" });
+                const hasMedia = Boolean(payload.mediaUrl) || (payload.mediaUrls?.length ?? 0) > 0;
+                if (stripped.shouldSkip && !hasMedia)
+                    return [];
+                return [{ ...payload, text: stripped.text }];
+            });
+            const replyTaggedPayloads = sanitizedPayloads
+                .map((payload) => {
+                const { cleaned, replyToId } = extractReplyToTag(payload.text);
+                return {
+                    ...payload,
+                    text: cleaned ? cleaned : undefined,
+                    replyToId: replyToId ?? payload.replyToId,
+                };
+            })
+                .filter((payload) => payload.text ||
+                payload.mediaUrl ||
+                (payload.mediaUrls && payload.mediaUrls.length > 0));
+            if (replyTaggedPayloads.length === 0)
+                return;
+            if (autoCompactionCompleted) {
+                const count = await incrementCompactionCount({
+                    sessionEntry,
+                    sessionStore,
+                    sessionKey,
+                    storePath,
+                });
+                if (queued.run.verboseLevel === "on") {
+                    const suffix = typeof count === "number" ? ` (count ${count})` : "";
+                    replyTaggedPayloads.unshift({
+                        text: `🧹 Auto-compaction complete${suffix}.`,
+                    });
+                }
+            }
+            if (sessionStore && sessionKey) {
+                const usage = runResult.meta.agentMeta?.usage;
+                const modelUsed = runResult.meta.agentMeta?.model ?? fallbackModel ?? defaultModel;
+                const contextTokensUsed = agentCfgContextTokens ??
+                    lookupContextTokens(modelUsed) ??
+                    sessionEntry?.contextTokens ??
+                    DEFAULT_CONTEXT_TOKENS;
+                if (hasNonzeroUsage(usage)) {
+                    const entry = sessionStore[sessionKey];
+                    if (entry) {
+                        const input = usage.input ?? 0;
+                        const output = usage.output ?? 0;
+                        const promptTokens = input + (usage.cacheRead ?? 0) + (usage.cacheWrite ?? 0);
+                        sessionStore[sessionKey] = {
+                            ...entry,
+                            inputTokens: input,
+                            outputTokens: output,
+                            totalTokens: promptTokens > 0 ? promptTokens : (usage.total ?? input),
+                            modelProvider: fallbackProvider ?? entry.modelProvider,
+                            model: modelUsed,
+                            contextTokens: contextTokensUsed ?? entry.contextTokens,
+                            updatedAt: Date.now(),
+                        };
+                        if (storePath) {
+                            await saveSessionStore(storePath, sessionStore);
+                        }
+                    }
+                }
+                else if (modelUsed || contextTokensUsed) {
+                    const entry = sessionStore[sessionKey];
+                    if (entry) {
+                        sessionStore[sessionKey] = {
+                            ...entry,
+                            modelProvider: fallbackProvider ?? entry.modelProvider,
+                            model: modelUsed ?? entry.model,
+                            contextTokens: contextTokensUsed ?? entry.contextTokens,
+                        };
+                        if (storePath) {
+                            await saveSessionStore(storePath, sessionStore);
+                        }
+                    }
+                }
+            }
+            await sendFollowupPayloads(replyTaggedPayloads);
+        }
+        finally {
+            typing.markRunComplete();
+        }
+    };
+}

package/dist/auto-reply/reply/groups.js

@@ -0,0 +1,152 @@
+import { resolveProviderGroupRequireMention } from "../../config/group-policy.js";
+import { normalizeGroupActivation } from "../group-activation.js";
+function normalizeDiscordSlug(value) {
+    if (!value)
+        return "";
+    let text = value.trim().toLowerCase();
+    if (!text)
+        return "";
+    text = text.replace(/^[@#]+/, "");
+    text = text.replace(/[\s_]+/g, "-");
+    text = text.replace(/[^a-z0-9-]+/g, "-");
+    text = text.replace(/-{2,}/g, "-").replace(/^-+|-+$/g, "");
+    return text;
+}
+function normalizeSlackSlug(raw) {
+    const trimmed = raw?.trim().toLowerCase() ?? "";
+    if (!trimmed)
+        return "";
+    const dashed = trimmed.replace(/\s+/g, "-");
+    const cleaned = dashed.replace(/[^a-z0-9#@._+-]+/g, "-");
+    return cleaned.replace(/-{2,}/g, "-").replace(/^[-.]+|[-.]+$/g, "");
+}
+function resolveDiscordGuildEntry(guilds, groupSpace) {
+    if (!guilds || Object.keys(guilds).length === 0)
+        return null;
+    const space = groupSpace?.trim();
+    if (space && guilds[space])
+        return guilds[space];
+    const normalized = normalizeDiscordSlug(space);
+    if (normalized && guilds[normalized])
+        return guilds[normalized];
+    if (normalized) {
+        const match = Object.values(guilds).find((entry) => normalizeDiscordSlug(entry?.slug ?? undefined) === normalized);
+        if (match)
+            return match;
+    }
+    return guilds["*"] ?? null;
+}
+export function resolveGroupRequireMention(params) {
+    const { cfg, ctx, groupResolution } = params;
+    const provider = groupResolution?.provider ?? ctx.Provider?.trim().toLowerCase();
+    const groupId = groupResolution?.id ?? ctx.From?.replace(/^group:/, "");
+    const groupRoom = ctx.GroupRoom?.trim() ?? ctx.GroupSubject?.trim();
+    const groupSpace = ctx.GroupSpace?.trim();
+    if (provider === "telegram" ||
+        provider === "whatsapp" ||
+        provider === "imessage") {
+        return resolveProviderGroupRequireMention({
+            cfg,
+            provider,
+            groupId,
+        });
+    }
+    if (provider === "discord") {
+        const guildEntry = resolveDiscordGuildEntry(cfg.discord?.guilds, groupSpace);
+        const channelEntries = guildEntry?.channels;
+        if (channelEntries && Object.keys(channelEntries).length > 0) {
+            const channelSlug = normalizeDiscordSlug(groupRoom);
+            const entry = (groupId ? channelEntries[groupId] : undefined) ??
+                (channelSlug
+                    ? (channelEntries[channelSlug] ?? channelEntries[`#${channelSlug}`])
+                    : undefined) ??
+                (groupRoom
+                    ? channelEntries[normalizeDiscordSlug(groupRoom)]
+                    : undefined);
+            if (entry && typeof entry.requireMention === "boolean") {
+                return entry.requireMention;
+            }
+        }
+        if (typeof guildEntry?.requireMention === "boolean") {
+            return guildEntry.requireMention;
+        }
+        return true;
+    }
+    if (provider === "slack") {
+        const channels = cfg.slack?.channels ?? {};
+        const keys = Object.keys(channels);
+        if (keys.length === 0)
+            return true;
+        const channelId = groupId?.trim();
+        const channelName = groupRoom?.replace(/^#/, "");
+        const normalizedName = normalizeSlackSlug(channelName);
+        const candidates = [
+            channelId ?? "",
+            channelName ? `#${channelName}` : "",
+            channelName ?? "",
+            normalizedName,
+        ].filter(Boolean);
+        let matched;
+        for (const candidate of candidates) {
+            if (candidate && channels[candidate]) {
+                matched = channels[candidate];
+                break;
+            }
+        }
+        const fallback = channels["*"];
+        const resolved = matched ?? fallback;
+        if (typeof resolved?.requireMention === "boolean") {
+            return resolved.requireMention;
+        }
+        return true;
+    }
+    return true;
+}
+export function defaultGroupActivation(requireMention) {
+    return requireMention === false ? "always" : "mention";
+}
+export function buildGroupIntro(params) {
+    const activation = normalizeGroupActivation(params.sessionEntry?.groupActivation) ??
+        params.defaultActivation;
+    const subject = params.sessionCtx.GroupSubject?.trim();
+    const members = params.sessionCtx.GroupMembers?.trim();
+    const provider = params.sessionCtx.Provider?.trim().toLowerCase();
+    const providerLabel = (() => {
+        if (!provider)
+            return "chat";
+        if (provider === "whatsapp")
+            return "WhatsApp";
+        if (provider === "telegram")
+            return "Telegram";
+        if (provider === "discord")
+            return "Discord";
+        if (provider === "webchat")
+            return "WebChat";
+        return `${provider.at(0)?.toUpperCase() ?? ""}${provider.slice(1)}`;
+    })();
+    const subjectLine = subject
+        ? `You are replying inside the ${providerLabel} group "${subject}".`
+        : `You are replying inside a ${providerLabel} group chat.`;
+    const membersLine = members ? `Group members: ${members}.` : undefined;
+    const activationLine = activation === "always"
+        ? "Activation: always-on (you receive every group message)."
+        : "Activation: trigger-only (you are invoked only when explicitly mentioned; recent context may be included).";
+    const silenceLine = activation === "always"
+        ? `If no response is needed, reply with exactly "${params.silentToken}" (no other text) so Nexus stays silent.`
+        : undefined;
+    const cautionLine = activation === "always"
+        ? "Be extremely selective: reply only when you are directly addressed, asked a question, or can add clear value. Otherwise stay silent."
+        : undefined;
+    const lurkLine = "Be a good group participant: lurk and follow the conversation, but only chime in when you have something genuinely helpful or relevant to add. Don't feel obligated to respond to every message — quality over quantity. Even when lurking silently, you can use emoji reactions to acknowledge messages, show support, or react to humor — reactions are always appreciated and don't clutter the chat.";
+    return [
+        subjectLine,
+        membersLine,
+        activationLine,
+        silenceLine,
+        cautionLine,
+        lurkLine,
+    ]
+        .filter(Boolean)
+        .join(" ")
+        .concat(" Address the specific sender noted in the message context.");
+}

package/dist/auto-reply/reply/mentions.js

@@ -0,0 +1,64 @@
+export function buildMentionRegexes(cfg) {
+    const patterns = cfg?.routing?.groupChat?.mentionPatterns ?? [];
+    return patterns
+        .map((pattern) => {
+        try {
+            return new RegExp(pattern, "i");
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((value) => Boolean(value));
+}
+export function normalizeMentionText(text) {
+    return (text ?? "")
+        .replace(/[\u200b-\u200f\u202a-\u202e\u2060-\u206f]/g, "")
+        .toLowerCase();
+}
+export function matchesMentionPatterns(text, mentionRegexes) {
+    if (mentionRegexes.length === 0)
+        return false;
+    const cleaned = normalizeMentionText(text ?? "");
+    if (!cleaned)
+        return false;
+    return mentionRegexes.some((re) => re.test(cleaned));
+}
+export function stripStructuralPrefixes(text) {
+    // Ignore wrapper labels, timestamps, and sender prefixes so directive-only
+    // detection still works in group batches that include history/context.
+    const marker = "[Current message - respond to this]";
+    const afterMarker = text.includes(marker)
+        ? text.slice(text.indexOf(marker) + marker.length)
+        : text;
+    return afterMarker
+        .replace(/\[[^\]]+\]\s*/g, "")
+        .replace(/^[ \t]*[A-Za-z0-9+()\-_. ]+:\s*/gm, "")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+export function stripMentions(text, ctx, cfg) {
+    let result = text;
+    const patterns = cfg?.routing?.groupChat?.mentionPatterns ?? [];
+    for (const p of patterns) {
+        try {
+            const re = new RegExp(p, "gi");
+            result = result.replace(re, " ");
+        }
+        catch {
+            // ignore invalid regex
+        }
+    }
+    const selfE164 = (ctx.To ?? "").replace(/^whatsapp:/, "");
+    if (selfE164) {
+        const esc = selfE164.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        result = result
+            .replace(new RegExp(esc, "gi"), " ")
+            .replace(new RegExp(`@${esc}`, "gi"), " ");
+    }
+    // Generic mention patterns like @123456789 or plain digits
+    result = result.replace(/@[0-9+]{5,}/g, " ");
+    // Discord-style mentions (<@123> or <@!123>)
+    result = result.replace(/<@!?\d+>/g, " ");
+    return result.replace(/\s+/g, " ").trim();
+}

package/dist/auto-reply/reply/model-selection.js

@@ -0,0 +1,209 @@
+import { lookupContextTokens } from "../../agents/context.js";
+import { DEFAULT_CONTEXT_TOKENS } from "../../agents/defaults.js";
+import { loadModelCatalog } from "../../agents/model-catalog.js";
+import { buildAllowedModelSet, modelKey, normalizeProviderId, resolveModelRefFromString, resolveThinkingDefault, } from "../../agents/model-selection.js";
+import { saveSessionStore } from "../../config/sessions.js";
+export async function createModelSelectionState(params) {
+    const { cfg, agentCfg, sessionEntry, sessionStore, sessionKey, storePath, defaultProvider, } = params;
+    let provider = params.provider;
+    let model = params.model;
+    const hasAllowlist = agentCfg?.models && Object.keys(agentCfg.models).length > 0;
+    const hasStoredOverride = Boolean(sessionEntry?.modelOverride || sessionEntry?.providerOverride);
+    const needsModelCatalog = params.hasModelDirective || hasAllowlist || hasStoredOverride;
+    let allowedModelKeys = new Set();
+    let allowedModelCatalog = [];
+    let modelCatalog = null;
+    let resetModelOverride = false;
+    if (needsModelCatalog) {
+        modelCatalog = await loadModelCatalog({ config: cfg });
+        const allowed = buildAllowedModelSet({
+            cfg,
+            catalog: modelCatalog,
+            defaultProvider,
+        });
+        allowedModelCatalog = allowed.allowedCatalog;
+        allowedModelKeys = allowed.allowedKeys;
+    }
+    if (sessionEntry && sessionStore && sessionKey && hasStoredOverride) {
+        const overrideProvider = sessionEntry.providerOverride?.trim() || defaultProvider;
+        const overrideModel = sessionEntry.modelOverride?.trim();
+        if (overrideModel) {
+            const key = modelKey(overrideProvider, overrideModel);
+            if (allowedModelKeys.size > 0 && !allowedModelKeys.has(key)) {
+                delete sessionEntry.providerOverride;
+                delete sessionEntry.modelOverride;
+                sessionEntry.updatedAt = Date.now();
+                sessionStore[sessionKey] = sessionEntry;
+                if (storePath) {
+                    await saveSessionStore(storePath, sessionStore);
+                }
+                resetModelOverride = true;
+            }
+        }
+    }
+    const storedProviderOverride = sessionEntry?.providerOverride?.trim();
+    const storedModelOverride = sessionEntry?.modelOverride?.trim();
+    if (storedModelOverride) {
+        const candidateProvider = storedProviderOverride || defaultProvider;
+        const key = modelKey(candidateProvider, storedModelOverride);
+        if (allowedModelKeys.size === 0 || allowedModelKeys.has(key)) {
+            provider = candidateProvider;
+            model = storedModelOverride;
+        }
+    }
+    if (sessionEntry &&
+        sessionStore &&
+        sessionKey &&
+        sessionEntry.authProfileOverride) {
+        const { ensureAuthProfileStore } = await import("../../agents/auth-profiles.js");
+        const store = ensureAuthProfileStore();
+        const profile = store.profiles[sessionEntry.authProfileOverride];
+        if (!profile || profile.provider !== provider) {
+            delete sessionEntry.authProfileOverride;
+            sessionEntry.updatedAt = Date.now();
+            sessionStore[sessionKey] = sessionEntry;
+            if (storePath) {
+                await saveSessionStore(storePath, sessionStore);
+            }
+        }
+    }
+    let defaultThinkingLevel;
+    const resolveDefaultThinkingLevel = async () => {
+        if (defaultThinkingLevel)
+            return defaultThinkingLevel;
+        let catalogForThinking = modelCatalog ?? allowedModelCatalog;
+        if (!catalogForThinking || catalogForThinking.length === 0) {
+            modelCatalog = await loadModelCatalog({ config: cfg });
+            catalogForThinking = modelCatalog;
+        }
+        defaultThinkingLevel = resolveThinkingDefault({
+            cfg,
+            provider,
+            model,
+            catalog: catalogForThinking,
+        });
+        return defaultThinkingLevel;
+    };
+    return {
+        provider,
+        model,
+        allowedModelKeys,
+        allowedModelCatalog,
+        resetModelOverride,
+        resolveDefaultThinkingLevel,
+        needsModelCatalog,
+    };
+}
+export function resolveModelDirectiveSelection(params) {
+    const { raw, defaultProvider, defaultModel, aliasIndex, allowedModelKeys } = params;
+    const rawTrimmed = raw.trim();
+    const rawLower = rawTrimmed.toLowerCase();
+    const pickAliasForKey = (provider, model) => aliasIndex.byKey.get(modelKey(provider, model))?.[0];
+    const buildSelection = (provider, model) => {
+        const alias = pickAliasForKey(provider, model);
+        return {
+            provider,
+            model,
+            isDefault: provider === defaultProvider && model === defaultModel,
+            ...(alias ? { alias } : undefined),
+        };
+    };
+    const resolveFuzzy = (params) => {
+        const fragment = params.fragment.trim().toLowerCase();
+        if (!fragment)
+            return {};
+        const candidates = [];
+        for (const key of allowedModelKeys) {
+            const slash = key.indexOf("/");
+            if (slash <= 0)
+                continue;
+            const provider = normalizeProviderId(key.slice(0, slash));
+            const model = key.slice(slash + 1);
+            if (params.provider && provider !== normalizeProviderId(params.provider))
+                continue;
+            const haystack = `${provider}/${model}`.toLowerCase();
+            if (haystack.includes(fragment) || model.toLowerCase().includes(fragment)) {
+                candidates.push({ provider, model });
+            }
+        }
+        // Allow partial alias matches when the user doesn't specify a provider.
+        if (!params.provider) {
+            const aliasMatches = [];
+            for (const [aliasKey, entry] of aliasIndex.byAlias.entries()) {
+                if (!aliasKey.includes(fragment))
+                    continue;
+                aliasMatches.push({ provider: entry.ref.provider, model: entry.ref.model });
+            }
+            for (const match of aliasMatches) {
+                const key = modelKey(match.provider, match.model);
+                if (!allowedModelKeys.has(key))
+                    continue;
+                if (!candidates.some((c) => c.provider === match.provider && c.model === match.model)) {
+                    candidates.push(match);
+                }
+            }
+        }
+        if (candidates.length === 1) {
+            const match = candidates[0];
+            if (!match)
+                return {};
+            return { selection: buildSelection(match.provider, match.model) };
+        }
+        if (candidates.length > 1) {
+            const shown = candidates
+                .slice(0, 5)
+                .map((c) => `${c.provider}/${c.model}`)
+                .join(", ");
+            const more = candidates.length > 5 ? ` (+${candidates.length - 5} more)` : "";
+            return {
+                error: `Ambiguous model "${rawTrimmed}". Matches: ${shown}${more}. Use /model to list or specify provider/model.`,
+            };
+        }
+        return {};
+    };
+    const resolved = resolveModelRefFromString({
+        raw: rawTrimmed,
+        defaultProvider,
+        aliasIndex,
+    });
+    if (!resolved) {
+        const fuzzy = resolveFuzzy({ fragment: rawTrimmed });
+        if (fuzzy.selection || fuzzy.error)
+            return fuzzy;
+        return {
+            error: `Unrecognized model "${rawTrimmed}". Use /model to list available models.`,
+        };
+    }
+    const resolvedKey = modelKey(resolved.ref.provider, resolved.ref.model);
+    if (allowedModelKeys.size === 0 || allowedModelKeys.has(resolvedKey)) {
+        const alias = resolved.alias ?? pickAliasForKey(resolved.ref.provider, resolved.ref.model);
+        return {
+            selection: {
+                provider: resolved.ref.provider,
+                model: resolved.ref.model,
+                isDefault: resolved.ref.provider === defaultProvider &&
+                    resolved.ref.model === defaultModel,
+                ...(alias ? { alias } : undefined),
+            },
+        };
+    }
+    if (rawLower.includes("/")) {
+        const slash = rawTrimmed.indexOf("/");
+        const provider = normalizeProviderId(rawTrimmed.slice(0, slash).trim());
+        const fragment = rawTrimmed.slice(slash + 1).trim();
+        const fuzzy = resolveFuzzy({ provider, fragment });
+        if (fuzzy.selection || fuzzy.error)
+            return fuzzy;
+    }
+    const fuzzy = resolveFuzzy({ fragment: rawTrimmed });
+    if (fuzzy.selection || fuzzy.error)
+        return fuzzy;
+    return {
+        error: `Model "${resolved.ref.provider}/${resolved.ref.model}" is not allowed. Use /model to list available models.`,
+    };
+}
+export function resolveContextTokens(params) {
+    return (params.agentCfg?.contextTokens ??
+        lookupContextTokens(params.model) ??
+        DEFAULT_CONTEXT_TOKENS);
+}