@parall/parall 1.12.0 → 1.13.0

package/src/hooks.ts

@@ -1,6 +1,6 @@
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
 import { extractAccountIdFromSessionKey } from "./session.js";
-import { clearDispatchGroupKey, clearDispatchMessageId, clearSessionMessageId, getDispatchGroupKey, getDispatchMessageId, getParallAccountState, getSessionChatId } from "./runtime.js";
+import { clearDispatchGroupKey, getDispatchGroupKey, getDispatchMessageId, getParallAccountState, getSessionChatId } from "./runtime.js";
 
 /**
  * Resolve the ParallClient + orgId + sessionId for a hook context.
@@ -83,8 +83,11 @@ export function registerParallHooks(api: OpenClawPluginApi) {
     // Dynamic per-dispatch context (changes each dispatch)
     const chatId = getSessionChatId(sessionKey);
     const triggerMsgId = getDispatchMessageId(sessionKey);
-
     const injectedEnv: Record<string, string> = {};
+    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) injectedEnv.PRLL_CHAT_ID = chatId;
@@ -130,32 +133,9 @@ export function registerParallHooks(api: OpenClawPluginApi) {
 
   // agent_end -> end of a dispatch cycle, NOT end of session.
   // Session lives across dispatches — don't update session status here.
-  // On error: emit a visible error step so the chat user sees the failure.
+  // Dispatch-specific IDs are cleaned up in the generic gateway; hooks only own the group key.
   api.on("agent_end", async (event, ctx) => {
-    // Emit error step if the dispatch failed
-    if (event.error && ctx.sessionKey) {
-      const accountId = extractAccountIdFromSessionKey(ctx.sessionKey);
-      const state = accountId ? getParallAccountState(accountId) : undefined;
-      const chatId = getSessionChatId(ctx.sessionKey);
-      if (state?.activeSessionId && chatId) {
-        try {
-          await state.client.createAgentStep(state.orgId, state.agentUserId, state.activeSessionId, {
-            step_type: "text",
-            target_type: "chat",
-            target_id: chatId,
-            content: { text: `Dispatch failed: ${String(event.error)}`, suppressed: false },
-            projection: true,
-          });
-        } catch (err) {
-          log?.warn(`parall hook agent_end: failed to emit error step: ${String(err)}`);
-        }
-      }
-    }
-
-    // Clean up dispatch-specific state
     if (ctx.sessionKey) {
-      clearSessionMessageId(ctx.sessionKey);
-      clearDispatchMessageId(ctx.sessionKey);
       clearDispatchGroupKey(ctx.sessionKey);
     }
   });

package/src/routing.ts

@@ -1,48 +1,8 @@
-import type { ParallEvent, DispatchState } from "./runtime.js";
-
-/** Where an inbound event should be routed. */
-export type TriggerDisposition =
-  | { action: "main" }
-  | { action: "buffer-main" }
-  | { action: "buffer-fork"; forkKey: string }
-  | { action: "new-fork" };
-
-/** Pluggable strategy for routing triggers when main session is busy. */
-export type RoutingStrategy = (event: ParallEvent, state: DispatchState) => TriggerDisposition;
-
-const MAX_CONCURRENT_FORKS = 20;
-
-/**
- * Default routing strategy:
- * - Same target as main → buffer-main (strict per-target serial ordering)
- * - Active fork for same target → buffer into that fork
- * - Too many forks → buffer-main (backpressure)
- * - Otherwise → create a new fork
- */
-export const defaultRoutingStrategy: RoutingStrategy = (event, state) => {
-  // P0: same target as main must stay serial — fork would see stale transcript
-  if (state.mainCurrentTargetId === event.targetId) {
-    return { action: "buffer-main" };
-  }
-
-  // Same target already has a fork → buffer into it
-  const existingForkKey = state.activeForks.get(event.targetId);
-  if (existingForkKey) return { action: "buffer-fork", forkKey: existingForkKey };
-
-  // Backpressure: cap concurrent forks to avoid unbounded fan-out
-  if (state.activeForks.size >= MAX_CONCURRENT_FORKS) {
-    return { action: "buffer-main" };
-  }
-
-  return { action: "new-fork" };
-};
-
-/** Route an inbound event based on current dispatch state. */
-export function routeTrigger(
-  event: ParallEvent,
-  state: DispatchState,
-  strategy: RoutingStrategy = defaultRoutingStrategy,
-): TriggerDisposition {
-  if (!state.mainDispatching) return { action: "main" };
-  return strategy(event, state);
-}
+export {
+  defaultRoutingStrategy,
+  routeTrigger,
+} from "@parall/agent-core";
+export type {
+  RoutingStrategy,
+  TriggerDisposition,
+} from "@parall/agent-core";

package/src/runtime.ts

@@ -1,5 +1,35 @@
 import type { PluginRuntime } from "openclaw/plugin-sdk";
 import type { ParallClient, ParallWs } from "@parall/sdk";
+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;
+};
 
 let runtime: PluginRuntime | null = null;
 
@@ -15,16 +45,6 @@ export function getParallRuntime(): PluginRuntime {
 }
 
 // Cached client state per account, populated by gateway.ts startAccount
-export type ParallAccountState = {
-  client: ParallClient;
-  orgId: string;
-  agentUserId: string;
-  activeSessionId?: string;
-  wikiMountRoot?: string;
-  ws?: ParallWs;
-  orchestratorSessionKey?: string;
-};
-
 const accountStates = new Map<string, ParallAccountState>();
 
 export function setParallAccountState(accountId: string, state: ParallAccountState) {
@@ -42,94 +62,3 @@ export function getParallAccountState(accountId: string): ParallAccountState | u
 export function getAllParallAccountStates(): ReadonlyMap<string, ParallAccountState> {
   return new Map(accountStates);
 }
-
-// Session key → original chat ID mapping.
-// OpenClaw normalizes session keys to lowercase, but Parall IDs are case-sensitive.
-const sessionChatIdMap = new Map<string, string>();
-const sessionMessageIdMap = new Map<string, string>();
-// Per-dispatch snapshot: message ID captured when a dispatch starts, immune to later overwrites.
-// Keyed by lowercased session key, cleared when the agent run ends.
-const dispatchMessageIdMap = new Map<string, string>();
-
-export function setSessionChatId(sessionKey: string, chatId: string) {
-  sessionChatIdMap.set(sessionKey.toLowerCase(), chatId);
-}
-
-export function getSessionChatId(sessionKey: string): string | undefined {
-  return sessionChatIdMap.get(sessionKey.toLowerCase());
-}
-
-export function setSessionMessageId(sessionKey: string, messageId: string) {
-  sessionMessageIdMap.set(sessionKey.toLowerCase(), messageId);
-}
-
-export function getSessionMessageId(sessionKey: string): string | undefined {
-  return sessionMessageIdMap.get(sessionKey.toLowerCase());
-}
-
-export function clearSessionMessageId(sessionKey: string) {
-  sessionMessageIdMap.delete(sessionKey.toLowerCase());
-}
-
-/** Snapshot the message ID at dispatch time — immune to later session-level overwrites. */
-export function setDispatchMessageId(sessionKey: string, messageId: string) {
-  dispatchMessageIdMap.set(sessionKey.toLowerCase(), messageId);
-}
-
-/** Read the dispatch-time snapshot. Prefer this over getSessionMessageId for provenance. */
-export function getDispatchMessageId(sessionKey: string): string | undefined {
-  return dispatchMessageIdMap.get(sessionKey.toLowerCase());
-}
-
-export function clearDispatchMessageId(sessionKey: string) {
-  dispatchMessageIdMap.delete(sessionKey.toLowerCase());
-}
-
-// Per-dispatch group key — shared between thinking + tool_call steps for Session Panel grouping.
-// Set per LLM response turn in gateway.ts, read in hooks.ts.
-const dispatchGroupKeyMap = new Map<string, string>();
-
-export function setDispatchGroupKey(sessionKey: string, groupKey: string) {
-  dispatchGroupKeyMap.set(sessionKey.toLowerCase(), groupKey);
-}
-
-export function getDispatchGroupKey(sessionKey: string): string | undefined {
-  return dispatchGroupKeyMap.get(sessionKey.toLowerCase());
-}
-
-export function clearDispatchGroupKey(sessionKey: string) {
-  dispatchGroupKeyMap.delete(sessionKey.toLowerCase());
-}
-
-/** Result from a completed fork dispatch, to be injected into main session's next turn. */
-export type ForkResult = {
-  forkSessionKey: string;
-  sourceEvent: { type: string; targetId: string; summary: string };
-  actions: string[];  // human-readable list of actions taken (e.g. "replied to cht_xxx")
-};
-
-/** Mutable dispatch state for the orchestrator gateway. Per-account, managed by gateway.ts. */
-export type DispatchState = {
-  mainDispatching: boolean;
-  /** The targetId currently being processed by main. Used to enforce per-target serial ordering. */
-  mainCurrentTargetId?: string;
-  /** targetId → fork session key. One active fork per target at most. */
-  activeForks: Map<string, string>;
-  pendingForkResults: ForkResult[];
-  mainBuffer: ParallEvent[];
-};
-
-/** Normalized inbound event from Parall. */
-export type ParallEvent = {
-  type: "message" | "task";
-  targetId: string;       // chatId or taskId
-  targetName?: string;
-  targetType?: string;    // "direct" | "group" | "task"
-  senderId: string;
-  senderName: string;
-  messageId: string;
-  body: string;           // raw message text or task description
-  threadRootId?: string;
-  noReply?: boolean;
-  mediaFields?: Record<string, string | undefined>;
-};