clawdbot 2026.1.4 → 2026.1.5-1

package/CHANGELOG.md

@@ -4,14 +4,45 @@
 
 ## Unreleased
 
+### Fixes
+- Onboarding: resolve CLI entrypoint when running via `npx` so gateway daemon install works without a build step.
+
+## 2026.1.5-1
+
+### Fixes
+- NPM package: include `dist/sessions` so `clawdbot agent` resolves session helpers in npx installs.
+- Node 25: avoid unsupported directory import by targeting `qrcode-terminal/vendor/QRCode/index.js`.
+
+## 2026.1.5
+
 ### Highlights
 - Models: add image-specific model config (`agent.imageModel` + fallbacks) and scan support.
 - Agent tools: new `image` tool routed to the image model (when configured).
+- Config: default model shorthands (`opus`, `sonnet`, `gpt`, `gpt-mini`, `gemini`, `gemini-flash`).
+- Docs: document built-in model shorthands + precedence (user config wins).
 
 ### Fixes
+- Control UI: render Markdown in tool result cards.
+- Control UI: prevent overlapping action buttons in Discord guild rules on narrow layouts.
 - Android: tapping the foreground service notification brings the app to the front. (#179) — thanks @Syhids
-- Cron tool passes `id` to the gateway for update/remove/run/runs (keeps `jobId` input). (#180) — thanks @adamgall
+- Cron tool uses `id` for update/remove/run/runs (aligns with gateway params). (#180) — thanks @adamgall
+- Control UI: chat view uses page scroll with sticky header/sidebar and fixed composer (no inner scroll frame).
 - macOS: treat location permission as always-only to avoid iOS-only enums. (#165) — thanks @Nachx639
+- macOS: make generated gateway protocol models `Sendable` for Swift 6 strict concurrency. (#195) — thanks @andranik-sahakyan
+- macOS: bundle QR code renderer modules so DMG gateway boot doesn't crash on missing qrcode-terminal vendor files.
+- WhatsApp: suppress typing indicator during heartbeat background tasks. (#190) — thanks @mcinteerj
+- WhatsApp: mark offline history sync messages as read without auto-reply. (#193) — thanks @mcinteerj
+- Discord: avoid duplicate replies when a provider emits late streaming `text_end` events (OpenAI/GPT).
+- CLI: use tailnet IP for local gateway calls when bind is tailnet/auto (fixes #176).
+- Env: load global `$CLAWDBOT_STATE_DIR/.env` (`~/.clawdbot/.env`) as a fallback after CWD `.env`.
+- Env: optional login-shell env fallback (opt-in; imports expected keys without overriding existing env).
+- Agent tools: OpenAI-compatible tool JSON Schemas (fix `browser`, normalize union schemas).
+- Onboarding: when running from source, auto-build missing Control UI assets (`pnpm ui:build`).
+- Discord/Slack: route reaction + system notifications to the correct session (no main-session bleed).
+- Agent tools: honor `agent.tools` allow/deny policy even when sandbox is off.
+- Discord: avoid duplicate replies when OpenAI emits repeated `message_end` events.
+- Commands: unify /status (inline) and command auth across providers; group bypass for authorized control commands; remove Discord /clawd slash handler.
+- Control UI: render Markdown in chat messages (sanitized).
 
 
 ## 2026.1.4

package/README.md

@@ -20,7 +20,7 @@ It answers you on the surfaces you already use (WhatsApp, Telegram, Discord, iMe
 
 If you want a personal, single-user assistant that feels local, fast, and always-on, this is it.
 
-Website: https://clawd.me · Docs: [`docs/index.md`](docs/index.md) · FAQ: [`docs/faq.md`](docs/faq.md) · Wizard: [`docs/wizard.md`](docs/wizard.md) · Docker (optional): [`docs/docker.md`](docs/docker.md) · Discord: https://discord.gg/clawd
+Website: https://clawd.me · Docs: [`docs/index.md`](docs/index.md) · FAQ: [`docs/faq.md`](docs/faq.md) · Wizard: [`docs/wizard.md`](docs/wizard.md) · Nix: [nix-clawdbot](https://github.com/clawdbot/nix-clawdbot) · Docker: [`docs/docker.md`](docs/docker.md) · Discord: https://discord.gg/clawd
 
 Preferred setup: run the onboarding wizard (`clawdbot onboard`). It walks through gateway, workspace, providers, and skills. The CLI wizard is the recommended path and works on **macOS, Windows, and Linux**.
 
@@ -111,6 +111,12 @@ Your surfaces
                └─ iOS node (Canvas + voice)
 ```
 
+## Skills registry (ClawdHub)
+
+ClawdHub is a minimal skill registry. With ClawdHub enabled, the agent can search for skills automatically and pull in new ones as needed.
+
+https://clawdhub.com
+
 ## Quick start (from source)
 
 Runtime: **Node ≥22** + **pnpm**.
@@ -214,6 +220,25 @@ Minimal `~/.clawdbot/clawdbot.json`:
 }
 ```
 
+Env vars: loaded from `.env` in the current working directory, plus a global fallback at `~/.clawdbot/.env` (aka `$CLAWDBOT_STATE_DIR/.env`) without overriding existing values.
+
+Optional: import missing keys from your login shell env (sources your shell profile) via config or env var:
+
+```json5
+{
+  env: {
+    shellEnv: {
+      enabled: true,
+      timeoutMs: 15000
+    }
+  }
+}
+```
+
+- Env var: `CLAWDBOT_LOAD_SHELL_ENV=1`
+- Timeout override: `CLAWDBOT_SHELL_ENV_TIMEOUT_MS=15000`
+- Behavior: only imports known/expected keys, never overrides existing `process.env`.
+
 ### WhatsApp
 
 - Link the device: `pnpm clawdbot login` (stores creds in `~/.clawdbot/credentials`).

package/dist/agents/pi-embedded-runner.js

@@ -192,6 +192,8 @@ export async function runEmbeddedPiAgent(params) {
             const bootstrapFiles = await loadWorkspaceBootstrapFiles(resolvedWorkspace);
             const contextFiles = buildBootstrapContextFiles(bootstrapFiles);
             const promptSkills = resolvePromptSkills(skillsSnapshot, skillEntries);
+            // Tool schemas must be provider-compatible (OpenAI requires top-level `type: "object"`).
+            // `createClawdbotCodingTools()` normalizes schemas so the session can pass them through unchanged.
             const tools = createClawdbotCodingTools({
                 bash: {
                     ...params.config?.agent?.bash,

package/dist/agents/pi-embedded-subscribe.js

@@ -283,6 +283,19 @@ export function subscribeEmbeddedPiSession(params) {
         assistantTextBaseline = 0;
     };
     const unsubscribe = params.session.subscribe((evt) => {
+        if (evt.type === "message_start") {
+            const msg = evt.message;
+            if (msg?.role === "assistant") {
+                // Start-of-message is a safer reset point than message_end: some providers
+                // may deliver late text_end updates after message_end, which would
+                // otherwise re-trigger block replies.
+                deltaBuffer = "";
+                blockBuffer = "";
+                lastStreamedAssistant = undefined;
+                lastBlockReplyText = undefined;
+                assistantTextBaseline = assistantTexts.length;
+            }
+        }
         if (evt.type === "tool_execution_start") {
             const toolName = String(evt.toolName);
             const toolCallId = String(evt.toolCallId);
@@ -482,8 +495,11 @@ export function subscribeEmbeddedPiSession(params) {
                     ? (extractFinalText(cleaned)?.trim() ?? cleaned)
                     : cleaned;
                 const addedDuringMessage = assistantTexts.length > assistantTextBaseline;
-                if (!addedDuringMessage && text)
-                    assistantTexts.push(text);
+                if (!addedDuringMessage && text) {
+                    const last = assistantTexts.at(-1);
+                    if (!last || last !== text)
+                        assistantTexts.push(text);
+                }
                 assistantTextBaseline = assistantTexts.length;
                 if ((blockReplyBreak === "message_end" || blockBuffer.length > 0) &&
                     text &&
@@ -505,7 +521,6 @@ export function subscribeEmbeddedPiSession(params) {
                 deltaBuffer = "";
                 blockBuffer = "";
                 lastStreamedAssistant = undefined;
-                lastBlockReplyText = undefined;
             }
         }
         if (evt.type === "tool_execution_end") {

package/dist/agents/pi-tools.js

@@ -171,6 +171,12 @@ function normalizeToolParameters(tool) {
         : undefined;
     if (!schema)
         return tool;
+    // Provider quirks:
+    // - Gemini rejects several JSON Schema keywords, so we scrub those.
+    // - OpenAI rejects function tool schemas unless the *top-level* is `type: "object"`.
+    //   (TypeBox root unions compile to `{ anyOf: [...] }` without `type`).
+    //
+    // Normalize once here so callers can always pass `tools` through unchanged.
     // If schema already has type + properties (no top-level anyOf to merge),
     // still clean it for Gemini compatibility
     if ("type" in schema &&
@@ -181,12 +187,29 @@ function normalizeToolParameters(tool) {
             parameters: cleanSchemaForGemini(schema),
         };
     }
-    if (!Array.isArray(schema.anyOf))
+    // Some tool schemas (esp. unions) may omit `type` at the top-level. If we see
+    // object-ish fields, force `type: "object"` so OpenAI accepts the schema.
+    if (!("type" in schema) &&
+        (typeof schema.properties === "object" || Array.isArray(schema.required)) &&
+        !Array.isArray(schema.anyOf) &&
+        !Array.isArray(schema.oneOf)) {
+        return {
+            ...tool,
+            parameters: cleanSchemaForGemini({ ...schema, type: "object" }),
+        };
+    }
+    const variantKey = Array.isArray(schema.anyOf)
+        ? "anyOf"
+        : Array.isArray(schema.oneOf)
+            ? "oneOf"
+            : null;
+    if (!variantKey)
         return tool;
+    const variants = schema[variantKey];
     const mergedProperties = {};
     const requiredCounts = new Map();
     let objectVariants = 0;
-    for (const entry of schema.anyOf) {
+    for (const entry of variants) {
         if (!entry || typeof entry !== "object")
             continue;
         const props = entry.properties;
@@ -222,9 +245,18 @@ function normalizeToolParameters(tool) {
     const nextSchema = { ...schema };
     return {
         ...tool,
+        // Flatten union schemas into a single object schema:
+        // - Gemini doesn't allow top-level `type` together with `anyOf`.
+        // - OpenAI rejects schemas without top-level `type: "object"`.
+        // Merging properties preserves useful enums like `action` while keeping schemas portable.
         parameters: cleanSchemaForGemini({
-            ...nextSchema,
-            type: nextSchema.type ?? "object",
+            type: "object",
+            ...(typeof nextSchema.title === "string"
+                ? { title: nextSchema.title }
+                : {}),
+            ...(typeof nextSchema.description === "string"
+                ? { description: nextSchema.description }
+                : {}),
             properties: Object.keys(mergedProperties).length > 0
                 ? mergedProperties
                 : (schema.properties ?? {}),
@@ -426,8 +458,15 @@ export function createClawdbotCodingTools(options) {
             return allowSlack;
         return true;
     });
-    const sandboxed = sandbox
-        ? filterToolsByPolicy(filtered, sandbox.tools)
+    const globallyFiltered = options?.config?.agent?.tools &&
+        (options.config.agent.tools.allow?.length ||
+            options.config.agent.tools.deny?.length)
+        ? filterToolsByPolicy(filtered, options.config.agent.tools)
         : filtered;
+    const sandboxed = sandbox
+        ? filterToolsByPolicy(globallyFiltered, sandbox.tools)
+        : globallyFiltered;
+    // Always normalize tool JSON Schemas before handing them to pi-agent/pi-ai.
+    // Without this, some providers (notably OpenAI) will reject root-level union schemas.
     return sandboxed.map(normalizeToolParameters);
 }

package/dist/agents/tools/browser-tool.js

@@ -72,95 +72,44 @@ const BrowserActSchema = Type.Union([
         targetId: Type.Optional(Type.String()),
     }),
 ]);
-const BrowserToolSchema = Type.Union([
-    Type.Object({
-        action: Type.Literal("status"),
-        controlUrl: Type.Optional(Type.String()),
-    }),
-    Type.Object({
-        action: Type.Literal("start"),
-        controlUrl: Type.Optional(Type.String()),
-    }),
-    Type.Object({
-        action: Type.Literal("stop"),
-        controlUrl: Type.Optional(Type.String()),
-    }),
-    Type.Object({
-        action: Type.Literal("tabs"),
-        controlUrl: Type.Optional(Type.String()),
-    }),
-    Type.Object({
-        action: Type.Literal("open"),
-        controlUrl: Type.Optional(Type.String()),
-        targetUrl: Type.String(),
-    }),
-    Type.Object({
-        action: Type.Literal("focus"),
-        controlUrl: Type.Optional(Type.String()),
-        targetId: Type.String(),
-    }),
-    Type.Object({
-        action: Type.Literal("close"),
-        controlUrl: Type.Optional(Type.String()),
-        targetId: Type.Optional(Type.String()),
-    }),
-    Type.Object({
-        action: Type.Literal("snapshot"),
-        controlUrl: Type.Optional(Type.String()),
-        format: Type.Optional(Type.Union([Type.Literal("aria"), Type.Literal("ai")])),
-        targetId: Type.Optional(Type.String()),
-        limit: Type.Optional(Type.Number()),
-    }),
-    Type.Object({
-        action: Type.Literal("screenshot"),
-        controlUrl: Type.Optional(Type.String()),
-        targetId: Type.Optional(Type.String()),
-        fullPage: Type.Optional(Type.Boolean()),
-        ref: Type.Optional(Type.String()),
-        element: Type.Optional(Type.String()),
-        type: Type.Optional(Type.Union([Type.Literal("png"), Type.Literal("jpeg")])),
-    }),
-    Type.Object({
-        action: Type.Literal("navigate"),
-        controlUrl: Type.Optional(Type.String()),
-        targetUrl: Type.String(),
-        targetId: Type.Optional(Type.String()),
-    }),
-    Type.Object({
-        action: Type.Literal("console"),
-        controlUrl: Type.Optional(Type.String()),
-        level: Type.Optional(Type.String()),
-        targetId: Type.Optional(Type.String()),
-    }),
-    Type.Object({
-        action: Type.Literal("pdf"),
-        controlUrl: Type.Optional(Type.String()),
-        targetId: Type.Optional(Type.String()),
-    }),
-    Type.Object({
-        action: Type.Literal("upload"),
-        controlUrl: Type.Optional(Type.String()),
-        paths: Type.Array(Type.String()),
-        ref: Type.Optional(Type.String()),
-        inputRef: Type.Optional(Type.String()),
-        element: Type.Optional(Type.String()),
-        targetId: Type.Optional(Type.String()),
-        timeoutMs: Type.Optional(Type.Number()),
-    }),
-    Type.Object({
-        action: Type.Literal("dialog"),
-        controlUrl: Type.Optional(Type.String()),
-        accept: Type.Boolean(),
-        promptText: Type.Optional(Type.String()),
-        targetId: Type.Optional(Type.String()),
-        timeoutMs: Type.Optional(Type.Number()),
-    }),
-    Type.Object({
-        action: Type.Literal("act"),
-        controlUrl: Type.Optional(Type.String()),
-        request: BrowserActSchema,
-    }),
-]);
+// IMPORTANT: OpenAI function tool schemas must have a top-level `type: "object"`.
+// A root-level `Type.Union([...])` compiles to `{ anyOf: [...] }` (no `type`),
+// which OpenAI rejects ("Invalid schema ... type: None"). Keep this schema an object.
+const BrowserToolSchema = Type.Object({
+    action: Type.Union([
+        Type.Literal("status"),
+        Type.Literal("start"),
+        Type.Literal("stop"),
+        Type.Literal("tabs"),
+        Type.Literal("open"),
+        Type.Literal("focus"),
+        Type.Literal("close"),
+        Type.Literal("snapshot"),
+        Type.Literal("screenshot"),
+        Type.Literal("navigate"),
+        Type.Literal("console"),
+        Type.Literal("pdf"),
+        Type.Literal("upload"),
+        Type.Literal("dialog"),
+        Type.Literal("act"),
+    ]),
+    controlUrl: Type.Optional(Type.String()),
+    targetUrl: Type.Optional(Type.String()),
+    targetId: Type.Optional(Type.String()),
+    limit: Type.Optional(Type.Number()),
+    format: Type.Optional(Type.Union([Type.Literal("aria"), Type.Literal("ai")])),
+    fullPage: Type.Optional(Type.Boolean()),
+    ref: Type.Optional(Type.String()),
+    element: Type.Optional(Type.String()),
+    type: Type.Optional(Type.Union([Type.Literal("png"), Type.Literal("jpeg")])),
+    level: Type.Optional(Type.String()),
+    paths: Type.Optional(Type.Array(Type.String())),
+    inputRef: Type.Optional(Type.String()),
+    timeoutMs: Type.Optional(Type.Number()),
+    accept: Type.Optional(Type.Boolean()),
+    promptText: Type.Optional(Type.String()),
+    request: Type.Optional(BrowserActSchema),
+});
 function resolveBrowserBaseUrl(controlUrl) {
     const cfg = loadConfig();
     const resolved = resolveBrowserConfig(cfg.browser);

package/dist/agents/tools/cron-tool.js

@@ -27,7 +27,7 @@ const CronToolSchema = Type.Union([
         gatewayUrl: Type.Optional(Type.String()),
         gatewayToken: Type.Optional(Type.String()),
         timeoutMs: Type.Optional(Type.Number()),
-        jobId: Type.String(),
+        id: Type.String(),
         patch: Type.Object({}, { additionalProperties: true }),
     }),
     Type.Object({
@@ -35,21 +35,21 @@ const CronToolSchema = Type.Union([
         gatewayUrl: Type.Optional(Type.String()),
         gatewayToken: Type.Optional(Type.String()),
         timeoutMs: Type.Optional(Type.Number()),
-        jobId: Type.String(),
+        id: Type.String(),
     }),
     Type.Object({
         action: Type.Literal("run"),
         gatewayUrl: Type.Optional(Type.String()),
         gatewayToken: Type.Optional(Type.String()),
         timeoutMs: Type.Optional(Type.Number()),
-        jobId: Type.String(),
+        id: Type.String(),
     }),
     Type.Object({
         action: Type.Literal("runs"),
         gatewayUrl: Type.Optional(Type.String()),
         gatewayToken: Type.Optional(Type.String()),
         timeoutMs: Type.Optional(Type.Number()),
-        jobId: Type.String(),
+        id: Type.String(),
     }),
     Type.Object({
         action: Type.Literal("wake"),
@@ -88,7 +88,7 @@ export function createCronTool() {
                     return jsonResult(await callGatewayTool("cron.add", gatewayOpts, params.job));
                 }
                 case "update": {
-                    const id = readStringParam(params, "jobId", { required: true });
+                    const id = readStringParam(params, "id", { required: true });
                     if (!params.patch || typeof params.patch !== "object") {
                         throw new Error("patch required");
                     }
@@ -98,15 +98,15 @@ export function createCronTool() {
                     }));
                 }
                 case "remove": {
-                    const id = readStringParam(params, "jobId", { required: true });
+                    const id = readStringParam(params, "id", { required: true });
                     return jsonResult(await callGatewayTool("cron.remove", gatewayOpts, { id }));
                 }
                 case "run": {
-                    const id = readStringParam(params, "jobId", { required: true });
+                    const id = readStringParam(params, "id", { required: true });
                     return jsonResult(await callGatewayTool("cron.run", gatewayOpts, { id }));
                 }
                 case "runs": {
-                    const id = readStringParam(params, "jobId", { required: true });
+                    const id = readStringParam(params, "id", { required: true });
                     return jsonResult(await callGatewayTool("cron.runs", gatewayOpts, { id }));
                 }
                 case "wake": {

package/dist/agents/workspace.js

@@ -3,7 +3,14 @@ import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { resolveUserPath } from "../utils.js";
-export const DEFAULT_AGENT_WORKSPACE_DIR = path.join(os.homedir(), "clawd");
+export function resolveDefaultAgentWorkspaceDir(env = process.env, homedir = os.homedir) {
+    const profile = env.CLAWDBOT_PROFILE?.trim();
+    if (profile && profile.toLowerCase() !== "default") {
+        return path.join(homedir(), `clawd-${profile}`);
+    }
+    return path.join(homedir(), "clawd");
+}
+export const DEFAULT_AGENT_WORKSPACE_DIR = resolveDefaultAgentWorkspaceDir();
 export const DEFAULT_AGENTS_FILENAME = "AGENTS.md";
 export const DEFAULT_SOUL_FILENAME = "SOUL.md";
 export const DEFAULT_TOOLS_FILENAME = "TOOLS.md";

package/dist/auto-reply/command-detection.js

@@ -0,0 +1,26 @@
+const CONTROL_COMMAND_RE = /(?:^|\s)\/(?:status|thinking|think|t|verbose|v|elevated|elev|model|queue|activation|send|restart|reset|new)(?=$|\s|:)\b/i;
+const CONTROL_COMMAND_EXACT = new Set([
+    "status",
+    "/status",
+    "restart",
+    "/restart",
+    "activation",
+    "/activation",
+    "send",
+    "/send",
+    "reset",
+    "/reset",
+    "new",
+    "/new",
+]);
+export function hasControlCommand(text) {
+    if (!text)
+        return false;
+    const trimmed = text.trim();
+    if (!trimmed)
+        return false;
+    const lowered = trimmed.toLowerCase();
+    if (CONTROL_COMMAND_EXACT.has(lowered))
+        return true;
+    return CONTROL_COMMAND_RE.test(text);
+}

package/dist/auto-reply/reply/agent-runner.js

@@ -15,6 +15,7 @@ import { enqueueFollowupRun, scheduleFollowupDrain, } from "./queue.js";
 import { extractReplyToTag } from "./reply-tags.js";
 export async function runReplyAgent(params) {
     const { commandBody, followupRun, queueKey, resolvedQueue, shouldSteer, shouldFollowup, isActive, isStreaming, opts, typing, sessionEntry, sessionStore, sessionKey, storePath, defaultModel, agentCfgContextTokens, resolvedVerboseLevel, isNewSession, blockStreamingEnabled, blockReplyChunking, resolvedBlockStreamingBreak, sessionCtx, shouldInjectGroupIntro, } = params;
+    const isHeartbeat = opts?.isHeartbeat === true;
     const shouldEmitToolResult = () => {
         if (!sessionKey || !storePath) {
             return resolvedVerboseLevel === "on";
@@ -126,7 +127,7 @@ export async function runReplyAgent(params) {
                     onPartialReply: opts?.onPartialReply
                         ? async (payload) => {
                             let text = payload.text;
-                            if (!opts?.isHeartbeat && text?.includes("HEARTBEAT_OK")) {
+                            if (!isHeartbeat && text?.includes("HEARTBEAT_OK")) {
                                 const stripped = stripHeartbeatToken(text, {
                                     mode: "message",
                                 });
@@ -140,7 +141,9 @@ export async function runReplyAgent(params) {
                                 }
                                 text = stripped.text;
                             }
-                            await typing.startTypingOnText(text);
+                            if (!isHeartbeat) {
+                                await typing.startTypingOnText(text);
+                            }
                             await opts.onPartialReply?.({
                                 text,
                                 mediaUrls: payload.mediaUrls,
@@ -150,7 +153,7 @@ export async function runReplyAgent(params) {
                     onBlockReply: blockStreamingEnabled && opts?.onBlockReply
                         ? async (payload) => {
                             let text = payload.text;
-                            if (!opts?.isHeartbeat && text?.includes("HEARTBEAT_OK")) {
+                            if (!isHeartbeat && text?.includes("HEARTBEAT_OK")) {
                                 const stripped = stripHeartbeatToken(text, {
                                     mode: "message",
                                 });
@@ -183,7 +186,9 @@ export async function runReplyAgent(params) {
                             }
                             pendingStreamedPayloadKeys.add(payloadKey);
                             const task = (async () => {
-                                await typing.startTypingOnText(cleaned);
+                                if (!isHeartbeat) {
+                                    await typing.startTypingOnText(cleaned);
+                                }
                                 await opts.onBlockReply?.(blockPayload);
                             })()
                                 .then(() => {
@@ -204,7 +209,7 @@ export async function runReplyAgent(params) {
                     onToolResult: opts?.onToolResult
                         ? async (payload) => {
                             let text = payload.text;
-                            if (!opts?.isHeartbeat && text?.includes("HEARTBEAT_OK")) {
+                            if (!isHeartbeat && text?.includes("HEARTBEAT_OK")) {
                                 const stripped = stripHeartbeatToken(text, {
                                     mode: "message",
                                 });
@@ -218,7 +223,9 @@ export async function runReplyAgent(params) {
                                 }
                                 text = stripped.text;
                             }
-                            await typing.startTypingOnText(text);
+                            if (!isHeartbeat) {
+                                await typing.startTypingOnText(text);
+                            }
                             await opts.onToolResult?.({
                                 text,
                                 mediaUrls: payload.mediaUrls,
@@ -259,7 +266,7 @@ export async function runReplyAgent(params) {
         if (pendingBlockTasks.size > 0) {
             await Promise.allSettled(pendingBlockTasks);
         }
-        const sanitizedPayloads = opts?.isHeartbeat
+        const sanitizedPayloads = isHeartbeat
             ? payloadArray
             : payloadArray.flatMap((payload) => {
                 const text = payload.text;
@@ -305,7 +312,7 @@ export async function runReplyAgent(params) {
                 return true;
             return false;
         });
-        if (shouldSignalTyping) {
+        if (shouldSignalTyping && !isHeartbeat) {
             await typing.startTypingLoop();
         }
         if (sessionStore && sessionKey) {