@songsid/agend 2.1.2-beta.22 → 2.1.2-beta.24

package/dist/fleet-manager.js

@@ -146,6 +146,7 @@ const IPC_RECONNECT_POLL_MS = 250;
 const CLASSIC_BACKEND_SELECTION_TIMEOUT_MS = 60_000;
 const CLASSIC_BACKEND_CALLBACK_PREFIX = "classic-backend:";
 const MODEL_SELECT_CALLBACK_PREFIX = "model-select:";
+const EFFORT_SELECT_CALLBACK_PREFIX = "effort-select:";
 const CLI_ENV_TTL_MS = 24 * 60 * 60 * 1000; // /model reads cached CLI env within 24h
 export class FleetManager {
     dataDir;
@@ -224,6 +225,8 @@ export class FleetManager {
     classicChannels = null;
     pendingClassicStarts = new Map();
     /** In-flight /model selections, keyed by nonce (see handleModelSelection). */
+    /** In-flight /effort selections, same coordinator shape as pendingModelSelects. */
+    pendingEffortSelects = new Map();
     pendingModelSelects = new Map();
     // Model failover state
     failoverActive = new Map(); // instance → current failover model
@@ -1679,6 +1682,8 @@ export class FleetManager {
                 return;
             if (await this.handleModelSelection(data))
                 return;
+            if (await this.handleEffortSelection(data))
+                return;
             if (data.callbackData.startsWith("hang:")) {
                 const parts = data.callbackData.split(":");
                 const action = parts[1];
@@ -1784,6 +1789,9 @@ export class FleetManager {
             else if (data.command === "model") {
                 await this.handleModelSlash(data, adapterId);
             }
+            else if (data.command === "effort") {
+                await this.handleEffortSlash(data, adapterId);
+            }
             else if (data.command === "cancel") {
                 const name = this.resolveSlashTarget(data.channelId, adapterId);
                 if (!name) {
@@ -1987,6 +1995,8 @@ export class FleetManager {
                 return;
             if (await this.handleModelSelection(data))
                 return;
+            if (await this.handleEffortSelection(data))
+                return;
             if (data.callbackData.startsWith("hang:")) {
                 const parts = data.callbackData.split(":");
                 const action = parts[1];
@@ -2079,6 +2089,9 @@ export class FleetManager {
             else if (data.command === "model") {
                 await this.handleModelSlash(data, adapterId);
             }
+            else if (data.command === "effort") {
+                await this.handleEffortSlash(data, adapterId);
+            }
             else if (data.command === "cancel") {
                 const name = this.resolveSlashTarget(data.channelId, adapterId);
                 if (!name) {
@@ -5227,6 +5240,170 @@ When users create specialized instances, suggest these configurations:
         return env?.models ?? [];
     }
     /** `/model` slash handler (admin only). No arg → DC menu; `/model <name>` → apply directly. */
+    /** Label an effort choice, marking the one currently configured. */
+    effortChoiceLabel(level, current) {
+        return level === current ? `✓ ${level}` : level;
+    }
+    effortMenuHeader(instanceName) {
+        const { effort, source } = this.resolveInstanceEffort(instanceName);
+        if (!effort)
+            return "Current effort: (CLI default)";
+        return source === "fleet-default"
+            ? `Current effort: ${effort} (fleet default)`
+            : `Current effort: ${effort}`;
+    }
+    /** `/effort` — DC Select Menu, or apply directly when a level is given. */
+    async handleEffortSlash(data, adapterId) {
+        if (!this.isModelAdmin(data.userId, data.channelId, adapterId)) {
+            await data.respond(t("permission.denied"));
+            return;
+        }
+        const name = this.resolveSlashTarget(data.channelId, adapterId);
+        if (!name) {
+            await data.respond(t("classic.no_agent"));
+            return;
+        }
+        const requested = (typeof data.options?.level === "string" ? data.options.level.trim() : "")
+            || (data.text?.trim() ?? "");
+        if (requested) {
+            await data.respond(await this.applyEffort(name, requested));
+            return;
+        }
+        const levels = this.effortLevelsFor(name);
+        if (levels.length === 0) {
+            await data.respond(`❌ ${this.backendNameForInstance(name)} has no reasoning-effort setting.`);
+            return;
+        }
+        if (!data.respondChoices) {
+            await data.respond(`Usage: /effort <${levels.join("|")}>`);
+            return;
+        }
+        const current = this.resolveInstanceEffort(name).effort;
+        const nonce = randomBytes(6).toString("hex");
+        const choices = levels.map(l => ({
+            id: `${EFFORT_SELECT_CALLBACK_PREFIX}${nonce}:${l}`,
+            label: this.effortChoiceLabel(l, current),
+        }));
+        const timer = setTimeout(() => this.pendingEffortSelects.delete(nonce), CLASSIC_BACKEND_SELECTION_TIMEOUT_MS);
+        timer.unref?.();
+        this.pendingEffortSelects.set(nonce, { instanceName: name, userId: data.userId, channelId: data.channelId, timer, respond: data.respond });
+        try {
+            await data.respondChoices(`${this.effortMenuHeader(name)}\nSelect a new effort level:`, choices);
+        }
+        catch (err) {
+            this.pendingEffortSelects.delete(nonce);
+            clearTimeout(timer);
+            this.logger.warn({ err, instanceName: name }, "effort menu failed");
+            await data.respond(`Usage: /effort <${levels.join("|")}>`);
+        }
+    }
+    /** TG inline-keyboard effort menu. Returns null on success, else a fallback string. */
+    async promptEffortMenu(instanceName, userId, channelId, adapter, chatId, threadId) {
+        const levels = this.effortLevelsFor(instanceName);
+        if (levels.length === 0) {
+            return `❌ ${this.backendNameForInstance(instanceName)} has no reasoning-effort setting.`;
+        }
+        const current = this.resolveInstanceEffort(instanceName).effort;
+        const nonce = randomBytes(6).toString("hex");
+        const choices = levels.map(l => ({
+            id: `${EFFORT_SELECT_CALLBACK_PREFIX}${nonce}:${l}`,
+            label: this.effortChoiceLabel(l, current),
+        }));
+        const respond = async (text) => {
+            await adapter.sendText(chatId, text, { threadId });
+            return undefined;
+        };
+        const timer = setTimeout(() => {
+            const p = this.pendingEffortSelects.get(nonce);
+            if (p) {
+                this.pendingEffortSelects.delete(nonce);
+                p.respond("⏰ Effort selection expired.").catch(() => { });
+            }
+        }, CLASSIC_BACKEND_SELECTION_TIMEOUT_MS);
+        timer.unref?.();
+        this.pendingEffortSelects.set(nonce, { instanceName, userId, channelId, timer, respond, adapter, adapterChatId: chatId, adapterThreadId: threadId });
+        try {
+            const menuMessageId = await adapter.promptUser(chatId, `${this.effortMenuHeader(instanceName)}\nSelect a new effort level:`, choices, { threadId });
+            const pending = this.pendingEffortSelects.get(nonce);
+            if (pending)
+                pending.menuMessageId = menuMessageId;
+            return null;
+        }
+        catch (err) {
+            this.pendingEffortSelects.delete(nonce);
+            clearTimeout(timer);
+            this.logger.warn({ err, instanceName }, "TG effort menu failed");
+            return `Usage: /effort <${levels.join("|")}>`;
+        }
+    }
+    /** Consume an `/effort` selection callback. Mirrors handleModelSelection. */
+    async handleEffortSelection(data) {
+        if (!data.callbackData.startsWith(EFFORT_SELECT_CALLBACK_PREFIX))
+            return false;
+        const match = data.callbackData.match(/^effort-select:([0-9a-f]+):(.+)$/);
+        if (!match)
+            return true;
+        const pending = this.pendingEffortSelects.get(match[1]);
+        if (!pending)
+            return true;
+        if (data.userId && data.userId !== pending.userId)
+            return true;
+        const cbChannel = data.threadId ?? data.chatId;
+        if (cbChannel !== pending.channelId && data.chatId !== pending.channelId)
+            return true;
+        this.pendingEffortSelects.delete(match[1]);
+        clearTimeout(pending.timer);
+        const level = match[2];
+        const progressText = `⏳ Setting ${pending.instanceName} effort to \`${level}\`…`;
+        let progressMsgId;
+        if (pending.adapter && pending.adapterChatId) {
+            const menuMessageId = pending.menuMessageId ?? data.messageId;
+            if (menuMessageId && pending.adapter.editMessageRemoveButtons) {
+                try {
+                    await pending.adapter.editMessageRemoveButtons(pending.adapterChatId, menuMessageId, progressText, pending.adapterThreadId);
+                    progressMsgId = menuMessageId;
+                }
+                catch { /* fall back to a new message */ }
+            }
+            if (!progressMsgId) {
+                try {
+                    const sent = await pending.adapter.sendText(pending.adapterChatId, progressText, { threadId: pending.adapterThreadId });
+                    progressMsgId = sent.messageId;
+                }
+                catch { /* non-fatal */ }
+            }
+        }
+        else {
+            await pending.respond(progressText).catch(() => { });
+        }
+        // Background-applied and guarded for the same reason as the model path: a
+        // restart backend respawns the instance here, and an unguarded rejection
+        // from a menu click must not take the fleet down.
+        void (async () => {
+            let result;
+            try {
+                result = await this.applyEffort(pending.instanceName, level);
+            }
+            catch (err) {
+                this.logger.error({ err, instance: pending.instanceName, level }, "Effort switch failed");
+                result = `Effort switch to \`${level}\` failed: ${err instanceof Error ? err.message : String(err)}`;
+            }
+            if (pending.adapter && pending.adapterChatId) {
+                if (progressMsgId) {
+                    pending.adapter.editMessage(pending.adapterChatId, progressMsgId, result, pending.adapterThreadId).catch(() => {
+                        pending.adapter.sendText(pending.adapterChatId, result, { threadId: pending.adapterThreadId }).catch(() => { });
+                    });
+                }
+                else {
+                    pending.adapter.sendText(pending.adapterChatId, result, { threadId: pending.adapterThreadId }).catch(() => { });
+                }
+            }
+            else {
+                await pending.respond(result).catch(() => { });
+            }
+        })();
+        return true;
+    }
     async handleModelSlash(data, adapterId) {
         if (!this.isModelAdmin(data.userId, data.channelId, adapterId)) {
             await data.respond(t("permission.denied"));
@@ -5393,6 +5570,96 @@ When users create specialized instances, suggest these configurations:
         return true;
     }
     /** Apply a model to an instance: runtime paste (claude-code) or persist + restart (others). */
+    /** AgEnD's canonical effort ladder, low → max. Backends expose a subset. */
+    static EFFORT_LEVELS = ["low", "medium", "high", "xhigh", "max"];
+    /** Effort levels this instance's backend actually accepts (empty = unsupported). */
+    effortLevelsFor(instanceName) {
+        try {
+            const backend = createBackend(this.backendNameForInstance(instanceName), this.getInstanceDir(instanceName));
+            if ((backend.getEffortStrategy?.() ?? "unsupported") === "unsupported")
+                return [];
+            return backend.getEffortLevels?.() ?? [];
+        }
+        catch {
+            return [];
+        }
+    }
+    /** Configured effort for an instance: per-instance, else fleet default, else none. */
+    resolveInstanceEffort(instanceName) {
+        const own = this.fleetConfig?.instances[instanceName]?.effort;
+        if (own)
+            return { effort: own, source: "instance" };
+        const fallback = this.fleetConfig?.defaults?.effort;
+        if (fallback)
+            return { effort: fallback, source: "fleet-default" };
+        return { effort: null, source: "unset" };
+    }
+    /**
+     * Clamp a canonical level to the nearest one this backend supports.
+     *
+     * Clamping DOWN the ladder, never up: asking for `max` on a CLI that stops at
+     * `high` should get high, not silently fall to low. The caller reports the
+     * clamp — a user who asks for max and quietly receives high has been told the
+     * request succeeded when it did not.
+     */
+    static clampEffort(level, supported) {
+        if (supported.includes(level))
+            return level;
+        const ladder = FleetManager.EFFORT_LEVELS;
+        const wanted = ladder.indexOf(level);
+        if (wanted < 0)
+            return null;
+        for (let i = wanted - 1; i >= 0; i--) {
+            if (supported.includes(ladder[i]))
+                return ladder[i];
+        }
+        return supported[0] ?? null;
+    }
+    /**
+     * Apply a reasoning-effort level, mirroring applyModel's shape.
+     *
+     * runtime backends take `/effort <level>` in the pane and keep working;
+     * restart backends only read it at launch, so it is persisted and the
+     * instance respawns.
+     */
+    async applyEffort(instanceName, requested) {
+        const level = requested.trim().toLowerCase();
+        const backendName = this.backendNameForInstance(instanceName);
+        let strategy = "unsupported";
+        let supported = [];
+        try {
+            const backend = createBackend(backendName, this.getInstanceDir(instanceName));
+            strategy = backend.getEffortStrategy?.() ?? "unsupported";
+            supported = backend.getEffortLevels?.() ?? [];
+        }
+        catch { /* treated as unsupported below */ }
+        if (strategy === "unsupported" || supported.length === 0) {
+            return `❌ ${backendName} has no reasoning-effort setting.`;
+        }
+        if (!FleetManager.EFFORT_LEVELS.includes(level)) {
+            return `❌ Unknown effort level \`${level}\`. Use: ${FleetManager.EFFORT_LEVELS.join(", ")}.`;
+        }
+        const applied = FleetManager.clampEffort(level, supported);
+        if (!applied)
+            return `❌ ${backendName} accepts none of the canonical effort levels.`;
+        const warn = applied === level
+            ? ""
+            : `⚠️ Clamped to \`${applied}\` (\`${level}\` not supported by ${backendName}).\n`;
+        // Persist either way: a runtime switch must survive the next respawn too,
+        // or the instance silently reverts on restart.
+        if (this.fleetConfig?.instances[instanceName]) {
+            this.fleetConfig.instances[instanceName].effort = applied;
+            this.saveFleetConfig();
+        }
+        if (strategy === "runtime") {
+            if (!this.instanceIpcClients.get(instanceName))
+                return `${warn}❌ ${instanceName} is not running.`;
+            this.pasteRawToClassicInstance(instanceName, `/effort ${applied}`);
+            return `${warn}✅ Set ${instanceName} effort to \`${applied}\` (runtime).`;
+        }
+        await this.restartSingleInstance(instanceName);
+        return `${warn}✅ Set ${instanceName} effort to \`${applied}\` and restarted.`;
+    }
     async applyModel(instanceName, model) {
         const backendName = this.backendNameForInstance(instanceName);
         let strategy = "restart";