@parall/parall 1.43.0 → 1.45.0

package/dist/gateway.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gateway.d.ts","sourceRoot":"","sources":["../src/gateway.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAE9D,uGAAuG;AACvG,KAAK,qBAAqB,CAAC,CAAC,GAAG,OAAO,IAAI,WAAW,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC;AACnF,OAAO,EAQL,KAAK,eAAe,EAGrB,MAAM,oBAAoB,CAAC;AAqB5B,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAiKxD,wBAAgB,6BAA6B,CAAC,IAAI,EAAE;IAClD,IAAI,EAAE,aAAa,CAAC;IACpB,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;CACtB,GAAG,eAAe,CA0KlB;AAED,eAAO,MAAM,aAAa,EAAE,qBAAqB,CAAC,qBAAqB,CAiKtE,CAAC"}
+{"version":3,"file":"gateway.d.ts","sourceRoot":"","sources":["../src/gateway.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAE9D,uGAAuG;AACvG,KAAK,qBAAqB,CAAC,CAAC,GAAG,OAAO,IAAI,WAAW,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC;AACnF,OAAO,EASL,KAAK,eAAe,EAGrB,MAAM,oBAAoB,CAAC;AAqB5B,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AA2KxD,wBAAgB,6BAA6B,CAAC,IAAI,EAAE;IAClD,IAAI,EAAE,aAAa,CAAC;IACpB,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;CACtB,GAAG,eAAe,CA0KlB;AAED,eAAO,MAAM,aAAa,EAAE,qBAAqB,CAAC,qBAAqB,CAqLtE,CAAC"}

package/dist/gateway.js

@@ -1,4 +1,4 @@
-import { ParallAgentGateway, capabilityBinDir, parseShutdownDeadlineMs, parseForkDeadlineMs, parseDispatchDeadlineMs, initAgentTelemetry, createOtelLogger, } from '@parall/agent-core';
+import { ParallAgentGateway, capabilityBinDir, dispatchLaneContextDir, 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';
@@ -11,6 +11,15 @@ import { fetchAndApplyPlatformConfig, getChannelCapabilityKeys } from './config-
 import { startWikiHelper } from './wiki-helper.js';
 import { SessionManager } from './oc-session.js';
 import { cleanupForkSession, clearSessionState, forkOrchestratorSession, resolveSessionId, resolveTranscriptFile, } from './fork.js';
+/**
+ * Per-session dispatch context file (PRLL_CONTEXT_FILE contract) — same
+ * encoding as the claude/codex bridges: base64url(sessionKey) under the
+ * state dir's dispatch-context/.
+ */
+function sessionContextFilePath(stateDir, sessionKey) {
+    const fileName = Buffer.from(sessionKey).toString('base64url');
+    return path.join(stateDir, 'dispatch-context', `${fileName}.json`);
+}
 function resolveWsUrl(account) {
     if (account.config.ws_url)
         return account.config.ws_url;
@@ -404,6 +413,18 @@ export const parallGateway = {
                 runtimeKey: orchestratorKey,
                 runtimeRef: { hostname: os.hostname(), pid: process.pid },
                 dispatchAdapter,
+                // Opts openclaw into the dispatch ledger (claim/fold/complete +
+                // idempotent reply effects) — the same shared-gateway machinery
+                // claude/codex ride; openclaw stays buffer-only (no mid-turn steer),
+                // which the ledger does not require. Replies already flow through
+                // @parall/cli, which reads PRLL_CONTEXT_DIR (injected in hooks.ts)
+                // to bind dispatch_lane + reply effect keys.
+                // Design: docs/engineering-design/dispatch-convergence-design.md §7 (S2).
+                dispatchContextDir: dispatchLaneContextDir(stateDir),
+                // Per-session context file (PRLL_CONTEXT_FILE contract) — the CLI's
+                // TYPED dispatch binding (parall tasks update → task_update effect)
+                // reads lane/event/task fields from this file, not the lane dir.
+                contextFilePathForSession: (sessionKey) => sessionContextFilePath(stateDir, sessionKey),
                 log: otelLog,
                 // Live capability view for hint routing: the channel reply hint
                 // points at the vendor CLI only while the grant is active.
@@ -428,6 +449,12 @@ export const parallGateway = {
                         wikiMountRoot,
                         ws,
                         orchestratorSessionKey: orchestratorKey,
+                        dispatchContextDir: dispatchLaneContextDir(stateDir),
+                        contextFilePathForSession: (sessionKey) => sessionContextFilePath(stateDir, sessionKey),
+                        // Lease-renewal bridge: openclaw tool calls flow through hooks,
+                        // not the RuntimeEvent stream, so hook activity must renew the
+                        // ledger lanes or a long exec outlives the lease (STALE_LANE).
+                        touchRuntimeActivity: (sessionKey) => gateway.touchRuntimeActivity(sessionKey),
                     });
                 },
                 onSessionBinding: async ({ sessionKey, agentSessionId }) => {

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;AAgH7D,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,iBAAiB,QAmLzD"}
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../src/hooks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAgH7D,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,iBAAiB,QA+OzD"}

package/dist/hooks.js

@@ -118,6 +118,45 @@ export function registerParallHooks(api) {
         };
     });
     const pendingSendCalls = new Map();
+    // Lane lease keepalive across the tool-call lifecycle. OpenClaw tool calls
+    // bypass the RuntimeEvent stream, so lane renewal must ride these hooks —
+    // and a ONE-SHOT touch at tool start is not enough: a single exec running
+    // past the lane TTL (10min server-side) would still be dethroned mid-call
+    // and the eventual CLI reply would die with STALE_LANE. While any tool call
+    // is in flight for a session, an unref'd interval keeps touching; the
+    // half-TTL throttle in the ledger decides when a real heartbeat is sent.
+    const laneRenewals = new Map();
+    const LANE_RENEW_INTERVAL_MS = 180_000;
+    const beginToolRenewal = (sessionKey) => {
+        const accountId = extractAccountIdFromSessionKey(sessionKey);
+        const state = accountId ? getParallAccountState(accountId) : undefined;
+        if (!state?.touchRuntimeActivity)
+            return;
+        state.touchRuntimeActivity(sessionKey);
+        const entry = laneRenewals.get(sessionKey) ?? { count: 0 };
+        entry.count++;
+        if (!entry.timer) {
+            entry.timer = setInterval(() => state.touchRuntimeActivity?.(sessionKey), LANE_RENEW_INTERVAL_MS);
+            entry.timer.unref?.();
+        }
+        laneRenewals.set(sessionKey, entry);
+    };
+    const endToolRenewal = (sessionKey) => {
+        const entry = laneRenewals.get(sessionKey);
+        if (entry) {
+            entry.count--;
+            if (entry.count <= 0) {
+                if (entry.timer)
+                    clearInterval(entry.timer);
+                laneRenewals.delete(sessionKey);
+            }
+        }
+        const accountId = extractAccountIdFromSessionKey(sessionKey);
+        const state = accountId ? getParallAccountState(accountId) : undefined;
+        // Final touch on completion — covers the reply window right after a
+        // long tool call ends.
+        state?.touchRuntimeActivity?.(sessionKey);
+    };
     // 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.
@@ -125,6 +164,9 @@ export function registerParallHooks(api) {
         const sessionKey = ctx.sessionKey;
         if (sessionKey) {
             recordToolCall(sessionKey);
+            // Every tool (not just exec) keeps the ledger lane alive for its
+            // whole lifetime — see laneRenewals above.
+            beginToolRenewal(sessionKey);
             if (event.toolName === 'exec' && event.toolCallId) {
                 const command = event.params?.command;
                 if (isParallSendCommand(command)) {
@@ -209,6 +251,20 @@ export function registerParallHooks(api) {
             injectedEnv.PRLL_TRIGGER_MESSAGE_ID = triggerMsgId;
         if (state.wikiMountRoot)
             injectedEnv.PRLL_WIKI_MOUNT_ROOT = state.wikiMountRoot;
+        // Dispatch-ledger contract: the CLI keys into this directory by send
+        // target to bind dispatch_lane + the reply:<dsp> effect key (idempotent
+        // replies). Set only when the gateway runs the ledger.
+        if (state.dispatchContextDir)
+            injectedEnv.PRLL_CONTEXT_DIR = state.dispatchContextDir;
+        // Per-session context file — the CLI's TYPED binding (parall tasks
+        // update → task_update:<dsp> effect) reads lane/event/task from here.
+        if (state.contextFilePathForSession) {
+            injectedEnv.PRLL_CONTEXT_FILE = state.contextFilePathForSession(sessionKey);
+        }
+        // Long tool calls bypass the RuntimeEvent stream — forward activity so
+        // the ledger lane lease renews (a >TTL exec would otherwise be dethroned
+        // mid-turn and the eventual CLI reply would die with STALE_LANE).
+        state.touchRuntimeActivity?.(sessionKey);
         // OpenClaw context (upstream doesn't inject these into exec env yet)
         injectedEnv.OPENCLAW_SESSION_KEY = sessionKey;
         if (event.toolCallId)
@@ -223,6 +279,8 @@ export function registerParallHooks(api) {
     });
     // after_tool_call -> track CLI outcomes + send tool_result step to AgentSession
     api.on('after_tool_call', async (event, ctx) => {
+        if (ctx.sessionKey)
+            endToolRenewal(ctx.sessionKey);
         if (ctx.sessionKey && event.toolCallId && pendingSendCalls.delete(event.toolCallId)) {
             recordMessageSend(ctx.sessionKey, !event.error);
         }