@songsid/agend 2.1.4-beta.9 → 2.1.4

package/dist/outbound-handlers.d.ts

@@ -22,6 +22,8 @@ export interface OutboundContext {
             name: string;
             backend?: string;
             model?: string;
+            displayName?: string;
+            description?: string;
             channelId: string;
             adapterId?: string;
         }[];
@@ -34,7 +36,9 @@ export interface OutboundContext {
     restartSingleInstance(name: string): Promise<void>;
     connectIpcToInstance(name: string): Promise<void>;
     /** FleetManager facade that wakes paused instances before delivery. */
-    deliverToInstance?(instanceName: string, payload: Record<string, unknown>): Promise<void>;
+    deliverToInstance?(instanceName: string, payload: Record<string, unknown>, options?: OutboundDeliveryOptions): Promise<void>;
+    /** True while an earlier idle-gated delivery still owns this target's FIFO tail. */
+    hasPendingIdleGatedDelivery?(instanceName: string): boolean;
     saveFleetConfig(): void;
     queueMirrorMessage?(text: string): void;
     getAdapterForInstance?(name: string): ChannelAdapter | null;
@@ -50,6 +54,8 @@ export interface OutboundContext {
     clearCancelButton?(instanceName: string): void;
     clearCancelButtonByCorrelation?(correlationId: string): void;
     getInstanceExecutionState?(name: string): "idle" | "working" | "stuck" | "paused" | null;
+    /** Subscription provider IDs used by running or paused fleet/Classic instances. */
+    getActiveUsageProviderIds?(): ReadonlySet<string>;
     /** Effective process state used to annotate cross-instance delivery results. */
     getInstanceStatus?(name: string): "running" | "paused" | "stopped" | "crashed";
     resolveInstanceModel?(name: string): {
@@ -58,6 +64,15 @@ export interface OutboundContext {
         display: string;
         reason?: string;
     };
+    listModelCatalog?(opts: {
+        backend?: string;
+        instanceName?: string;
+    }): Promise<import("./fleet-manager.js").ModelCatalog>;
+}
+interface OutboundDeliveryOptions {
+    isCrossInstance?: boolean;
+    waitForIdle?: boolean;
+    idleTimeoutMs?: number;
 }
 /** Metadata extracted from the raw outbound message. */
 export interface OutboundMeta {

package/dist/outbound-handlers.js

@@ -1,8 +1,36 @@
 import { resolve as pathResolve, isAbsolute } from "node:path";
 import { homedir } from "node:os";
 import { GENERAL_PAUSE_ERROR, isGeneralInstance } from "./general-instance.js";
-import { BroadcastArgs, CreateInstanceArgs, CreateTeamArgs, DelegateTaskArgs, DeleteInstanceArgs, DeleteTeamArgs, DeployTemplateArgs, DescribeInstanceArgs, ListDeploymentsArgs, ListInstancesArgs, ListTeamsArgs, ReplaceInstanceArgs, ReportResultArgs, RequestInformationArgs, RestartInstanceArgs, SendToInstanceArgs, PauseInstanceArgs, WakeInstanceArgs, StopInstanceArgs, GetInstanceLogsArgs, GetEffortArgs, GetUsageArgs, GetFleetConfigArgs, UpdateInstanceConfigArgs, UpdateFleetDefaultsArgs, StartInstanceArgs, TeardownDeploymentArgs, UpdateTeamArgs, validateArgs, } from "./outbound-schemas.js";
+import { DEFAULT_MAX_CROSS_INSTANCE_MESSAGE_BYTES } from "./config.js";
+import { t } from "./locale.js";
+import { truncatePreview } from "./channel/markdown-chunk.js";
+import { backendSupportsSteer } from "./steer-capability.js";
+import { formatCrossInstanceInboundMessage, MAX_ASSEMBLED_CROSS_INSTANCE_MESSAGE_BYTES, } from "./cross-instance-envelope.js";
+import { BroadcastArgs, CreateInstanceArgs, CreateTeamArgs, DelegateTaskArgs, DeleteInstanceArgs, DeleteTeamArgs, DeployTemplateArgs, DescribeInstanceArgs, ListDeploymentsArgs, ListInstancesArgs, ListTeamsArgs, ReplaceInstanceArgs, ReportResultArgs, RequestInformationArgs, RestartInstanceArgs, SendToInstanceArgs, PauseInstanceArgs, WakeInstanceArgs, StopInstanceArgs, GetInstanceLogsArgs, GetEffortArgs, GetUsageArgs, ListModelsArgs, GetFleetConfigArgs, UpdateInstanceConfigArgs, UpdateFleetDefaultsArgs, StartInstanceArgs, TeardownDeploymentArgs, UpdateTeamArgs, validateArgs, } from "./outbound-schemas.js";
 const HOME_DIR = homedir();
+function formatByteSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    const kib = bytes / 1024;
+    return `${Number.isInteger(kib) ? kib : kib.toFixed(1)} KiB`;
+}
+/** Hard rejects must happen while the originating MCP request can still fail. */
+function rejectOversizedCrossInstanceMessage(ctx, message, respond) {
+    const limit = ctx.fleetConfig?.defaults?.max_cross_instance_message_bytes
+        ?? DEFAULT_MAX_CROSS_INSTANCE_MESSAGE_BYTES;
+    const actual = Buffer.byteLength(message, "utf8");
+    if (actual <= limit)
+        return false;
+    respond(null, t("cross_instance.message_too_large", formatByteSize(actual), formatByteSize(limit)));
+    return true;
+}
+function rejectOversizedCrossInstanceEnvelope(message, meta, respond) {
+    const actual = Buffer.byteLength(formatCrossInstanceInboundMessage(message, meta), "utf8");
+    if (actual <= MAX_ASSEMBLED_CROSS_INSTANCE_MESSAGE_BYTES)
+        return false;
+    respond(null, t("cross_instance.envelope_too_large", formatByteSize(actual), formatByteSize(MAX_ASSEMBLED_CROSS_INSTANCE_MESSAGE_BYTES)));
+    return true;
+}
 /**
  * Sanitize an error for inclusion in outbound responses sent to agents.
  * Logs the full error server-side, then returns a redacted message that
@@ -24,9 +52,12 @@ function sanitizeError(err, ctx, operation) {
  * The fallback keeps standalone handler harnesses/backward-compatible embedders
  * working; FleetManager always supplies the facade in production.
  */
-async function deliverToInstance(ctx, instanceName, payload) {
+async function deliverToInstance(ctx, instanceName, payload, options) {
     if (ctx.deliverToInstance) {
-        await ctx.deliverToInstance(instanceName, payload);
+        if (options)
+            await ctx.deliverToInstance(instanceName, payload, options);
+        else
+            await ctx.deliverToInstance(instanceName, payload);
         return;
     }
     const ipc = ctx.instanceIpcClients.get(instanceName);
@@ -73,10 +104,10 @@ export function setCrossInstanceRetryForTests(cfg) {
  * sender's and the target's topic so the agent that sent it and any watching human
  * both find out.
  */
-async function deliverCrossInstanceWithRetry(ctx, targetInstanceName, targetLabel, senderLabel, correlationId, payload) {
+async function deliverCrossInstanceWithRetry(ctx, targetInstanceName, targetLabel, senderLabel, correlationId, payload, deliveryOptions) {
     const attempt = async () => {
         try {
-            await deliverToInstance(ctx, targetInstanceName, payload);
+            await deliverToInstance(ctx, targetInstanceName, payload, deliveryOptions);
             return null;
         }
         catch (err) {
@@ -106,6 +137,21 @@ async function deliverCrossInstanceWithRetry(ctx, targetInstanceName, targetLabe
     if (targetInstanceName !== senderLabel)
         ctx.notifyInstanceTopic?.(targetInstanceName, notice);
 }
+function effectiveBackendForTarget(ctx, instanceName) {
+    const configured = ctx.fleetConfig?.instances?.[instanceName]?.backend;
+    if (configured)
+        return configured;
+    const classic = ctx.classicChannels?.getAll().find(channel => channel.instanceName === instanceName);
+    if (classic) {
+        if (classic.backend)
+            return classic.backend;
+        return ctx.classicChannels?.getBackendByInstance?.(instanceName, ctx.fleetConfig?.defaults?.backend) ?? (ctx.fleetConfig ? ctx.fleetConfig.defaults?.backend ?? "claude-code" : undefined);
+    }
+    if (ctx.fleetConfig?.instances?.[instanceName]) {
+        return ctx.fleetConfig.defaults?.backend ?? "claude-code";
+    }
+    return undefined;
+}
 // ── Handler implementations ─────────────────────────────────────────────
 const sendToInstance = async (ctx, rawArgs, respond, meta) => {
     const v = validateArgs(SendToInstanceArgs, rawArgs, "send_to_instance");
@@ -113,7 +159,9 @@ const sendToInstance = async (ctx, rawArgs, respond, meta) => {
         respond(null, v.error);
         return;
     }
-    const { instance_name: targetName, message, request_kind: reqKind, requires_reply, task_summary, working_directory, branch, correlation_id: parsedCorrelationId } = v.data;
+    const { instance_name: targetName, message, steer, request_kind: reqKind, requires_reply, task_summary, working_directory, branch, correlation_id: parsedCorrelationId } = v.data;
+    if (rejectOversizedCrossInstanceMessage(ctx, message, respond))
+        return;
     const senderLabel = meta.senderSessionName ?? meta.instanceName;
     const isExternalSender = meta.senderSessionName != null && meta.senderSessionName !== meta.instanceName;
     let targetIpc = ctx.instanceIpcClients.get(targetName);
@@ -145,6 +193,33 @@ const sendToInstance = async (ctx, rawArgs, respond, meta) => {
         respond(null, `Instance '${targetName}' is stopped (target_state=stopped). Use start_instance('${targetName}') to start it first.`);
         return;
     }
+    // Pane steering can target only the hosting instance's own CLI. External MCP
+    // sessions share that daemon but are separate conversations, so steering the
+    // host pane would deliver to the wrong recipient; safely keep their ordinary
+    // targetSession-aware idle queue instead.
+    const isExternalSession = targetSession !== targetInstanceName;
+    const targetBackend = steer === true
+        ? effectiveBackendForTarget(ctx, targetInstanceName)
+        : undefined;
+    const steerCapable = steer === true
+        && !isExternalSession
+        && targetBackend !== undefined
+        && backendSupportsSteer(targetBackend);
+    // A supplement must not jump ahead of the work it is meant to amend. The
+    // facade publishes its idle-gated tail synchronously, so a send immediately
+    // followed by steer observes the predecessor and joins the same FIFO queue.
+    const queuedPredecessor = steerCapable
+        && ctx.hasPendingIdleGatedDelivery?.(targetInstanceName) === true;
+    const useSteer = steerCapable && !queuedPredecessor;
+    const steerFallbackWarning = steer === true && !useSteer
+        ? isExternalSession
+            ? "Steer was not applied because external sessions cannot be targeted safely at pane level. The message was safely queued for idle delivery instead."
+            : queuedPredecessor
+                ? "Steer was not applied because a previous message to this target is still queued and steering would overtake it. The supplement was safely queued behind it for idle delivery instead."
+                : targetBackend === undefined
+                    ? "Steer was not applied because the target backend could not be confirmed. The message was safely queued for idle delivery instead."
+                    : `Steer was not applied because the '${targetBackend}' backend cannot accept mid-turn input. The message was safely queued for idle delivery instead.`
+        : undefined;
     const correlationId = parsedCorrelationId || `cid-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
     const ipcMeta = {
         chat_id: "",
@@ -171,6 +246,8 @@ const sendToInstance = async (ctx, rawArgs, respond, meta) => {
     const senderDisplay = ctx.fleetConfig?.instances[senderLabel]?.display_name;
     if (senderDisplay && senderDisplay !== senderLabel)
         ipcMeta.from_display = senderDisplay;
+    if (rejectOversizedCrossInstanceEnvelope(message, ipcMeta, respond))
+        return;
     // Fire-and-queue: hand the message to the fleet and respond immediately.
     // deliverToInstance owns waking a paused target, the idle gate and retries;
     // awaiting it here blocked this call for as long as the target stayed busy
@@ -180,7 +257,7 @@ const sendToInstance = async (ctx, rawArgs, respond, meta) => {
     // failing past this point is a delivery problem to log, not a caller error.
     // Retries and, on final failure, tells both agents' topics — see
     // deliverCrossInstanceWithRetry. It never rejects, so nothing escapes here.
-    void deliverCrossInstanceWithRetry(ctx, targetInstanceName, targetName, senderLabel, correlationId, { type: "fleet_inbound", targetSession, content: message, meta: ipcMeta });
+    void deliverCrossInstanceWithRetry(ctx, targetInstanceName, targetName, senderLabel, correlationId, { type: useSteer ? "steer" : "fleet_inbound", targetSession, content: message, meta: ipcMeta }, useSteer ? { isCrossInstance: true, waitForIdle: false } : undefined);
     // Show a cancel button on the target's topic so a watching user can interrupt
     // work started by another instance — but only for messages that actually put
     // the recipient to work (task/query). Informational report/update messages
@@ -219,7 +296,7 @@ const sendToInstance = async (ctx, rawArgs, respond, meta) => {
                 const showFull = requestKind === "task" || requestKind === "query";
                 const text = showFull
                     ? `${notificationLabel}:\n${message}`
-                    : `${notificationLabel}: ${ipcMeta.task_summary ?? `${message.slice(0, 100)}${message.length > 100 ? "…" : ""}`}`;
+                    : `${notificationLabel}: ${ipcMeta.task_summary ?? truncatePreview(message, 100)}`;
                 targetAdapter.sendText(String(targetGroupId), text, { threadId: String(targetTopicId) })
                     .catch(e => ctx.logger.warn({ err: e }, "Failed to post target topic notification"));
             }
@@ -238,22 +315,23 @@ const sendToInstance = async (ctx, rawArgs, respond, meta) => {
     ctx.logger.info(`✉ ${senderLabel} → ${targetName}: ${(message ?? "").slice(0, 100)}`);
     const taskSummary = ipcMeta.task_summary || (message ?? "").slice(0, 200);
     ctx.eventLog?.logActivity("message", senderLabel, taskSummary, targetName, ipcMeta.request_kind);
-    ctx.queueMirrorMessage?.(`${senderLabel} → ${targetName}: ${(message ?? "").slice(0, 500)}${(message ?? "").length > 500 ? " […]" : ""}`);
+    ctx.queueMirrorMessage?.(`${senderLabel} → ${targetName}: ${truncatePreview(message ?? "", 500)}`);
+    const targetDaemon = ctx.lifecycle.daemons.get(targetInstanceName);
+    const targetStateWarning = targetDaemon?.isErrorState
+        ? targetDaemon.isCrashLoop
+            ? `${targetName} is in a crash loop — restart or replace required. Message delivered but may not be processed.`
+            : targetDaemon.lastErrorType === "rate_limit" || targetDaemon.lastErrorType === "timeout"
+                ? `${targetName} is rate-limited by provider — paused. Message delivered but may be delayed.`
+                : targetDaemon.lastErrorType === "auth_error"
+                    ? `${targetName} has an authentication error — paused. Check credentials. Message delivered but may not be processed.`
+                    : `${targetName} is in an error state (paused due to repeated errors). Message delivered but may not be processed.`
+        : undefined;
+    const warnings = [steerFallbackWarning, targetStateWarning].filter((value) => !!value);
     respond({ sent: true, queued: true, target: targetName, target_state: state,
         ...(state === "paused" ? { waking: true } : {}), correlation_id: correlationId,
-        ...(ctx.lifecycle.daemons.get(targetInstanceName)?.isErrorState && {
-            warning: (() => {
-                const daemon = ctx.lifecycle.daemons.get(targetInstanceName);
-                if (daemon.isCrashLoop)
-                    return `${targetName} is in a crash loop — restart or replace required. Message delivered but may not be processed.`;
-                const errType = daemon.lastErrorType;
-                if (errType === "rate_limit" || errType === "timeout")
-                    return `${targetName} is rate-limited by provider — paused. Message delivered but may be delayed.`;
-                if (errType === "auth_error")
-                    return `${targetName} has an authentication error — paused. Check credentials. Message delivered but may not be processed.`;
-                return `${targetName} is in an error state (paused due to repeated errors). Message delivered but may not be processed.`;
-            })(),
-        }),
+        ...(useSteer ? { delivery_mode: "steer" } : {}),
+        ...(steerFallbackWarning ? { delivery_mode: "idle_queue" } : {}),
+        ...(warnings.length > 0 ? { warning: warnings.join(" ") } : {}),
     });
 };
 const listInstances = (ctx, rawArgs, respond, meta) => {
@@ -297,8 +375,8 @@ const listInstances = (ctx, rawArgs, respond, meta) => {
                 instance_state: ctx.getInstanceExecutionState?.(ch.instanceName) ?? null,
                 working_directory: "",
                 topic_id: ch.channelId,
-                display_name: `classic: ${ch.name}`,
-                description: `ClassicBot channel (${ch.name})`,
+                display_name: ch.displayName ?? `classic: ${ch.name}`,
+                description: ch.description ?? `ClassicBot channel (${ch.name})`,
                 backend: ctx.classicChannels.getBackendByInstance?.(ch.instanceName, ctx.fleetConfig?.defaults?.backend) ?? ch.backend ?? ctx.fleetConfig?.defaults?.backend ?? "claude-code",
                 model: ctx.resolveInstanceModel?.(ch.instanceName).model
                     ?? ctx.classicChannels.getModel?.(ch.channelId, ch.adapterId, ctx.fleetConfig?.defaults?.model)
@@ -558,12 +636,46 @@ const getUsage = async (ctx, rawArgs, respond) => {
     try {
         // Same structure as GET /api/ai-usage, same 5-minute cache behind it.
         const { getUsageSnapshot } = await import("./usage/usage-api.js");
-        respond(await getUsageSnapshot(v.data.force === true));
+        respond(await getUsageSnapshot(v.data.force === true, ctx.getActiveUsageProviderIds?.()));
     }
     catch (err) {
         respond(null, `Usage fetch failed: ${err.message}`);
     }
 };
+/**
+ * Enumerate a backend's models. Read-only and best-effort by design: the
+ * catalog is an aid for picking a name, and AgEnD passes model strings through
+ * to the CLI regardless, so an empty list is a reportable answer rather than an
+ * error. The one real error is naming an instance that does not exist — that is
+ * a mistake in the call, and silently answering with the fleet default backend
+ * would hide it.
+ */
+const listModels = async (ctx, rawArgs, respond) => {
+    const v = validateArgs(ListModelsArgs, rawArgs, "list_models");
+    if (!v.ok) {
+        respond(null, v.error);
+        return;
+    }
+    const { backend, instance_name } = v.data;
+    if (!ctx.listModelCatalog) {
+        respond(null, "list_models is unavailable on this fleet");
+        return;
+    }
+    if (instance_name) {
+        const known = Boolean(ctx.fleetConfig?.instances?.[instance_name])
+            || (ctx.classicChannels?.getAll() ?? []).some(c => c.instanceName === instance_name);
+        if (!known) {
+            respond(null, `Instance not found: ${instance_name}`);
+            return;
+        }
+    }
+    try {
+        respond(await ctx.listModelCatalog({ backend, instanceName: instance_name }));
+    }
+    catch (err) {
+        respond(null, `Model listing failed: ${err.message}`);
+    }
+};
 const getInstanceLogs = async (ctx, rawArgs, respond) => {
     const v = validateArgs(GetInstanceLogsArgs, rawArgs, "get_instance_logs");
     if (!v.ok) {
@@ -614,7 +726,11 @@ const updateInstanceConfig = (ctx, rawArgs, respond) => {
     }
     const inst = ctx.fleetConfig?.instances[v.data.name];
     if (!inst) {
-        respond(null, `Instance '${v.data.name}' not found in fleet config`);
+        const isClassic = (ctx.classicChannels?.getAll() ?? [])
+            .some(channel => channel.instanceName === v.data.name);
+        respond(null, isClassic
+            ? "This is a ClassicBot instance (managed in classicBot.yaml). Use set_display_name or set_description to configure it."
+            : `Instance '${v.data.name}' not found in fleet config`);
         return;
     }
     const patch = v.data.config;
@@ -654,6 +770,9 @@ const updateFleetDefaults = (ctx, rawArgs, respond) => {
         defaults.model = patch.model;
     if (patch.auto_pause_after !== undefined)
         defaults.auto_pause_after = patch.auto_pause_after;
+    if (patch.max_cross_instance_message_bytes !== undefined) {
+        defaults.max_cross_instance_message_bytes = patch.max_cross_instance_message_bytes;
+    }
     ctx.fleetConfig.defaults = defaults;
     try {
         ctx.saveFleetConfig();
@@ -682,6 +801,9 @@ function wrapAsSend(schema, toolName, buildArgs, warnMissing) {
             ...extra,
             instance_name: targetName,
             message: body,
+            ...(v.data.steer !== undefined
+                ? { steer: v.data.steer }
+                : {}),
             request_kind: kind,
             requires_reply: reply,
             task_summary: summary,
@@ -765,8 +887,31 @@ const broadcast = async (ctx, rawArgs, respond, meta) => {
         return;
     }
     const { message, targets, team: teamName, tags: filterTags, task_summary, request_kind, requires_reply } = v.data;
+    if (rejectOversizedCrossInstanceMessage(ctx, message, respond))
+        return;
     const senderLabel = meta.senderSessionName ?? meta.instanceName;
     const senderDisplay = ctx.fleetConfig?.instances[senderLabel]?.display_name;
+    const makeBroadcastMeta = (correlationId, messageId = `bcast-${Date.now()}`) => {
+        const ipcMeta = {
+            chat_id: "", message_id: messageId, user: `instance:${senderLabel}`,
+            user_id: `instance:${senderLabel}`, ts: new Date().toISOString(), thread_id: "",
+            from_instance: senderLabel, correlation_id: correlationId,
+        };
+        if (request_kind)
+            ipcMeta.request_kind = request_kind;
+        if (requires_reply != null)
+            ipcMeta.requires_reply = String(requires_reply);
+        if (task_summary)
+            ipcMeta.task_summary = task_summary;
+        if (senderDisplay && senderDisplay !== senderLabel)
+            ipcMeta.from_display = senderDisplay;
+        return ipcMeta;
+    };
+    // Validate once before dispatching any target. The placeholders are the
+    // longest values generated below, so every real per-target envelope fits if
+    // this one does. Keeping this outside the loop prevents partial broadcasts.
+    if (rejectOversizedCrossInstanceEnvelope(message, makeBroadcastMeta("bcast-9999999999999-zzzzzz", "bcast-9999999999999"), respond))
+        return;
     // Resolve target list: team, explicit targets, tag filter, or all running
     let targetNames;
     if (teamName) {
@@ -803,19 +948,7 @@ const broadcast = async (ctx, rawArgs, respond, meta) => {
             continue;
         }
         const correlationId = `bcast-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-        const ipcMeta = {
-            chat_id: "", message_id: `bcast-${Date.now()}`, user: `instance:${senderLabel}`,
-            user_id: `instance:${senderLabel}`, ts: new Date().toISOString(), thread_id: "",
-            from_instance: senderLabel, correlation_id: correlationId,
-        };
-        if (request_kind)
-            ipcMeta.request_kind = request_kind;
-        if (requires_reply != null)
-            ipcMeta.requires_reply = String(requires_reply);
-        if (task_summary)
-            ipcMeta.task_summary = task_summary;
-        if (senderDisplay && senderDisplay !== senderLabel)
-            ipcMeta.from_display = senderDisplay;
+        const ipcMeta = makeBroadcastMeta(correlationId);
         // Same at-least-once treatment as send_to_instance: retry, then surface a
         // final failure on both topics instead of dying in a warn-level log line.
         void deliverCrossInstanceWithRetry(ctx, hostInstance, targetName, senderLabel, correlationId, { type: "fleet_inbound", targetSession: targetName, content: message, meta: ipcMeta });
@@ -826,7 +959,7 @@ const broadcast = async (ctx, rawArgs, respond, meta) => {
     for (const target of sentTo) {
         ctx.eventLog?.logActivity("message", senderLabel, summary, target);
     }
-    ctx.queueMirrorMessage?.(`📢 ${senderLabel} → [${sentTo.join(", ")}]: ${message.slice(0, 500)}${message.length > 500 ? " […]" : ""}`);
+    ctx.queueMirrorMessage?.(`📢 ${senderLabel} → [${sentTo.join(", ")}]: ${truncatePreview(message, 500)}`);
     respond({ sent_to: sentTo, failed, count: sentTo.length, queued: true });
 };
 // ── Teams ────────────────────────────────────────────────────────────────
@@ -1173,6 +1306,7 @@ export const outboundHandlers = new Map([
     ["get_fleet_status", getFleetStatus],
     ["get_effort", getEffort],
     ["get_usage", getUsage],
+    ["list_models", listModels],
     ["get_instance_logs", getInstanceLogs],
     ["get_fleet_config", getFleetConfig],
     ["update_instance_config", updateInstanceConfig],