@parall/parall 1.64.0 → 1.65.0

package/dist/index.bundle.mjs

@@ -52248,6 +52248,67 @@ function describeRuntimeTurnTrigger(trigger) {
   }
 }
 
+// ../agent-core/dist/redact.js
+function redactSecrets(s, knownValues = []) {
+  return maskKnownValues(s, knownValues).replace(/\b(agk|mck|cpk)_[A-Za-z0-9_-]+/g, "$1_***").replace(/\b(sk|pk|rk)-[A-Za-z0-9_-]{8,}/g, "$1-***").replace(/\bAKIA[0-9A-Z]{16}\b/g, "AKIA***").replace(/\b((?:bearer|basic)\s+)[A-Za-z0-9._~+/=-]+/gi, "$1***").replace(/(\b(?:[\w-]*[_-])?(?:api[_-]?key|key|token|secret|password|passwd|authorization)["']?\s*[=:]\s*)(?:"(?:\\.|[^"\\\r\n])*"|'(?:\\.|[^'\\\r\n])*'|[^\s&;,}\]"']+)/gi, "$1***").replace(/[A-Za-z0-9_-]{32,}/g, "***");
+}
+function maskKnownValues(s, knownValues) {
+  let out = s;
+  for (const v of knownValues) {
+    if (typeof v === "string" && v.length >= 6)
+      out = out.split(v).join("***");
+  }
+  return out;
+}
+function redactTurnOutcome(event, knownValues) {
+  const redacted = { ...event };
+  if (redacted.detail)
+    redacted.detail = redactSecrets(redacted.detail, knownValues);
+  if (redacted.raw) {
+    redacted.raw = Object.fromEntries(Object.entries(redacted.raw).map(([k, v]) => [
+      k,
+      typeof v === "string" ? redactSecrets(v, knownValues) : v
+    ]));
+  }
+  return redacted;
+}
+function describeTurnOutcomeFailure(outcome) {
+  const retryNote = outcome.retryAt ? `, retry at ${outcome.retryAt}` : "";
+  return {
+    warn: `${outcome.outcome}${retryNote}${outcome.detail ? ` \u2014 ${outcome.detail}` : ""}`,
+    stepMessage: `LLM turn ${outcome.outcome}${retryNote}${outcome.detail ? `: ${outcome.detail}` : ""}`
+  };
+}
+function redactLogger(log, knownValues) {
+  if (!log)
+    return void 0;
+  return {
+    info: (message) => log.info(redactSecrets(message, knownValues)),
+    warn: (message) => log.warn(redactSecrets(message, knownValues)),
+    error: (message) => log.error(redactSecrets(message, knownValues)),
+    ...log.child ? { child: (name) => redactLogger(log.child(name), knownValues) } : {}
+  };
+}
+
+// ../agent-core/dist/runtime-observation.js
+async function persistRuntimeObservation(persister, sessionId, target, event, log, knownSecrets = []) {
+  const native = event.content.native && Object.fromEntries(Object.entries(event.content.native).map(([key, value]) => [
+    key,
+    typeof value !== "string" ? value : key.endsWith("_id") ? maskKnownValues(value, knownSecrets) : redactSecrets(value, knownSecrets)
+  ]));
+  try {
+    await persister.persist(sessionId, "observation", {
+      step_type: "observation",
+      ...target,
+      idempotency_key: `observation:${event.observationId}`,
+      content: { ...event.content, ...native ? { native } : {} },
+      projection: false
+    });
+  } catch (err) {
+    log?.warn(`runtime observation could not be saved for ${sessionId}: ${String(err)}`);
+  }
+}
+
 // ../agent-core/dist/fork-prefix.js
 function sanitizeMeta(value) {
   return value.replace(/[\r\n]+/g, " ").replace(/[[\]|]/g, " ").trim();
@@ -52286,6 +52347,108 @@ function buildForkResultPrefix(results) {
   return blocks.join("\n\n") + "\n\n---\n\n";
 }
 
+// ../agent-core/dist/gateway-runtime-step.js
+import { randomUUID } from "node:crypto";
+async function createRuntimeStep(host, sessionId, target, runtimeEvent, stepIdFilePath, contextFilePath, laneContextFilePath2) {
+  switch (runtimeEvent.type) {
+    case "observation":
+      await persistRuntimeObservation(host.stepPersister, sessionId, target, runtimeEvent, host.opts?.log, host.opts?.config ? [host.opts.config.api_key] : []);
+      break;
+    case "thinking":
+      await host.stepPersister.persist(sessionId, "thinking", {
+        step_type: "thinking",
+        target_type: target.target_type,
+        target_id: target.target_id,
+        idempotency_key: randomUUID(),
+        content: { text: runtimeEvent.text },
+        group_key: runtimeEvent.groupKey
+      });
+      break;
+    case "text":
+      await host.stepPersister.persist(sessionId, "text", {
+        step_type: "text",
+        target_type: target.target_type,
+        target_id: target.target_id,
+        idempotency_key: randomUUID(),
+        content: {
+          text: runtimeEvent.text,
+          suppressed: runtimeEvent.project !== true
+        },
+        projection: runtimeEvent.project === true,
+        group_key: runtimeEvent.groupKey
+      });
+      break;
+    case "tool_call": {
+      const step = await host.stepPersister.persist(sessionId, "tool_call", {
+        step_type: "tool_call",
+        target_type: target.target_type,
+        target_id: target.target_id,
+        // call_id is session-unique for bridge runtimes (server-enforced),
+        // so the bare form anchors the tool step pair across retries —
+        // unlike parel's turn-scoped `tc:{turnId}:{callId}` (see
+        // protocol-vectors/agent-steps.json).
+        idempotency_key: `tc:${runtimeEvent.callId}`,
+        content: {
+          call_id: runtimeEvent.callId,
+          tool_name: runtimeEvent.toolName,
+          tool_input: runtimeEvent.input,
+          status: "running",
+          started_at: runtimeEvent.startedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+        },
+        group_key: runtimeEvent.groupKey,
+        runtime_key: runtimeEvent.callId
+      });
+      if (step) {
+        if (contextFilePath) {
+          host.updateContextFileStepId(contextFilePath, step.id);
+        } else if (stepIdFilePath) {
+          host.writeStepIdFile(stepIdFilePath, step.id);
+        }
+        if (laneContextFilePath2) {
+          host.updateContextFileStepId(laneContextFilePath2, step.id);
+        }
+      }
+      break;
+    }
+    case "tool_result":
+      await host.stepPersister.persist(sessionId, "tool_result", {
+        step_type: "tool_result",
+        target_type: target.target_type,
+        target_id: target.target_id,
+        idempotency_key: `tr:${runtimeEvent.callId}`,
+        content: {
+          call_id: runtimeEvent.callId,
+          tool_name: runtimeEvent.toolName,
+          status: runtimeEvent.error ? "error" : "success",
+          output: runtimeEvent.output,
+          duration_ms: runtimeEvent.durationMs ?? 0,
+          collapsible: true
+        },
+        group_key: runtimeEvent.groupKey
+      });
+      if (contextFilePath) {
+        host.updateContextFileStepId(contextFilePath, null);
+      } else if (stepIdFilePath) {
+        host.clearStepIdFile(stepIdFilePath);
+      }
+      if (laneContextFilePath2) {
+        host.updateContextFileStepId(laneContextFilePath2, null);
+      }
+      break;
+    case "error":
+      await host.stepPersister.persist(sessionId, "error", {
+        step_type: "text",
+        target_type: target.target_type,
+        target_id: target.target_id,
+        idempotency_key: randomUUID(),
+        content: buildErrorStepContent(runtimeEvent.message),
+        projection: false,
+        group_key: runtimeEvent.groupKey
+      });
+      break;
+  }
+}
+
 // ../agent-core/dist/dispatch-recovery.js
 var DispatchRecovery = class {
   scan;
@@ -52345,7 +52508,7 @@ function splitChangeSource(sourceId) {
 // ../agent-core/dist/gateway-base.js
 import * as fs4 from "node:fs";
 import * as path5 from "node:path";
-import { randomUUID } from "node:crypto";
+import { randomUUID as randomUUID2 } from "node:crypto";
 
 // ../sdk/dist/browser-viewer.js
 var BROWSER_VIEWER_READINESS_TIMEOUT_MS = 6e4;
@@ -52358,6 +52521,20 @@ function browserViewerRequestOptions(command, opts) {
   };
 }
 
+// ../sdk/dist/slack-endpoints.js
+function slackEndpoints(apiBase) {
+  return {
+    SLACK_CHANNELS: (orgId) => `${apiBase}/orgs/${orgId}/agents/me/slack/channels`,
+    SLACK_USERS: (orgId) => `${apiBase}/orgs/${orgId}/agents/me/slack/users`,
+    SLACK_REPLIES: (orgId) => `${apiBase}/orgs/${orgId}/agents/me/slack/replies`,
+    SLACK_HISTORY: (orgId) => `${apiBase}/orgs/${orgId}/agents/me/slack/history`,
+    SLACK_MEMBERS: (orgId) => `${apiBase}/orgs/${orgId}/agents/me/slack/members`,
+    SLACK_STATUS: (orgId) => `${apiBase}/orgs/${orgId}/agents/me/slack/status`,
+    SLACK_FILE: (orgId) => `${apiBase}/orgs/${orgId}/agents/me/slack/file`,
+    SLACK_FILES: (orgId) => `${apiBase}/orgs/${orgId}/agents/me/slack/files`
+  };
+}
+
 // ../sdk/dist/clip-connection-endpoints.js
 var clipConnectionEndpoints = {
   ORG_CLIP_MCP_OAUTH_ATTEMPT: (orgId, clipId, attemptId) => `/api/v1/orgs/${orgId}/clip-registry/${clipId}/mcp-oauth-attempts/${attemptId}`,
@@ -52686,13 +52863,7 @@ var ENDPOINTS = {
   // Tier-B platform verb (agent-only): send one message as the bound bot.
   CHANNEL_SEND: (orgId) => `${API_BASE2}/orgs/${orgId}/agents/me/channel-send`,
   // Tier-B read verbs (agent-only): workspace visibility as the bot sees it.
-  SLACK_CHANNELS: (orgId) => `${API_BASE2}/orgs/${orgId}/agents/me/slack/channels`,
-  SLACK_USERS: (orgId) => `${API_BASE2}/orgs/${orgId}/agents/me/slack/users`,
-  SLACK_HISTORY: (orgId) => `${API_BASE2}/orgs/${orgId}/agents/me/slack/history`,
-  SLACK_MEMBERS: (orgId) => `${API_BASE2}/orgs/${orgId}/agents/me/slack/members`,
-  SLACK_STATUS: (orgId) => `${API_BASE2}/orgs/${orgId}/agents/me/slack/status`,
-  SLACK_FILE: (orgId) => `${API_BASE2}/orgs/${orgId}/agents/me/slack/file`,
-  SLACK_FILES: (orgId) => `${API_BASE2}/orgs/${orgId}/agents/me/slack/files`,
+  ...slackEndpoints(API_BASE2),
   // WeChat tier-B read verbs (agent-only; internal research preview).
   ...wechatEndpoints(API_BASE2),
   // Invitations (org-scoped, admin)
@@ -53374,14 +53545,16 @@ var SlackFilesClient = class extends AttachmentClient {
   }
   /**
    * Tier-B file upload verb (agent-only): share a file into a Slack
-   * conversation this connection has seen inbound, with the same
-   * reply-anchor contract as the text send.
+   * conversation or thread with the same addressing as text sends.
+   * Native threadTs requires a server supporting Slack thread sends.
    */
   async sendSlackFile(orgId, input) {
     const fd = new FormData();
     fd.append("conversation_id", input.conversationId);
     if (input.replyTo)
       fd.append("reply_to", input.replyTo);
+    if (input.threadTs)
+      fd.append("thread_ts", input.threadTs);
     if (input.text)
       fd.append("text", input.text);
     fd.append("file", input.content, input.fileName);
@@ -53389,8 +53562,48 @@ var SlackFilesClient = class extends AttachmentClient {
   }
 };
 
+// ../sdk/dist/slack-read-client.js
+var SlackReadClient = class extends SlackFilesClient {
+  slackReadQuery(base, query, extra) {
+    const params = new URLSearchParams();
+    if (query?.cursor)
+      params.set("cursor", query.cursor);
+    if (query?.limit)
+      params.set("limit", String(query.limit));
+    for (const [k, v] of Object.entries(extra ?? {}))
+      params.set(k, v);
+    const qs = params.toString();
+    return qs ? `${base}?${qs}` : base;
+  }
+  /**
+   * Tier-B read verbs (agent-only): workspace visibility as the bot sees
+   * it. Same live gate as the send verb; authorization beyond it is the
+   * bot's own Slack permissions.
+   */
+  async listSlackChannels(orgId, query) {
+    return this.request("GET", this.slackReadQuery(ENDPOINTS.SLACK_CHANNELS(orgId), query));
+  }
+  async listSlackUsers(orgId, query) {
+    return this.request("GET", this.slackReadQuery(ENDPOINTS.SLACK_USERS(orgId), query));
+  }
+  async slackHistory(orgId, conversationId, query) {
+    return this.request("GET", this.slackReadQuery(ENDPOINTS.SLACK_HISTORY(orgId), query, { conversation: conversationId }));
+  }
+  /** Read a Slack thread (parent and replies), one page in Slack order. */
+  async slackReplies(orgId, channel, ts, query) {
+    return this.request("GET", this.slackReadQuery(ENDPOINTS.SLACK_REPLIES(orgId), query, { channel, ts }));
+  }
+  async slackMembers(orgId, conversationId, query) {
+    return this.request("GET", this.slackReadQuery(ENDPOINTS.SLACK_MEMBERS(orgId), query, { conversation: conversationId }));
+  }
+  /** Set/clear the Agents-pane "typing…" indicator (best-effort cosmetic). */
+  async setSlackStatus(orgId, input) {
+    await this.request("POST", ENDPOINTS.SLACK_STATUS(orgId), input);
+  }
+};
+
 // ../sdk/dist/channel-conversation-client.js
-var ChannelConversationClient = class extends SlackFilesClient {
+var ChannelConversationClient = class extends SlackReadClient {
   /**
    * Org-admin write of what the agent receives from a group root
    * (`PATCH …/channel-conversations/{id}/attention`); the agent's own path
@@ -55064,38 +55277,6 @@ var ParallClient = class _ParallClient extends BrowserProfileClient {
   async sendChannelMessage(orgId, input) {
     return this.request("POST", ENDPOINTS.CHANNEL_SEND(orgId), input);
   }
-  slackReadQuery(base, query, extra) {
-    const params = new URLSearchParams();
-    if (query?.cursor)
-      params.set("cursor", query.cursor);
-    if (query?.limit)
-      params.set("limit", String(query.limit));
-    for (const [k, v] of Object.entries(extra ?? {}))
-      params.set(k, v);
-    const qs = params.toString();
-    return qs ? `${base}?${qs}` : base;
-  }
-  /**
-   * Tier-B read verbs (agent-only): workspace visibility as the bot sees
-   * it. Same live gate as the send verb; authorization beyond it is the
-   * bot's own Slack permissions.
-   */
-  async listSlackChannels(orgId, query) {
-    return this.request("GET", this.slackReadQuery(ENDPOINTS.SLACK_CHANNELS(orgId), query));
-  }
-  async listSlackUsers(orgId, query) {
-    return this.request("GET", this.slackReadQuery(ENDPOINTS.SLACK_USERS(orgId), query));
-  }
-  async slackHistory(orgId, conversationId, query) {
-    return this.request("GET", this.slackReadQuery(ENDPOINTS.SLACK_HISTORY(orgId), query, { conversation: conversationId }));
-  }
-  async slackMembers(orgId, conversationId, query) {
-    return this.request("GET", this.slackReadQuery(ENDPOINTS.SLACK_MEMBERS(orgId), query, { conversation: conversationId }));
-  }
-  /** Set/clear the Agents-pane "typing…" indicator (best-effort cosmetic). */
-  async setSlackStatus(orgId, input) {
-    await this.request("POST", ENDPOINTS.SLACK_STATUS(orgId), input);
-  }
   /**
    * Authorized raw GET (binary responses) with the same auth, 401
    * refresh-and-retry-once, and error-envelope handling as `request` — the
@@ -56810,46 +56991,60 @@ function createActiveForkState(fork, targetId, continuationPrefix) {
   };
 }
 
-// ../agent-core/dist/redact.js
-function redactSecrets(s, knownValues = []) {
-  return maskKnownValues(s, knownValues).replace(/\b(agk|mck|cpk)_[A-Za-z0-9_-]+/g, "$1_***").replace(/\b(sk|pk|rk)-[A-Za-z0-9_-]{8,}/g, "$1-***").replace(/\bAKIA[0-9A-Z]{16}\b/g, "AKIA***").replace(/\b((?:bearer|basic)\s+)[A-Za-z0-9._~+/=-]+/gi, "$1***").replace(/(\b(?:[\w-]*[_-])?(?:api[_-]?key|key|token|secret|password|passwd|authorization)["']?\s*[=:]\s*)(?:"(?:\\.|[^"\\\r\n])*"|'(?:\\.|[^'\\\r\n])*'|[^\s&;,}\]"']+)/gi, "$1***").replace(/[A-Za-z0-9_-]{32,}/g, "***");
+// ../agent-core/dist/gateway-steer.js
+var pendingSteers = /* @__PURE__ */ new WeakMap();
+function hasMainSteers(state) {
+  return (pendingSteers.get(state)?.size ?? 0) > 0;
 }
-function maskKnownValues(s, knownValues) {
-  let out = s;
-  for (const v of knownValues) {
-    if (typeof v === "string" && v.length >= 6)
-      out = out.split(v).join("***");
-  }
-  return out;
+async function waitForMainSteers(state) {
+  await Promise.allSettled(pendingSteers.get(state) ?? []);
 }
-function redactTurnOutcome(event, knownValues) {
-  const redacted = { ...event };
-  if (redacted.detail)
-    redacted.detail = redactSecrets(redacted.detail, knownValues);
-  if (redacted.raw) {
-    redacted.raw = Object.fromEntries(Object.entries(redacted.raw).map(([k, v]) => [
-      k,
-      typeof v === "string" ? redactSecrets(v, knownValues) : v
-    ]));
+async function steerLaneMessage(host, event) {
+  let pending = pendingSteers.get(host.dispatchState);
+  if (!pending) {
+    pending = /* @__PURE__ */ new Set();
+    pendingSteers.set(host.dispatchState, pending);
+  }
+  const work = Promise.resolve().then(() => steerLaneMessageInner(host, event));
+  pending.add(work);
+  try {
+    await work;
+  } finally {
+    pending.delete(work);
+    if (pending.size === 0)
+      pendingSteers.delete(host.dispatchState);
+    host.notifyDrainWaiters?.();
   }
-  return redacted;
 }
-function describeTurnOutcomeFailure(outcome) {
-  const retryNote = outcome.retryAt ? `, retry at ${outcome.retryAt}` : "";
-  return {
-    warn: `${outcome.outcome}${retryNote}${outcome.detail ? ` \u2014 ${outcome.detail}` : ""}`,
-    stepMessage: `LLM turn ${outcome.outcome}${retryNote}${outcome.detail ? `: ${outcome.detail}` : ""}`
-  };
+function hasUninjectedSameLaneEventAhead(host, event) {
+  const eventIndex = host.dispatchState.mainBuffer.lastIndexOf(event);
+  if (eventIndex <= 0)
+    return false;
+  const groupKey = host.dispatchGroupKey(event);
+  return host.dispatchState.mainBuffer.slice(0, eventIndex).some((buffered) => host.dispatchGroupKey(buffered) === groupKey && !host.injectedMainBufferEvents.has(buffered));
 }
-function redactLogger(log, knownValues) {
-  if (!log)
-    return void 0;
-  return {
-    info: (message) => log.info(redactSecrets(message, knownValues)),
-    warn: (message) => log.warn(redactSecrets(message, knownValues)),
-    error: (message) => log.error(redactSecrets(message, knownValues)),
-    ...log.child ? { child: (name) => redactLogger(log.child(name), knownValues) } : {}
-  };
+async function steerLaneMessageInner(host, event) {
+  const { laneLedger: ledger, opts } = host;
+  const adapter = opts.dispatchAdapter;
+  if (!ledger || !adapter.enqueueDuringDispatch)
+    return;
+  if (hasUninjectedSameLaneEventAhead(host, event))
+    return;
+  const folded = await ledger.steerLive(event);
+  if (!folded)
+    return;
+  if (!folded.frame)
+    return;
+  event.frame = folded.frame;
+  const injected = await adapter.enqueueDuringDispatch(opts.runtimeKey, eventBody(event), folded.inputLifecycle);
+  if (injected) {
+    host.injectedMainBufferEvents.add(event);
+    ledger.markSeen(event, folded.covered);
+    opts.log?.info(`steer frame handed to adapter for ${event.messageId} (will drain for bookkeeping)`);
+  } else if (folded.frame) {
+    ledger.deferFrame(event, folded.frame, folded.covered);
+    opts.log?.info(`steer folded but not injected for ${event.messageId} \u2014 frame deferred to the drain`);
+  }
 }
 
 // ../agent-core/dist/lane-ledger.js
@@ -58595,36 +58790,6 @@ function applyWake(event, wake) {
   if (wake.attachments?.length)
     event.attachments = wake.attachments;
 }
-function hasUninjectedSameLaneEventAhead(host, event) {
-  const eventIndex = host.dispatchState.mainBuffer.lastIndexOf(event);
-  if (eventIndex <= 0)
-    return false;
-  const groupKey = host.dispatchGroupKey(event);
-  return host.dispatchState.mainBuffer.slice(0, eventIndex).some((buffered) => host.dispatchGroupKey(buffered) === groupKey && !host.injectedMainBufferEvents.has(buffered));
-}
-async function steerLaneMessage(host, event) {
-  const { laneLedger: ledger, opts } = host;
-  const adapter = opts.dispatchAdapter;
-  if (!ledger || !adapter.enqueueDuringDispatch)
-    return;
-  if (hasUninjectedSameLaneEventAhead(host, event))
-    return;
-  const folded = await ledger.steerLive(event);
-  if (!folded)
-    return;
-  if (!folded.frame)
-    return;
-  event.frame = folded.frame;
-  const injected = await adapter.enqueueDuringDispatch(opts.runtimeKey, eventBody(event), folded.inputLifecycle);
-  if (injected) {
-    host.injectedMainBufferEvents.add(event);
-    ledger.markSeen(event, folded.covered);
-    opts.log?.info(`steer folded+injected for ${event.messageId} (will drain for bookkeeping)`);
-  } else if (folded.frame) {
-    ledger.deferFrame(event, folded.frame, folded.covered);
-    opts.log?.info(`steer folded but not injected for ${event.messageId} \u2014 frame deferred to the drain`);
-  }
-}
 async function dispatchLaneGroup(host, opts) {
   const event = opts.events[opts.events.length - 1];
   return runInDispatchTrace({
@@ -58730,6 +58895,9 @@ async function dispatchLaneGroupInner(host, opts) {
     ]);
     dispatched = await host.runDispatch(event, opts.sessionKey, opts.bodyPrefix + eventBody(event), opts.earlier, opts.captureText, inputLifecycle);
   } catch (err) {
+    while (opts.sessionKey === host.opts.runtimeKey && hasMainSteers(host.dispatchState)) {
+      await waitForMainSteers(host.dispatchState);
+    }
     host.noteSessionLane(opts.sessionKey, null);
     await runInPhaseSpan("settle", () => ledger.release(lane.laneKey, "runtime_error", releaseErrorInfo(err, [host.opts.config.api_key])).catch(() => {
     }));
@@ -58741,6 +58909,9 @@ async function dispatchLaneGroupInner(host, opts) {
   if (!dispatched) {
     return "shutdown";
   }
+  while (opts.sessionKey === host.opts.runtimeKey && hasMainSteers(host.dispatchState)) {
+    await waitForMainSteers(host.dispatchState);
+  }
   const settled = host.consumeTurnOutcome(opts.sessionKey);
   if (settled) {
     if (settled.kind === "deferred") {
@@ -59084,6 +59255,19 @@ async function handleCompactSignal(host, data) {
 // ../agent-core/dist/gateway-runtime-turns.js
 var UNTARGETED_STEP = { target_type: "" };
 function handleRuntimeActivity(host, event) {
+  if (event.kind === "observation") {
+    const binding = host.sessionBindings.get(event.sessionKey);
+    if (!binding || binding.runtimeSessionId !== event.event.runtimeSessionId) {
+      host.opts.log?.warn(`runtime observation has no matching session binding on ${event.sessionKey}`);
+      return;
+    }
+    host.inFlightRuntimeTurns += 1;
+    void persistRuntimeObservation(host.stepPersister, binding.agentSessionId, UNTARGETED_STEP, event.event, host.opts.log, [host.opts.config.api_key]).finally(() => {
+      host.inFlightRuntimeTurns -= 1;
+      host.notifyDrainWaiters();
+    });
+    return;
+  }
   const sessionKey = event.kind === "turn" ? event.turn.sessionKey : event.sessionKey;
   const label = event.kind === "turn" ? `runtime-initiated turn ${event.turn.groupKey} on ${sessionKey}` : `runtime child session close for ${sessionKey}`;
   const prior = host.runtimeActivityChains.get(sessionKey) ?? Promise.resolve();
@@ -59126,7 +59310,8 @@ async function runRuntimeTurn(host, turn) {
   };
   try {
     for await (const runtimeEvent of turn.events) {
-      deadline.touch();
+      if (runtimeEvent.type !== "observation")
+        deadline.touch();
       if (runtimeEvent.type === "runtime_session") {
         try {
           binding = await host.bindRuntimeSession(sessionKey, runtimeEvent, contextFilePath);
@@ -59136,7 +59321,7 @@ async function runRuntimeTurn(host, turn) {
         }
         continue;
       }
-      if (!binding) {
+      if (!binding || runtimeEvent.type === "observation" && binding.runtimeSessionId !== runtimeEvent.runtimeSessionId) {
         droppedWithoutBinding += 1;
         continue;
       }
@@ -59151,7 +59336,8 @@ async function runRuntimeTurn(host, turn) {
         await host.createRuntimeStep(binding.agentSessionId, UNTARGETED_STEP, { type: "error", message: failure.stepMessage, groupKey }, void 0, contextFilePath);
         continue;
       }
-      await ensureBegun();
+      if (runtimeEvent.type !== "observation")
+        await ensureBegun();
       stepCount += 1;
       await host.createRuntimeStep(binding.agentSessionId, UNTARGETED_STEP, runtimeEvent, void 0, contextFilePath);
     }
@@ -60319,11 +60505,11 @@ function parseDispatchDeadlineMs(raw) {
 }
 function inputStepIdempotencyKey(event) {
   if (event.type === "message" || event.type === "channel_message") {
-    return event.messageId ? `input:${event.messageId}` : randomUUID();
+    return event.messageId ? `input:${event.messageId}` : randomUUID2();
   }
   if (event.dispatchEventId)
     return `input:${event.dispatchEventId}`;
-  return randomUUID();
+  return randomUUID2();
 }
 function resolveStepTarget(event) {
   if (event.input?.step_target) {
@@ -60830,100 +61016,7 @@ var ParallAgentGateway = class {
     });
   }
   async createRuntimeStep(sessionId, target, runtimeEvent, stepIdFilePath, contextFilePath, laneContextFilePath2) {
-    switch (runtimeEvent.type) {
-      case "thinking":
-        await this.stepPersister.persist(sessionId, "thinking", {
-          step_type: "thinking",
-          target_type: target.target_type,
-          target_id: target.target_id,
-          idempotency_key: randomUUID(),
-          content: { text: runtimeEvent.text },
-          group_key: runtimeEvent.groupKey
-        });
-        break;
-      case "text":
-        await this.stepPersister.persist(sessionId, "text", {
-          step_type: "text",
-          target_type: target.target_type,
-          target_id: target.target_id,
-          idempotency_key: randomUUID(),
-          content: {
-            text: runtimeEvent.text,
-            suppressed: runtimeEvent.project !== true
-          },
-          projection: runtimeEvent.project === true,
-          group_key: runtimeEvent.groupKey
-        });
-        break;
-      case "tool_call": {
-        const step = await this.stepPersister.persist(sessionId, "tool_call", {
-          step_type: "tool_call",
-          target_type: target.target_type,
-          target_id: target.target_id,
-          // call_id is session-unique for bridge runtimes (server-enforced),
-          // so the bare form anchors the tool step pair across retries —
-          // unlike parel's turn-scoped `tc:{turnId}:{callId}` (see
-          // protocol-vectors/agent-steps.json).
-          idempotency_key: `tc:${runtimeEvent.callId}`,
-          content: {
-            call_id: runtimeEvent.callId,
-            tool_name: runtimeEvent.toolName,
-            tool_input: runtimeEvent.input,
-            status: "running",
-            started_at: runtimeEvent.startedAt ?? (/* @__PURE__ */ new Date()).toISOString()
-          },
-          group_key: runtimeEvent.groupKey,
-          runtime_key: runtimeEvent.callId
-        });
-        if (step) {
-          if (contextFilePath) {
-            this.updateContextFileStepId(contextFilePath, step.id);
-          } else if (stepIdFilePath) {
-            this.writeStepIdFile(stepIdFilePath, step.id);
-          }
-          if (laneContextFilePath2) {
-            this.updateContextFileStepId(laneContextFilePath2, step.id);
-          }
-        }
-        break;
-      }
-      case "tool_result":
-        await this.stepPersister.persist(sessionId, "tool_result", {
-          step_type: "tool_result",
-          target_type: target.target_type,
-          target_id: target.target_id,
-          idempotency_key: `tr:${runtimeEvent.callId}`,
-          content: {
-            call_id: runtimeEvent.callId,
-            tool_name: runtimeEvent.toolName,
-            status: runtimeEvent.error ? "error" : "success",
-            output: runtimeEvent.output,
-            duration_ms: runtimeEvent.durationMs ?? 0,
-            collapsible: true
-          },
-          group_key: runtimeEvent.groupKey
-        });
-        if (contextFilePath) {
-          this.updateContextFileStepId(contextFilePath, null);
-        } else if (stepIdFilePath) {
-          this.clearStepIdFile(stepIdFilePath);
-        }
-        if (laneContextFilePath2) {
-          this.updateContextFileStepId(laneContextFilePath2, null);
-        }
-        break;
-      case "error":
-        await this.stepPersister.persist(sessionId, "error", {
-          step_type: "text",
-          target_type: target.target_type,
-          target_id: target.target_id,
-          idempotency_key: randomUUID(),
-          content: buildErrorStepContent(runtimeEvent.message),
-          projection: false,
-          group_key: runtimeEvent.groupKey
-        });
-        break;
-    }
+    return createRuntimeStep(this, sessionId, target, runtimeEvent, stepIdFilePath, contextFilePath, laneContextFilePath2);
   }
   writeContextFile(filePath, ctx) {
     try {
@@ -61073,7 +61166,8 @@ var ParallAgentGateway = class {
             inputLifecycle,
             noteActivity: dispatchDeadline.touch
           })) {
-            dispatchDeadline.touch();
+            if (runtimeEvent.type !== "observation")
+              dispatchDeadline.touch();
             if (runtimeEvent.type === "runtime_session") {
               const priorAgentSessionId = binding?.agentSessionId;
               binding = await runInPhaseSpan("session", () => this.bindRuntimeSession(sessionKey, runtimeEvent, contextFilePath, laneContextFilePath2));
@@ -61098,6 +61192,14 @@ var ParallAgentGateway = class {
               }
               continue;
             }
+            if (runtimeEvent.type === "observation") {
+              if (binding?.runtimeSessionId === runtimeEvent.runtimeSessionId) {
+                await this.createRuntimeStep(binding.agentSessionId, stepTarget, runtimeEvent);
+              } else {
+                this.opts.log?.warn("runtime observation has no matching active session binding");
+              }
+              continue;
+            }
             if (runtimeEvent.type === "turn_outcome") {
               const outcomeEvent = redactTurnOutcome(runtimeEvent, [this.opts.config.api_key]);
               turnOutcomeEvent = outcomeEvent;
@@ -61470,6 +61572,8 @@ var ParallAgentGateway = class {
       while (this.idleCompact.inFlight)
         await this.idleCompact.inFlight;
       while (this.dispatchState.mainBuffer.length > 0) {
+        while (hasMainSteers(this.dispatchState))
+          await waitForMainSteers(this.dispatchState);
         if (this.shuttingDown) {
           this.opts.log?.info(`drainMainBuffer halted (shutting down) \u2014 ${this.dispatchState.mainBuffer.length} buffered, ${this.dispatchState.pendingForkResults.length} pending fork results left for catch-up`);
           break;
@@ -62045,13 +62149,9 @@ ${fullSummary}` : fullSummary;
       }
     }
   }
-  /**
-   * Nothing in flight: no dispatch, no runtime-initiated turn, and the
-   * runtime itself reports idle (isBusy — a turn it is executing that has
-   * not surfaced yet, or a follow-up hold after background work finished).
-   */
+  /** Drain includes in-flight native work and unfinished steer registration. */
   isDrained() {
-    return this.inFlightDispatches === 0 && this.inFlightRuntimeTurns === 0 && !this.adapterBusy();
+    return this.inFlightDispatches === 0 && this.inFlightRuntimeTurns === 0 && !hasMainSteers(this.dispatchState) && !this.adapterBusy();
   }
   adapterBusy() {
     try {
@@ -63094,17 +63194,17 @@ async function startWikiHelper(params) {
 }
 
 // dist/oc-session.js
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { randomUUID as randomUUID3 } from "node:crypto";
 import { existsSync as existsSync4, mkdirSync as mkdirSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "node:fs";
 import { join as join7, resolve as resolve2 } from "node:path";
 var CURRENT_SESSION_VERSION = 3;
 function generateId(existing) {
   for (let i = 0; i < 100; i++) {
-    const id = randomUUID2().slice(0, 8);
+    const id = randomUUID3().slice(0, 8);
     if (!existing.has(id))
       return id;
   }
-  return randomUUID2();
+  return randomUUID3();
 }
 function loadEntries(filePath) {
   if (!existsSync4(filePath))
@@ -63219,14 +63319,14 @@ var SessionManager = class _SessionManager {
     if (header && header.version > CURRENT_SESSION_VERSION) {
       throw new Error(`Session file ${this.sessionFile} uses version ${header.version}, but oc-session.ts only supports up to ${CURRENT_SESSION_VERSION}. Sync oc-session.ts with upstream pi-coding-agent (see AGENTS.md step 4).`);
     }
-    this.sessionId = header?.id ?? randomUUID2();
+    this.sessionId = header?.id ?? randomUUID3();
     if (migrate(this.fileEntries))
       this.rewrite();
     this.buildIndex();
     this.flushed = true;
   }
   initEmpty() {
-    this.sessionId = randomUUID2();
+    this.sessionId = randomUUID3();
     const timestamp = (/* @__PURE__ */ new Date()).toISOString();
     this.fileEntries = [
       {
@@ -63303,7 +63403,7 @@ var SessionManager = class _SessionManager {
     if (branch.length === 0)
       throw new Error(`Entry ${leafId} not found`);
     const pathWithoutLabels = branch.filter((e) => e.type !== "label");
-    const newId = randomUUID2();
+    const newId = randomUUID3();
     const timestamp = (/* @__PURE__ */ new Date()).toISOString();
     const ts = timestamp.replace(/[:.]/g, "-");
     const newFile = join7(this.sessionDir, `${ts}_${newId}.jsonl`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@parall/parall",
-  "version": "1.64.0",
+  "version": "1.65.0",
   "description": "OpenClaw channel plugin for Parall IM",
   "license": "MIT",
   "repository": {
@@ -16,8 +16,8 @@
     "openclaw.plugin.json"
   ],
   "dependencies": {
-    "@parall/agent-core": "1.64.0",
-    "@parall/sdk": "1.64.0"
+    "@parall/agent-core": "1.65.0",
+    "@parall/sdk": "1.65.0"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",