@poolzin/pool-bot 2026.3.25 → 2026.3.27

package/dist/auto-reply/auto-reply/reply/commands-tts.js

@@ -0,0 +1,231 @@
+import { logVerbose } from "../../globals.js";
+import { getLastTtsAttempt, getTtsMaxLength, getTtsProvider, isSummarizationEnabled, isTtsEnabled, isTtsProviderConfigured, resolveTtsApiKey, resolveTtsConfig, resolveTtsPrefsPath, setLastTtsAttempt, setSummarizationEnabled, setTtsEnabled, setTtsMaxLength, setTtsProvider, textToSpeech, } from "../../tts/tts.js";
+function parseTtsCommand(normalized) {
+    // Accept `/tts` and `/tts <action> [args]` as a single control surface.
+    if (normalized === "/tts") {
+        return { action: "status", args: "" };
+    }
+    if (!normalized.startsWith("/tts ")) {
+        return null;
+    }
+    const rest = normalized.slice(5).trim();
+    if (!rest) {
+        return { action: "status", args: "" };
+    }
+    const [action, ...tail] = rest.split(/\s+/);
+    return { action: action.toLowerCase(), args: tail.join(" ").trim() };
+}
+function ttsUsage() {
+    // Keep usage in one place so help/validation stays consistent.
+    return {
+        text: `🔊 **TTS (Text-to-Speech) Help**\n\n` +
+            `**Commands:**\n` +
+            `• /tts on — Enable automatic TTS for replies\n` +
+            `• /tts off — Disable TTS\n` +
+            `• /tts status — Show current settings\n` +
+            `• /tts provider [name] — View/change provider\n` +
+            `• /tts limit [number] — View/change text limit\n` +
+            `• /tts summary [on|off] — View/change auto-summary\n` +
+            `• /tts audio <text> — Generate audio from text\n\n` +
+            `**Providers:**\n` +
+            `• edge — Free, fast (default)\n` +
+            `• openai — High quality (requires API key)\n` +
+            `• elevenlabs — Premium voices (requires API key)\n\n` +
+            `**Text Limit (default: 1500, max: 4096):**\n` +
+            `When text exceeds the limit:\n` +
+            `• Summary ON: AI summarizes, then generates audio\n` +
+            `• Summary OFF: Truncates text, then generates audio\n\n` +
+            `**Examples:**\n` +
+            `/tts provider edge\n` +
+            `/tts limit 2000\n` +
+            `/tts audio Hello, this is a test!`,
+    };
+}
+export const handleTtsCommands = async (params, allowTextCommands) => {
+    if (!allowTextCommands) {
+        return null;
+    }
+    const parsed = parseTtsCommand(params.command.commandBodyNormalized);
+    if (!parsed) {
+        return null;
+    }
+    if (!params.command.isAuthorizedSender) {
+        logVerbose(`Ignoring TTS command from unauthorized sender: ${params.command.senderId || "<unknown>"}`);
+        return { shouldContinue: false };
+    }
+    const config = resolveTtsConfig(params.cfg);
+    const prefsPath = resolveTtsPrefsPath(config);
+    const action = parsed.action;
+    const args = parsed.args;
+    if (action === "help") {
+        return { shouldContinue: false, reply: ttsUsage() };
+    }
+    if (action === "on") {
+        setTtsEnabled(prefsPath, true);
+        return { shouldContinue: false, reply: { text: "🔊 TTS enabled." } };
+    }
+    if (action === "off") {
+        setTtsEnabled(prefsPath, false);
+        return { shouldContinue: false, reply: { text: "🔇 TTS disabled." } };
+    }
+    if (action === "audio") {
+        if (!args.trim()) {
+            return {
+                shouldContinue: false,
+                reply: {
+                    text: `🎤 Generate audio from text.\n\n` +
+                        `Usage: /tts audio <text>\n` +
+                        `Example: /tts audio Hello, this is a test!`,
+                },
+            };
+        }
+        const start = Date.now();
+        const result = await textToSpeech({
+            text: args,
+            cfg: params.cfg,
+            channel: params.command.channel,
+            prefsPath,
+        });
+        if (result.success && result.audioPath) {
+            // Store last attempt for `/tts status`.
+            setLastTtsAttempt({
+                timestamp: Date.now(),
+                success: true,
+                textLength: args.length,
+                summarized: false,
+                provider: result.provider,
+                latencyMs: result.latencyMs,
+            });
+            const payload = {
+                mediaUrl: result.audioPath,
+                audioAsVoice: result.voiceCompatible === true,
+            };
+            return { shouldContinue: false, reply: payload };
+        }
+        // Store failure details for `/tts status`.
+        setLastTtsAttempt({
+            timestamp: Date.now(),
+            success: false,
+            textLength: args.length,
+            summarized: false,
+            error: result.error,
+            latencyMs: Date.now() - start,
+        });
+        return {
+            shouldContinue: false,
+            reply: { text: `❌ Error generating audio: ${result.error ?? "unknown error"}` },
+        };
+    }
+    if (action === "provider") {
+        const currentProvider = getTtsProvider(config, prefsPath);
+        if (!args.trim()) {
+            const hasOpenAI = Boolean(resolveTtsApiKey(config, "openai"));
+            const hasElevenLabs = Boolean(resolveTtsApiKey(config, "elevenlabs"));
+            const hasEdge = isTtsProviderConfigured(config, "edge");
+            return {
+                shouldContinue: false,
+                reply: {
+                    text: `🎙️ TTS provider\n` +
+                        `Primary: ${currentProvider}\n` +
+                        `OpenAI key: ${hasOpenAI ? "✅" : "❌"}\n` +
+                        `ElevenLabs key: ${hasElevenLabs ? "✅" : "❌"}\n` +
+                        `Edge enabled: ${hasEdge ? "✅" : "❌"}\n` +
+                        `Usage: /tts provider openai | elevenlabs | edge`,
+                },
+            };
+        }
+        const requested = args.trim().toLowerCase();
+        if (requested !== "openai" && requested !== "elevenlabs" && requested !== "edge") {
+            return { shouldContinue: false, reply: ttsUsage() };
+        }
+        setTtsProvider(prefsPath, requested);
+        return {
+            shouldContinue: false,
+            reply: { text: `✅ TTS provider set to ${requested}.` },
+        };
+    }
+    if (action === "limit") {
+        if (!args.trim()) {
+            const currentLimit = getTtsMaxLength(prefsPath);
+            return {
+                shouldContinue: false,
+                reply: {
+                    text: `📏 TTS limit: ${currentLimit} characters.\n\n` +
+                        `Text longer than this triggers summary (if enabled).\n` +
+                        `Range: 100-4096 chars (Telegram max).\n\n` +
+                        `To change: /tts limit <number>\n` +
+                        `Example: /tts limit 2000`,
+                },
+            };
+        }
+        const next = Number.parseInt(args.trim(), 10);
+        if (!Number.isFinite(next) || next < 100 || next > 4096) {
+            return {
+                shouldContinue: false,
+                reply: { text: "❌ Limit must be between 100 and 4096 characters." },
+            };
+        }
+        setTtsMaxLength(prefsPath, next);
+        return {
+            shouldContinue: false,
+            reply: { text: `✅ TTS limit set to ${next} characters.` },
+        };
+    }
+    if (action === "summary") {
+        if (!args.trim()) {
+            const enabled = isSummarizationEnabled(prefsPath);
+            const maxLen = getTtsMaxLength(prefsPath);
+            return {
+                shouldContinue: false,
+                reply: {
+                    text: `📝 TTS auto-summary: ${enabled ? "on" : "off"}.\n\n` +
+                        `When text exceeds ${maxLen} chars:\n` +
+                        `• ON: summarizes text, then generates audio\n` +
+                        `• OFF: truncates text, then generates audio\n\n` +
+                        `To change: /tts summary on | off`,
+                },
+            };
+        }
+        const requested = args.trim().toLowerCase();
+        if (requested !== "on" && requested !== "off") {
+            return { shouldContinue: false, reply: ttsUsage() };
+        }
+        setSummarizationEnabled(prefsPath, requested === "on");
+        return {
+            shouldContinue: false,
+            reply: {
+                text: requested === "on" ? "✅ TTS auto-summary enabled." : "❌ TTS auto-summary disabled.",
+            },
+        };
+    }
+    if (action === "status") {
+        const enabled = isTtsEnabled(config, prefsPath);
+        const provider = getTtsProvider(config, prefsPath);
+        const hasKey = isTtsProviderConfigured(config, provider);
+        const maxLength = getTtsMaxLength(prefsPath);
+        const summarize = isSummarizationEnabled(prefsPath);
+        const last = getLastTtsAttempt();
+        const lines = [
+            "📊 TTS status",
+            `State: ${enabled ? "✅ enabled" : "❌ disabled"}`,
+            `Provider: ${provider} (${hasKey ? "✅ configured" : "❌ not configured"})`,
+            `Text limit: ${maxLength} chars`,
+            `Auto-summary: ${summarize ? "on" : "off"}`,
+        ];
+        if (last) {
+            const timeAgo = Math.round((Date.now() - last.timestamp) / 1000);
+            lines.push("");
+            lines.push(`Last attempt (${timeAgo}s ago): ${last.success ? "✅" : "❌"}`);
+            lines.push(`Text: ${last.textLength} chars${last.summarized ? " (summarized)" : ""}`);
+            if (last.success) {
+                lines.push(`Provider: ${last.provider ?? "unknown"}`);
+                lines.push(`Latency: ${last.latencyMs ?? 0}ms`);
+            }
+            else if (last.error) {
+                lines.push(`Error: ${last.error}`);
+            }
+        }
+        return { shouldContinue: false, reply: { text: lines.join("\n") } };
+    }
+    return { shouldContinue: false, reply: ttsUsage() };
+};

package/dist/auto-reply/auto-reply/reply/directive-handling.impl.js

@@ -0,0 +1,380 @@
+import { resolveAgentConfig, resolveAgentDir, resolveSessionAgentId, } from "../../agents/agent-scope.js";
+import { resolveSandboxRuntimeStatus } from "../../agents/sandbox.js";
+import { updateSessionStore } from "../../config/sessions.js";
+import { enqueueSystemEvent } from "../../infra/system-events.js";
+import { applyVerboseOverride } from "../../sessions/level-overrides.js";
+import { applyModelOverrideToSessionEntry } from "../../sessions/model-overrides.js";
+import { formatThinkingLevels, formatXHighModelHint, supportsXHighThinking } from "../thinking.js";
+import { maybeHandleModelDirectiveInfo, resolveModelSelectionFromDirective, } from "./directive-handling.model.js";
+import { maybeHandleQueueDirective } from "./directive-handling.queue-validation.js";
+import { formatDirectiveAck, formatElevatedEvent, formatElevatedRuntimeHint, formatElevatedUnavailableText, formatReasoningEvent, withOptions, } from "./directive-handling.shared.js";
+function resolveExecDefaults(params) {
+    const globalExec = params.cfg.tools?.exec;
+    const agentExec = params.agentId
+        ? resolveAgentConfig(params.cfg, params.agentId)?.tools?.exec
+        : undefined;
+    return {
+        host: params.sessionEntry?.execHost ??
+            agentExec?.host ??
+            globalExec?.host ??
+            "sandbox",
+        security: params.sessionEntry?.execSecurity ??
+            agentExec?.security ??
+            globalExec?.security ??
+            "deny",
+        ask: params.sessionEntry?.execAsk ??
+            agentExec?.ask ??
+            globalExec?.ask ??
+            "on-miss",
+        node: params.sessionEntry?.execNode ?? agentExec?.node ?? globalExec?.node,
+    };
+}
+export async function handleDirectiveOnly(params) {
+    const { directives, sessionEntry, sessionStore, sessionKey, storePath, elevatedEnabled, elevatedAllowed, defaultProvider, defaultModel, aliasIndex, allowedModelKeys, allowedModelCatalog, resetModelOverride, provider, model, initialModelLabel, formatModelSwitchEvent, currentThinkLevel, currentVerboseLevel, currentReasoningLevel, currentElevatedLevel, } = params;
+    const activeAgentId = resolveSessionAgentId({
+        sessionKey: params.sessionKey,
+        config: params.cfg,
+    });
+    const agentDir = resolveAgentDir(params.cfg, activeAgentId);
+    const runtimeIsSandboxed = resolveSandboxRuntimeStatus({
+        cfg: params.cfg,
+        sessionKey: params.sessionKey,
+    }).sandboxed;
+    const shouldHintDirectRuntime = directives.hasElevatedDirective && !runtimeIsSandboxed;
+    const modelInfo = await maybeHandleModelDirectiveInfo({
+        directives,
+        cfg: params.cfg,
+        agentDir,
+        activeAgentId,
+        provider,
+        model,
+        defaultProvider,
+        defaultModel,
+        aliasIndex,
+        allowedModelCatalog,
+        resetModelOverride,
+    });
+    if (modelInfo)
+        return modelInfo;
+    const modelResolution = resolveModelSelectionFromDirective({
+        directives,
+        cfg: params.cfg,
+        agentDir,
+        defaultProvider,
+        defaultModel,
+        aliasIndex,
+        allowedModelKeys,
+        allowedModelCatalog,
+        provider,
+    });
+    if (modelResolution.errorText)
+        return { text: modelResolution.errorText };
+    const modelSelection = modelResolution.modelSelection;
+    const profileOverride = modelResolution.profileOverride;
+    const resolvedProvider = modelSelection?.provider ?? provider;
+    const resolvedModel = modelSelection?.model ?? model;
+    if (directives.hasThinkDirective && !directives.thinkLevel) {
+        // If no argument was provided, show the current level
+        if (!directives.rawThinkLevel) {
+            const level = currentThinkLevel ?? "off";
+            return {
+                text: withOptions(`Current thinking level: ${level}.`, formatThinkingLevels(resolvedProvider, resolvedModel)),
+            };
+        }
+        return {
+            text: `Unrecognized thinking level "${directives.rawThinkLevel}". Valid levels: ${formatThinkingLevels(resolvedProvider, resolvedModel)}.`,
+        };
+    }
+    if (directives.hasVerboseDirective && !directives.verboseLevel) {
+        if (!directives.rawVerboseLevel) {
+            const level = currentVerboseLevel ?? "off";
+            return {
+                text: withOptions(`Current verbose level: ${level}.`, "on, full, off"),
+            };
+        }
+        return {
+            text: `Unrecognized verbose level "${directives.rawVerboseLevel}". Valid levels: off, on, full.`,
+        };
+    }
+    if (directives.hasReasoningDirective && !directives.reasoningLevel) {
+        if (!directives.rawReasoningLevel) {
+            const level = currentReasoningLevel ?? "off";
+            return {
+                text: withOptions(`Current reasoning level: ${level}.`, "on, off, stream"),
+            };
+        }
+        return {
+            text: `Unrecognized reasoning level "${directives.rawReasoningLevel}". Valid levels: on, off, stream.`,
+        };
+    }
+    if (directives.hasElevatedDirective && !directives.elevatedLevel) {
+        if (!directives.rawElevatedLevel) {
+            if (!elevatedEnabled || !elevatedAllowed) {
+                return {
+                    text: formatElevatedUnavailableText({
+                        runtimeSandboxed: runtimeIsSandboxed,
+                        failures: params.elevatedFailures,
+                        sessionKey: params.sessionKey,
+                    }),
+                };
+            }
+            const level = currentElevatedLevel ?? "off";
+            return {
+                text: [
+                    withOptions(`Current elevated level: ${level}.`, "on, off, ask, full"),
+                    shouldHintDirectRuntime ? formatElevatedRuntimeHint() : null,
+                ]
+                    .filter(Boolean)
+                    .join("\n"),
+            };
+        }
+        return {
+            text: `Unrecognized elevated level "${directives.rawElevatedLevel}". Valid levels: off, on, ask, full.`,
+        };
+    }
+    if (directives.hasElevatedDirective && (!elevatedEnabled || !elevatedAllowed)) {
+        return {
+            text: formatElevatedUnavailableText({
+                runtimeSandboxed: runtimeIsSandboxed,
+                failures: params.elevatedFailures,
+                sessionKey: params.sessionKey,
+            }),
+        };
+    }
+    if (directives.hasExecDirective) {
+        if (directives.invalidExecHost) {
+            return {
+                text: `Unrecognized exec host "${directives.rawExecHost ?? ""}". Valid hosts: sandbox, gateway, node.`,
+            };
+        }
+        if (directives.invalidExecSecurity) {
+            return {
+                text: `Unrecognized exec security "${directives.rawExecSecurity ?? ""}". Valid: deny, allowlist, full.`,
+            };
+        }
+        if (directives.invalidExecAsk) {
+            return {
+                text: `Unrecognized exec ask "${directives.rawExecAsk ?? ""}". Valid: off, on-miss, always.`,
+            };
+        }
+        if (directives.invalidExecNode) {
+            return {
+                text: "Exec node requires a value.",
+            };
+        }
+        if (!directives.hasExecOptions) {
+            const execDefaults = resolveExecDefaults({
+                cfg: params.cfg,
+                sessionEntry,
+                agentId: activeAgentId,
+            });
+            const nodeLabel = execDefaults.node ? `node=${execDefaults.node}` : "node=(unset)";
+            return {
+                text: withOptions(`Current exec defaults: host=${execDefaults.host}, security=${execDefaults.security}, ask=${execDefaults.ask}, ${nodeLabel}.`, "host=sandbox|gateway|node, security=deny|allowlist|full, ask=off|on-miss|always, node=<id>"),
+            };
+        }
+    }
+    const queueAck = maybeHandleQueueDirective({
+        directives,
+        cfg: params.cfg,
+        channel: provider,
+        sessionEntry,
+    });
+    if (queueAck)
+        return queueAck;
+    if (directives.hasThinkDirective &&
+        directives.thinkLevel === "xhigh" &&
+        !supportsXHighThinking(resolvedProvider, resolvedModel)) {
+        return {
+            text: `Thinking level "xhigh" is only supported for ${formatXHighModelHint()}.`,
+        };
+    }
+    const nextThinkLevel = directives.hasThinkDirective
+        ? directives.thinkLevel
+        : (sessionEntry?.thinkingLevel ?? currentThinkLevel);
+    const shouldDowngradeXHigh = !directives.hasThinkDirective &&
+        nextThinkLevel === "xhigh" &&
+        !supportsXHighThinking(resolvedProvider, resolvedModel);
+    const prevElevatedLevel = currentElevatedLevel ??
+        sessionEntry.elevatedLevel ??
+        (elevatedAllowed ? "on" : "off");
+    const prevReasoningLevel = currentReasoningLevel ?? sessionEntry.reasoningLevel ?? "off";
+    let elevatedChanged = directives.hasElevatedDirective &&
+        directives.elevatedLevel !== undefined &&
+        elevatedEnabled &&
+        elevatedAllowed;
+    let reasoningChanged = directives.hasReasoningDirective && directives.reasoningLevel !== undefined;
+    if (directives.hasThinkDirective && directives.thinkLevel) {
+        if (directives.thinkLevel === "off")
+            delete sessionEntry.thinkingLevel;
+        else
+            sessionEntry.thinkingLevel = directives.thinkLevel;
+    }
+    if (shouldDowngradeXHigh) {
+        sessionEntry.thinkingLevel = "high";
+    }
+    if (directives.hasVerboseDirective && directives.verboseLevel) {
+        applyVerboseOverride(sessionEntry, directives.verboseLevel);
+    }
+    if (directives.hasReasoningDirective && directives.reasoningLevel) {
+        if (directives.reasoningLevel === "off")
+            delete sessionEntry.reasoningLevel;
+        else
+            sessionEntry.reasoningLevel = directives.reasoningLevel;
+        reasoningChanged =
+            directives.reasoningLevel !== prevReasoningLevel && directives.reasoningLevel !== undefined;
+    }
+    if (directives.hasElevatedDirective && directives.elevatedLevel) {
+        // Unlike other toggles, elevated defaults can be "on".
+        // Persist "off" explicitly so `/elevated off` actually overrides defaults.
+        sessionEntry.elevatedLevel = directives.elevatedLevel;
+        elevatedChanged =
+            elevatedChanged ||
+                (directives.elevatedLevel !== prevElevatedLevel && directives.elevatedLevel !== undefined);
+    }
+    if (directives.hasExecDirective && directives.hasExecOptions) {
+        if (directives.execHost) {
+            sessionEntry.execHost = directives.execHost;
+        }
+        if (directives.execSecurity) {
+            sessionEntry.execSecurity = directives.execSecurity;
+        }
+        if (directives.execAsk) {
+            sessionEntry.execAsk = directives.execAsk;
+        }
+        if (directives.execNode) {
+            sessionEntry.execNode = directives.execNode;
+        }
+    }
+    if (modelSelection) {
+        applyModelOverrideToSessionEntry({
+            entry: sessionEntry,
+            selection: modelSelection,
+            profileOverride,
+        });
+    }
+    if (directives.hasQueueDirective && directives.queueReset) {
+        delete sessionEntry.queueMode;
+        delete sessionEntry.queueDebounceMs;
+        delete sessionEntry.queueCap;
+        delete sessionEntry.queueDrop;
+    }
+    else if (directives.hasQueueDirective) {
+        if (directives.queueMode)
+            sessionEntry.queueMode = directives.queueMode;
+        if (typeof directives.debounceMs === "number") {
+            sessionEntry.queueDebounceMs = directives.debounceMs;
+        }
+        if (typeof directives.cap === "number") {
+            sessionEntry.queueCap = directives.cap;
+        }
+        if (directives.dropPolicy) {
+            sessionEntry.queueDrop = directives.dropPolicy;
+        }
+    }
+    sessionEntry.updatedAt = Date.now();
+    sessionStore[sessionKey] = sessionEntry;
+    if (storePath) {
+        await updateSessionStore(storePath, (store) => {
+            store[sessionKey] = sessionEntry;
+        });
+    }
+    if (modelSelection) {
+        const nextLabel = `${modelSelection.provider}/${modelSelection.model}`;
+        if (nextLabel !== initialModelLabel) {
+            enqueueSystemEvent(formatModelSwitchEvent(nextLabel, modelSelection.alias), {
+                sessionKey,
+                contextKey: `model:${nextLabel}`,
+            });
+        }
+    }
+    if (elevatedChanged) {
+        const nextElevated = (sessionEntry.elevatedLevel ?? "off");
+        enqueueSystemEvent(formatElevatedEvent(nextElevated), {
+            sessionKey,
+            contextKey: "mode:elevated",
+        });
+    }
+    if (reasoningChanged) {
+        const nextReasoning = (sessionEntry.reasoningLevel ?? "off");
+        enqueueSystemEvent(formatReasoningEvent(nextReasoning), {
+            sessionKey,
+            contextKey: "mode:reasoning",
+        });
+    }
+    const parts = [];
+    if (directives.hasThinkDirective && directives.thinkLevel) {
+        parts.push(directives.thinkLevel === "off"
+            ? "Thinking disabled."
+            : `Thinking level set to ${directives.thinkLevel}.`);
+    }
+    if (directives.hasVerboseDirective && directives.verboseLevel) {
+        parts.push(directives.verboseLevel === "off"
+            ? formatDirectiveAck("Verbose logging disabled.")
+            : directives.verboseLevel === "full"
+                ? formatDirectiveAck("Verbose logging set to full.")
+                : formatDirectiveAck("Verbose logging enabled."));
+    }
+    if (directives.hasReasoningDirective && directives.reasoningLevel) {
+        parts.push(directives.reasoningLevel === "off"
+            ? formatDirectiveAck("Reasoning visibility disabled.")
+            : directives.reasoningLevel === "stream"
+                ? formatDirectiveAck("Reasoning stream enabled (Telegram only).")
+                : formatDirectiveAck("Reasoning visibility enabled."));
+    }
+    if (directives.hasElevatedDirective && directives.elevatedLevel) {
+        parts.push(directives.elevatedLevel === "off"
+            ? formatDirectiveAck("Elevated mode disabled.")
+            : directives.elevatedLevel === "full"
+                ? formatDirectiveAck("Elevated mode set to full (auto-approve).")
+                : formatDirectiveAck("Elevated mode set to ask (approvals may still apply)."));
+        if (shouldHintDirectRuntime)
+            parts.push(formatElevatedRuntimeHint());
+    }
+    if (directives.hasExecDirective && directives.hasExecOptions) {
+        const execParts = [];
+        if (directives.execHost)
+            execParts.push(`host=${directives.execHost}`);
+        if (directives.execSecurity)
+            execParts.push(`security=${directives.execSecurity}`);
+        if (directives.execAsk)
+            execParts.push(`ask=${directives.execAsk}`);
+        if (directives.execNode)
+            execParts.push(`node=${directives.execNode}`);
+        if (execParts.length > 0) {
+            parts.push(formatDirectiveAck(`Exec defaults set (${execParts.join(", ")}).`));
+        }
+    }
+    if (shouldDowngradeXHigh) {
+        parts.push(`Thinking level set to high (xhigh not supported for ${resolvedProvider}/${resolvedModel}).`);
+    }
+    if (modelSelection) {
+        const label = `${modelSelection.provider}/${modelSelection.model}`;
+        const labelWithAlias = modelSelection.alias ? `${modelSelection.alias} (${label})` : label;
+        parts.push(modelSelection.isDefault
+            ? `Model reset to default (${labelWithAlias}).`
+            : `Model set to ${labelWithAlias}.`);
+        if (profileOverride) {
+            parts.push(`Auth profile set to ${profileOverride}.`);
+        }
+    }
+    if (directives.hasQueueDirective && directives.queueMode) {
+        parts.push(formatDirectiveAck(`Queue mode set to ${directives.queueMode}.`));
+    }
+    else if (directives.hasQueueDirective && directives.queueReset) {
+        parts.push(formatDirectiveAck("Queue mode reset to default."));
+    }
+    if (directives.hasQueueDirective && typeof directives.debounceMs === "number") {
+        parts.push(formatDirectiveAck(`Queue debounce set to ${directives.debounceMs}ms.`));
+    }
+    if (directives.hasQueueDirective && typeof directives.cap === "number") {
+        parts.push(formatDirectiveAck(`Queue cap set to ${directives.cap}.`));
+    }
+    if (directives.hasQueueDirective && directives.dropPolicy) {
+        parts.push(formatDirectiveAck(`Queue drop set to ${directives.dropPolicy}.`));
+    }
+    const ack = parts.join(" ").trim();
+    if (!ack && directives.hasStatusDirective)
+        return undefined;
+    return { text: ack || "OK." };
+}