@botcord/daemon 0.2.41 → 0.2.44

package/dist/gateway/dispatcher.js

@@ -862,11 +862,12 @@ export class Dispatcher {
             if (controller.signal.aborted && !slot.timedOut) {
                 return;
             }
-            // Reply gating: only owner-chat rooms accept the runtime's plain text
-            // output as a delivered message. Every other room expects the agent to
+            // Reply gating: BotCord network rooms only accept the runtime's plain
+            // text output in owner-chat. Other BotCord rooms expect the agent to
             // call the `botcord_send` tool (or `botcord send` CLI via Bash)
-            // explicitly; runtime text in those rooms is logged and dropped,
-            // including timeout / error notifications.
+            // explicitly, so final assistant text is logged and dropped there.
+            // Third-party gateways (Telegram / WeChat) are themselves direct
+            // message transports; their final runtime text is the reply.
             //
             // Owner-chat is identified by either the `rm_oc_` room prefix OR
             // `source_type === "dashboard_user_chat"` on the raw envelope — the
@@ -879,6 +880,7 @@ export class Dispatcher {
             // expectation is that the agent's `botcord_send` tool calls do their
             // own loop-risk accounting downstream.
             const isOwnerChat = isOwnerChatRoom(msg);
+            const canDeliverRuntimeText = isOwnerChat || !isBotCordChannel(channel);
             if (slot.timedOut) {
                 this.transcript.write({
                     ts: nowIso(),
@@ -891,7 +893,7 @@ export class Dispatcher {
                     error: `runtime timeout after ${this.turnTimeoutMs}ms`,
                     durationMs: Date.now() - slot.dispatchedAt,
                 });
-                if (isOwnerChat) {
+                if (canDeliverRuntimeText) {
                     await this.sendReply(channel, {
                         channel: msg.channel,
                         accountId: msg.accountId,
@@ -936,7 +938,7 @@ export class Dispatcher {
                     error: errMsg,
                     durationMs: Date.now() - slot.dispatchedAt,
                 });
-                if (isOwnerChat) {
+                if (canDeliverRuntimeText) {
                     await this.sendReply(channel, {
                         channel: msg.channel,
                         accountId: msg.accountId,
@@ -1026,7 +1028,7 @@ export class Dispatcher {
                         runtime: route.runtime,
                         error: result.error,
                     });
-                    if (isOwnerChat) {
+                    if (canDeliverRuntimeText) {
                         const sendResult = await this.sendReply(channel, {
                             channel: msg.channel,
                             accountId: msg.accountId,
@@ -1065,8 +1067,8 @@ export class Dispatcher {
                 });
                 return;
             }
-            if (!isOwnerChat) {
-                // Non-owner-chat rooms: result.text never goes out. The agent is
+            if (!canDeliverRuntimeText) {
+                // Non-owner BotCord rooms: result.text never goes out. The agent is
                 // expected to have used the `botcord_send` tool / `botcord send` CLI
                 // already; whatever it left in the runtime's final assistant text is
                 // discarded so it doesn't leak into the room.
@@ -1266,6 +1268,9 @@ function isOwnerChatRoom(msg) {
     }
     return false;
 }
+function isBotCordChannel(channel) {
+    return channel.type === "botcord" || channel.id === "botcord";
+}
 function resolveQueueMode(route, kind) {
     if (route.queueMode)
         return route.queueMode;

package/dist/gateway-control.d.ts

@@ -51,6 +51,12 @@ interface GatewayLoginStatusParams {
     loginId: string;
     accountId: string;
 }
+interface GatewayRecentSendersParams {
+    provider: GatewayProvider;
+    loginId: string;
+    accountId: string;
+    timeoutSeconds?: number;
+}
 export type { FetchLike };
 export interface GatewayControlContext {
     gateway: Gateway;
@@ -84,6 +90,7 @@ export declare function createGatewayControl(ctx: GatewayControlContext): {
     handleTest: (params: TestGatewayParams) => Promise<AckBody>;
     handleLoginStart: (params: GatewayLoginStartParams) => Promise<AckBody>;
     handleLoginStatus: (params: GatewayLoginStatusParams) => Promise<AckBody>;
+    handleRecentSenders: (params: GatewayRecentSendersParams) => Promise<AckBody>;
     /** Exposed for tests — direct access to the in-memory session map. */
     _sessions: LoginSessionStore;
 };

package/dist/gateway-control.js

@@ -12,6 +12,7 @@ import { loadConfig, saveConfig, resolveConfiguredAgentIds, } from "./config.js"
 import { deleteGatewaySecret, loadGatewaySecret, saveGatewaySecret, } from "./gateway/channels/secret-store.js";
 import { LoginSessionStore, maskTokenPreview, mintLoginId, } from "./gateway/channels/login-session.js";
 import { DEFAULT_WECHAT_BASE_URL, getBotQrcode, getQrcodeStatus, } from "./gateway/channels/wechat-login.js";
+import { WECHAT_BASE_INFO, wechatHeaders } from "./gateway/channels/wechat-http.js";
 import { assertSafeBaseUrl, UnsafeBaseUrlError } from "./gateway/channels/url-guard.js";
 import { log as daemonLog } from "./log.js";
 /**
@@ -506,6 +507,92 @@ export function createGatewayControl(ctx) {
         const result = { status };
         return { ok: true, result };
     }
+    // --- gateway_recent_senders --------------------------------------------
+    async function handleRecentSenders(params) {
+        if (!isProvider(params.provider)) {
+            return badParams(`gateway_recent_senders: unknown provider "${String(params.provider)}"`);
+        }
+        if (params.provider !== "wechat") {
+            return badParams(`gateway_recent_senders: provider "${params.provider}" not supported`);
+        }
+        if (!params.loginId) {
+            return badParams("gateway_recent_senders: loginId is required");
+        }
+        if (!params.accountId || typeof params.accountId !== "string") {
+            return badParams("gateway_recent_senders: accountId is required");
+        }
+        const session = sessions.get(params.loginId);
+        if (!session) {
+            return {
+                ok: false,
+                error: { code: "login_expired", message: `wechat login session "${params.loginId}" not found or expired` },
+            };
+        }
+        if (session.provider !== "wechat") {
+            return badParams("gateway_recent_senders: provider does not match login session");
+        }
+        if (session.accountId !== params.accountId) {
+            return {
+                ok: false,
+                error: {
+                    code: "forbidden",
+                    message: "gateway_recent_senders: accountId does not match login session",
+                },
+            };
+        }
+        if (!session.botToken) {
+            return {
+                ok: false,
+                error: { code: "login_unconfirmed", message: "wechat login session has no bot token yet" },
+            };
+        }
+        try {
+            assertSafeBaseUrl(session.baseUrl);
+        }
+        catch (urlErr) {
+            if (urlErr instanceof UnsafeBaseUrlError)
+                return badParams(urlErr.message);
+            throw urlErr;
+        }
+        const baseUrl = (session.baseUrl ?? DEFAULT_WECHAT_BASE_URL).replace(/\/+$/, "");
+        const timeoutSeconds = typeof params.timeoutSeconds === "number"
+            ? Math.min(Math.max(Math.floor(params.timeoutSeconds), 0), 10)
+            : 0;
+        try {
+            const res = await fetchImpl(`${baseUrl}/ilink/bot/getupdates`, {
+                method: "POST",
+                headers: wechatHeaders(session.botToken),
+                body: JSON.stringify({
+                    get_updates_buf: "",
+                    base_info: { ...WECHAT_BASE_INFO },
+                }),
+                signal: AbortSignal.timeout((timeoutSeconds + 10) * 1000),
+            });
+            const raw = await res.text();
+            const data = raw ? JSON.parse(raw) : {};
+            if (data.ret !== undefined && data.ret !== 0) {
+                return {
+                    ok: false,
+                    error: {
+                        code: "provider_auth_failed",
+                        message: `wechat getupdates failed: ret=${data.ret}`,
+                    },
+                };
+            }
+            const result = {
+                senders: extractWechatSenders(data.msgs),
+            };
+            return { ok: true, result };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            daemonLog.warn("gateway_recent_senders.getupdates failed", { error: message });
+            return {
+                ok: false,
+                error: { code: "provider_unreachable", message },
+            };
+        }
+    }
     return {
         handleList,
         handleUpsert,
@@ -513,6 +600,7 @@ export function createGatewayControl(ctx) {
         handleTest,
         handleLoginStart,
         handleLoginStatus,
+        handleRecentSenders,
         /** Exposed for tests — direct access to the in-memory session map. */
         _sessions: sessions,
     };
@@ -636,3 +724,21 @@ function mapWechatStatus(raw) {
         return "expired";
     return "failed";
 }
+function extractWechatSenders(msgs) {
+    const out = new Map();
+    if (!Array.isArray(msgs))
+        return [];
+    for (const msg of msgs) {
+        if (!msg || typeof msg !== "object")
+            continue;
+        const raw = msg;
+        const id = typeof raw.from_user_id === "string" ? raw.from_user_id.trim() : "";
+        if (!id)
+            continue;
+        const label = (typeof raw.from_user_name === "string" && raw.from_user_name.trim()) ||
+            (typeof raw.sender_name === "string" && raw.sender_name.trim()) ||
+            null;
+        out.set(id, { id, label });
+    }
+    return Array.from(out.values());
+}

package/dist/provision.js

@@ -239,6 +239,14 @@ export function createProvisioner(opts) {
                     return v.ack;
                 return gatewayControl.handleLoginStatus(v.params);
             }
+            case "gateway_recent_senders": {
+                const v = validateGatewayParams(frame.params, {
+                    required: ["provider", "loginId", "accountId"],
+                });
+                if (!v.ok)
+                    return v.ack;
+                return gatewayControl.handleRecentSenders(v.params);
+            }
             case "list_agent_files": {
                 const params = (frame.params ?? {});
                 if (!params.agentId) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botcord/daemon",
-  "version": "0.2.41",
+  "version": "0.2.44",
   "description": "BotCord local daemon — bridges Hub inbox push to local Claude Code / Codex / Gemini CLIs",
   "type": "module",
   "bin": {

package/src/__tests__/gateway-control.test.ts

@@ -239,6 +239,87 @@ describe("gateway_login_start / status", () => {
     // Bot token never escapes the daemon.
     expect(JSON.stringify(statusResult)).not.toContain("wechat-bot-token-1234567890");
   });
+
+  it("discovers recent WeChat senders from a confirmed login session", async () => {
+    const gw = makeFakeGateway();
+    const { io } = makeConfigIO(baseCfg());
+    const sessions = new LoginSessionStore();
+    sessions.create({
+      loginId: "wxl_discover",
+      accountId: "ag_alice",
+      provider: "wechat",
+      qrcode: "QR",
+      baseUrl: "https://ilinkai.weixin.qq.com",
+      botToken: "wechat-bot-token-1234567890",
+    });
+    const fetchImpl = vi.fn(async (_url: string, init?: RequestInit) => {
+      expect(String(_url)).toBe("https://ilinkai.weixin.qq.com/ilink/bot/getupdates");
+      expect(init?.method).toBe("POST");
+      expect((init?.headers as Record<string, string>).Authorization).toBe(
+        "Bearer wechat-bot-token-1234567890",
+      );
+      return {
+        text: async () =>
+          JSON.stringify({
+            ret: 0,
+            msgs: [
+              { from_user_id: "alice@im.wechat", from_user_name: "Alice" },
+              { from_user_id: "bob@im.wechat" },
+              { from_user_id: "alice@im.wechat", from_user_name: "Alice" },
+              { to_user_id: "ignored" },
+            ],
+          }),
+      };
+    });
+    const ctrl = createGatewayControl({
+      gateway: gw as any,
+      configIO: io,
+      loginSessions: sessions,
+      fetchImpl: fetchImpl as any,
+    });
+
+    const ack = await ctrl.handleRecentSenders({
+      provider: "wechat",
+      loginId: "wxl_discover",
+      accountId: "ag_alice",
+      timeoutSeconds: 8,
+    });
+
+    expect(ack.ok).toBe(true);
+    expect(ack.result).toEqual({
+      senders: [
+        { id: "alice@im.wechat", label: "Alice" },
+        { id: "bob@im.wechat", label: null },
+      ],
+    });
+  });
+
+  it("rejects sender discovery before WeChat login is confirmed", async () => {
+    const gw = makeFakeGateway();
+    const { io } = makeConfigIO(baseCfg());
+    const sessions = new LoginSessionStore();
+    sessions.create({
+      loginId: "wxl_pending",
+      accountId: "ag_alice",
+      provider: "wechat",
+      qrcode: "QR",
+      baseUrl: "https://ilinkai.weixin.qq.com",
+    });
+    const ctrl = createGatewayControl({
+      gateway: gw as any,
+      configIO: io,
+      loginSessions: sessions,
+    });
+
+    const ack = await ctrl.handleRecentSenders({
+      provider: "wechat",
+      loginId: "wxl_pending",
+      accountId: "ag_alice",
+    });
+
+    expect(ack.ok).toBe(false);
+    expect(ack.error?.code).toBe("login_unconfirmed");
+  });
 });
 
 describe("frame schema validation", () => {

package/src/__tests__/provision.test.ts

@@ -1763,4 +1763,19 @@ describe("W8: gateway frame param validation in provision dispatch", () => {
     expect(ack.ok).toBe(false);
     expect(ack.error?.code).toBe("bad_params");
   });
+
+  it("rejects malformed GATEWAY_RECENT_SENDERS (missing accountId)", async () => {
+    const gw = makeFakeGateway();
+    const provisioner = createProvisioner({
+      gateway: gw as unknown as Parameters<typeof createProvisioner>[0]["gateway"],
+    });
+    const ack = await provisioner({
+      id: "req_w8f",
+      type: "gateway_recent_senders",
+      params: { provider: "wechat", loginId: "wxl_1" },
+    });
+    expect(ack.ok).toBe(false);
+    expect(ack.error?.code).toBe("bad_params");
+    expect(ack.error?.message).toContain("accountId");
+  });
 });

package/src/gateway/__tests__/transcript.test.ts

@@ -43,6 +43,11 @@ class FakeChannel implements ChannelAdapter {
   }
 }
 
+class FakeTelegramChannel extends FakeChannel {
+  override readonly id = "gw_telegram_test";
+  override readonly type = "telegram";
+}
+
 interface FakeRuntimeOptions {
   reply?: string;
   newSessionId?: string;
@@ -286,6 +291,26 @@ describe("Dispatcher transcript integration", () => {
     expect(s.channel.sends.length).toBe(0);
   });
 
+  it("third-party direct chat: runtime text is delivered", async () => {
+    const channel = new FakeTelegramChannel();
+    const s = track(await scaffold({
+      runtimeFactory: () => new FakeRuntime({ reply: "ok" }),
+      channel,
+    }));
+    await s.dispatcher.handle(
+      makeEnvelope({
+        channel: "gw_telegram_test",
+        conversation: { id: "telegram:user:7904063707", kind: "direct" },
+        sender: { id: "telegram:user:7904063707", kind: "user", name: "danny_aaas" },
+      }),
+    );
+    const recs = await s.recordsForRoom("telegram:user:7904063707");
+    const out = recs.find((r) => r.kind === "outbound") as Extract<TranscriptRecord, { kind: "outbound" }>;
+    expect(out.deliveryStatus).toBe("delivered");
+    expect(channel.sends).toHaveLength(1);
+    expect(channel.sends[0].message.conversationId).toBe("telegram:user:7904063707");
+  });
+
   it("dashboard_user_chat raw.source_type → delivered even outside rm_oc_", async () => {
     const s = track(await scaffold({ runtimeFactory: () => new FakeRuntime({ reply: "yo" }) }));
     await s.dispatcher.handle(

package/src/gateway/dispatcher.ts

@@ -1076,11 +1076,12 @@ export class Dispatcher {
         return;
       }
 
-      // Reply gating: only owner-chat rooms accept the runtime's plain text
-      // output as a delivered message. Every other room expects the agent to
+      // Reply gating: BotCord network rooms only accept the runtime's plain
+      // text output in owner-chat. Other BotCord rooms expect the agent to
       // call the `botcord_send` tool (or `botcord send` CLI via Bash)
-      // explicitly; runtime text in those rooms is logged and dropped,
-      // including timeout / error notifications.
+      // explicitly, so final assistant text is logged and dropped there.
+      // Third-party gateways (Telegram / WeChat) are themselves direct
+      // message transports; their final runtime text is the reply.
       //
       // Owner-chat is identified by either the `rm_oc_` room prefix OR
       // `source_type === "dashboard_user_chat"` on the raw envelope — the
@@ -1093,6 +1094,7 @@ export class Dispatcher {
       // expectation is that the agent's `botcord_send` tool calls do their
       // own loop-risk accounting downstream.
       const isOwnerChat = isOwnerChatRoom(msg);
+      const canDeliverRuntimeText = isOwnerChat || !isBotCordChannel(channel);
 
       if (slot.timedOut) {
         this.transcript.write({
@@ -1106,7 +1108,7 @@ export class Dispatcher {
           error: `runtime timeout after ${this.turnTimeoutMs}ms`,
           durationMs: Date.now() - slot.dispatchedAt,
         });
-        if (isOwnerChat) {
+        if (canDeliverRuntimeText) {
           await this.sendReply(channel, {
             channel: msg.channel,
             accountId: msg.accountId,
@@ -1151,7 +1153,7 @@ export class Dispatcher {
           error: errMsg,
           durationMs: Date.now() - slot.dispatchedAt,
         });
-        if (isOwnerChat) {
+        if (canDeliverRuntimeText) {
           await this.sendReply(channel, {
             channel: msg.channel,
             accountId: msg.accountId,
@@ -1240,7 +1242,7 @@ export class Dispatcher {
             runtime: route.runtime,
             error: result.error,
           });
-          if (isOwnerChat) {
+          if (canDeliverRuntimeText) {
             const sendResult = await this.sendReply(channel, {
               channel: msg.channel,
               accountId: msg.accountId,
@@ -1280,8 +1282,8 @@ export class Dispatcher {
         return;
       }
 
-      if (!isOwnerChat) {
-        // Non-owner-chat rooms: result.text never goes out. The agent is
+      if (!canDeliverRuntimeText) {
+        // Non-owner BotCord rooms: result.text never goes out. The agent is
         // expected to have used the `botcord_send` tool / `botcord send` CLI
         // already; whatever it left in the runtime's final assistant text is
         // discarded so it doesn't leak into the room.
@@ -1496,6 +1498,10 @@ function isOwnerChatRoom(msg: GatewayInboundEnvelope["message"]): boolean {
   return false;
 }
 
+function isBotCordChannel(channel: ChannelAdapter): boolean {
+  return channel.type === "botcord" || channel.id === "botcord";
+}
+
 function resolveQueueMode(
   route: GatewayRoute,
   kind: "direct" | "group",

package/src/gateway-control.ts

@@ -33,6 +33,7 @@ import {
   getBotQrcode,
   getQrcodeStatus,
 } from "./gateway/channels/wechat-login.js";
+import { WECHAT_BASE_INFO, wechatHeaders } from "./gateway/channels/wechat-http.js";
 import { assertSafeBaseUrl, UnsafeBaseUrlError } from "./gateway/channels/url-guard.js";
 import { log as daemonLog } from "./log.js";
 // W7: canonical FetchLike lives in gateway/channels/http-types.ts so the
@@ -143,6 +144,22 @@ interface GatewayLoginStatusResult {
   tokenPreview?: string;
 }
 
+interface GatewayRecentSendersParams {
+  provider: GatewayProvider;
+  loginId: string;
+  accountId: string;
+  timeoutSeconds?: number;
+}
+
+interface GatewayRecentSender {
+  id: string;
+  label?: string | null;
+}
+
+interface GatewayRecentSendersResult {
+  senders: GatewayRecentSender[];
+}
+
 export type { FetchLike };
 
 export interface GatewayControlContext {
@@ -664,6 +681,92 @@ export function createGatewayControl(ctx: GatewayControlContext) {
     return { ok: true, result };
   }
 
+  // --- gateway_recent_senders --------------------------------------------
+  async function handleRecentSenders(params: GatewayRecentSendersParams): Promise<AckBody> {
+    if (!isProvider(params.provider)) {
+      return badParams(`gateway_recent_senders: unknown provider "${String(params.provider)}"`);
+    }
+    if (params.provider !== "wechat") {
+      return badParams(`gateway_recent_senders: provider "${params.provider}" not supported`);
+    }
+    if (!params.loginId) {
+      return badParams("gateway_recent_senders: loginId is required");
+    }
+    if (!params.accountId || typeof params.accountId !== "string") {
+      return badParams("gateway_recent_senders: accountId is required");
+    }
+    const session = sessions.get(params.loginId);
+    if (!session) {
+      return {
+        ok: false,
+        error: { code: "login_expired", message: `wechat login session "${params.loginId}" not found or expired` },
+      };
+    }
+    if (session.provider !== "wechat") {
+      return badParams("gateway_recent_senders: provider does not match login session");
+    }
+    if (session.accountId !== params.accountId) {
+      return {
+        ok: false,
+        error: {
+          code: "forbidden",
+          message: "gateway_recent_senders: accountId does not match login session",
+        },
+      };
+    }
+    if (!session.botToken) {
+      return {
+        ok: false,
+        error: { code: "login_unconfirmed", message: "wechat login session has no bot token yet" },
+      };
+    }
+    try {
+      assertSafeBaseUrl(session.baseUrl);
+    } catch (urlErr) {
+      if (urlErr instanceof UnsafeBaseUrlError) return badParams(urlErr.message);
+      throw urlErr;
+    }
+
+    const baseUrl = (session.baseUrl ?? DEFAULT_WECHAT_BASE_URL).replace(/\/+$/, "");
+    const timeoutSeconds =
+      typeof params.timeoutSeconds === "number"
+        ? Math.min(Math.max(Math.floor(params.timeoutSeconds), 0), 10)
+        : 0;
+    try {
+      const res = await fetchImpl(`${baseUrl}/ilink/bot/getupdates`, {
+        method: "POST",
+        headers: wechatHeaders(session.botToken),
+        body: JSON.stringify({
+          get_updates_buf: "",
+          base_info: { ...WECHAT_BASE_INFO },
+        }),
+        signal: AbortSignal.timeout((timeoutSeconds + 10) * 1000),
+      });
+      const raw = await res.text();
+      const data = raw ? (JSON.parse(raw) as { msgs?: unknown[]; ret?: number }) : {};
+      if (data.ret !== undefined && data.ret !== 0) {
+        return {
+          ok: false,
+          error: {
+            code: "provider_auth_failed",
+            message: `wechat getupdates failed: ret=${data.ret}`,
+          },
+        };
+      }
+      const result: GatewayRecentSendersResult = {
+        senders: extractWechatSenders(data.msgs),
+      };
+      return { ok: true, result };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      daemonLog.warn("gateway_recent_senders.getupdates failed", { error: message });
+      return {
+        ok: false,
+        error: { code: "provider_unreachable", message },
+      };
+    }
+  }
+
   return {
     handleList,
     handleUpsert,
@@ -671,6 +774,7 @@ export function createGatewayControl(ctx: GatewayControlContext) {
     handleTest,
     handleLoginStart,
     handleLoginStatus,
+    handleRecentSenders,
     /** Exposed for tests — direct access to the in-memory session map. */
     _sessions: sessions,
   };
@@ -794,3 +898,20 @@ function mapWechatStatus(raw: string): GatewayLoginStatusResult["status"] {
   if (v === "expired" || v === "timeout") return "expired";
   return "failed";
 }
+
+function extractWechatSenders(msgs: unknown): GatewayRecentSender[] {
+  const out = new Map<string, GatewayRecentSender>();
+  if (!Array.isArray(msgs)) return [];
+  for (const msg of msgs) {
+    if (!msg || typeof msg !== "object") continue;
+    const raw = msg as Record<string, unknown>;
+    const id = typeof raw.from_user_id === "string" ? raw.from_user_id.trim() : "";
+    if (!id) continue;
+    const label =
+      (typeof raw.from_user_name === "string" && raw.from_user_name.trim()) ||
+      (typeof raw.sender_name === "string" && raw.sender_name.trim()) ||
+      null;
+    out.set(id, { id, label });
+  }
+  return Array.from(out.values());
+}

package/src/provision.ts

@@ -371,6 +371,16 @@ export function createProvisioner(opts: ProvisionerOptions): (
         );
       }
 
+      case "gateway_recent_senders": {
+        const v = validateGatewayParams(frame.params, {
+          required: ["provider", "loginId", "accountId"],
+        });
+        if (!v.ok) return v.ack;
+        return gatewayControl.handleRecentSenders(
+          v.params as unknown as Parameters<typeof gatewayControl.handleRecentSenders>[0],
+        );
+      }
+
       case "list_agent_files": {
         const params = (frame.params ?? {}) as unknown as ListAgentFilesParams;
         if (!params.agentId) {