@parall/parall 1.26.1 → 1.26.3

package/dist/accounts.d.ts

@@ -0,0 +1,9 @@
+import type { ResolvedParallAccount } from "./types.js";
+type OpenClawConfig = Record<string, unknown>;
+export declare function listParallAccountIds(cfg: OpenClawConfig): string[];
+export declare function resolveParallAccount(params: {
+    cfg: OpenClawConfig;
+    accountId?: string;
+}): ResolvedParallAccount;
+export {};
+//# sourceMappingURL=accounts.d.ts.map

package/dist/accounts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"accounts.d.ts","sourceRoot":"","sources":["../src/accounts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAuB,MAAM,YAAY,CAAC;AAI7E,KAAK,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAO9C,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM,EAAE,CAIlE;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE;IAC3C,GAAG,EAAE,cAAc,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,GAAG,qBAAqB,CAiBxB"}

package/dist/accounts.js

@@ -0,0 +1,29 @@
+const DEFAULT_ACCOUNT_ID = "default";
+function readParallConfig(cfg) {
+    const channels = cfg.channels;
+    return channels?.parall;
+}
+export function listParallAccountIds(cfg) {
+    const parallCfg = readParallConfig(cfg);
+    if (!parallCfg)
+        return [];
+    return [DEFAULT_ACCOUNT_ID];
+}
+export function resolveParallAccount(params) {
+    const { cfg, accountId = DEFAULT_ACCOUNT_ID } = params;
+    const parallCfg = readParallConfig(cfg);
+    const config = {
+        parall_url: parallCfg?.parall_url ?? "",
+        api_key: parallCfg?.api_key ?? "",
+        org_id: parallCfg?.org_id ?? "",
+        ws_url: parallCfg?.ws_url,
+        enabled: parallCfg?.enabled,
+    };
+    const configured = Boolean(config.api_key && config.parall_url && config.org_id);
+    return {
+        accountId,
+        enabled: config.enabled !== false,
+        configured,
+        config,
+    };
+}

package/dist/channel.d.ts

@@ -0,0 +1,4 @@
+import type { ChannelPlugin } from "openclaw/plugin-sdk/core";
+import type { ResolvedParallAccount } from "./types.js";
+export declare const parallPlugin: ChannelPlugin<ResolvedParallAccount>;
+//# sourceMappingURL=channel.d.ts.map

package/dist/channel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"channel.d.ts","sourceRoot":"","sources":["../src/channel.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAI9D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAWxD,eAAO,MAAM,YAAY,EAAE,aAAa,CAAC,qBAAqB,CAwB7D,CAAC"}

package/dist/channel.js

@@ -0,0 +1,36 @@
+import { listParallAccountIds, resolveParallAccount } from "./accounts.js";
+import { parallGateway } from "./gateway.js";
+import { parallOutbound } from "./outbound.js";
+const meta = {
+    id: "parall",
+    label: "Parall",
+    selectionLabel: "Parall IM",
+    docsPath: "/channels/parall",
+    blurb: "Agent-Native IM platform.",
+    order: 80,
+};
+export const parallPlugin = {
+    id: "parall",
+    meta,
+    capabilities: {
+        chatTypes: ["direct", "group"],
+        polls: false,
+        threads: false,
+        media: true,
+        reactions: false,
+        edit: false,
+        reply: false,
+    },
+    config: {
+        listAccountIds: (cfg) => listParallAccountIds(cfg),
+        resolveAccount: (cfg, accountId) => resolveParallAccount({ cfg, accountId: accountId ?? undefined }),
+        isConfigured: (account) => account.configured,
+        describeAccount: (account) => ({
+            accountId: account.accountId,
+            enabled: account.enabled,
+            configured: account.configured,
+        }),
+    },
+    outbound: parallOutbound,
+    gateway: parallGateway,
+};

package/dist/config-manager.d.ts

@@ -0,0 +1,22 @@
+import type { ParallClient } from "@parall/sdk";
+interface ConfigManagerOpts {
+    client: ParallClient;
+    stateDir: string;
+    configPath: string;
+    credentials: {
+        api_key: string;
+        parall_url: string;
+    };
+    log?: {
+        info: (msg: string) => void;
+        warn: (msg: string) => void;
+        error: (msg: string) => void;
+    };
+}
+/**
+ * Fetch platform config from the server, cache it (LKG), and apply to openclaw.json.
+ * Degrades gracefully: uses cached config on fetch failure, continues if neither is available.
+ */
+export declare function fetchAndApplyPlatformConfig(opts: ConfigManagerOpts): Promise<void>;
+export {};
+//# sourceMappingURL=config-manager.d.ts.map

package/dist/config-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-manager.d.ts","sourceRoot":"","sources":["../src/config-manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAWhD,UAAU,iBAAiB;IACzB,MAAM,EAAE,YAAY,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC;IACrD,GAAG,CAAC,EAAE;QAAE,IAAI,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;QAAC,IAAI,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;QAAC,KAAK,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAA;KAAE,CAAC;CAClG;AA+HD;;;GAGG;AACH,wBAAsB,2BAA2B,CAAC,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CA6CxF"}

package/dist/config-manager.js

@@ -0,0 +1,154 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+const CACHE_FILENAME = "parall-platform-config.json";
+/** Tool names are no longer registered — all operations go through CLI. */
+function cachePath(stateDir) {
+    return path.join(stateDir, CACHE_FILENAME);
+}
+function loadCachedConfig(stateDir) {
+    try {
+        const raw = fs.readFileSync(cachePath(stateDir), "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+function saveCachedConfig(stateDir, config) {
+    const cached = {
+        version: config.version,
+        config: config.config,
+        fetchedAt: new Date().toISOString(),
+    };
+    const filePath = cachePath(stateDir);
+    const tmpPath = `${filePath}.tmp`;
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(tmpPath, JSON.stringify(cached, null, 2), "utf-8");
+    fs.renameSync(tmpPath, filePath);
+}
+/**
+ * Deep-merge platform config into an existing openclaw.json file.
+ * Only overwrites `models.providers.parall` and `agents.defaults` sections;
+ * all other keys (user customizations, other providers) are preserved.
+ */
+function applyToOpenClawConfig(configPath, platformConfig, credentials) {
+    let existing = {};
+    try {
+        const raw = fs.readFileSync(configPath, "utf-8");
+        existing = JSON.parse(raw);
+    }
+    catch {
+        // File doesn't exist or is invalid — start fresh
+    }
+    // Deep-merge models.providers.parall (preserve existing fields, overlay platform, inject credentials)
+    const models = (existing.models ?? {});
+    const providers = (models.providers ?? {});
+    const existingParall = (providers.parall ?? {});
+    const platformModels = (platformConfig.models ?? {});
+    const platformProviders = (platformModels.providers ?? {});
+    const platformParall = (platformProviders.parall ?? {});
+    // 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.map((m) => {
+            const cleaned = {};
+            for (const [k, v] of Object.entries(m)) {
+                if (OPENCLAW_MODEL_KEYS.has(k)) {
+                    cleaned[k] = v;
+                }
+            }
+            return cleaned;
+        });
+    }
+    providers.parall = {
+        ...existingParall,
+        ...platformParall,
+        apiKey: credentials.api_key,
+    };
+    models.providers = providers;
+    existing.models = models;
+    // 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", "compaction"]);
+    // Unconditionally sanitize existing defaults to self-heal already-poisoned
+    // openclaw.json files (e.g. mode=self agents that were poisoned while in
+    // platform mode).
+    const agents = (existing.agents ?? {});
+    const existingDefaults = (agents.defaults ?? {});
+    const cleanedExisting = {};
+    for (const [k, v] of Object.entries(existingDefaults)) {
+        if (OPENCLAW_AGENTS_DEFAULTS_KEYS.has(k)) {
+            cleanedExisting[k] = v;
+        }
+    }
+    // Overlay platform defaults (filtered) when present.
+    const platformAgents = (platformConfig.agents ?? {});
+    const rawDefaults = platformAgents.defaults;
+    if (rawDefaults !== undefined &&
+        rawDefaults !== null &&
+        typeof rawDefaults === "object" &&
+        !Array.isArray(rawDefaults)) {
+        const raw = rawDefaults;
+        for (const [k, v] of Object.entries(raw)) {
+            if (OPENCLAW_AGENTS_DEFAULTS_KEYS.has(k)) {
+                cleanedExisting[k] = v;
+            }
+        }
+    }
+    agents.defaults = cleanedExisting;
+    existing.agents = agents;
+    // No plugin tools to allow — all operations go through CLI.
+    // Atomic write
+    const tmpPath = `${configPath}.tmp`;
+    fs.mkdirSync(path.dirname(configPath), { recursive: true });
+    fs.writeFileSync(tmpPath, JSON.stringify(existing, null, 2), "utf-8");
+    fs.renameSync(tmpPath, configPath);
+}
+/**
+ * Fetch platform config from the server, cache it (LKG), and apply to openclaw.json.
+ * Degrades gracefully: uses cached config on fetch failure, continues if neither is available.
+ */
+export async function fetchAndApplyPlatformConfig(opts) {
+    const { client, stateDir, configPath, credentials, log } = opts;
+    // 1. Load cached config (LKG)
+    const cached = loadCachedConfig(stateDir);
+    // 2. Fetch from server (with version for 304)
+    let fresh = null;
+    try {
+        fresh = await client.getPlatformConfig(cached?.version);
+    }
+    catch (err) {
+        // Fetch failed — fall through to use cache
+        if (cached) {
+            log?.warn(`platform config fetch failed, using cached version ${cached.version}: ${String(err)}`);
+            applyToOpenClawConfig(configPath, cached.config, credentials);
+            return;
+        }
+        // No cache and fetch fails — degrade gracefully
+        log?.error(`platform config fetch failed and no cache available: ${String(err)}`);
+        return;
+    }
+    // 3. 304 — config unchanged
+    if (fresh === null) {
+        log?.info("platform config unchanged (304)");
+        if (cached) {
+            applyToOpenClawConfig(configPath, cached.config, credentials);
+        }
+        return;
+    }
+    // 4. Validate schema compatibility before accepting
+    const SUPPORTED_SCHEMA_VERSION = 1;
+    if (fresh.schema_version !== undefined && fresh.schema_version > SUPPORTED_SCHEMA_VERSION) {
+        log?.error(`platform config schema_version ${fresh.schema_version} is newer than supported (${SUPPORTED_SCHEMA_VERSION}), keeping current config`);
+        if (cached) {
+            applyToOpenClawConfig(configPath, cached.config, credentials);
+        }
+        return;
+    }
+    // 5. Newer config received — save cache and apply
+    log?.info(`platform config updated to version ${fresh.version}`);
+    saveCachedConfig(stateDir, fresh);
+    applyToOpenClawConfig(configPath, fresh.config, credentials);
+}

package/dist/fork.d.ts

@@ -0,0 +1,30 @@
+export type ForkSessionResult = {
+    sessionKey: string;
+    sessionId: string;
+    sessionFile: string;
+};
+export declare function resolveTranscriptFile(sessionsDir: string, sessionKey: string): string | null;
+/**
+ * Fork the orchestrator session's transcript into a new parallel session.
+ *
+ * The fork inherits all history up to the current dispatch start (on-disk state).
+ * It gets its own session key, write lock, and can dispatch independently.
+ *
+ * Creates a session store entry with lineage metadata (spawnedBy).
+ */
+export declare function forkOrchestratorSession(opts: {
+    orchestratorSessionKey: string;
+    accountId: string;
+    transcriptFile: string;
+    sessionsDir: string;
+    branchPointId?: string;
+}): ForkSessionResult | null;
+/**
+ * Clean up a fork session: delete transcript file AND session store entry.
+ */
+export declare function cleanupForkSession(opts: {
+    sessionFile: string;
+    sessionKey: string;
+    sessionsDir: string;
+}): void;
+//# sourceMappingURL=fork.d.ts.map

package/dist/fork.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fork.d.ts","sourceRoot":"","sources":["../src/fork.ts"],"names":[],"mappings":"AAcA,MAAM,MAAM,iBAAiB,GAAG;IAC9B,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AA+CF,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAqB5F;AAMD;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE;IAC5C,sBAAsB,EAAE,MAAM,CAAC;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,GAAG,iBAAiB,GAAG,IAAI,CA+D3B;AAMD;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE;IACvC,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;CACrB,GAAG,IAAI,CASP"}

package/dist/fork.js

@@ -0,0 +1,162 @@
+// fork.ts — Fork-on-busy engine for orchestrator mode
+//
+// 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 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";
+import * as crypto from "node:crypto";
+import { CURRENT_SESSION_VERSION, SessionManager } from "@mariozechner/pi-coding-agent";
+function readStoreEntry(sessionsDir, sessionKey) {
+    const storeFile = path.join(sessionsDir, "sessions.json");
+    try {
+        const store = JSON.parse(fs.readFileSync(storeFile, "utf-8"));
+        return store[sessionKey] ?? store[sessionKey.toLowerCase()] ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function writeStoreEntry(sessionsDir, sessionKey, entry) {
+    const storeFile = path.join(sessionsDir, "sessions.json");
+    try {
+        let store = {};
+        try {
+            store = JSON.parse(fs.readFileSync(storeFile, "utf-8"));
+        }
+        catch {
+            // Empty or missing — start fresh.
+        }
+        store[sessionKey.toLowerCase()] = entry;
+        fs.writeFileSync(storeFile, JSON.stringify(store, null, 2), { encoding: "utf-8" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function deleteStoreEntry(sessionsDir, sessionKey) {
+    const storeFile = path.join(sessionsDir, "sessions.json");
+    try {
+        const store = JSON.parse(fs.readFileSync(storeFile, "utf-8"));
+        delete store[sessionKey];
+        delete store[sessionKey.toLowerCase()];
+        fs.writeFileSync(storeFile, JSON.stringify(store, null, 2), { encoding: "utf-8" });
+    }
+    catch {
+        // Best-effort cleanup.
+    }
+}
+export function resolveTranscriptFile(sessionsDir, sessionKey) {
+    const entry = readStoreEntry(sessionsDir, sessionKey);
+    if (!entry?.sessionId)
+        return null;
+    if (entry.sessionFile) {
+        const resolved = path.isAbsolute(entry.sessionFile)
+            ? entry.sessionFile
+            : path.join(sessionsDir, entry.sessionFile);
+        if (fs.existsSync(resolved))
+            return resolved;
+    }
+    const conventional = path.join(sessionsDir, `${entry.sessionId}.jsonl`);
+    if (fs.existsSync(conventional))
+        return conventional;
+    try {
+        const files = fs.readdirSync(sessionsDir);
+        const match = files.find((file) => file.includes(entry.sessionId) && file.endsWith(".jsonl"));
+        return match ? path.join(sessionsDir, match) : null;
+    }
+    catch {
+        return null;
+    }
+}
+// ---------------------------------------------------------------------------
+// Fork creation
+// ---------------------------------------------------------------------------
+/**
+ * Fork the orchestrator session's transcript into a new parallel session.
+ *
+ * The fork inherits all history up to the current dispatch start (on-disk state).
+ * It gets its own session key, write lock, and can dispatch independently.
+ *
+ * Creates a session store entry with lineage metadata (spawnedBy).
+ */
+export function forkOrchestratorSession(opts) {
+    const { orchestratorSessionKey, accountId, transcriptFile, sessionsDir } = opts;
+    if (!fs.existsSync(transcriptFile))
+        return null;
+    try {
+        const manager = SessionManager.open(transcriptFile);
+        const leafId = opts.branchPointId ?? manager.getLeafId();
+        let sessionId;
+        let sessionFile;
+        if (leafId) {
+            // Branch from the current leaf — inherits full transcript history
+            const branched = manager.createBranchedSession(leafId) ?? manager.getSessionFile();
+            const branchedId = manager.getSessionId();
+            if (branched && branchedId) {
+                sessionFile = branched;
+                sessionId = branchedId;
+            }
+            else {
+                return null;
+            }
+        }
+        else {
+            // Fallback: no leaf node — create a header-only fork file manually.
+            sessionId = crypto.randomUUID();
+            const timestamp = new Date().toISOString();
+            const fileTimestamp = timestamp.replace(/[:.]/g, "-");
+            sessionFile = path.join(manager.getSessionDir(), `${fileTimestamp}_${sessionId}.jsonl`);
+            const header = {
+                type: "session",
+                version: CURRENT_SESSION_VERSION,
+                id: sessionId,
+                timestamp,
+                cwd: manager.getCwd(),
+                parentSession: transcriptFile,
+            };
+            fs.writeFileSync(sessionFile, `${JSON.stringify(header)}\n`, {
+                encoding: "utf-8",
+                mode: 0o600,
+                flag: "wx",
+            });
+        }
+        const forkSessionKey = `${orchestratorSessionKey}:fork:${sessionId}`;
+        // Register in session store — fail closed if store is unwritable
+        const wrote = writeStoreEntry(sessionsDir, forkSessionKey, {
+            sessionId,
+            sessionFile: path.relative(sessionsDir, sessionFile),
+            updatedAt: Date.now(),
+            spawnedBy: orchestratorSessionKey,
+            parentSessionKey: orchestratorSessionKey,
+            forkedFromParent: true,
+        });
+        if (!wrote)
+            return null;
+        return { sessionKey: forkSessionKey, sessionId, sessionFile };
+    }
+    catch {
+        return null;
+    }
+}
+// ---------------------------------------------------------------------------
+// Fork cleanup (store-driven)
+// ---------------------------------------------------------------------------
+/**
+ * Clean up a fork session: delete transcript file AND session store entry.
+ */
+export function cleanupForkSession(opts) {
+    try {
+        if (fs.existsSync(opts.sessionFile)) {
+            fs.unlinkSync(opts.sessionFile);
+        }
+    }
+    catch {
+        // Best-effort file cleanup
+    }
+    deleteStoreEntry(opts.sessionsDir, opts.sessionKey);
+}

package/dist/gateway.d.ts

@@ -0,0 +1,7 @@
+import type { ChannelPlugin } from "openclaw/plugin-sdk/core";
+/** Extract ChannelGatewayAdapter from ChannelPlugin (removed from public SDK exports in 2026.3.24). */
+type ChannelGatewayAdapter<T = unknown> = NonNullable<ChannelPlugin<T>["gateway"]>;
+import type { ResolvedParallAccount } from "./types.js";
+export declare const parallGateway: ChannelGatewayAdapter<ResolvedParallAccount>;
+export {};
+//# sourceMappingURL=gateway.d.ts.map

package/dist/gateway.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gateway.d.ts","sourceRoot":"","sources":["../src/gateway.ts"],"names":[],"mappings":"AACA,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;AAsBnF,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AA6NxD,eAAO,MAAM,aAAa,EAAE,qBAAqB,CAAC,qBAAqB,CA2HtE,CAAC"}