@parall/parall 1.26.1 → 1.26.2

package/dist/gateway.js

@@ -0,0 +1,330 @@
+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, 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 "@mariozechner/pi-coding-agent";
+import { cleanupForkSession, forkOrchestratorSession, 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");
+    return `${wsBase}/ws`;
+}
+async function getAgentMeWithLegacyFallback(client, orgId) {
+    try {
+        return await client.getAgentMe(orgId);
+    }
+    catch (err) {
+        if (!(err instanceof ApiError && err.status === 404)) {
+            throw err;
+        }
+        const user = await client.getMe();
+        return { ...user, agent_profile: null };
+    }
+}
+function buildInboundCtx(core, accountId, event, sessionKey, bodyForAgent, earlierEvents = []) {
+    const inboundHistory = earlierEvents.length > 0 ? buildInboundHistory(earlierEvents) : undefined;
+    return core.channel.reply.finalizeInboundContext({
+        Body: event.body,
+        BodyForAgent: bodyForAgent,
+        RawBody: event.body,
+        CommandBody: event.body,
+        // Attachment metadata is now in event.attachments (structured), not mediaFields
+        ...(inboundHistory?.length ? { InboundHistory: inboundHistory } : {}),
+        From: `parall:${event.senderId}`,
+        To: `parall:orchestrator`,
+        SessionKey: sessionKey,
+        AccountId: accountId,
+        ChatType: event.targetType ?? "unknown",
+        SenderName: event.senderName,
+        SenderId: event.senderId,
+        Provider: "parall",
+        Surface: "parall",
+        MessageSid: event.messageId,
+        Timestamp: Date.now(),
+        CommandAuthorized: true,
+        OriginatingChannel: "parall",
+        OriginatingTo: `parall:orchestrator`,
+    });
+}
+function buildInboundHistory(events) {
+    return events.map((event) => {
+        const meta = [];
+        meta.push(`[Message ID: ${event.messageId}]`);
+        if (event.noReply)
+            meta.push(`[Hint: no_reply]`);
+        if (event.threadRootId)
+            meta.push(`[Thread: ${event.threadRootId}]`);
+        if (event.attachments?.length) {
+            for (const att of event.attachments) {
+                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,
+        };
+    });
+}
+function createRuntimeEventStream() {
+    const queue = [];
+    const waiters = [];
+    let done = false;
+    let failure;
+    function flush() {
+        while (waiters.length > 0) {
+            if (failure) {
+                waiters.shift().reject(failure);
+                continue;
+            }
+            if (queue.length > 0) {
+                waiters.shift().resolve(queue.shift());
+                continue;
+            }
+            if (done) {
+                waiters.shift().resolve(undefined);
+                continue;
+            }
+            break;
+        }
+    }
+    return {
+        push(event) {
+            queue.push(event);
+            flush();
+        },
+        end() {
+            done = true;
+            flush();
+        },
+        fail(err) {
+            failure = err;
+            flush();
+        },
+        async *stream() {
+            while (true) {
+                if (queue.length > 0) {
+                    yield queue.shift();
+                    continue;
+                }
+                if (failure)
+                    throw failure;
+                if (done)
+                    return;
+                const next = await new Promise((resolve, reject) => {
+                    waiters.push({ resolve, reject });
+                });
+                if (!next)
+                    return;
+                yield next;
+            }
+        },
+    };
+}
+function createOpenClawDispatchAdapter(opts) {
+    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));
+            yield* stream.stream();
+        },
+        getBranchPoint(sessionKey) {
+            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({
+                orchestratorSessionKey: sessionKey,
+                accountId: opts.accountId,
+                transcriptFile,
+                sessionsDir: opts.sessionsDir,
+                branchPointId: preDispatchBranchPoint,
+            });
+        },
+        cleanupFork({ fork }) {
+            if (typeof fork.sessionFile !== "string")
+                return;
+            cleanupForkSession({
+                sessionFile: fork.sessionFile,
+                sessionKey: fork.sessionKey,
+                sessionsDir: opts.sessionsDir,
+            });
+        },
+    };
+}
+export const parallGateway = {
+    startAccount: async (ctx) => {
+        const account = resolveParallAccount({ cfg: ctx.cfg, accountId: ctx.accountId });
+        if (!account.enabled)
+            return;
+        if (!account.configured)
+            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;
+        const client = new ParallClient({
+            baseUrl: config.parall_url,
+            token: config.api_key,
+            swimlaneName: process.env.PRLL_SWIMLANE_NAME,
+        });
+        const me = await getAgentMeWithLegacyFallback(client, config.org_id);
+        const agentUserId = me.id;
+        setAgentIdentity({
+            userId: agentUserId,
+            displayName: me.display_name,
+            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,
+        };
+        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,
+                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 () => {
+                await fetchAndApplyPlatformConfig(configManagerOpts);
+            },
+            onSessionReady: async ({ activeSessionId }) => {
+                setParallAccountState(ctx.accountId, {
+                    client,
+                    apiUrl: config.parall_url,
+                    apiKey: config.api_key,
+                    orgId: config.org_id,
+                    agentUserId,
+                    activeSessionId,
+                    wikiMountRoot,
+                    ws,
+                    orchestratorSessionKey: orchestratorKey,
+                });
+            },
+            onBeforeDisconnect: async () => {
+                stopWikiHelper?.();
+                removeParallAccountState(ctx.accountId);
+            },
+        });
+        try {
+            await gateway.run(ctx.abortSignal);
+        }
+        finally {
+            if (!ctx.abortSignal.aborted) {
+                stopWikiHelper?.();
+                removeParallAccountState(ctx.accountId);
+            }
+        }
+    },
+};

package/dist/hooks.d.ts

@@ -0,0 +1,3 @@
+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

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

package/dist/hooks.js

@@ -0,0 +1,194 @@
+import { PRLL_BEHAVIOR, PRLL_REFERENCE_GUIDE, buildIdentity } from "@parall/agent-core";
+import { extractAccountIdFromSessionKey } from "./session.js";
+import { clearDispatchGroupKey, getAgentIdentity, getDispatchGroupKey, getDispatchMessageId, getParallAccountState, getSessionChatId } from "./runtime.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 "";
+}
+/**
+ * Resolve the ParallClient + orgId + sessionId for a hook context.
+ * Returns undefined if the account/session is not active.
+ */
+function resolveClientForHook(sessionKey) {
+    if (!sessionKey)
+        return undefined;
+    const chatId = getSessionChatId(sessionKey);
+    if (!chatId)
+        return undefined;
+    const accountId = extractAccountIdFromSessionKey(sessionKey);
+    if (!accountId)
+        return undefined;
+    const state = getParallAccountState(accountId);
+    if (!state)
+        return undefined;
+    return { ...state, chatId, sessionId: state.activeSessionId };
+}
+const PRLL_CHANNEL_CONTEXT = `## Parall Channel — Message Delivery
+
+Events from the Parall channel arrive as \`[Event: ...]\` blocks.
+Your text output is **not delivered to the user** — it is discarded silently.
+To respond, you **must** use the Parall CLI via the exec (Bash) tool. If \`parall\` is not on PATH, use \`npx --yes @parall/cli@latest\` instead.
+
+### Event types and where to reply
+
+- **\`[Event: message.new]\`** — includes \`[Chat: ... (prll://cht_xxx)]\`. Reply into that chat:
+
+        parall messages send prll://cht_xxx --text "Your reply here"
+
+- **\`[Event: task.assigned]\` / \`[Event: task.comment.created]\`** — includes \`[Task: ... (prll://tsk_xxx)]\`. Act on the task; use task CLI subcommands (\`tasks update\`, \`tasks comment\`). See the \`parall-tasks\` skill.
+
+- **\`[Event: schedule.fired]\`** — includes \`[Schedule: prll://sch_xxx]\` + \`[Run: prll://srn_xxx]\` + optional \`[Attached: prll://...]\`. The body is the fire-time \`description\` verbatim. It is an opaque trigger — decide what to do (reply into an attached chat, create a task, update a wiki file, or do nothing) based on the description. The CLI does not have a "reply to schedule" primitive; any follow-up goes through the appropriate target (chat / task / wiki).
+
+Credentials are pre-configured in every Bash command — no setup needed.
+Load the \`parall-platform\` skill for full CLI reference.
+When an event has \`[Hint: no_reply]\`, do not reply to that specific event.
+A dispatch may contain multiple events — only skip replies to the hinted ones.
+
+To silence a turn without running any \`messages send\` / \`dm\`, call:
+
+    parall no-reply [--reason "..."]
+
+Do NOT emit polite acknowledgements like "No response needed" via \`messages send\` — they become real messages and start agent-to-agent loops.`;
+export function registerParallHooks(api) {
+    const log = api.logger;
+    // Append Parall identity + channel context + behavior charter + reference guide
+    // AFTER workspace files so it takes precedence. Order matters: identity anchors
+    // who the agent is, channel context is a hard interface constraint, behavior
+    // sets working principles, reference guide is the URI lookup reference.
+    // Identity is resolved lazily from runtime state — not available at plugin
+    // 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", () => {
+        return {
+            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 sessionKey = ctx.sessionKey;
+        // (1) Create tool_call step and await to get step ID
+        let stepId;
+        const resolved = resolveClientForHook(sessionKey);
+        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(),
+                    },
+                    group_key: groupKey,
+                    runtime_key: event.toolCallId,
+                });
+                stepId = step.id;
+            }
+            catch (err) {
+                log?.warn(`parall hook before_tool_call failed: ${String(err)}`);
+            }
+        }
+        // (2) ENV injection — only for the exec (Bash) tool
+        if (event.toolName !== "exec")
+            return;
+        if (!sessionKey)
+            return;
+        const accountId = extractAccountIdFromSessionKey(sessionKey);
+        if (!accountId)
+            return;
+        const state = getParallAccountState(accountId);
+        if (!state)
+            return;
+        // Dynamic per-dispatch context (changes each dispatch)
+        const chatId = getSessionChatId(sessionKey);
+        const triggerMsgId = getDispatchMessageId(sessionKey);
+        const injectedEnv = {};
+        injectedEnv.PRLL_API_URL = state.apiUrl;
+        injectedEnv.PRLL_API_KEY = state.apiKey;
+        injectedEnv.PRLL_ORG_ID = state.orgId;
+        injectedEnv.PRLL_AGENT_ID = state.agentUserId;
+        if (state.activeSessionId)
+            injectedEnv.PRLL_SESSION_ID = state.activeSessionId;
+        if (stepId)
+            injectedEnv.PRLL_STEP_ID = stepId;
+        if (chatId) {
+            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
+                // chatId=sch_* would mislead scripts into `messages send
+                // prll://sch_*` (a non-existent CLI path). The run snapshot is
+                // available via PRLL_TRIGGER_MESSAGE_ID (srn_*) for agents that
+                // want to re-fetch fire-time content.
+                injectedEnv.PRLL_SCHEDULE_ID = chatId;
+            }
+            else {
+                // Chat and task dispatches continue to populate PRLL_CHAT_ID for
+                // backward compatibility with existing agent scripts.
+                injectedEnv.PRLL_CHAT_ID = chatId;
+            }
+        }
+        if (triggerMsgId)
+            injectedEnv.PRLL_TRIGGER_MESSAGE_ID = triggerMsgId;
+        if (state.wikiMountRoot)
+            injectedEnv.PRLL_WIKI_MOUNT_ROOT = state.wikiMountRoot;
+        // OpenClaw context (upstream doesn't inject these into exec env yet)
+        injectedEnv.OPENCLAW_SESSION_KEY = sessionKey;
+        if (event.toolCallId)
+            injectedEnv.OPENCLAW_TOOL_CALL_ID = event.toolCallId;
+        // Shallow merge — preserve agent's original env params
+        const existingEnv = event.params?.env;
+        return {
+            params: {
+                env: { ...existingEnv, ...injectedEnv },
+            },
+        };
+    });
+    // after_tool_call -> send tool_result step to AgentSession
+    api.on("after_tool_call", async (event, ctx) => {
+        const resolved = 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,
+                },
+            });
+        }
+        catch (err) {
+            log?.warn(`parall hook after_tool_call failed: ${String(err)}`);
+        }
+    });
+    // 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) => {
+        if (ctx.sessionKey) {
+            clearDispatchGroupKey(ctx.sessionKey);
+        }
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+declare const plugin: {
+    id: string;
+    name: string;
+    description: string;
+    configSchema: import("openclaw/plugin-sdk").OpenClawPluginConfigSchema;
+    register(api: OpenClawPluginApi): void;
+};
+export default plugin;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAM7D,QAAA,MAAM,MAAM;;;;;kBAKI,iBAAiB;CAKhC,CAAC;AAEF,eAAe,MAAM,CAAC"}

package/dist/index.js

@@ -0,0 +1,16 @@
+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.",
+    configSchema: emptyPluginConfigSchema(),
+    register(api) {
+        setParallRuntime(api.runtime);
+        api.registerChannel({ plugin: parallPlugin });
+        registerParallHooks(api);
+    },
+};
+export default plugin;

package/dist/outbound.d.ts

@@ -0,0 +1,6 @@
+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"]>;
+export declare const parallOutbound: ChannelOutboundAdapter;
+export {};
+//# sourceMappingURL=outbound.d.ts.map

package/dist/outbound.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"outbound.d.ts","sourceRoot":"","sources":["../src/outbound.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAE9D,wGAAwG;AACxG,KAAK,sBAAsB,GAAG,WAAW,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC,CAAC;AAMrE,eAAO,MAAM,cAAc,EAAE,sBA2B5B,CAAC"}

package/dist/outbound.js

@@ -0,0 +1,30 @@
+import { resolveParallAccount } from "./accounts.js";
+import { getParallAccountState } from "./runtime.js";
+import { ParallClient } from "@parall/sdk";
+export const parallOutbound = {
+    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");
+        const state = getParallAccountState(account.accountId);
+        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 = {
+            message_type: "text",
+            content: { text },
+        };
+        const msg = await client.sendMessage(orgId, chatId, req);
+        return { channel: "parall", messageId: msg.id, channelId: chatId };
+    },
+};

package/dist/routing.d.ts

@@ -0,0 +1,3 @@
+export { defaultRoutingStrategy, routeTrigger, } from "@parall/agent-core";
+export type { RoutingStrategy, TriggerDisposition, } from "@parall/agent-core";
+//# sourceMappingURL=routing.d.ts.map

package/dist/routing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routing.d.ts","sourceRoot":"","sources":["../src/routing.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,sBAAsB,EACtB,YAAY,GACb,MAAM,oBAAoB,CAAC;AAC5B,YAAY,EACV,eAAe,EACf,kBAAkB,GACnB,MAAM,oBAAoB,CAAC"}

package/dist/routing.js

@@ -0,0 +1 @@
+export { defaultRoutingStrategy, routeTrigger, } from "@parall/agent-core";

package/dist/runtime.d.ts

@@ -0,0 +1,26 @@
+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, setSessionMessageId, getSessionMessageId, clearSessionMessageId, setDispatchMessageId, getDispatchMessageId, clearDispatchMessageId, setDispatchGroupKey, getDispatchGroupKey, clearDispatchGroupKey, setDispatchNoReply, getDispatchNoReply, clearDispatchNoReply, } from "@parall/agent-core";
+export type ParallAccountState = {
+    client: ParallClient;
+    apiUrl: string;
+    apiKey: string;
+    orgId: string;
+    agentUserId: string;
+    activeSessionId?: string;
+    wikiMountRoot?: string;
+    ws?: ParallWs;
+    orchestratorSessionKey?: string;
+    [key: string]: unknown;
+};
+export declare function setParallRuntime(next: PluginRuntime): void;
+export declare function getParallRuntime(): PluginRuntime;
+export declare function setParallAccountState(accountId: string, state: ParallAccountState): void;
+export declare function removeParallAccountState(accountId: string): void;
+export declare function getParallAccountState(accountId: string): ParallAccountState | undefined;
+export declare function getAllParallAccountStates(): ReadonlyMap<string, ParallAccountState>;
+export declare function setAgentIdentity(identity: AgentIdentity): void;
+export declare function getAgentIdentity(): AgentIdentity | undefined;
+//# sourceMappingURL=runtime.d.ts.map

package/dist/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC1D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACxD,YAAY,EAAE,UAAU,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjF,OAAO,EACL,gBAAgB,EAChB,gBAAgB,EAChB,mBAAmB,EACnB,mBAAmB,EACnB,qBAAqB,EACrB,oBAAoB,EACpB,oBAAoB,EACpB,sBAAsB,EACtB,mBAAmB,EACnB,mBAAmB,EACnB,qBAAqB,EACrB,kBAAkB,EAClB,kBAAkB,EAClB,oBAAoB,GACrB,MAAM,oBAAoB,CAAC;AAE5B,MAAM,MAAM,kBAAkB,GAAG;IAC/B,MAAM,EAAE,YAAY,CAAC;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,EAAE,CAAC,EAAE,QAAQ,CAAC;IACd,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB,CAAC;AAIF,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,aAAa,QAEnD;AAED,wBAAgB,gBAAgB,IAAI,aAAa,CAKhD;AAKD,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,kBAAkB,QAEjF;AAED,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,MAAM,QAEzD;AAED,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,MAAM,GAAG,kBAAkB,GAAG,SAAS,CAEvF;AAED,wBAAgB,yBAAyB,IAAI,WAAW,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAEnF;AAID,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,aAAa,QAEvD;AAED,wBAAgB,gBAAgB,IAAI,aAAa,GAAG,SAAS,CAE5D"}