@parall/parall 1.30.0 → 1.32.0

package/src/hooks.ts

@@ -1,8 +1,26 @@
-import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
-import { PRLL_BEHAVIOR, PRLL_REFERENCE_GUIDE, buildIdentity } from "@parall/agent-core";
-import { extractAccountIdFromSessionKey } from "./session.js";
-import { clearDispatchGroupKey, getAgentIdentity, getAgentSessionBinding, getDispatchGroupKey, getDispatchMessageId, getParallAccountState, getSessionChatId, setAgentSessionBinding } from "./runtime.js";
-import { resolveSessionId } from "./fork.js";
+import type { OpenClawPluginApi } from 'openclaw/plugin-sdk';
+import {
+  PRLL_BEHAVIOR,
+  PRLL_REFERENCE_GUIDE,
+  buildIdentity,
+  isParallSendCommand,
+  isParallNoReplyCommand,
+  recordToolCall,
+  recordMessageSend,
+  recordNoReply,
+} from '@parall/agent-core';
+import { extractAccountIdFromSessionKey } from './session.js';
+import {
+  clearDispatchGroupKey,
+  getAgentIdentity,
+  getAgentSessionBinding,
+  getDispatchGroupKey,
+  getDispatchMessageId,
+  getParallAccountState,
+  getSessionChatId,
+  setAgentSessionBinding,
+} from './runtime.js';
+import { resolveSessionId } from './fork.js';
 
 /**
  * Map the session's stored target ID (whatever the current dispatch routed
@@ -10,10 +28,10 @@ import { resolveSessionId } from "./fork.js";
  * Keeps tool_call / tool_result attribution correct across event types.
  */
 function stepTargetType(targetId: string): string {
-  if (targetId.startsWith("cht_")) return "chat";
-  if (targetId.startsWith("tsk_")) return "task";
-  if (targetId.startsWith("sch_")) return "schedule";
-  return "";
+  if (targetId.startsWith('cht_')) return 'chat';
+  if (targetId.startsWith('tsk_')) return 'task';
+  if (targetId.startsWith('sch_')) return 'schedule';
+  return '';
 }
 
 /**
@@ -37,14 +55,15 @@ async function resolveClientForHook(sessionKey: string | undefined) {
   if (!sessionId && state.sessionsDir) {
     const runtimeSessionId = resolveSessionId(state.sessionsDir, sessionKey);
     if (runtimeSessionId) {
-      const parentSessionId = sessionKey === state.orchestratorSessionKey
-        ? undefined
-        : state.orchestratorSessionKey
-          ? getAgentSessionBinding(accountId, state.orchestratorSessionKey)
-          : undefined;
+      const parentSessionId =
+        sessionKey === state.orchestratorSessionKey
+          ? undefined
+          : state.orchestratorSessionKey
+            ? getAgentSessionBinding(accountId, state.orchestratorSessionKey)
+            : undefined;
       try {
         const session = await state.client.createAgentSession(state.orgId, state.agentUserId, {
-          runtime_type: "openclaw",
+          runtime_type: 'openclaw',
           runtime_key: sessionKey,
           runtime_lane_key: sessionKey,
           runtime_session_id: runtimeSessionId,
@@ -101,15 +120,35 @@ export function registerParallHooks(api: OpenClawPluginApi) {
   // registration time, only after the gateway authenticates via getMe().
   // Uses process-global identity because hosted agents run one-agent-per-pod;
   // before_prompt_build doesn't receive session context anyway.
-  api.on("before_prompt_build", () => {
+  api.on('before_prompt_build', () => {
     return {
-      appendSystemContext: [buildIdentity(getAgentIdentity()), PRLL_CHANNEL_CONTEXT, PRLL_BEHAVIOR, PRLL_REFERENCE_GUIDE].join("\n\n"),
+      appendSystemContext: [
+        buildIdentity(getAgentIdentity()),
+        PRLL_CHANNEL_CONTEXT,
+        PRLL_BEHAVIOR,
+        PRLL_REFERENCE_GUIDE,
+      ].join('\n\n'),
     };
   });
 
-  // before_tool_call -> (1) await step creation to get step ID, (2) ENV injection for exec tool
-  api.on("before_tool_call", async (event, ctx) => {
+  const pendingSendCalls = new Map<string, boolean>();
+
+  // before_tool_call -> (1) update dispatch metrics, (2) await step creation, (3) ENV injection
+  // OpenClaw tool calls bypass the RuntimeEvent stream (they go through hooks, not the
+  // gateway-base for-await loop), so dispatch metrics must be updated here as well.
+  api.on('before_tool_call', async (event, ctx) => {
     const sessionKey = ctx.sessionKey;
+    if (sessionKey) {
+      recordToolCall(sessionKey);
+      if (event.toolName === 'exec' && event.toolCallId) {
+        const command = (event.params as Record<string, unknown>)?.command as string | undefined;
+        if (isParallSendCommand(command)) {
+          pendingSendCalls.set(event.toolCallId, true);
+        } else if (isParallNoReplyCommand(command)) {
+          recordNoReply(sessionKey);
+        }
+      }
+    }
 
     // (1) Create tool_call step and await to get step ID
     let stepId: string | undefined;
@@ -117,20 +156,25 @@ export function registerParallHooks(api: OpenClawPluginApi) {
     if (resolved?.sessionId && event.toolCallId) {
       const groupKey = sessionKey ? getDispatchGroupKey(sessionKey) : undefined;
       try {
-        const step = await resolved.client.createAgentStep(resolved.orgId, resolved.agentUserId, resolved.sessionId, {
-          step_type: "tool_call",
-          target_type: stepTargetType(resolved.chatId),
-          target_id: resolved.chatId || undefined,
-          content: {
-            call_id: event.toolCallId,
-            tool_name: event.toolName,
-            tool_input: event.params ?? {},
-            status: "running",
-            started_at: new Date().toISOString(),
+        const step = await resolved.client.createAgentStep(
+          resolved.orgId,
+          resolved.agentUserId,
+          resolved.sessionId,
+          {
+            step_type: 'tool_call',
+            target_type: stepTargetType(resolved.chatId),
+            target_id: resolved.chatId || undefined,
+            content: {
+              call_id: event.toolCallId,
+              tool_name: event.toolName,
+              tool_input: event.params ?? {},
+              status: 'running',
+              started_at: new Date().toISOString(),
+            },
+            group_key: groupKey,
+            runtime_key: event.toolCallId,
           },
-          group_key: groupKey,
-          runtime_key: event.toolCallId,
-        });
+        );
         stepId = step.id;
       } catch (err) {
         log?.warn(`parall hook before_tool_call failed: ${String(err)}`);
@@ -138,7 +182,7 @@ export function registerParallHooks(api: OpenClawPluginApi) {
     }
 
     // (2) ENV injection — only for the exec (Bash) tool
-    if (event.toolName !== "exec") return;
+    if (event.toolName !== 'exec') return;
     if (!sessionKey) return;
     const accountId = extractAccountIdFromSessionKey(sessionKey);
     if (!accountId) return;
@@ -160,7 +204,7 @@ export function registerParallHooks(api: OpenClawPluginApi) {
     }
     if (stepId) injectedEnv.PRLL_STEP_ID = stepId;
     if (chatId) {
-      if (chatId.startsWith("sch_")) {
+      if (chatId.startsWith('sch_')) {
         // Schedule-triggered dispatch: expose PRLL_SCHEDULE_ID so the agent
         // can resolve the schedule; deliberately do NOT set PRLL_CHAT_ID,
         // because schedule events have no chat to reply into, and leaving
@@ -183,7 +227,9 @@ export function registerParallHooks(api: OpenClawPluginApi) {
     if (event.toolCallId) injectedEnv.OPENCLAW_TOOL_CALL_ID = event.toolCallId;
 
     // Shallow merge — preserve agent's original env params
-    const existingEnv = (event.params as Record<string, unknown>)?.env as Record<string, string> | undefined;
+    const existingEnv = (event.params as Record<string, unknown>)?.env as
+      | Record<string, string>
+      | undefined;
 
     return {
       params: {
@@ -192,24 +238,37 @@ export function registerParallHooks(api: OpenClawPluginApi) {
     };
   });
 
-  // after_tool_call -> send tool_result step to AgentSession
-  api.on("after_tool_call", async (event, ctx) => {
+  // after_tool_call -> track CLI outcomes + send tool_result step to AgentSession
+  api.on('after_tool_call', async (event, ctx) => {
+    if (ctx.sessionKey && event.toolCallId && pendingSendCalls.delete(event.toolCallId)) {
+      recordMessageSend(ctx.sessionKey, !event.error);
+    }
+
     const resolved = await resolveClientForHook(ctx.sessionKey);
     if (!resolved?.sessionId || !event.toolCallId) return;
     try {
-      await resolved.client.createAgentStep(resolved.orgId, resolved.agentUserId, resolved.sessionId, {
-        step_type: "tool_result",
-        target_type: stepTargetType(resolved.chatId),
-        target_id: resolved.chatId || undefined,
-        content: {
-          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 ?? "")),
-          duration_ms: event.durationMs ?? 0,
-          collapsible: true,
+      await resolved.client.createAgentStep(
+        resolved.orgId,
+        resolved.agentUserId,
+        resolved.sessionId,
+        {
+          step_type: 'tool_result',
+          target_type: stepTargetType(resolved.chatId),
+          target_id: resolved.chatId || undefined,
+          content: {
+            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 ?? '')),
+            duration_ms: event.durationMs ?? 0,
+            collapsible: true,
+          },
         },
-      });
+      );
     } catch (err) {
       log?.warn(`parall hook after_tool_call failed: ${String(err)}`);
     }
@@ -218,7 +277,7 @@ export function registerParallHooks(api: OpenClawPluginApi) {
   // agent_end -> end of a dispatch cycle, NOT end of session.
   // Session lives across dispatches — don't update session status here.
   // Dispatch-specific IDs are cleaned up in the generic gateway; hooks only own the group key.
-  api.on("agent_end", async (event, ctx) => {
+  api.on('agent_end', async (event, ctx) => {
     if (ctx.sessionKey) {
       clearDispatchGroupKey(ctx.sessionKey);
     }

package/src/index.ts

@@ -1,13 +1,13 @@
-import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
-import { emptyPluginConfigSchema } from "openclaw/plugin-sdk/core";
-import { parallPlugin } from "./channel.js";
-import { setParallRuntime } from "./runtime.js";
-import { registerParallHooks } from "./hooks.js";
+import type { OpenClawPluginApi } from 'openclaw/plugin-sdk';
+import { emptyPluginConfigSchema } from 'openclaw/plugin-sdk/core';
+import { parallPlugin } from './channel.js';
+import { setParallRuntime } from './runtime.js';
+import { registerParallHooks } from './hooks.js';
 
 const plugin = {
-  id: "parall",
-  name: "Parall",
-  description: "Parall IM channel plugin — Agent-Native messaging with tool call visualization.",
+  id: 'parall',
+  name: 'Parall',
+  description: 'Parall IM channel plugin — Agent-Native messaging with tool call visualization.',
   configSchema: emptyPluginConfigSchema(),
   register(api: OpenClawPluginApi) {
     setParallRuntime(api.runtime);

package/src/oc-session.ts

@@ -6,14 +6,9 @@
 // pi-coding-agent/dist/core/session-manager.js for new migration steps
 // or structural changes to createBranchedSession / _buildIndex.
 
-import { randomUUID } from "node:crypto";
-import {
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  writeFileSync,
-} from "node:fs";
-import { join, resolve } from "node:path";
+import { randomUUID } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
 
 export const CURRENT_SESSION_VERSION = 3;
 
@@ -22,7 +17,7 @@ export const CURRENT_SESSION_VERSION = 3;
 // ---------------------------------------------------------------------------
 
 interface SessionHeader {
-  type: "session";
+  type: 'session';
   version: number;
   id: string;
   timestamp: string;
@@ -59,7 +54,7 @@ function generateId(existing: Map<string, unknown> | Set<string>): string {
 
 function loadEntries(filePath: string): AnyEntry[] {
   if (!existsSync(filePath)) return [];
-  const lines = readFileSync(filePath, "utf-8").trim().split("\n");
+  const lines = readFileSync(filePath, 'utf-8').trim().split('\n');
   const entries: AnyEntry[] = [];
   for (const line of lines) {
     if (!line.trim()) continue;
@@ -71,7 +66,7 @@ function loadEntries(filePath: string): AnyEntry[] {
   }
   if (entries.length === 0) return entries;
   const h = entries[0] as Record<string, unknown>;
-  if (h.type !== "session" || typeof h.id !== "string") return [];
+  if (h.type !== 'session' || typeof h.id !== 'string') return [];
   return entries;
 }
 
@@ -81,7 +76,7 @@ function migrateV1ToV2(entries: AnyEntry[]): void {
   const ids = new Set<string>();
   let prevId: string | null = null;
   for (const entry of entries) {
-    if ((entry as SessionHeader).type === "session") {
+    if ((entry as SessionHeader).type === 'session') {
       (entry as SessionHeader).version = 2;
       continue;
     }
@@ -90,11 +85,11 @@ function migrateV1ToV2(entries: AnyEntry[]): void {
     ids.add(e.id);
     e.parentId = prevId;
     prevId = e.id;
-    if (e.type === "compaction") {
+    if (e.type === 'compaction') {
       const comp = e as Record<string, unknown>;
-      if (typeof comp.firstKeptEntryIndex === "number") {
+      if (typeof comp.firstKeptEntryIndex === 'number') {
         const target = entries[comp.firstKeptEntryIndex as number] as SessionEntry | undefined;
-        if (target && target.type !== "session") {
+        if (target && target.type !== 'session') {
           comp.firstKeptEntryId = target.id;
         }
         delete comp.firstKeptEntryIndex;
@@ -105,19 +100,23 @@ function migrateV1ToV2(entries: AnyEntry[]): void {
 
 function migrateV2ToV3(entries: AnyEntry[]): void {
   for (const entry of entries) {
-    if ((entry as SessionHeader).type === "session") {
+    if ((entry as SessionHeader).type === 'session') {
       (entry as SessionHeader).version = 3;
       continue;
     }
     const e = entry as SessionEntry;
-    if (e.type === "message" && e.message && (e.message as Record<string, unknown>).role === "hookMessage") {
-      (e.message as Record<string, unknown>).role = "custom";
+    if (
+      e.type === 'message' &&
+      e.message &&
+      (e.message as Record<string, unknown>).role === 'hookMessage'
+    ) {
+      (e.message as Record<string, unknown>).role = 'custom';
     }
   }
 }
 
 function migrate(entries: AnyEntry[]): boolean {
-  const header = entries.find((e) => e.type === "session") as SessionHeader | undefined;
+  const header = entries.find((e) => e.type === 'session') as SessionHeader | undefined;
   const version = header?.version ?? 1;
   if (version >= CURRENT_SESSION_VERSION) return false;
   if (version < 2) migrateV1ToV2(entries);
@@ -130,7 +129,7 @@ function migrate(entries: AnyEntry[]): boolean {
 // ---------------------------------------------------------------------------
 
 export class SessionManager {
-  private sessionId = "";
+  private sessionId = '';
   private sessionFile: string | undefined;
   private readonly sessionDir: string;
   private readonly cwd: string;
@@ -174,12 +173,12 @@ export class SessionManager {
       this.flushed = true;
       return;
     }
-    const header = this.fileEntries.find((e) => e.type === "session") as SessionHeader | undefined;
+    const header = this.fileEntries.find((e) => e.type === 'session') as SessionHeader | undefined;
     if (header && header.version > CURRENT_SESSION_VERSION) {
       throw new Error(
         `Session file ${this.sessionFile} uses version ${header.version}, ` +
-        `but oc-session.ts only supports up to ${CURRENT_SESSION_VERSION}. ` +
-        `Sync oc-session.ts with upstream pi-coding-agent (see AGENTS.md step 4).`,
+          `but oc-session.ts only supports up to ${CURRENT_SESSION_VERSION}. ` +
+          `Sync oc-session.ts with upstream pi-coding-agent (see AGENTS.md step 4).`,
       );
     }
     this.sessionId = header?.id ?? randomUUID();
@@ -192,13 +191,19 @@ export class SessionManager {
     this.sessionId = randomUUID();
     const timestamp = new Date().toISOString();
     this.fileEntries = [
-      { type: "session", version: CURRENT_SESSION_VERSION, id: this.sessionId, timestamp, cwd: this.cwd },
+      {
+        type: 'session',
+        version: CURRENT_SESSION_VERSION,
+        id: this.sessionId,
+        timestamp,
+        cwd: this.cwd,
+      },
     ];
     this.byId.clear();
     this.labelsById.clear();
     this.leafId = null;
     this.flushed = false;
-    const ts = timestamp.replace(/[:.]/g, "-");
+    const ts = timestamp.replace(/[:.]/g, '-');
     this.sessionFile = join(this.sessionDir, `${ts}_${this.sessionId}.jsonl`);
   }
 
@@ -208,11 +213,11 @@ export class SessionManager {
     this.labelTimestampsById.clear();
     this.leafId = null;
     for (const entry of this.fileEntries) {
-      if (entry.type === "session") continue;
+      if (entry.type === 'session') continue;
       const e = entry as SessionEntry;
       this.byId.set(e.id, e);
       this.leafId = e.id;
-      if (e.type === "label") {
+      if (e.type === 'label') {
         if (e.label) {
           this.labelsById.set(e.targetId!, e.label);
           this.labelTimestampsById.set(e.targetId!, e.timestamp);
@@ -226,7 +231,10 @@ export class SessionManager {
 
   private rewrite(): void {
     if (!this.sessionFile) return;
-    writeFileSync(this.sessionFile, this.fileEntries.map((e) => JSON.stringify(e)).join("\n") + "\n");
+    writeFileSync(
+      this.sessionFile,
+      this.fileEntries.map((e) => JSON.stringify(e)).join('\n') + '\n',
+    );
   }
 
   // -- Public accessors ------------------------------------------------------
@@ -268,14 +276,14 @@ export class SessionManager {
     const branch = this.getBranch(leafId);
     if (branch.length === 0) throw new Error(`Entry ${leafId} not found`);
 
-    const pathWithoutLabels = branch.filter((e) => e.type !== "label");
+    const pathWithoutLabels = branch.filter((e) => e.type !== 'label');
     const newId = randomUUID();
     const timestamp = new Date().toISOString();
-    const ts = timestamp.replace(/[:.]/g, "-");
+    const ts = timestamp.replace(/[:.]/g, '-');
     const newFile = join(this.sessionDir, `${ts}_${newId}.jsonl`);
 
     const header: SessionHeader = {
-      type: "session",
+      type: 'session',
       version: CURRENT_SESSION_VERSION,
       id: newId,
       timestamp,
@@ -296,7 +304,7 @@ export class SessionManager {
     const labelEntries: SessionEntry[] = [];
     for (const { targetId, label, timestamp: labelTs } of labelsToWrite) {
       const le: SessionEntry = {
-        type: "label",
+        type: 'label',
         id: generateId(pathEntryIds),
         parentId,
         timestamp: labelTs ?? timestamp,
@@ -314,7 +322,7 @@ export class SessionManager {
     this.buildIndex();
 
     const hasAssistant = this.fileEntries.some(
-      (e) => e.type === "message" && (e as SessionEntry).message?.role === "assistant",
+      (e) => e.type === 'message' && (e as SessionEntry).message?.role === 'assistant',
     );
     if (hasAssistant) {
       this.rewrite();
@@ -329,9 +337,9 @@ export class SessionManager {
 
   static open(path: string): SessionManager {
     const entries = loadEntries(path);
-    const header = entries.find((e) => e.type === "session") as SessionHeader | undefined;
+    const header = entries.find((e) => e.type === 'session') as SessionHeader | undefined;
     const cwd = header?.cwd ?? process.cwd();
-    const dir = resolve(path, "..");
+    const dir = resolve(path, '..');
     return new SessionManager(cwd, dir, path);
   }
 }

package/src/outbound.ts

@@ -1,37 +1,38 @@
-import type { ChannelPlugin } from "openclaw/plugin-sdk/core";
+import type { ChannelPlugin } from 'openclaw/plugin-sdk/core';
 
 /** Extract ChannelOutboundAdapter from ChannelPlugin (removed from public SDK exports in 2026.3.24). */
-type ChannelOutboundAdapter = NonNullable<ChannelPlugin["outbound"]>;
-import { resolveParallAccount } from "./accounts.js";
-import { getParallAccountState } from "./runtime.js";
-import { ParallClient } from "@parall/sdk";
-import type { SendMessageRequest } from "@parall/sdk";
+type ChannelOutboundAdapter = NonNullable<ChannelPlugin['outbound']>;
+import { resolveParallAccount } from './accounts.js';
+import { getParallAccountState } from './runtime.js';
+import { ParallClient } from '@parall/sdk';
+import type { SendMessageRequest } from '@parall/sdk';
 
 export const parallOutbound: ChannelOutboundAdapter = {
-  deliveryMode: "direct",
+  deliveryMode: 'direct',
   textChunkLimit: 10000,
   chunker: null,
 
   sendText: async ({ cfg, to, text, accountId }) => {
     const account = resolveParallAccount({ cfg, accountId: accountId ?? undefined });
-    if (!account.enabled) throw new Error("Parall account is disabled");
-    if (!account.configured) throw new Error("Parall account is not configured: parall_url/api_key/org_id required");
+    if (!account.enabled) throw new Error('Parall account is disabled');
+    if (!account.configured)
+      throw new Error('Parall account is not configured: parall_url/api_key/org_id required');
 
     const state = getParallAccountState(account.accountId);
-    const client = state?.client ?? new ParallClient({
-      baseUrl: account.config.parall_url,
-      token: account.config.api_key,
-    });
+    const client =
+      state?.client ??
+      new ParallClient({
+        baseUrl: account.config.parall_url,
+        token: account.config.api_key,
+      });
     const orgId = state?.orgId ?? account.config.org_id;
     const chatId = to;
 
-    // Outbound path has no step context — send without agent_step_id.
-    // Step linkage happens via the CLI's ENV-injected PRLL_STEP_ID in the normal dispatch path.
     const req: SendMessageRequest = {
-      message_type: "text",
+      message_type: 'text',
       content: { text },
     };
     const msg = await client.sendMessage(orgId, chatId, req);
-    return { channel: "parall", messageId: msg.id, channelId: chatId };
+    return { channel: 'parall', messageId: msg.id, channelId: chatId };
   },
 };

package/src/routing.ts

@@ -1,8 +1,8 @@
 export {
   defaultRoutingStrategy,
   routeTrigger,
-} from "@parall/agent-core";
+} from '@parall/agent-core';
 export type {
   RoutingStrategy,
   TriggerDisposition,
-} from "@parall/agent-core";
+} from '@parall/agent-core';

package/src/runtime.ts

@@ -1,7 +1,7 @@
-import type { PluginRuntime } from "openclaw/plugin-sdk";
-import type { ParallClient, ParallWs } from "@parall/sdk";
-import type { AgentIdentity } from "@parall/agent-core";
-export type { ForkResult, DispatchState, ParallEvent } from "@parall/agent-core";
+import type { PluginRuntime } from 'openclaw/plugin-sdk';
+import type { ParallClient, ParallWs } from '@parall/sdk';
+import type { AgentIdentity } from '@parall/agent-core';
+export type { ForkResult, DispatchState, ParallEvent } from '@parall/agent-core';
 export {
   setSessionChatId,
   getSessionChatId,
@@ -17,7 +17,7 @@ export {
   setDispatchNoReply,
   getDispatchNoReply,
   clearDispatchNoReply,
-} from "@parall/agent-core";
+} from '@parall/agent-core';
 
 export type ParallAccountState = {
   client: ParallClient;
@@ -43,7 +43,7 @@ export function setParallRuntime(next: PluginRuntime) {
 
 export function getParallRuntime(): PluginRuntime {
   if (!runtime) {
-    throw new Error("Parall runtime not initialized");
+    throw new Error('Parall runtime not initialized');
   }
   return runtime;
 }
@@ -63,7 +63,11 @@ export function getParallAccountState(accountId: string): ParallAccountState | u
   return accountStates.get(accountId);
 }
 
-export function setAgentSessionBinding(accountId: string, sessionKey: string, agentSessionId: string) {
+export function setAgentSessionBinding(
+  accountId: string,
+  sessionKey: string,
+  agentSessionId: string,
+) {
   const state = accountStates.get(accountId);
   if (!state) return;
   const sessionBindings = state.sessionBindings ?? new Map<string, string>();

package/src/session.ts

@@ -1,4 +1,4 @@
-const PRLL_SESSION_PREFIX = "agent:main:parall:";
+const PRLL_SESSION_PREFIX = 'agent:main:parall:';
 
 /** Build OpenClaw session key from Parall account, chat type, and chat ID. */
 export function buildSessionKey(accountId: string, chatType: string, chatId: string): string {
@@ -12,7 +12,7 @@ export function buildSessionKey(accountId: string, chatType: string, chatId: str
 export function extractAccountIdFromSessionKey(sessionKey: string | undefined): string | undefined {
   if (!sessionKey?.startsWith(PRLL_SESSION_PREFIX)) return undefined;
   const rest = sessionKey.slice(PRLL_SESSION_PREFIX.length);
-  const firstColon = rest.indexOf(":");
+  const firstColon = rest.indexOf(':');
   if (firstColon < 0) return undefined;
   return rest.slice(0, firstColon) || undefined;
 }
@@ -25,9 +25,9 @@ export function extractChatIdFromSessionKey(sessionKey: string | undefined): str
   if (!sessionKey?.startsWith(PRLL_SESSION_PREFIX)) return undefined;
   const rest = sessionKey.slice(PRLL_SESSION_PREFIX.length);
   // Skip accountId and chatType segments
-  const parts = rest.split(":");
+  const parts = rest.split(':');
   if (parts.length < 3) return undefined;
-  return parts.slice(2).join(":") || undefined;
+  return parts.slice(2).join(':') || undefined;
 }
 
 /** Build the single orchestrator session key for all Parall events. */