talon-agent 1.2.0 → 1.4.0

package/src/backend/opencode/index.ts

@@ -17,7 +17,6 @@ import {
   resetSession,
 } from "../../storage/sessions.js";
 import { getChatSettings } from "../../storage/chat-settings.js";
-import { getRecentHistory } from "../../storage/history.js";
 import { classify } from "../../core/errors.js";
 import { log, logError, logWarn } from "../../util/log.js";
 import { traceMessage } from "../../util/trace.js";
@@ -53,7 +52,7 @@ async function ensureServer(): Promise<OpencodeClient> {
 
   // Register our MCP tools server with OpenCode
   try {
-    const toolsPath = new URL("../claude-sdk/tools.ts", import.meta.url)
+    const toolsPath = new URL("../../core/tools/mcp-server.ts", import.meta.url)
       .pathname;
     await client.mcp.add({
       body: {
@@ -63,6 +62,7 @@ async function ensureServer(): Promise<OpencodeClient> {
           command: ["node", "--import", "tsx", toolsPath],
           environment: {
             TALON_BRIDGE_URL: `http://127.0.0.1:${gatewayPortFn()}`,
+            TALON_FRONTEND: "telegram",
           },
         },
       },
@@ -149,24 +149,9 @@ export async function handleMessage(
 
   // Build prompt with group context
   const msgIdHint = params.messageId ? ` [msg_id:${params.messageId}]` : "";
-  let continuityPrefix = "";
-  const session = getSession(chatId);
-  if (!session.sessionId && session.turns > 0) {
-    const recent = getRecentHistory(chatId, 3);
-    if (recent.length > 0) {
-      const ctx = recent
-        .map(
-          (m) =>
-            `[${new Date(m.timestamp).toISOString().slice(11, 16)}] ${m.senderName}: ${m.text.slice(0, 300)}`,
-        )
-        .join("\n");
-      continuityPrefix = `[Session resumed — recent context:\n${ctx}]\n\n`;
-    }
-  }
-
   const prompt = isGroup
-    ? `${continuityPrefix}[${senderName}]${msgIdHint}: ${text}`
-    : `${continuityPrefix}${text}${msgIdHint}`;
+    ? `[${senderName}]${msgIdHint}: ${text}`
+    : `${text}${msgIdHint}`;
 
   log("agent", `[${chatId}] <- (${text.length} chars)`);
   traceMessage(chatId, "in", text, { senderName, isGroup });
@@ -211,7 +196,7 @@ export async function handleMessage(
       model: activeModel,
     });
 
-    if (session.turns === 0 && text) {
+    if (getSession(chatId).turns === 0 && text) {
       const cleanText = text
         .replace(/^\[.*?\]\s*/g, "")
         .replace(/\[msg_id:\d+\]\s*/g, "")

package/src/bootstrap.ts

@@ -58,18 +58,127 @@ export async function bootstrap(
 ): Promise<BootstrapResult> {
   const config = loadConfig();
 
-  // Expose search config as env vars for gateway-actions
-  if (config.braveApiKey) process.env.TALON_BRAVE_API_KEY = config.braveApiKey;
-  if (config.searxngUrl) process.env.TALON_SEARXNG_URL = config.searxngUrl;
-
-  // Load plugins (external tool packages)
-  if (config.plugins.length > 0) {
-    const { loadPlugins, getPluginPromptAdditions } =
+  // Load plugins (external tool packages + built-in GitHub, MemPalace, Playwright)
+  const hasPlugins =
+    config.plugins.length > 0 ||
+    config.github?.enabled === true ||
+    config.mempalace?.enabled === true ||
+    config.playwright?.enabled === true;
+  if (hasPlugins) {
+    const { loadPlugins, getPluginPromptAdditions, registerPlugin } =
       await import("./core/plugin.js");
-    const frontends =
-      options.frontendNames ??
-      (Array.isArray(config.frontend) ? config.frontend : [config.frontend]);
-    await loadPlugins(config.plugins, frontends);
+
+    // External plugins
+    if (config.plugins.length > 0) {
+      const frontends =
+        options.frontendNames ??
+        (Array.isArray(config.frontend) ? config.frontend : [config.frontend]);
+      await loadPlugins(config.plugins, frontends);
+    }
+
+    // Built-in: GitHub
+    if (config.github?.enabled) {
+      const { createGitHubPlugin } = await import("./plugins/github/index.js");
+      const { getPlugin } = await import("./core/plugin.js");
+      const githubConfig = config.github as unknown as Record<string, unknown>;
+      const gh = createGitHubPlugin({ token: config.github.token });
+      registerPlugin(gh, githubConfig);
+
+      if (getPlugin("github")) {
+        try {
+          const GITHUB_INIT_TIMEOUT_MS = 15_000;
+          await Promise.race([
+            gh.init?.(githubConfig),
+            new Promise((_, reject) =>
+              setTimeout(
+                () => reject(new Error("GitHub init timed out after 15s")),
+                GITHUB_INIT_TIMEOUT_MS,
+              ),
+            ),
+          ]);
+        } catch (err) {
+          log(
+            "github",
+            `Init warning: ${err instanceof Error ? err.message : err}`,
+          );
+        }
+      }
+    }
+
+    // Built-in: MemPalace
+    if (config.mempalace?.enabled) {
+      const { createMempalacePlugin } =
+        await import("./plugins/mempalace/index.js");
+      const { getPlugin } = await import("./core/plugin.js");
+      const { dirs, files: pathFiles } = await import("./util/paths.js");
+      const pythonPath =
+        config.mempalace.pythonPath ?? pathFiles.mempalacePython;
+      const palacePath = config.mempalace.palacePath ?? dirs.palace;
+      const mempalaceConfig = config.mempalace as unknown as Record<
+        string,
+        unknown
+      >;
+      const mp = createMempalacePlugin({ pythonPath, palacePath });
+      registerPlugin(mp, mempalaceConfig);
+
+      // Only call init if registration succeeded (validation passed)
+      if (getPlugin("mempalace")) {
+        try {
+          const MEMPALACE_INIT_TIMEOUT_MS = 30_000;
+          await Promise.race([
+            mp.init?.(mempalaceConfig),
+            new Promise((_, reject) =>
+              setTimeout(
+                () => reject(new Error("MemPalace init timed out after 30s")),
+                MEMPALACE_INIT_TIMEOUT_MS,
+              ),
+            ),
+          ]);
+        } catch (err) {
+          log(
+            "mempalace",
+            `Init warning: ${err instanceof Error ? err.message : err}`,
+          );
+        }
+      }
+    }
+
+    // Built-in: Playwright
+    if (config.playwright?.enabled) {
+      const { createPlaywrightPlugin } =
+        await import("./plugins/playwright/index.js");
+      const { getPlugin } = await import("./core/plugin.js");
+      const playwrightConfig = config.playwright as unknown as Record<
+        string,
+        unknown
+      >;
+      const pw = createPlaywrightPlugin({
+        browser: config.playwright.browser,
+        headless: config.playwright.headless,
+      });
+      registerPlugin(pw, playwrightConfig);
+
+      if (getPlugin("playwright")) {
+        try {
+          const PW_INIT_TIMEOUT_MS = 15_000;
+          await Promise.race([
+            pw.init?.(playwrightConfig),
+            new Promise((_, reject) =>
+              setTimeout(
+                () => reject(new Error("Playwright init timed out after 15s")),
+                PW_INIT_TIMEOUT_MS,
+              ),
+            ),
+          ]);
+        } catch (err) {
+          log(
+            "playwright",
+            `Init warning: ${err instanceof Error ? err.message : err}`,
+          );
+        }
+      }
+    }
+
     rebuildSystemPrompt(config, getPluginPromptAdditions());
   }
 
@@ -119,11 +228,31 @@ export async function initBackendAndDispatcher(
 
   initPulse();
   initCron({ sendMessage: frontend.sendMessage });
+
+  // Only enable mempalace dream integration if the plugin actually registered
+  let mempalaceCfg: { pythonPath: string; palacePath: string } | undefined;
+  if (config.mempalace?.enabled) {
+    const { getPlugin } = await import("./core/plugin.js");
+    if (getPlugin("mempalace")) {
+      const { dirs, files: pathFiles } = await import("./util/paths.js");
+      mempalaceCfg = {
+        pythonPath: config.mempalace.pythonPath ?? pathFiles.mempalacePython,
+        palacePath: config.mempalace.palacePath ?? dirs.palace,
+      };
+    } else {
+      log(
+        "mempalace",
+        "Enabled in config but plugin not registered — skipping dream integration",
+      );
+    }
+  }
+
   initDream({
     model: config.model,
     dreamModel: config.dreamModel,
     claudeBinary: config.claudeBinary,
     workspace: config.workspace,
+    mempalace: mempalaceCfg,
   });
   initHeartbeat({
     model: config.model,

package/src/core/dream.ts

@@ -7,7 +7,7 @@
  *   2. Spawns a background Agent that reads recent logs and merges new
  *      facts/preferences/events into memory.md
  *
- * The dream agent runs entirely on filesystem tools — no Telegram/MCP access.
+ * The dream agent runs on filesystem tools, with optional MCP access for MemPalace when configured.
  * It does NOT use the main dispatcher (no chat session, no typing indicator).
  */
 
@@ -19,6 +19,7 @@ import { query } from "@anthropic-ai/claude-agent-sdk";
 import type { SDKMessage } from "@anthropic-ai/claude-agent-sdk";
 import { files as pathFiles, dirs } from "../util/paths.js";
 import { log, logError, logWarn } from "../util/log.js";
+import { getPluginMcpServers } from "./plugin.js";
 
 // ── Types ────────────────────────────────────────────────────────────────────
 
@@ -46,6 +47,7 @@ let configRef: {
   dreamModel?: string;
   claudeBinary?: string;
   workspace?: string;
+  mempalace?: { pythonPath: string; palacePath: string };
 } | null = null;
 
 export function initDream(cfg: {
@@ -54,6 +56,8 @@ export function initDream(cfg: {
   dreamModel?: string;
   claudeBinary?: string;
   workspace?: string;
+  /** MemPalace config for mining logs into the palace during dream runs. */
+  mempalace?: { pythonPath: string; palacePath: string };
 }): void {
   configRef = cfg;
 }
@@ -137,12 +141,39 @@ async function runDreamAgent(lastRunTimestamp: number): Promise<string> {
 
   let prompt: string;
   try {
+    // Build optional mempalace mining section
+    const mempalaceSection = configRef.mempalace
+      ? `If mempalace is available, mine the daily memory notes (your curated observations, NOT raw logs) into the palace for long-term semantic retrieval.
+Run this command using the Bash tool:
+
+\`\`\`bash
+'${configRef.mempalace.pythonPath.replace(/'/g, "'\\''")}' -m mempalace mine '${dirs.dailyMemory.replace(/'/g, "'\\''")}' --palace '${configRef.mempalace.palacePath.replace(/'/g, "'\\''")}' --mode convos --wing daily-notes
+\`\`\`
+
+Then write a personal diary entry. This is YOUR journal — not a status report. Reflect on:
+- What happened today. What conversations stood out.
+- How you feel. Your state of mind, emotions, energy.
+- What you learned. What surprised you. What you got wrong.
+- What you're curious about. Loose threads. Things you want to follow up on.
+- Your honest thoughts — about users, projects, yourself.
+
+Write the diary using the \`mempalace_diary_write\` MCP tool (available during dream):
+\`\`\`
+mempalace_diary_write(agent_name="talon", entry="YOUR_DIARY_ENTRY_HERE", topic="dream-reflection")
+\`\`\`
+
+If the MCP tool is not available, write the diary entry to a file at ${dirs.dailyMemory}/diary-YYYY-MM-DD.md instead.
+Keep the diary authentic. Write in first person. Be honest. This is for you, not for anyone else.
+If commands fail, log the error and continue — this stage is optional.`
+      : "MemPalace is not configured. Skip this stage.";
+
     prompt = readFileSync(promptPath, "utf-8")
       .replace(/\{\{dreamStateFile\}\}/g, dreamStateFile)
       .replace(/\{\{logsDir\}\}/g, logsDir)
       .replace(/\{\{lastRunIso\}\}/g, lastRunIso)
       .replace(/\{\{memoryFile\}\}/g, memoryFile)
-      .replace(/\{\{dailyMemoryDir\}\}/g, dirs.dailyMemory);
+      .replace(/\{\{dailyMemoryDir\}\}/g, dirs.dailyMemory)
+      .replace(/\{\{mempalaceSection\}\}/g, mempalaceSection);
   } catch {
     throw new Error(`Failed to read dream prompt from ${promptPath}`);
   }
@@ -164,16 +195,19 @@ async function runDreamAgent(lastRunTimestamp: number): Promise<string> {
 
   const options = {
     model,
-    systemPrompt:
-      "You are a background memory consolidation agent for Talon. Use only filesystem tools. Be precise and surgical — update memory.md without losing existing accurate information.",
+    systemPrompt: configRef.mempalace
+      ? "You are a background memory consolidation agent for Talon. Use filesystem tools and MemPalace MCP tools. Do NOT use Telegram or messaging tools. Be precise and surgical — update memory.md without losing existing accurate information."
+      : "You are a background memory consolidation agent for Talon. Use only filesystem tools. Be precise and surgical — update memory.md without losing existing accurate information.",
     cwd: workspace,
     permissionMode: "bypassPermissions" as const,
     allowDangerouslySkipPermissions: true,
     ...(configRef.claudeBinary
       ? { pathToClaudeCodeExecutable: configRef.claudeBinary }
       : {}),
-    // No MCP servers — filesystem tools only
-    mcpServers: {},
+    // Only load mempalace MCP server for dream — no other plugins needed
+    mcpServers: configRef.mempalace
+      ? getPluginMcpServers("", "dream", ["mempalace"])
+      : {},
     disallowedTools: [
       "EnterPlanMode",
       "ExitPlanMode",

package/src/core/gateway-actions.ts

@@ -87,93 +87,6 @@ export async function handleSharedAction(
         ),
       };
 
-    // ── Web search (SearXNG) ────────────────────────────────────────────
-
-    case "web_search": {
-      const query = String(body.query ?? "");
-      if (!query) return { ok: false, error: "Missing query" };
-      const limit = Math.min(10, Number(body.limit ?? 5));
-
-      // Try Brave first (if API key configured), fall back to SearXNG
-      const braveKey = process.env.TALON_BRAVE_API_KEY;
-      const searxUrl = process.env.TALON_SEARXNG_URL || "http://localhost:8080";
-
-      type SearchResult = { title: string; url: string; snippet: string };
-      let results: SearchResult[] = [];
-      let provider = "";
-
-      // Brave Search API
-      if (braveKey) {
-        try {
-          const resp = await fetch(
-            `https://api.search.brave.com/res/v1/web/search?q=${encodeURIComponent(query)}&count=${limit}`,
-            {
-              signal: AbortSignal.timeout(8_000),
-              headers: {
-                "X-Subscription-Token": braveKey,
-                Accept: "application/json",
-              },
-            },
-          );
-          if (resp.ok) {
-            const data = (await resp.json()) as {
-              web?: {
-                results?: Array<{
-                  title: string;
-                  url: string;
-                  description: string;
-                }>;
-              };
-            };
-            results = (data.web?.results ?? []).map((r) => ({
-              title: r.title,
-              url: r.url,
-              snippet: r.description ?? "",
-            }));
-            provider = "Brave";
-          }
-        } catch {
-          /* fall through to SearXNG */
-        }
-      }
-
-      // SearXNG fallback
-      if (results.length === 0) {
-        try {
-          const resp = await fetch(
-            `${searxUrl}/search?q=${encodeURIComponent(query)}&format=json`,
-            { signal: AbortSignal.timeout(10_000) },
-          );
-          if (resp.ok) {
-            const data = (await resp.json()) as {
-              results?: Array<{ title: string; url: string; content: string }>;
-            };
-            results = (data.results ?? []).slice(0, limit).map((r) => ({
-              title: r.title,
-              url: r.url,
-              snippet: r.content ?? "",
-            }));
-            provider = "SearXNG";
-          }
-        } catch {
-          /* both failed */
-        }
-      }
-
-      if (results.length === 0)
-        return { ok: true, text: `No results for "${query}".` };
-      const formatted = results
-        .map(
-          (r, i) =>
-            `${i + 1}. ${r.title}\n   ${r.url}\n   ${r.snippet.slice(0, 200)}`,
-        )
-        .join("\n\n");
-      return {
-        ok: true,
-        text: `Search results for "${query}" (via ${provider}):\n\n${formatted}`,
-      };
-    }
-
     // ── Web fetch ────────────────────────────────────────────────────────
 
     case "fetch_url": {

package/src/core/plugin.ts

@@ -61,11 +61,22 @@ export interface TalonPlugin {
   destroy?(): Promise<void> | void;
 
   /**
-   * Absolute path to the MCP server script (spawned as subprocess).
+   * Absolute path to the MCP server script (spawned as subprocess via node/tsx).
    * Omit if the plugin only provides action handlers without MCP tools.
+   * For non-Node MCP servers (Python, Go, etc.), use `mcpServer` instead.
    */
   mcpServerPath?: string;
 
+  /**
+   * Custom MCP server command and arguments (e.g. Python, Go, Rust servers).
+   * Takes priority over `mcpServerPath` when both are set.
+   * Example: { command: "/path/to/python", args: ["-m", "mempalace.mcp_server"] }
+   */
+  mcpServer?: {
+    readonly command: string;
+    readonly args: readonly string[];
+  };
+
   /**
    * Map plugin config to env vars for the MCP subprocess and action handlers.
    * Called once at load time. Values are set on process.env for the main
@@ -309,6 +320,18 @@ function extractPlugin(mod: Record<string, unknown>): TalonPlugin | null {
     typeof plugin.mcpServerPath !== "string"
   )
     return null;
+  if (plugin.mcpServer !== undefined) {
+    if (typeof plugin.mcpServer !== "object" || plugin.mcpServer === null)
+      return null;
+    const srv = plugin.mcpServer as Record<string, unknown>;
+    if (
+      typeof srv.command !== "string" ||
+      !srv.command ||
+      !Array.isArray(srv.args) ||
+      !srv.args.every((a) => typeof a === "string")
+    )
+      return null;
+  }
   if (plugin.frontends !== undefined && !Array.isArray(plugin.frontends))
     return null;
   return candidate as TalonPlugin;
@@ -336,6 +359,49 @@ export async function destroyPlugins(): Promise<void> {
   await registry.destroyAll();
 }
 
+/**
+ * Register a built-in plugin directly (bypasses filesystem loader).
+ * Used for tightly-integrated plugins like mempalace that are configured
+ * via dedicated config fields rather than the plugins[] array.
+ *
+ * NOTE: This only registers the plugin — it does NOT call `init()`.
+ * The caller is responsible for calling `plugin.init()` separately
+ * after registration if initialization is needed.
+ */
+export function registerPlugin(
+  plugin: TalonPlugin,
+  config: Record<string, unknown> = {},
+): void {
+  // Check for duplicates first — avoids re-running expensive validation
+  if (registry.getByName(plugin.name)) {
+    logWarn(
+      "plugin",
+      `Built-in plugin "${plugin.name}" already registered — skipping`,
+    );
+    return;
+  }
+
+  const errors = plugin.validateConfig?.(config);
+  if (errors && errors.length > 0) {
+    logError(
+      "plugin",
+      `Built-in plugin "${plugin.name}" config validation failed:\n  ${errors.join("\n  ")}`,
+    );
+    return;
+  }
+
+  const envVars = plugin.getEnvVars?.(config) ?? {};
+  for (const [k, v] of Object.entries(envVars)) {
+    process.env[k] = v;
+  }
+  const loaded: LoadedPlugin = { plugin, config, envVars, path: "(built-in)" };
+  registry.register(loaded);
+
+  const version = plugin.version ? ` v${plugin.version}` : "";
+  const desc = plugin.description ? ` — ${plugin.description}` : "";
+  log("plugin", `Registered built-in: ${plugin.name}${version}${desc}`);
+}
+
 /**
  * Collect system prompt additions from all plugins.
  * Called during config/prompt assembly.
@@ -396,13 +462,22 @@ export interface McpServerConfig {
 }
 
 /**
- * Build MCP server entries for all plugins that provide an MCP server.
- * Plugins without `mcpServerPath` are skipped.
+ * Build MCP server entries for plugins that provide an MCP server.
+ * Plugins can expose an MCP server in two ways:
+ *   - `mcpServerPath` — path to a Node/TypeScript MCP server script (run via tsx)
+ *   - `mcpServer` — custom command/args for non-Node servers (Python, Go, etc.)
+ * Plugins with neither are skipped. When both are set, `mcpServer` takes priority.
+ *
+ * @param only — optional list of plugin names to include. If omitted, all
+ *   plugins with MCP servers are returned. Pass `[]` to get none.
  */
 export function getPluginMcpServers(
   bridgeUrl: string,
   chatId: string,
+  only?: string[],
 ): Record<string, McpServerConfig> {
+  if (only !== undefined && only.length === 0) return {};
+
   const servers: Record<string, McpServerConfig> = {};
 
   // Resolve tsx from Talon's own node_modules (not cwd which may be ~/.talon/workspace/)
@@ -412,20 +487,32 @@ export function getPluginMcpServers(
   );
 
   for (const { plugin, envVars } of registry.all) {
-    if (!plugin.mcpServerPath) continue;
-
-    servers[`${plugin.name}-tools`] = {
-      command: process.platform === "win32" ? "npx" : "node",
-      args:
-        process.platform === "win32"
-          ? ["tsx", plugin.mcpServerPath]
-          : ["--import", tsxPath, plugin.mcpServerPath],
-      env: {
-        TALON_BRIDGE_URL: bridgeUrl,
-        TALON_CHAT_ID: chatId,
-        ...envVars,
-      },
+    // Skip plugins not in the allow-list when filtering
+    if (only !== undefined && !only.includes(plugin.name)) continue;
+    const baseEnv = {
+      TALON_BRIDGE_URL: bridgeUrl,
+      TALON_CHAT_ID: chatId,
+      ...envVars,
     };
+
+    if (plugin.mcpServer) {
+      // Custom command/args (Python, Go, etc.) — no tsx wrapper
+      servers[`${plugin.name}-tools`] = {
+        command: plugin.mcpServer.command,
+        args: [...plugin.mcpServer.args],
+        env: baseEnv,
+      };
+    } else if (plugin.mcpServerPath) {
+      // Existing Node/tsx pattern
+      servers[`${plugin.name}-tools`] = {
+        command: process.platform === "win32" ? "npx" : "node",
+        args:
+          process.platform === "win32"
+            ? ["tsx", plugin.mcpServerPath]
+            : ["--import", tsxPath, plugin.mcpServerPath],
+        env: baseEnv,
+      };
+    }
   }
 
   return servers;

package/src/core/tools/bridge.ts

@@ -0,0 +1,40 @@
+/**
+ * Bridge utilities — shared by the unified MCP server.
+ *
+ * Extracted from the old per-backend tools.ts files so there's
+ * exactly one copy of callBridge / textResult.
+ */
+
+import type { BridgeFunction } from "./types.js";
+
+/** Create a bridge caller bound to a specific URL and chat. */
+export function createBridge(
+  bridgeUrl: string,
+  chatId: string,
+): BridgeFunction {
+  return async (action, params) => {
+    const resp = await fetch(`${bridgeUrl}/action`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ action, ...params, _chatId: chatId }),
+      signal: AbortSignal.timeout(120_000),
+    });
+    if (!resp.ok) {
+      const text = await resp.text();
+      throw new Error(`Bridge error (${resp.status}): ${text}`);
+    }
+    return resp.json();
+  };
+}
+
+/** Wrap a bridge result into the MCP content format. */
+export function textResult(result: unknown): {
+  content: Array<{ type: "text"; text: string }>;
+} {
+  const r = result as { text?: string; error?: string };
+  return {
+    content: [
+      { type: "text" as const, text: r.text ?? JSON.stringify(result) },
+    ],
+  };
+}

package/src/core/tools/chat.ts

@@ -0,0 +1,52 @@
+/**
+ * Chat info tools — metadata, admins, settings.
+ */
+
+import { z } from "zod";
+import type { ToolDefinition } from "./types.js";
+
+export const chatTools: ToolDefinition[] = [
+  {
+    name: "get_chat_info",
+    description: "Get chat title, type, member count.",
+    schema: {},
+    execute: (_params, bridge) => bridge("get_chat_info", {}),
+    tag: "chat",
+  },
+
+  {
+    name: "get_chat_admins",
+    description: "List chat administrators.",
+    schema: {},
+    execute: (_params, bridge) => bridge("get_chat_admins", {}),
+    frontends: ["telegram"],
+    tag: "chat",
+  },
+
+  {
+    name: "get_chat_member_count",
+    description: "Get total member count.",
+    schema: {},
+    execute: (_params, bridge) => bridge("get_chat_member_count", {}),
+    frontends: ["telegram"],
+    tag: "chat",
+  },
+
+  {
+    name: "set_chat_title",
+    description: "Change chat title (admin).",
+    schema: { title: z.string() },
+    execute: (params, bridge) => bridge("set_chat_title", params),
+    frontends: ["telegram"],
+    tag: "chat",
+  },
+
+  {
+    name: "set_chat_description",
+    description: "Change chat description (admin).",
+    schema: { description: z.string() },
+    execute: (params, bridge) => bridge("set_chat_description", params),
+    frontends: ["telegram"],
+    tag: "chat",
+  },
+];