@pnds/pond 0.2.0 → 1.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pnds/pond",
-  "version": "0.2.0",
+  "version": "1.0.1",
   "description": "OpenClaw channel plugin for Pond IM",
   "license": "MIT",
   "repository": {
@@ -14,7 +14,7 @@
     "openclaw.plugin.json"
   ],
   "dependencies": {
-    "@pnds/sdk": "^0.1.1"
+    "@pnds/sdk": "1.0.1"
   },
   "devDependencies": {
     "typescript": "^5.7.0"

package/src/gateway.ts

@@ -49,46 +49,87 @@ async function dispatchToAgent(opts: {
   config: PondChannelConfig;
   agentUserId: string;
   accountId: string;
+  sessionKey: string;
   chatId: string;
   messageId: string;
   inboundCtx: Record<string, unknown>;
   log?: { info: (msg: string) => void; warn: (msg: string) => void; error: (msg: string) => void };
 }) {
-  const { core, cfg, client, config, agentUserId, accountId, chatId, messageId, inboundCtx, log } = opts;
+  const { core, cfg, client, config, agentUserId, accountId, sessionKey, chatId, messageId, inboundCtx, log } = opts;
+  const sessionKeyLower = sessionKey.toLowerCase();
   let thinkingSent = false;
+  let runIdPromise: Promise<string | undefined> | undefined;
+  let reasoningBuffer = "";
   try {
     await core.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
       ctx: inboundCtx,
       cfg,
       dispatcherOptions: {
-        deliver: async (payload: { text?: string }) => {
+        deliver: async (payload: { text?: string }, info: { kind: string }) => {
           const replyText = payload.text?.trim();
           if (!replyText) return;
-          await client.sendMessage(config.org_id, chatId, {
-            message_type: "text",
-            content: { text: replyText },
-          });
+          // Wait for run creation to complete before sending
+          const runId = runIdPromise ? await runIdPromise : undefined;
+
+          if (info.kind === "final") {
+            // Final reply → chat message
+            await client.sendMessage(config.org_id, chatId, {
+              message_type: "text",
+              content: { text: replyText },
+              agent_run_id: runId,
+            });
+          } else if (info.kind === "block" && runId) {
+            // Intermediate text → step with chat_projection hint (server decides)
+            try {
+              await client.createAgentStep(config.org_id, agentUserId, runId, {
+                step_type: "text",
+                content: { text: replyText },
+                chat_projection: true,
+              });
+            } catch (err) {
+              log?.warn(`pond[${accountId}]: failed to create text step: ${String(err)}`);
+            }
+          }
+          // kind === "tool" → ignore (handled by hooks)
         },
         onReplyStart: () => {
           if (thinkingSent) return;
           thinkingSent = true;
-          (async () => {
+          runIdPromise = (async () => {
             try {
               const run = await client.createAgentRun(config.org_id, agentUserId, {
                 trigger_type: "mention",
                 trigger_ref: { message_id: messageId },
                 chat_id: chatId,
               });
-              const state = getPondAccountState(accountId);
-              if (state) state.activeRunId = run.id;
-              await client.createAgentStep(config.org_id, agentUserId, run.id, {
-                step_type: "thinking",
-                content: { text: "" },
-              });
+              return run.id;
             } catch (err) {
               log?.warn(`pond[${accountId}]: failed to create agent run: ${String(err)}`);
+              return undefined;
             }
           })();
+          // Store promise immediately so hooks can await it before the run is created
+          const state = getPondAccountState(accountId);
+          if (state) state.activeRuns.set(sessionKeyLower, runIdPromise);
+        },
+      },
+      replyOptions: {
+        onReasoningStream: (payload: { text?: string }) => {
+          reasoningBuffer += payload.text ?? "";
+        },
+        onReasoningEnd: async () => {
+          const runId = runIdPromise ? await runIdPromise : undefined;
+          if (runId && reasoningBuffer) {
+            try {
+              await client.createAgentStep(config.org_id, agentUserId, runId, {
+                step_type: "thinking",
+                content: { text: reasoningBuffer },
+              });
+            } catch (err) {
+              log?.warn(`pond[${accountId}]: failed to create thinking step: ${String(err)}`);
+            }
+          }
+          reasoningBuffer = "";
         },
       },
     });
@@ -155,6 +196,10 @@ export const pondGateway: ChannelGatewayAdapter<ResolvedPondAccount> = {
     let sessionId = "";
     // Heartbeat interval handle — created inside hello handler with server-provided interval
     let heartbeatTimer: ReturnType<typeof setInterval> | null = null;
+    // Track active dispatches per chat for typing indicator management
+    const activeDispatches = new Map<string, { count: number; typingTimer: ReturnType<typeof setInterval> }>();
+    // Heartbeat watchdog: detect event loop blocking during long CC runs
+    let lastHeartbeatAt = Date.now();
 
     // Log connection state changes (covers reconnection)
     ws.onStateChange((state) => {
@@ -174,11 +219,20 @@ export const pondGateway: ChannelGatewayAdapter<ResolvedPondAccount> = {
           client,
           orgId: config.org_id,
           agentUserId,
+          activeRuns: new Map(),
         });
 
         // (Re)start heartbeat with server-provided interval
         if (heartbeatTimer) clearInterval(heartbeatTimer);
+        lastHeartbeatAt = Date.now();
         heartbeatTimer = setInterval(() => {
+          const now = Date.now();
+          const expectedMs = intervalSec * 1000;
+          const drift = now - lastHeartbeatAt - expectedMs;
+          if (drift > 15000) {
+            log?.warn(`pond[${ctx.accountId}]: heartbeat drift ${drift}ms — event loop may be blocked`);
+          }
+          lastHeartbeatAt = now;
           if (ws.state !== "connected") return;
           ws.sendAgentHeartbeat(sessionId, {
             hostname: os.hostname(),
@@ -195,8 +249,9 @@ export const pondGateway: ChannelGatewayAdapter<ResolvedPondAccount> = {
 
     // Track chat type changes (new chats, renames, etc.)
     ws.on("chat.update", (data: ChatUpdateData) => {
-      if (data.changes && typeof data.changes.type === "string") {
-        chatTypeMap.set(data.chat_id, data.changes.type as Chat["type"]);
+      const changes = data.changes as Record<string, unknown> | undefined;
+      if (changes && typeof changes.type === "string") {
+        chatTypeMap.set(data.chat_id, changes.type as Chat["type"]);
       }
     });
 
@@ -288,18 +343,45 @@ export const pondGateway: ChannelGatewayAdapter<ResolvedPondAccount> = {
         OriginatingTo: `pond:${chatId}`,
       });
 
-      await dispatchToAgent({
-        core,
-        cfg: ctx.cfg,
-        client,
-        config,
-        agentUserId,
-        accountId: ctx.accountId,
-        chatId,
-        messageId: data.id,
-        inboundCtx,
-        log,
-      });
+      // Manage typing indicator so the user sees the agent is working.
+      // Reference-counted: concurrent dispatches for the same chat share one timer.
+      const existingDispatch = activeDispatches.get(chatId);
+      if (existingDispatch) {
+        existingDispatch.count++;
+      } else {
+        if (ws.state === "connected") ws.sendTyping(chatId, "start");
+        // Frontend auto-clears typing after 3s, so refresh at 2s to avoid flicker
+        const typingRefresh = setInterval(() => {
+          if (ws.state === "connected") ws.sendTyping(chatId, "start");
+        }, 2000);
+        activeDispatches.set(chatId, { count: 1, typingTimer: typingRefresh });
+      }
+
+      try {
+        await dispatchToAgent({
+          core,
+          cfg: ctx.cfg,
+          client,
+          config,
+          agentUserId,
+          accountId: ctx.accountId,
+          sessionKey,
+          chatId,
+          messageId: data.id,
+          inboundCtx,
+          log,
+        });
+      } finally {
+        const dispatch = activeDispatches.get(chatId);
+        if (dispatch) {
+          dispatch.count--;
+          if (dispatch.count <= 0) {
+            clearInterval(dispatch.typingTimer);
+            activeDispatches.delete(chatId);
+            if (ws.state === "connected") ws.sendTyping(chatId, "stop");
+          }
+        }
+      }
     });
 
     // Re-apply platform config when server pushes an update notification
@@ -318,6 +400,11 @@ export const pondGateway: ChannelGatewayAdapter<ResolvedPondAccount> = {
     // Clean up on abort
     ctx.abortSignal.addEventListener("abort", () => {
       if (heartbeatTimer) clearInterval(heartbeatTimer);
+      // Clean up all active typing timers to prevent leaks
+      for (const [, dispatch] of activeDispatches) {
+        clearInterval(dispatch.typingTimer);
+      }
+      activeDispatches.clear();
       ws.disconnect();
       removePondAccountState(ctx.accountId);
       // Clear injected env vars so stale credentials don't leak to future subprocesses

package/src/hooks.ts

@@ -1,12 +1,13 @@
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
 import { extractAccountIdFromSessionKey } from "./session.js";
-import { getPondAccountState, getSessionChatId } from "./runtime.js";
+import { getActiveRunId, getPondAccountState, getSessionChatId } from "./runtime.js";
 
 /**
  * Resolve the PondClient + orgId + runId for a hook context.
- * Matches by accountId extracted from the session key.
+ * Awaits the run ID promise so hooks that fire before createAgentRun
+ * completes will block until the run ID is available (not silently drop).
  */
-function resolveClientForHook(sessionKey: string | undefined) {
+async function resolveClientForHook(sessionKey: string | undefined) {
   if (!sessionKey) return undefined;
   // Use stored mapping to recover original (case-sensitive) chat ID,
   // because openclaw normalizes session keys to lowercase.
@@ -17,7 +18,10 @@ function resolveClientForHook(sessionKey: string | undefined) {
 
   const state = getPondAccountState(accountId);
   if (!state) return undefined;
-  return { ...state, chatId };
+
+  // Await the run ID promise — may block briefly if the run is still being created
+  const activeRunId = await getActiveRunId(state, sessionKey);
+  return { ...state, chatId, activeRunId };
 }
 
 const POND_CLI_CONTEXT = `## Pond CLI
@@ -48,33 +52,38 @@ export function registerPondHooks(api: OpenClawPluginApi) {
   });
 
   // before_tool_call -> send tool_call step to AgentRun
-  api.on("before_tool_call", async (event, ctx) => {
-    const resolved = resolveClientForHook(ctx.sessionKey);
-    if (!resolved || !resolved.activeRunId) return;
-    try {
-      await resolved.client.createAgentStep(resolved.orgId, resolved.agentUserId, resolved.activeRunId, {
-        step_type: "tool_call",
-        content: {
-          tool_name: event.toolName,
-          tool_input: event.params ?? {},
-          status: "running",
-          started_at: new Date().toISOString(),
-        },
-      });
-    } catch (err) {
-      log?.warn(`pond hook before_tool_call failed: ${String(err)}`);
-    }
+  // Fire-and-forget: before_tool_call is an awaited hook in OpenClaw (can block/modify
+  // tool params), so we must not block tool execution waiting for run creation.
+  api.on("before_tool_call", (event, ctx) => {
+    void (async () => {
+      const resolved = await resolveClientForHook(ctx.sessionKey);
+      if (!resolved || !resolved.activeRunId || !event.toolCallId) return;
+      try {
+        await resolved.client.createAgentStep(resolved.orgId, resolved.agentUserId, resolved.activeRunId, {
+          step_type: "tool_call",
+          content: {
+            call_id: event.toolCallId,
+            tool_name: event.toolName,
+            tool_input: event.params ?? {},
+            status: "running",
+            started_at: new Date().toISOString(),
+          },
+        });
+      } catch (err) {
+        log?.warn(`pond hook before_tool_call failed: ${String(err)}`);
+      }
+    })();
   });
 
   // after_tool_call -> send tool_result step to AgentRun
   api.on("after_tool_call", async (event, ctx) => {
-    const resolved = resolveClientForHook(ctx.sessionKey);
-    if (!resolved || !resolved.activeRunId) return;
+    const resolved = await resolveClientForHook(ctx.sessionKey);
+    if (!resolved || !resolved.activeRunId || !event.toolCallId) return;
     try {
       await resolved.client.createAgentStep(resolved.orgId, resolved.agentUserId, resolved.activeRunId, {
         step_type: "tool_result",
         content: {
-          tool_call_id: event.toolCallId ?? "",
+          call_id: event.toolCallId,
           tool_name: event.toolName,
           status: event.error ? "error" : "success",
           output: event.error ?? (typeof event.result === "string" ? event.result : JSON.stringify(event.result ?? "")),
@@ -89,23 +98,25 @@ export function registerPondHooks(api: OpenClawPluginApi) {
 
   // agent_end -> complete the AgentRun
   api.on("agent_end", async (_event, ctx) => {
-    const resolved = resolveClientForHook(ctx.sessionKey);
+    const resolved = await resolveClientForHook(ctx.sessionKey);
     if (!resolved) {
       log?.warn(`pond hook agent_end: could not resolve client (sessionKey=${ctx.sessionKey})`);
       return;
     }
     if (!resolved.activeRunId) return;
+    const accountId = extractAccountIdFromSessionKey(ctx.sessionKey ?? "");
+    const state = accountId ? getPondAccountState(accountId) : undefined;
     try {
       await resolved.client.updateAgentRun(resolved.orgId, resolved.agentUserId, resolved.activeRunId, {
         status: "completed",
       });
-      // Clear the active run
-      const state = getPondAccountState(
-        extractAccountIdFromSessionKey(ctx.sessionKey ?? "") ?? "",
-      );
-      if (state) state.activeRunId = undefined;
     } catch (err) {
       log?.warn(`pond hook agent_end failed: ${String(err)}`);
+    } finally {
+      // Always clear local state — even if the server call failed, the run is over locally
+      if (state && ctx.sessionKey) {
+        state.activeRuns.delete(ctx.sessionKey.toLowerCase());
+      }
     }
   });
 }

package/src/outbound.ts

@@ -1,6 +1,6 @@
 import type { ChannelOutboundAdapter } from "openclaw/plugin-sdk";
 import { resolvePondAccount } from "./accounts.js";
-import { getPondAccountState } from "./runtime.js";
+import { getPondAccountState, getSessionChatId } from "./runtime.js";
 import { PondClient } from "@pnds/sdk";
 import type { SendMessageRequest } from "@pnds/sdk";
 
@@ -22,9 +22,21 @@ export const pondOutbound: ChannelOutboundAdapter = {
     const orgId = state?.orgId ?? account.config.org_id;
     const chatId = to;
 
+    // Match active run by chatId (outbound path has no sessionKey, but has chatId via `to`)
+    let agentRunId: string | undefined;
+    if (state) {
+      for (const [sessionKey, runPromise] of state.activeRuns.entries()) {
+        if (getSessionChatId(sessionKey) === chatId) {
+          agentRunId = await runPromise;
+          break;
+        }
+      }
+    }
+
     const req: SendMessageRequest = {
       message_type: "text",
       content: { text },
+      agent_run_id: agentRunId,
     };
     const msg = await client.sendMessage(orgId, chatId, req);
     return { channel: "pond", messageId: msg.id, channelId: chatId };

package/src/runtime.ts

@@ -19,9 +19,18 @@ export type PondAccountState = {
   client: PondClient;
   orgId: string;
   agentUserId: string;
-  activeRunId?: string; // current AgentRun ID, set by gateway on reply start
+  activeRuns: Map<string, Promise<string | undefined>>; // sessionKey (lowercased) → runId promise
 };
 
+/** Resolve run ID for a session, awaiting if the run is still being created. */
+export async function getActiveRunId(
+  state: PondAccountState,
+  sessionKey: string,
+): Promise<string | undefined> {
+  const promise = state.activeRuns.get(sessionKey.toLowerCase());
+  return promise ? await promise : undefined;
+}
+
 const accountStates = new Map<string, PondAccountState>();
 
 export function setPondAccountState(accountId: string, state: PondAccountState) {