@parall/parall 1.30.0 → 1.32.0

package/dist/gateway.js

@@ -1,20 +1,21 @@
-import { ParallAgentGateway, parseShutdownDeadlineMs, } from "@parall/agent-core";
-import { ApiError, ParallClient, ParallWs } from "@parall/sdk";
-import * as crypto from "node:crypto";
-import * as os from "node:os";
-import * as path from "node:path";
-import { resolveParallAccount } from "./accounts.js";
-import { getParallRuntime, removeParallAccountState, setAgentIdentity, setAgentSessionBinding, setDispatchGroupKey, setParallAccountState, } from "./runtime.js";
-import { buildOrchestratorSessionKey } from "./session.js";
-import { fetchAndApplyPlatformConfig } from "./config-manager.js";
-import { startWikiHelper } from "./wiki-helper.js";
-import { SessionManager } from "./oc-session.js";
-import { cleanupForkSession, clearSessionState, forkOrchestratorSession, resolveSessionId, resolveTranscriptFile } from "./fork.js";
+import { ParallAgentGateway, parseShutdownDeadlineMs, parseForkDeadlineMs, parseDispatchDeadlineMs, initAgentTelemetry, createOtelLogger, } from '@parall/agent-core';
+import { appendPreparedLocalAttachmentRefs, ensureLocalAttachmentGitExclude, pinLocalAttachmentPaths, } from '@parall/agent-core/internal/attachment-input';
+import { ApiError, ParallClient, ParallWs } from '@parall/sdk';
+import * as crypto from 'node:crypto';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { resolveParallAccount } from './accounts.js';
+import { getParallRuntime, removeParallAccountState, setAgentIdentity, setAgentSessionBinding, setDispatchGroupKey, setParallAccountState, } from './runtime.js';
+import { buildOrchestratorSessionKey } from './session.js';
+import { fetchAndApplyPlatformConfig } from './config-manager.js';
+import { startWikiHelper } from './wiki-helper.js';
+import { SessionManager } from './oc-session.js';
+import { cleanupForkSession, clearSessionState, forkOrchestratorSession, resolveSessionId, resolveTranscriptFile, } from './fork.js';
 function resolveWsUrl(account) {
     if (account.config.ws_url)
         return account.config.ws_url;
-    const base = account.config.parall_url.replace(/\/$/, "");
-    const wsBase = base.replace(/^http/, "ws");
+    const base = account.config.parall_url.replace(/\/$/, '');
+    const wsBase = base.replace(/^http/, 'ws');
     return `${wsBase}/ws`;
 }
 async function getAgentMeWithLegacyFallback(client, orgId) {
@@ -42,15 +43,15 @@ function buildInboundCtx(core, accountId, event, sessionKey, bodyForAgent, earli
         To: `parall:orchestrator`,
         SessionKey: sessionKey,
         AccountId: accountId,
-        ChatType: event.targetType ?? "unknown",
+        ChatType: event.targetType ?? 'unknown',
         SenderName: event.senderName,
         SenderId: event.senderId,
-        Provider: "parall",
-        Surface: "parall",
+        Provider: 'parall',
+        Surface: 'parall',
         MessageSid: event.messageId,
         Timestamp: Date.now(),
         CommandAuthorized: true,
-        OriginatingChannel: "parall",
+        OriginatingChannel: 'parall',
         OriginatingTo: `parall:orchestrator`,
     });
 }
@@ -64,13 +65,13 @@ function buildInboundHistory(events) {
             meta.push(`[Thread: ${event.threadRootId}]`);
         if (event.attachments?.length) {
             for (const att of event.attachments) {
-                const safeMime = att.mimeType.replace(/[\r\n[\]|]/g, " ").trim();
+                const safeMime = att.mimeType.replace(/[\r\n[\]|]/g, ' ').trim();
                 meta.push(`[Attachment: prll://${att.id} | ${safeMime}]`);
             }
         }
         return {
             sender: event.senderName,
-            body: meta.length > 0 ? `${meta.join(" ")}\n${event.body}` : event.body,
+            body: meta.length > 0 ? `${meta.join(' ')}\n${event.body}` : event.body,
         };
     });
 }
@@ -145,69 +146,95 @@ async function waitForOpenClawSessionId(sessionsDir, sessionKey, timeoutMs = 10_
     return null;
 }
 function createOpenClawDispatchAdapter(opts) {
+    const activeStreams = new Map();
     return {
-        async *dispatch({ event, earlierEvents = [], bodyForAgent, sessionKey }) {
-            const stream = createRuntimeEventStream();
-            let reasoningBuffer = "";
-            let turnGroupKey = "";
-            const run = opts.core.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
-                ctx: buildInboundCtx(opts.core, opts.accountId, event, sessionKey, bodyForAgent, earlierEvents),
-                cfg: opts.cfg,
-                dispatcherOptions: {
-                    deliver: async (payload) => {
-                        const replyText = payload.text?.trim();
-                        if (!replyText)
-                            return;
-                        stream.push({
-                            type: "text",
-                            text: replyText,
-                            project: false,
-                            groupKey: turnGroupKey || undefined,
-                        });
-                    },
-                    onReplyStart: () => {
-                        turnGroupKey = crypto.randomUUID();
-                        setDispatchGroupKey(sessionKey, turnGroupKey);
-                    },
-                },
-                replyOptions: {
-                    onReasoningStream: (payload) => {
-                        reasoningBuffer += payload.text ?? "";
-                    },
-                    onReasoningEnd: async () => {
-                        if (!reasoningBuffer)
-                            return;
-                        stream.push({
-                            type: "thinking",
-                            text: reasoningBuffer,
-                            groupKey: turnGroupKey || undefined,
-                        });
-                        reasoningBuffer = "";
-                    },
-                },
-            });
-            run.then(() => stream.end()).catch((err) => stream.fail(err));
-            let sessionId;
+        abortDispatch(sessionKey) {
+            activeStreams.get(sessionKey)?.fail(new Error('dispatch deadline exceeded'));
+        },
+        async *dispatch({ event, earlierEvents = [], bodyForAgent, sessionKey, context }) {
+            let promptBody = bodyForAgent;
+            let releasePreparedAttachments = () => { };
             try {
-                sessionId = await Promise.race([
-                    waitForOpenClawSessionId(opts.sessionsDir, sessionKey),
-                    run.then(() => null, (err) => { throw err; }),
-                ]);
+                const prepared = await appendPreparedLocalAttachmentRefs(bodyForAgent, event, context, {
+                    workspaceDir: opts.workspaceDir,
+                    log: context.log,
+                });
+                promptBody = prepared.body;
+                releasePreparedAttachments = pinLocalAttachmentPaths(prepared.attachments.images);
             }
-            catch {
-                sessionId = null;
+            catch (err) {
+                context.log?.warn?.(`failed to prepare local attachments: ${String(err)}`);
             }
-            if (!sessionId) {
-                stream.fail(new Error(`OpenClaw did not expose a sessionId for ${sessionKey}`));
+            try {
+                const stream = createRuntimeEventStream();
+                activeStreams.set(sessionKey, stream);
+                let reasoningBuffer = '';
+                let turnGroupKey = '';
+                const run = opts.core.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+                    ctx: buildInboundCtx(opts.core, opts.accountId, event, sessionKey, promptBody, earlierEvents),
+                    cfg: opts.cfg,
+                    dispatcherOptions: {
+                        deliver: async (payload) => {
+                            const replyText = payload.text?.trim();
+                            if (!replyText)
+                                return;
+                            stream.push({
+                                type: 'text',
+                                text: replyText,
+                                project: false,
+                                groupKey: turnGroupKey || undefined,
+                            });
+                        },
+                        onReplyStart: () => {
+                            turnGroupKey = crypto.randomUUID();
+                            setDispatchGroupKey(sessionKey, turnGroupKey);
+                        },
+                    },
+                    replyOptions: {
+                        onReasoningStream: (payload) => {
+                            reasoningBuffer += payload.text ?? '';
+                        },
+                        onReasoningEnd: async () => {
+                            if (!reasoningBuffer)
+                                return;
+                            stream.push({
+                                type: 'thinking',
+                                text: reasoningBuffer,
+                                groupKey: turnGroupKey || undefined,
+                            });
+                            reasoningBuffer = '';
+                        },
+                    },
+                });
+                run.then(() => stream.end()).catch((err) => stream.fail(err));
+                let sessionId;
+                try {
+                    sessionId = await Promise.race([
+                        waitForOpenClawSessionId(opts.sessionsDir, sessionKey),
+                        run.then(() => null, (err) => {
+                            throw err;
+                        }),
+                    ]);
+                }
+                catch {
+                    sessionId = null;
+                }
+                if (!sessionId) {
+                    stream.fail(new Error(`OpenClaw did not expose a sessionId for ${sessionKey}`));
+                }
+                else {
+                    yield {
+                        type: 'runtime_session',
+                        runtimeSessionId: sessionId,
+                        runtimeLaneKey: sessionKey,
+                    };
+                }
+                yield* stream.stream();
             }
-            else {
-                yield {
-                    type: "runtime_session",
-                    runtimeSessionId: sessionId,
-                    runtimeLaneKey: sessionKey,
-                };
+            finally {
+                activeStreams.delete(sessionKey);
+                releasePreparedAttachments();
             }
-            yield* stream.stream();
         },
         getBranchPoint(sessionKey) {
             const transcriptFile = resolveTranscriptFile(opts.sessionsDir, sessionKey);
@@ -234,7 +261,7 @@ function createOpenClawDispatchAdapter(opts) {
             });
         },
         cleanupFork({ fork }) {
-            if (typeof fork.sessionFile !== "string")
+            if (typeof fork.sessionFile !== 'string')
                 return;
             cleanupForkSession({
                 sessionFile: fork.sessionFile,
@@ -250,7 +277,7 @@ export const parallGateway = {
         if (!account.enabled)
             return;
         if (!account.configured)
-            throw new Error("Parall account is not configured: parall_url/api_key/org_id required");
+            throw new Error('Parall account is not configured: parall_url/api_key/org_id required');
         const { config } = account;
         const core = getParallRuntime();
         const log = ctx.log;
@@ -267,106 +294,122 @@ export const parallGateway = {
             description: me.agent_profile?.description ?? undefined,
         });
         log?.info(`parall[${ctx.accountId}]: authenticated as ${me.display_name} (${agentUserId})`);
-        const stateDir = process.env.OPENCLAW_STATE_DIR
-            || path.join(process.env.HOME || "/data", ".openclaw");
-        const openclawConfigPath = path.join(stateDir, "openclaw.json");
-        const configManagerOpts = {
-            client,
-            stateDir,
-            configPath: openclawConfigPath,
-            credentials: { api_key: config.api_key, parall_url: config.parall_url },
-            log,
-        };
+        const telemetry = await initAgentTelemetry('parall-openclaw-agent', 'openclaw');
+        const otelLog = createOtelLogger('agent', 'openclaw-agent');
         try {
-            await fetchAndApplyPlatformConfig(configManagerOpts);
-        }
-        catch (err) {
-            log?.warn(`parall[${ctx.accountId}]: platform config fetch failed: ${String(err)}`);
-        }
-        let stopWikiHelper = null;
-        let wikiMountRoot;
-        try {
-            const wikiHelper = await startWikiHelper({
-                accountId: ctx.accountId,
-                parallUrl: config.parall_url,
-                apiKey: config.api_key,
-                orgId: config.org_id,
-                agentId: agentUserId,
+            const stateDir = process.env.OPENCLAW_STATE_DIR || path.join(process.env.HOME || '/data', '.openclaw');
+            const openclawConfigPath = path.join(stateDir, 'openclaw.json');
+            const configManagerOpts = {
+                client,
                 stateDir,
-                log,
-            });
-            wikiMountRoot = wikiHelper.mountRoot;
-            stopWikiHelper = wikiHelper.stop;
-        }
-        catch (err) {
-            log?.warn(`parall[${ctx.accountId}]: wiki helper startup failed: ${String(err)}`);
-        }
-        const wsUrl = resolveWsUrl(account);
-        const ws = new ParallWs({
-            getTicket: () => client.getWsTicket(),
-            wsUrl,
-        });
-        const orchestratorKey = buildOrchestratorSessionKey(ctx.accountId);
-        const sessionsDir = path.join(stateDir, "agents", "main", "sessions");
-        const dispatchAdapter = createOpenClawDispatchAdapter({
-            core,
-            cfg: ctx.cfg,
-            accountId: ctx.accountId,
-            sessionsDir,
-        });
-        const gateway = new ParallAgentGateway({
-            accountId: ctx.accountId,
-            client,
-            ws,
-            connectionLabel: wsUrl,
-            config: {
-                parall_url: config.parall_url,
-                api_key: config.api_key,
-                org_id: config.org_id,
-            },
-            agentUserId,
-            runtimeType: "openclaw",
-            runtimeKey: orchestratorKey,
-            runtimeRef: { hostname: os.hostname(), pid: process.pid },
-            dispatchAdapter,
-            log,
-            shutdownDeadlineMs: parseShutdownDeadlineMs(process.env.PRLL_SHUTDOWN_DEADLINE_MS),
-            onConfigUpdate: async () => {
+                configPath: openclawConfigPath,
+                credentials: { api_key: config.api_key, parall_url: config.parall_url },
+                log: otelLog,
+            };
+            try {
                 await fetchAndApplyPlatformConfig(configManagerOpts);
-            },
-            onSessionReady: async ({ activeSessionId }) => {
-                setParallAccountState(ctx.accountId, {
-                    client,
-                    apiUrl: config.parall_url,
+            }
+            catch (err) {
+                otelLog.warn(`parall[${ctx.accountId}]: platform config fetch failed: ${String(err)}`);
+            }
+            let stopWikiHelper = null;
+            let wikiMountRoot;
+            try {
+                const wikiHelper = await startWikiHelper({
+                    accountId: ctx.accountId,
+                    parallUrl: config.parall_url,
                     apiKey: config.api_key,
                     orgId: config.org_id,
-                    agentUserId,
-                    activeSessionId,
-                    sessionBindings: new Map(),
-                    sessionsDir,
-                    runtimeRef: { hostname: os.hostname(), pid: process.pid },
-                    wikiMountRoot,
-                    ws,
-                    orchestratorSessionKey: orchestratorKey,
+                    agentId: agentUserId,
+                    stateDir,
+                    log: otelLog,
                 });
-            },
-            onSessionBinding: async ({ sessionKey, agentSessionId }) => {
-                setAgentSessionBinding(ctx.accountId, sessionKey, agentSessionId);
-            },
-            onBeforeDisconnect: async () => {
-                stopWikiHelper?.();
-                removeParallAccountState(ctx.accountId);
-            },
-            onNewSession: () => { clearSessionState(sessionsDir, orchestratorKey); },
-        });
-        try {
-            await gateway.run(ctx.abortSignal);
+                wikiMountRoot = wikiHelper.mountRoot;
+                stopWikiHelper = wikiHelper.stop;
+            }
+            catch (err) {
+                otelLog.warn(`parall[${ctx.accountId}]: wiki helper startup failed: ${String(err)}`);
+            }
+            const wsUrl = resolveWsUrl(account);
+            const ws = new ParallWs({
+                getTicket: () => client.getWsTicket(),
+                wsUrl,
+            });
+            const orchestratorKey = buildOrchestratorSessionKey(ctx.accountId);
+            const sessionsDir = path.join(stateDir, 'agents', 'main', 'sessions');
+            const workspaceDir = process.cwd();
+            ensureLocalAttachmentGitExclude(workspaceDir);
+            const dispatchAdapter = createOpenClawDispatchAdapter({
+                core,
+                cfg: ctx.cfg,
+                accountId: ctx.accountId,
+                sessionsDir,
+                workspaceDir,
+            });
+            const gateway = new ParallAgentGateway({
+                accountId: ctx.accountId,
+                client,
+                ws,
+                connectionLabel: wsUrl,
+                config: {
+                    parall_url: config.parall_url,
+                    api_key: config.api_key,
+                    org_id: config.org_id,
+                },
+                agentUserId,
+                runtimeType: 'openclaw',
+                runtimeKey: orchestratorKey,
+                runtimeRef: { hostname: os.hostname(), pid: process.pid },
+                dispatchAdapter,
+                log: otelLog,
+                shutdownDeadlineMs: parseShutdownDeadlineMs(process.env.PRLL_SHUTDOWN_DEADLINE_MS),
+                forkDeadlineMs: parseForkDeadlineMs(process.env.PRLL_FORK_DEADLINE_MS),
+                dispatchDeadlineMs: parseDispatchDeadlineMs(process.env.PRLL_DISPATCH_DEADLINE_MS),
+                onConfigUpdate: async () => {
+                    await fetchAndApplyPlatformConfig(configManagerOpts);
+                },
+                onSessionReady: async ({ activeSessionId }) => {
+                    setParallAccountState(ctx.accountId, {
+                        client,
+                        apiUrl: config.parall_url,
+                        apiKey: config.api_key,
+                        orgId: config.org_id,
+                        agentUserId,
+                        activeSessionId,
+                        sessionBindings: new Map(),
+                        sessionsDir,
+                        runtimeRef: { hostname: os.hostname(), pid: process.pid },
+                        wikiMountRoot,
+                        ws,
+                        orchestratorSessionKey: orchestratorKey,
+                    });
+                },
+                onSessionBinding: async ({ sessionKey, agentSessionId }) => {
+                    setAgentSessionBinding(ctx.accountId, sessionKey, agentSessionId);
+                },
+                onBeforeDisconnect: async () => {
+                    stopWikiHelper?.();
+                    removeParallAccountState(ctx.accountId);
+                },
+                onNewSession: () => {
+                    clearSessionState(sessionsDir, orchestratorKey);
+                },
+                onSessionStale: () => {
+                    clearSessionState(sessionsDir, orchestratorKey);
+                },
+            });
+            try {
+                await gateway.run(ctx.abortSignal);
+            }
+            finally {
+                if (!ctx.abortSignal.aborted) {
+                    stopWikiHelper?.();
+                    removeParallAccountState(ctx.accountId);
+                }
+            }
         }
         finally {
-            if (!ctx.abortSignal.aborted) {
-                stopWikiHelper?.();
-                removeParallAccountState(ctx.accountId);
-            }
+            await telemetry.shutdown();
         }
     },
 };

package/dist/hooks.d.ts

@@ -1,3 +1,3 @@
-import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import type { OpenClawPluginApi } from 'openclaw/plugin-sdk';
 export declare function registerParallHooks(api: OpenClawPluginApi): void;
 //# sourceMappingURL=hooks.d.ts.map

package/dist/hooks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../src/hooks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AA4F7D,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,iBAAiB,QAqIzD"}
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../src/hooks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AA+G7D,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,iBAAiB,QA6KzD"}

package/dist/hooks.js

@@ -1,20 +1,20 @@
-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 { 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
  * to — chat, task, or schedule) to the `target_type` field on agent_step.
  * Keeps tool_call / tool_result attribution correct across event types.
  */
 function stepTargetType(targetId) {
-    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 '';
 }
 /**
  * Resolve the ParallClient + orgId + sessionId for a hook context.
@@ -46,7 +46,7 @@ async function resolveClientForHook(sessionKey) {
                     : 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,
@@ -100,14 +100,34 @@ export function registerParallHooks(api) {
     // 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();
+    // 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?.command;
+                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;
         const resolved = await resolveClientForHook(sessionKey);
@@ -115,14 +135,14 @@ export function registerParallHooks(api) {
             const groupKey = sessionKey ? getDispatchGroupKey(sessionKey) : undefined;
             try {
                 const step = await resolved.client.createAgentStep(resolved.orgId, resolved.agentUserId, resolved.sessionId, {
-                    step_type: "tool_call",
+                    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",
+                        status: 'running',
                         started_at: new Date().toISOString(),
                     },
                     group_key: groupKey,
@@ -135,7 +155,7 @@ export function registerParallHooks(api) {
             }
         }
         // (2) ENV injection — only for the exec (Bash) tool
-        if (event.toolName !== "exec")
+        if (event.toolName !== 'exec')
             return;
         if (!sessionKey)
             return;
@@ -162,7 +182,7 @@ export function registerParallHooks(api) {
         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
@@ -194,21 +214,27 @@ export function registerParallHooks(api) {
             },
         };
     });
-    // 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",
+                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 ?? "")),
+                    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,
                 },
@@ -221,7 +247,7 @@ export function registerParallHooks(api) {
     // 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/dist/index.d.ts

@@ -1,4 +1,4 @@
-import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import type { OpenClawPluginApi } from 'openclaw/plugin-sdk';
 declare const plugin: {
     id: string;
     name: string;

package/dist/index.js

@@ -1,11 +1,11 @@
-import { emptyPluginConfigSchema } from "openclaw/plugin-sdk/core";
-import { parallPlugin } from "./channel.js";
-import { setParallRuntime } from "./runtime.js";
-import { registerParallHooks } from "./hooks.js";
+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) {
         setParallRuntime(api.runtime);

package/dist/oc-session.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"oc-session.d.ts","sourceRoot":"","sources":["../src/oc-session.ts"],"names":[],"mappings":"AAiBA,eAAO,MAAM,uBAAuB,IAAI,CAAC;AAkHzC,qBAAa,cAAc;IACzB,OAAO,CAAC,SAAS,CAAM;IACvB,OAAO,CAAC,WAAW,CAAqB;IACxC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAE7B,OAAO,CAAC,WAAW,CAAkB;IACrC,OAAO,CAAC,IAAI,CAAmC;IAC/C,OAAO,CAAC,UAAU,CAA6B;IAC/C,OAAO,CAAC,mBAAmB,CAA6B;IACxD,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,OAAO,CAAS;IAExB,OAAO;IAeP,OAAO,CAAC,IAAI;IA+BZ,OAAO,CAAC,SAAS;IAcjB,OAAO,CAAC,UAAU;IAsBlB,OAAO,CAAC,OAAO;IAOf,SAAS,IAAI,MAAM,GAAG,IAAI;IAI1B,MAAM,IAAI,MAAM;IAIhB,aAAa,IAAI,MAAM;IAIvB,YAAY,IAAI,MAAM;IAItB,cAAc,IAAI,MAAM,GAAG,SAAS;IAMpC,OAAO,CAAC,SAAS;IAWjB,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IA+DzD,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc;CAO1C"}
+{"version":3,"file":"oc-session.d.ts","sourceRoot":"","sources":["../src/oc-session.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,uBAAuB,IAAI,CAAC;AAsHzC,qBAAa,cAAc;IACzB,OAAO,CAAC,SAAS,CAAM;IACvB,OAAO,CAAC,WAAW,CAAqB;IACxC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAE7B,OAAO,CAAC,WAAW,CAAkB;IACrC,OAAO,CAAC,IAAI,CAAmC;IAC/C,OAAO,CAAC,UAAU,CAA6B;IAC/C,OAAO,CAAC,mBAAmB,CAA6B;IACxD,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,OAAO,CAAS;IAExB,OAAO;IAeP,OAAO,CAAC,IAAI;IA+BZ,OAAO,CAAC,SAAS;IAoBjB,OAAO,CAAC,UAAU;IAsBlB,OAAO,CAAC,OAAO;IAUf,SAAS,IAAI,MAAM,GAAG,IAAI;IAI1B,MAAM,IAAI,MAAM;IAIhB,aAAa,IAAI,MAAM;IAIvB,YAAY,IAAI,MAAM;IAItB,cAAc,IAAI,MAAM,GAAG,SAAS;IAMpC,OAAO,CAAC,SAAS;IAWjB,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IA+DzD,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc;CAO1C"}