@parall/parall 1.26.0 → 1.26.2

package/dist/runtime.js

@@ -0,0 +1,32 @@
+export { setSessionChatId, getSessionChatId, setSessionMessageId, getSessionMessageId, clearSessionMessageId, setDispatchMessageId, getDispatchMessageId, clearDispatchMessageId, setDispatchGroupKey, getDispatchGroupKey, clearDispatchGroupKey, setDispatchNoReply, getDispatchNoReply, clearDispatchNoReply, } from "@parall/agent-core";
+let runtime = null;
+export function setParallRuntime(next) {
+    runtime = next;
+}
+export function getParallRuntime() {
+    if (!runtime) {
+        throw new Error("Parall runtime not initialized");
+    }
+    return runtime;
+}
+// Cached client state per account, populated by gateway.ts startAccount
+const accountStates = new Map();
+export function setParallAccountState(accountId, state) {
+    accountStates.set(accountId, state);
+}
+export function removeParallAccountState(accountId) {
+    accountStates.delete(accountId);
+}
+export function getParallAccountState(accountId) {
+    return accountStates.get(accountId);
+}
+export function getAllParallAccountStates() {
+    return new Map(accountStates);
+}
+let agentIdentity;
+export function setAgentIdentity(identity) {
+    agentIdentity = identity;
+}
+export function getAgentIdentity() {
+    return agentIdentity;
+}

package/dist/session.d.ts

@@ -0,0 +1,15 @@
+/** Build OpenClaw session key from Parall account, chat type, and chat ID. */
+export declare function buildSessionKey(accountId: string, chatType: string, chatId: string): string;
+/**
+ * Extract account ID from an OpenClaw session key.
+ * Format: "agent:main:parall:{accountId}:{type}:{chatId}"
+ */
+export declare function extractAccountIdFromSessionKey(sessionKey: string | undefined): string | undefined;
+/**
+ * Extract chat ID from an OpenClaw session key.
+ * Format: "agent:main:parall:{accountId}:{type}:{chatId}"
+ */
+export declare function extractChatIdFromSessionKey(sessionKey: string | undefined): string | undefined;
+/** Build the single orchestrator session key for all Parall events. */
+export declare function buildOrchestratorSessionKey(accountId: string): string;
+//# sourceMappingURL=session.d.ts.map

package/dist/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../src/session.ts"],"names":[],"mappings":"AAEA,8EAA8E;AAC9E,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAE3F;AAED;;;GAGG;AACH,wBAAgB,8BAA8B,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAMjG;AAED;;;GAGG;AACH,wBAAgB,2BAA2B,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAO9F;AAED,uEAAuE;AACvE,wBAAgB,2BAA2B,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAErE"}

package/dist/session.js

@@ -0,0 +1,36 @@
+const PRLL_SESSION_PREFIX = "agent:main:parall:";
+/** Build OpenClaw session key from Parall account, chat type, and chat ID. */
+export function buildSessionKey(accountId, chatType, chatId) {
+    return `${PRLL_SESSION_PREFIX}${accountId}:${chatType}:${chatId}`;
+}
+/**
+ * Extract account ID from an OpenClaw session key.
+ * Format: "agent:main:parall:{accountId}:{type}:{chatId}"
+ */
+export function extractAccountIdFromSessionKey(sessionKey) {
+    if (!sessionKey?.startsWith(PRLL_SESSION_PREFIX))
+        return undefined;
+    const rest = sessionKey.slice(PRLL_SESSION_PREFIX.length);
+    const firstColon = rest.indexOf(":");
+    if (firstColon < 0)
+        return undefined;
+    return rest.slice(0, firstColon) || undefined;
+}
+/**
+ * Extract chat ID from an OpenClaw session key.
+ * Format: "agent:main:parall:{accountId}:{type}:{chatId}"
+ */
+export function extractChatIdFromSessionKey(sessionKey) {
+    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(":");
+    if (parts.length < 3)
+        return undefined;
+    return parts.slice(2).join(":") || undefined;
+}
+/** Build the single orchestrator session key for all Parall events. */
+export function buildOrchestratorSessionKey(accountId) {
+    return `${PRLL_SESSION_PREFIX}${accountId}:orchestrator`;
+}

package/dist/types.d.ts

@@ -0,0 +1,18 @@
+export type ParallChannelConfig = {
+    enabled?: boolean;
+    /** Parall server URL, e.g. "https://parall.example.com" */
+    parall_url: string;
+    /** Agent API key (agk_xxx) */
+    api_key: string;
+    /** Organization ID */
+    org_id: string;
+    /** WS Gateway URL (defaults to parall_url with ws:// scheme + /ws path) */
+    ws_url?: string;
+};
+export type ResolvedParallAccount = {
+    accountId: string;
+    enabled: boolean;
+    configured: boolean;
+    config: ParallChannelConfig;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,mBAAmB,GAAG;IAChC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,2DAA2D;IAC3D,UAAU,EAAE,MAAM,CAAC;IACnB,8BAA8B;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,sBAAsB;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,2EAA2E;IAC3E,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAClC,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,OAAO,CAAC;IACpB,MAAM,EAAE,mBAAmB,CAAC;CAC7B,CAAC"}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/wiki-helper.d.ts

@@ -0,0 +1,21 @@
+type Logger = {
+    info?: (message: string) => void;
+    warn?: (message: string) => void;
+    error?: (message: string) => void;
+};
+type StartWikiHelperParams = {
+    accountId: string;
+    parallUrl: string;
+    apiKey: string;
+    orgId: string;
+    agentId: string;
+    stateDir: string;
+    log?: Logger;
+};
+type WikiHelperRuntime = {
+    mountRoot: string;
+    stop: () => void;
+};
+export declare function startWikiHelper(params: StartWikiHelperParams): Promise<WikiHelperRuntime>;
+export {};
+//# sourceMappingURL=wiki-helper.d.ts.map

package/dist/wiki-helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wiki-helper.d.ts","sourceRoot":"","sources":["../src/wiki-helper.ts"],"names":[],"mappings":"AAGA,KAAK,MAAM,GAAG;IACZ,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACjC,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACjC,KAAK,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACnC,CAAC;AAEF,KAAK,qBAAqB,GAAG;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,KAAK,iBAAiB,GAAG;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,IAAI,CAAC;CAClB,CAAC;AAqGF,wBAAsB,eAAe,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAgD/F"}

package/dist/wiki-helper.js

@@ -0,0 +1,131 @@
+import { spawn, spawnSync } from "node:child_process";
+import path from "node:path";
+const DEFAULT_SYNC_TIMEOUT_MS = 90_000; // includes npx cold-start download time
+const DEFAULT_WATCH_INTERVAL_SEC = 30;
+function isCommandMissing(error) {
+    return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+// Prefer bare `parall` (globally installed in hosted images). Fall back to
+// npx for self-hosted environments that haven't installed @parall/cli yet.
+let _cli;
+function resolveParallCli() {
+    if (!_cli) {
+        const r = spawnSync("parall", ["--version"], { stdio: "ignore", timeout: 5_000 });
+        _cli = r.error
+            ? { cmd: "npx", prefix: ["--yes", "@parall/cli@latest"] }
+            : { cmd: "parall", prefix: [] };
+    }
+    return _cli;
+}
+function resolveMountRoot(stateDir) {
+    return process.env.PRLL_WIKI_MOUNT_ROOT?.trim() || path.join(stateDir, "workspace");
+}
+function resolveWatchIntervalSec() {
+    const raw = process.env.PRLL_WIKI_REFRESH_INTERVAL_SEC?.trim();
+    if (!raw) {
+        return DEFAULT_WATCH_INTERVAL_SEC;
+    }
+    const parsed = Number.parseInt(raw, 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_WATCH_INTERVAL_SEC;
+}
+function buildWikiHelperEnv(params, mountRoot) {
+    return {
+        ...process.env,
+        PRLL_API_URL: params.parallUrl,
+        PRLL_API_KEY: params.apiKey,
+        PRLL_ORG_ID: params.orgId,
+        PRLL_AGENT_ID: params.agentId,
+        PRLL_WIKI_MOUNT_ROOT: mountRoot,
+    };
+}
+async function runWikiSync(params, env) {
+    return new Promise((resolve) => {
+        let timedOut = false;
+        let settled = false;
+        const { cmd, prefix } = resolveParallCli();
+        const child = spawn(cmd, [...prefix, "wiki", "sync"], {
+            env,
+            stdio: "ignore",
+        });
+        const settle = (value) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve(value);
+        };
+        const timer = setTimeout(() => {
+            timedOut = true;
+            params.log?.warn?.(`parall[${params.accountId}]: parall sync timed out after ${DEFAULT_SYNC_TIMEOUT_MS}ms`);
+            child.kill("SIGTERM");
+            setTimeout(() => child.kill("SIGKILL"), 5_000).unref();
+        }, DEFAULT_SYNC_TIMEOUT_MS);
+        timer.unref();
+        child.on("error", (error) => {
+            clearTimeout(timer);
+            if (isCommandMissing(error)) {
+                params.log?.warn?.(`parall[${params.accountId}]: parall not installed, skipping wiki auto-sync/watch`);
+                settle("missing");
+                return;
+            }
+            params.log?.warn?.(`parall[${params.accountId}]: parall sync failed to start: ${String(error)}`);
+            settle("failed");
+        });
+        child.on("exit", (code, signal) => {
+            clearTimeout(timer);
+            if (timedOut) {
+                settle("failed");
+                return;
+            }
+            if (code === 0) {
+                params.log?.info?.(`parall[${params.accountId}]: parall sync completed`);
+                settle("ok");
+                return;
+            }
+            params.log?.warn?.(`parall[${params.accountId}]: parall sync exited with code=${code ?? "null"} signal=${signal ?? "null"}`);
+            settle("failed");
+        });
+    });
+}
+export async function startWikiHelper(params) {
+    const mountRoot = resolveMountRoot(params.stateDir);
+    const env = buildWikiHelperEnv(params, mountRoot);
+    const syncResult = await runWikiSync(params, env);
+    if (syncResult === "missing") {
+        return {
+            mountRoot,
+            stop() { },
+        };
+    }
+    const intervalSec = resolveWatchIntervalSec();
+    let stopped = false;
+    const { cmd, prefix } = resolveParallCli();
+    const watch = spawn(cmd, [...prefix, "wiki", "watch", "--interval-sec", String(intervalSec)], {
+        env,
+        stdio: "ignore",
+    });
+    watch.on("error", (error) => {
+        if (stopped)
+            return;
+        if (isCommandMissing(error)) {
+            params.log?.warn?.(`parall[${params.accountId}]: parall disappeared before watch could start`);
+            return;
+        }
+        params.log?.warn?.(`parall[${params.accountId}]: parall watch failed: ${String(error)}`);
+    });
+    watch.on("exit", (code, signal) => {
+        if (stopped)
+            return;
+        params.log?.warn?.(`parall[${params.accountId}]: parall watch exited with code=${code ?? "null"} signal=${signal ?? "null"}`);
+    });
+    params.log?.info?.(`parall[${params.accountId}]: parall watch started (interval=${intervalSec}s)`);
+    return {
+        mountRoot,
+        stop() {
+            stopped = true;
+            if (watch.exitCode === null && watch.signalCode === null) {
+                watch.kill("SIGTERM");
+                setTimeout(() => watch.kill("SIGKILL"), 5_000).unref();
+            }
+        },
+    };
+}

package/openclaw.plugin.json

@@ -1,6 +1,23 @@
 {
   "id": "parall",
   "channels": ["parall"],
+  "channelConfigs": {
+    "parall": {
+      "label": "Parall",
+      "description": "Agent-Native IM platform.",
+      "schema": {
+        "type": "object",
+        "additionalProperties": true,
+        "properties": {
+          "parall_url": { "type": "string", "description": "Parall API base URL" },
+          "api_key": { "type": "string", "description": "Agent API key (agk_xxx)" },
+          "org_id": { "type": "string", "description": "Organisation ID" },
+          "ws_url": { "type": "string", "description": "WebSocket URL (optional, derived from parall_url)" }
+        },
+        "required": ["parall_url", "api_key", "org_id"]
+      }
+    }
+  },
   "skills": [
     "./skills/parall-wiki",
     "./skills/parall-tasks",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@parall/parall",
-  "version": "1.26.0",
+  "version": "1.26.2",
   "description": "OpenClaw channel plugin for Parall IM",
   "license": "MIT",
   "repository": {
@@ -11,28 +11,29 @@
   "type": "module",
   "files": [
     "src",
+    "dist",
     "skills",
     "openclaw.plugin.json"
   ],
   "dependencies": {
-    "@parall/agent-core": "1.26.0",
-    "@parall/sdk": "1.26.0"
+    "@parall/sdk": "1.26.2",
+    "@parall/agent-core": "1.26.2"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
-    "openclaw": "2026.4.2",
+    "openclaw": "2026.5.7",
     "typescript": "^5.7.0"
   },
   "peerDependencies": {
     "@mariozechner/pi-coding-agent": "*",
-    "openclaw": ">=2026.4.2"
+    "openclaw": ">=2026.5.7"
   },
   "openclaw": {
     "extensions": [
       "./src/index.ts"
     ],
     "install": {
-      "minHostVersion": ">=2026.4.2"
+      "minHostVersion": ">=2026.5.7"
     }
   },
   "scripts": {

package/src/config-manager.ts

@@ -73,6 +73,21 @@ function applyToOpenClawConfig(
   const platformProviders = (platformModels.providers ?? {}) as Record<string, unknown>;
   const platformParall = (platformProviders.parall ?? {}) as Record<string, unknown>;
 
+  // Only forward keys OpenClaw's model schema recognizes — its strict Zod
+  // validation rejects unrecognized keys and skips the entire config reload.
+  const OPENCLAW_MODEL_KEYS = new Set(["id", "name", "contextWindow", "maxTokens"]);
+  if (Array.isArray(platformParall.models)) {
+    platformParall.models = (platformParall.models as Record<string, unknown>[]).map((m) => {
+      const cleaned: Record<string, unknown> = {};
+      for (const [k, v] of Object.entries(m)) {
+        if (OPENCLAW_MODEL_KEYS.has(k)) {
+          cleaned[k] = v;
+        }
+      }
+      return cleaned;
+    });
+  }
+
   providers.parall = {
     ...existingParall,
     ...platformParall,
@@ -84,7 +99,7 @@ function applyToOpenClawConfig(
   // Strip keys OpenClaw doesn't recognize from agents.defaults — platform-only
   // keys like thinking_effort are consumed by agent-core's PlatformConfigManager.
   // See: OpenClaw agents.defaults config schema.
-  const OPENCLAW_AGENTS_DEFAULTS_KEYS = new Set(["model", "maxTokens", "compaction"]);
+  const OPENCLAW_AGENTS_DEFAULTS_KEYS = new Set(["model", "compaction"]);
 
   // Unconditionally sanitize existing defaults to self-heal already-poisoned
   // openclaw.json files (e.g. mode=self agents that were poisoned while in

package/src/fork.ts

@@ -2,9 +2,10 @@
 //
 // When the orchestrator's main session is busy, new events are handled by
 // forking the main session's transcript and dispatching to the fork in parallel.
-// The on-disk JSONL transcript always reflects the state BEFORE the current
-// dispatch (in-flight messages are memory-only), so the fork inherits all
-// prior history without race conditions.
+// The caller provides a pre-dispatch branch point so the fork inherits
+// history up to (but not including) the in-flight dispatch. Without a
+// branch point, the fork falls back to the current on-disk leaf — which
+// may include partial in-flight state.
 
 import * as fs from "node:fs";
 import * as path from "node:path";
@@ -102,6 +103,7 @@ export function forkOrchestratorSession(opts: {
   accountId: string;
   transcriptFile: string;
   sessionsDir: string;
+  branchPointId?: string;
 }): ForkSessionResult | null {
   const { orchestratorSessionKey, accountId, transcriptFile, sessionsDir } = opts;
 
@@ -109,7 +111,7 @@ export function forkOrchestratorSession(opts: {
 
   try {
     const manager = SessionManager.open(transcriptFile);
-    const leafId = manager.getLeafId();
+    const leafId = opts.branchPointId ?? manager.getLeafId();
 
     let sessionId: string;
     let sessionFile: string;

package/src/gateway.ts

@@ -27,6 +27,7 @@ import { buildOrchestratorSessionKey } from "./session.js";
 import type { ResolvedParallAccount } from "./types.js";
 import { fetchAndApplyPlatformConfig } from "./config-manager.js";
 import { startWikiHelper } from "./wiki-helper.js";
+import { SessionManager } from "@mariozechner/pi-coding-agent";
 import { cleanupForkSession, forkOrchestratorSession, resolveTranscriptFile } from "./fork.js";
 
 function resolveWsUrl(account: ResolvedParallAccount): string {
@@ -210,7 +211,18 @@ function createOpenClawDispatchAdapter(opts: {
       yield* stream.stream();
     },
 
-    forkSession({ sessionKey }) {
+    getBranchPoint(sessionKey: string): string | undefined {
+      const transcriptFile = resolveTranscriptFile(opts.sessionsDir, sessionKey);
+      if (!transcriptFile) return undefined;
+      try {
+        const manager = SessionManager.open(transcriptFile);
+        return manager.getLeafId() ?? undefined;
+      } catch {
+        return undefined;
+      }
+    },
+
+    forkSession({ sessionKey, preDispatchBranchPoint }) {
       const transcriptFile = resolveTranscriptFile(opts.sessionsDir, sessionKey);
       if (!transcriptFile) return null;
       return forkOrchestratorSession({
@@ -218,6 +230,7 @@ function createOpenClawDispatchAdapter(opts: {
         accountId: opts.accountId,
         transcriptFile,
         sessionsDir: opts.sessionsDir,
+        branchPointId: preDispatchBranchPoint,
       });
     },