@songsid/agend 2.1.0-beta.39 → 2.1.0-beta.40

package/dist/fleet-manager.d.ts

@@ -95,6 +95,8 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     controlClient: TmuxControlClient | null;
     classicChannels: ClassicChannelManager | null;
     private pendingClassicStarts;
+    /** In-flight /model selections, keyed by nonce (see handleModelSelection). */
+    private pendingModelSelects;
     private failoverActive;
     readonly ipcStoppingInstances: Set<string>;
     private adapterRestarting;
@@ -364,6 +366,16 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     private forwardToClassicInstance;
     /** Paste raw text directly to a classic instance's CLI (no [user:] wrapping) */
     private pasteRawToClassicInstance;
+    /** Resolve the backend name configured for an instance (fleet or classic). */
+    private backendNameForInstance;
+    /** Best-effort model list for `/model` (empty ⇒ caller falls back to free-text). Never throws. */
+    private getModelOptions;
+    /** `/model` slash handler (admin only). No arg → DC menu; `/model <name>` → apply directly. */
+    private handleModelSlash;
+    /** Consume a `/model` selection callback. Returns true for all model-select ids (incl. stale). */
+    private handleModelSelection;
+    /** Apply a model to an instance: runtime paste (claude-code) or persist + restart (others). */
+    applyModel(instanceName: string, model: string): Promise<string>;
     /** Read recent chat log for agent context */
     private getRecentChatLog;
     /** Return a user-facing blocker without mutating ClassicBot state. */

package/dist/fleet-manager.js

@@ -19,6 +19,8 @@ import { TmuxManager } from "./tmux-manager.js";
 import { AccessManager } from "./channel/access-manager.js";
 import { IpcClient } from "./channel/ipc-bridge.js";
 import { createAdapter } from "./channel/factory.js";
+import { createBackend } from "./backend/factory.js";
+import { isModelCompatible } from "./backend/types.js";
 import { createLogger } from "./logger.js";
 import { processAttachments } from "./channel/attachment-handler.js";
 import { routeToolCall } from "./channel/tool-router.js";
@@ -82,6 +84,7 @@ const CANCEL_BTN_MAX_RETRIES = 3;
 const CANCEL_BTN_IDLE_CHECK_INTERVAL_MS = 5 * 60_000;
 const CLASSIC_BACKEND_SELECTION_TIMEOUT_MS = 60_000;
 const CLASSIC_BACKEND_CALLBACK_PREFIX = "classic-backend:";
+const MODEL_SELECT_CALLBACK_PREFIX = "model-select:";
 export class FleetManager {
     dataDir;
     children = new Map();
@@ -144,6 +147,8 @@ export class FleetManager {
     controlClient = null;
     classicChannels = null;
     pendingClassicStarts = new Map();
+    /** In-flight /model selections, keyed by nonce (see handleModelSelection). */
+    pendingModelSelects = new Map();
     // Model failover state
     failoverActive = new Map(); // instance → current failover model
     // IPC reconnect: tracks instances being intentionally stopped (skip reconnect)
@@ -1341,6 +1346,8 @@ export class FleetManager {
         this.adapter.on("callback_query", safeHandler(async (data) => {
             if (await this.handleClassicBackendSelection(data))
                 return;
+            if (await this.handleModelSelection(data))
+                return;
             if (data.callbackData.startsWith("hang:")) {
                 const parts = data.callbackData.split(":");
                 const action = parts[1];
@@ -1443,6 +1450,9 @@ export class FleetManager {
                 const result = await this.topicCommands.sendCompact(name);
                 await data.respond(result);
             }
+            else if (data.command === "model") {
+                await this.handleModelSlash(data, adapterId);
+            }
             else if (data.command === "cancel") {
                 const name = this.resolveSlashTarget(data.channelId, adapterId);
                 if (!name) {
@@ -1628,6 +1638,8 @@ export class FleetManager {
         adapter.on("callback_query", safeHandler(async (data) => {
             if (await this.handleClassicBackendSelection(data))
                 return;
+            if (await this.handleModelSelection(data))
+                return;
             if (data.callbackData.startsWith("hang:")) {
                 const parts = data.callbackData.split(":");
                 const action = parts[1];
@@ -1717,6 +1729,9 @@ export class FleetManager {
                 this.pasteRawToClassicInstance(name, `/chat load ${filename}`);
                 await data.respond(t("save.sent", `/chat load ${filename}`, name));
             }
+            else if (data.command === "model") {
+                await this.handleModelSlash(data, adapterId);
+            }
             else if (data.command === "cancel") {
                 const name = this.resolveSlashTarget(data.channelId, adapterId);
                 if (!name) {
@@ -4183,6 +4198,131 @@ When users create specialized instances, suggest these configurations:
         ipc.send({ type: "raw_paste", content: text });
         this.logger.info({ instanceName, text: text.slice(0, 100) }, "Raw paste sent to classic instance");
     }
+    /** Resolve the backend name configured for an instance (fleet or classic). */
+    backendNameForInstance(instanceName) {
+        const fleetCfg = this.fleetConfig?.instances[instanceName];
+        if (fleetCfg?.backend)
+            return fleetCfg.backend;
+        const classic = this.classicChannels?.getChannelIdByInstance(instanceName) !== undefined
+            ? this.classicChannels?.getBackendByInstance(instanceName, this.fleetConfig?.defaults?.backend)
+            : undefined;
+        return classic ?? this.fleetConfig?.defaults?.backend ?? "claude-code";
+    }
+    /** Best-effort model list for `/model` (empty ⇒ caller falls back to free-text). Never throws. */
+    async getModelOptions(instanceName) {
+        try {
+            const backend = createBackend(this.backendNameForInstance(instanceName), this.getInstanceDir(instanceName));
+            if (!backend.listModels)
+                return [];
+            return (await backend.listModels({
+                workingDirectory: this.fleetConfig?.instances[instanceName]?.working_directory ?? "",
+                instanceDir: this.getInstanceDir(instanceName),
+                instanceName,
+                mcpServers: {},
+            })) ?? [];
+        }
+        catch (err) {
+            this.logger.warn({ err, instanceName }, "listModels failed");
+            return [];
+        }
+    }
+    /** `/model` slash handler (admin only). No arg → DC menu; `/model <name>` → apply directly. */
+    async handleModelSlash(data, adapterId) {
+        if (!this.isFleetAdmin(data.userId, adapterId)) {
+            await data.respond(t("admin.required"));
+            return;
+        }
+        const name = this.resolveSlashTarget(data.channelId, adapterId);
+        if (!name) {
+            await data.respond(t("classic.no_agent"));
+            return;
+        }
+        const requested = (typeof data.options?.name === "string" ? data.options.name.trim() : "")
+            || (data.text?.trim() ?? "");
+        if (requested) {
+            await data.respond(await this.applyModel(name, requested));
+            return;
+        }
+        // No arg → menu. Menu is DC-only this round (respondChoices); TG uses `/model <name>`.
+        if (!data.respondChoices) {
+            await data.respond("Usage: /model <name> — e.g. /model sonnet");
+            return;
+        }
+        const options = await this.getModelOptions(name);
+        if (options.length === 0) {
+            await data.respond(`No model list available for ${name}. Type \`/model <name>\` to set one directly.`);
+            return;
+        }
+        const nonce = randomBytes(6).toString("hex");
+        const choices = options.slice(0, 25).map(o => ({
+            id: `${MODEL_SELECT_CALLBACK_PREFIX}${nonce}:${o.id}`,
+            label: o.description ? `${o.label} — ${o.description}` : o.label,
+        }));
+        const timer = setTimeout(() => this.pendingModelSelects.delete(nonce), CLASSIC_BACKEND_SELECTION_TIMEOUT_MS);
+        timer.unref?.();
+        this.pendingModelSelects.set(nonce, { instanceName: name, model: "", userId: data.userId, channelId: data.channelId, timer, respond: data.respond });
+        try {
+            await data.respondChoices(`Choose a model for ${name}:`, choices);
+        }
+        catch (err) {
+            this.pendingModelSelects.delete(nonce);
+            clearTimeout(timer);
+            this.logger.warn({ err, instanceName: name }, "model menu failed");
+            await data.respond("Usage: /model <name> — e.g. /model sonnet");
+        }
+    }
+    /** Consume a `/model` selection callback. Returns true for all model-select ids (incl. stale). */
+    async handleModelSelection(data) {
+        if (!data.callbackData.startsWith(MODEL_SELECT_CALLBACK_PREFIX))
+            return false;
+        const match = data.callbackData.match(/^model-select:([0-9a-f]+):(.+)$/);
+        if (!match)
+            return true;
+        const pending = this.pendingModelSelects.get(match[1]);
+        if (!pending)
+            return true;
+        // Only the admin who opened the menu, in the same channel, may consume it.
+        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.pendingModelSelects.delete(match[1]);
+        clearTimeout(pending.timer);
+        const result = await this.applyModel(pending.instanceName, match[2]);
+        await pending.respond(result).catch(() => { });
+        return true;
+    }
+    /** Apply a model to an instance: runtime paste (claude-code) or persist + restart (others). */
+    async applyModel(instanceName, model) {
+        const backendName = this.backendNameForInstance(instanceName);
+        let strategy = "restart";
+        try {
+            strategy = createBackend(backendName, this.getInstanceDir(instanceName)).getModelSwitchStrategy?.(model) ?? "restart";
+        }
+        catch { /* default restart */ }
+        const warn = isModelCompatible(backendName, model) ? "" : `⚠️ "${model}" doesn't match ${backendName}'s usual pattern — passing through anyway.\n`;
+        if (strategy === "runtime") {
+            if (!this.instanceIpcClients.get(instanceName))
+                return `${warn}❌ ${instanceName} is not running.`;
+            this.pasteRawToClassicInstance(instanceName, `/model ${model}`);
+            return `${warn}✅ Switched ${instanceName} to \`${model}\` (runtime).`;
+        }
+        // restart: persist the model so the respawned CLI launches with it.
+        let persisted = false;
+        if (this.fleetConfig?.instances[instanceName]) {
+            this.fleetConfig.instances[instanceName].model = model;
+            this.saveFleetConfig();
+            persisted = true;
+        }
+        else if (this.classicChannels?.setModelByInstance(instanceName, model)) {
+            persisted = true;
+        }
+        if (!persisted)
+            return `${warn}❌ Could not set model for ${instanceName}.`;
+        await this.restartSingleInstance(instanceName);
+        return `${warn}✅ Set ${instanceName} to \`${model}\` and restarted.`;
+    }
     /** Read recent chat log for agent context */
     getRecentChatLog(instanceName, maxLines = 10) {
         const logDir = ClassicChannelManager.chatLogDir(instanceName);