chrome-openclaw-sider 1.0.2 → 1.0.26

package/dist/src/channel-streaming.js

@@ -0,0 +1,645 @@
+import { resolveOutboundMediaUrls } from "openclaw/plugin-sdk/reply-payload";
+import { logDebug, logWarn } from "./channel-runtime.js";
+import {
+  buildPendingMessageContextForRun,
+  clearBindingRunId,
+  discardSiderRunState,
+  consumePendingMessageContextForRun,
+  enqueueCompletedParts,
+  flushFinalQueuedPartForRun,
+  flushQueuedPartsExceptTailForRun,
+  resolvePendingFinalTextForRun,
+  hasTextParts
+} from "./channel-state.js";
+import { mergeTextSegments } from "./channel-util.js";
+import {
+  buildStreamingStartEvent,
+  buildStreamingDeltaEvent,
+  buildStreamingDoneEvent,
+  buildReasoningStartEvent,
+  buildReasoningDeltaEvent,
+  buildReasoningDoneEvent,
+  buildTextPart
+} from "./channel-builders.js";
+import {
+  sendSiderEventBestEffort,
+  sendMessageToSider
+} from "./channel-relay.js";
+import { buildSiderPartsFromReplyPayload } from "./media-upload.js";
+function cleanupSiderRunAfterReply(params) {
+  clearBindingRunId(params.streamState.sessionKey, params.runId);
+  discardSiderRunState(params.runId);
+  params.streamState.currentRunId = void 0;
+  if (params.resetFallbackText !== false) {
+    resetAllFallbackTextState(params.streamState);
+  }
+}
+async function openStreamingSessionIfNeeded(params) {
+  if (params.laneState.active && params.laneState.streamId) {
+    return;
+  }
+  params.laneState.active = true;
+  params.laneState.streamId = crypto.randomUUID();
+  params.laneState.seq = 0;
+  const streamStartEvent = buildStreamingStartEvent({
+    sessionId: params.sessionId,
+    streamId: params.laneState.streamId,
+    accountId: params.account.accountId
+  });
+  await sendSiderEventBestEffort({
+    account: params.account,
+    sessionId: params.sessionId,
+    event: streamStartEvent,
+    context: "stream.start"
+  });
+}
+async function openReasoningSessionIfNeeded(params) {
+  if (params.laneState.active && params.laneState.streamId) {
+    return;
+  }
+  params.laneState.active = true;
+  params.laneState.streamId = crypto.randomUUID();
+  params.laneState.seq = 0;
+  const reasoningStartEvent = buildReasoningStartEvent({
+    sessionId: params.sessionId,
+    streamId: params.laneState.streamId,
+    accountId: params.account.accountId
+  });
+  logDebug("sending reasoning start event", {
+    accountId: params.account.accountId,
+    sessionId: params.sessionId,
+    eventType: reasoningStartEvent.eventType,
+    streamId: params.laneState.streamId,
+    context: "reasoning.start"
+  });
+  await sendSiderEventBestEffort({
+    account: params.account,
+    sessionId: params.sessionId,
+    event: reasoningStartEvent,
+    context: "reasoning.start"
+  });
+}
+async function sendStreamingDeltaEvent(params) {
+  if (!params.delta) {
+    return;
+  }
+  await openStreamingSessionIfNeeded({
+    account: params.account,
+    sessionId: params.sessionId,
+    laneState: params.streamState.answer
+  });
+  params.streamState.answer.seq += 1;
+  const streamDeltaEvent = buildStreamingDeltaEvent({
+    sessionId: params.sessionId,
+    streamId: params.streamState.answer.streamId,
+    seq: params.streamState.answer.seq,
+    delta: params.delta,
+    text: params.text,
+    accountId: params.account.accountId
+  });
+  logDebug("sending stream delta event", {
+    accountId: params.account.accountId,
+    sessionId: params.sessionId,
+    eventType: streamDeltaEvent.eventType,
+    streamId: params.streamState.answer.streamId,
+    seq: params.streamState.answer.seq,
+    deltaLength: params.delta.length,
+    textLength: params.text.length,
+    context: params.context
+  });
+  await sendSiderEventBestEffort({
+    account: params.account,
+    sessionId: params.sessionId,
+    event: streamDeltaEvent,
+    context: params.context
+  });
+}
+async function sendReasoningDeltaEvent(params) {
+  if (!params.delta) {
+    return;
+  }
+  await openReasoningSessionIfNeeded({
+    account: params.account,
+    sessionId: params.sessionId,
+    laneState: params.streamState.reasoning
+  });
+  params.streamState.reasoning.seq += 1;
+  const reasoningDeltaEvent = buildReasoningDeltaEvent({
+    sessionId: params.sessionId,
+    streamId: params.streamState.reasoning.streamId,
+    seq: params.streamState.reasoning.seq,
+    delta: params.delta,
+    text: params.text,
+    accountId: params.account.accountId
+  });
+  logDebug("sending reasoning delta event", {
+    accountId: params.account.accountId,
+    sessionId: params.sessionId,
+    eventType: reasoningDeltaEvent.eventType,
+    streamId: params.streamState.reasoning.streamId,
+    seq: params.streamState.reasoning.seq,
+    deltaLength: params.delta.length,
+    textLength: params.text.length,
+    context: params.context
+  });
+  await sendSiderEventBestEffort({
+    account: params.account,
+    sessionId: params.sessionId,
+    event: reasoningDeltaEvent,
+    context: params.context
+  });
+}
+async function closeStreamingSessionIfActive(params) {
+  if (!params.streamState.answer.active || !params.streamState.answer.streamId) {
+    return;
+  }
+  params.streamState.answer.seq += 1;
+  const streamDoneEvent = buildStreamingDoneEvent({
+    sessionId: params.sessionId,
+    streamId: params.streamState.answer.streamId,
+    seq: params.streamState.answer.seq,
+    accountId: params.account.accountId,
+    reason: params.reason
+  });
+  await sendSiderEventBestEffort({
+    account: params.account,
+    sessionId: params.sessionId,
+    event: streamDoneEvent,
+    context: params.context
+  });
+  params.streamState.answer.active = false;
+  params.streamState.answer.streamId = void 0;
+  params.streamState.answer.seq = 0;
+}
+async function closeReasoningSessionIfActive(params) {
+  if (!params.streamState.reasoning.active || !params.streamState.reasoning.streamId) {
+    return;
+  }
+  params.streamState.reasoning.seq += 1;
+  const reasoningDoneEvent = buildReasoningDoneEvent({
+    sessionId: params.sessionId,
+    streamId: params.streamState.reasoning.streamId,
+    seq: params.streamState.reasoning.seq,
+    accountId: params.account.accountId,
+    reason: params.reason
+  });
+  logDebug("sending reasoning done event", {
+    accountId: params.account.accountId,
+    sessionId: params.sessionId,
+    eventType: reasoningDoneEvent.eventType,
+    streamId: params.streamState.reasoning.streamId,
+    seq: params.streamState.reasoning.seq,
+    reason: params.reason,
+    context: params.context
+  });
+  await sendSiderEventBestEffort({
+    account: params.account,
+    sessionId: params.sessionId,
+    event: reasoningDoneEvent,
+    context: params.context
+  });
+  params.streamState.reasoning.active = false;
+  params.streamState.reasoning.streamId = void 0;
+  params.streamState.reasoning.seq = 0;
+}
+function enqueueStreamEventTask(params) {
+  const next = params.streamState.streamEventQueue.then(params.task).catch((err) => {
+    logWarn("sider stream event queue task failed", {
+      error: String(err)
+    });
+  });
+  params.streamState.streamEventQueue = next;
+  return next;
+}
+async function flushStreamEventQueue(streamState) {
+  await streamState.streamEventQueue;
+}
+function derivePartialDelta(params) {
+  const prev = params.previous;
+  const next = params.next;
+  if (!next) {
+    return "";
+  }
+  if (!prev) {
+    return next;
+  }
+  if (next === prev) {
+    return "";
+  }
+  if (next.startsWith(prev)) {
+    return next.slice(prev.length);
+  }
+  if (prev.startsWith(next)) {
+    return "";
+  }
+  const maxOverlap = Math.min(prev.length, next.length);
+  for (let overlap = maxOverlap; overlap > 0; overlap -= 1) {
+    if (prev.endsWith(next.slice(0, overlap))) {
+      return next.slice(overlap);
+    }
+  }
+  return next;
+}
+function mergeBlockTextIntoStreamState(params) {
+  params.streamState.answer.accumulatedBlockText = mergeTextSegments(
+    params.streamState.answer.accumulatedBlockText,
+    params.text
+  );
+  if (params.text) {
+    if (params.streamState.answer.assistantSeq <= 0) {
+      params.streamState.answer.assistantSeq = 1;
+    }
+    params.streamState.answer.fallbackAssistantSeq = params.streamState.answer.assistantSeq;
+    params.streamState.answer.fallbackCurrentText = mergeTextSegments(
+      params.streamState.answer.fallbackCurrentText,
+      params.text
+    );
+  }
+}
+function resolveCurrentStreamVisibleText(streamState) {
+  if (streamState.answer.streamDeltaMode === "partial" && streamState.answer.partialSnapshot) {
+    return streamState.answer.partialSnapshot;
+  }
+  return streamState.answer.accumulatedBlockText;
+}
+function resolveFallbackFinalText(streamState) {
+  if (streamState.answer.assistantSeq <= 0 || streamState.answer.fallbackAssistantSeq !== streamState.answer.assistantSeq) {
+    return "";
+  }
+  return mergeTextSegments(
+    streamState.answer.fallbackTextPrefix,
+    streamState.answer.fallbackCurrentText
+  ).trim();
+}
+function commitCurrentStreamTextToFallbackPrefix(streamState) {
+  if (streamState.answer.assistantSeq <= 0) {
+    streamState.answer.assistantSeq = 1;
+  }
+  streamState.answer.fallbackAssistantSeq = streamState.answer.assistantSeq;
+  streamState.answer.fallbackTextPrefix = mergeTextSegments(
+    streamState.answer.fallbackTextPrefix,
+    streamState.answer.fallbackCurrentText
+  );
+  streamState.answer.fallbackCurrentText = "";
+}
+function rotateAssistantMessageFallbackState(streamState) {
+  streamState.answer.assistantSeq += 1;
+  streamState.answer.fallbackAssistantSeq = streamState.answer.assistantSeq;
+  streamState.answer.fallbackCurrentText = "";
+  streamState.answer.fallbackTextPrefix = "";
+}
+function resetCurrentStreamTextState(streamState) {
+  streamState.answer.blockDeltaCount = 0;
+  streamState.answer.partialDeltaCount = 0;
+  streamState.answer.streamDeltaMode = "undecided";
+  streamState.answer.partialSnapshot = "";
+  streamState.answer.accumulatedBlockText = "";
+}
+function resetAllFallbackTextState(streamState) {
+  streamState.answer.assistantSeq = 0;
+  streamState.answer.fallbackAssistantSeq = 0;
+  streamState.answer.fallbackCurrentText = "";
+  streamState.answer.fallbackTextPrefix = "";
+  resetCurrentStreamTextState(streamState);
+}
+function resetReasoningStreamState(streamState) {
+  streamState.reasoning.snapshot = "";
+  streamState.reasoning.deltaCount = 0;
+}
+async function handleStreamingPartialSnapshot(params) {
+  if (params.streamState.answer.streamDeltaMode === "block") {
+    return;
+  }
+  if (params.streamState.answer.streamDeltaMode === "undecided") {
+    params.streamState.answer.streamDeltaMode = "partial";
+  }
+  if (!params.snapshot) {
+    return;
+  }
+  const delta = derivePartialDelta({
+    previous: params.streamState.answer.partialSnapshot,
+    next: params.snapshot
+  });
+  if (params.streamState.answer.assistantSeq <= 0) {
+    params.streamState.answer.assistantSeq = 1;
+  }
+  params.streamState.answer.fallbackAssistantSeq = params.streamState.answer.assistantSeq;
+  params.streamState.answer.partialSnapshot = params.snapshot;
+  params.streamState.answer.fallbackCurrentText = params.snapshot;
+  if (!delta) {
+    return;
+  }
+  await sendStreamingDeltaEvent({
+    account: params.account,
+    sessionId: params.sessionId,
+    streamState: params.streamState,
+    delta,
+    text: params.snapshot,
+    context: "stream.delta.partial"
+  });
+  params.streamState.answer.partialDeltaCount += 1;
+}
+async function handleReasoningSnapshot(params) {
+  if (!params.snapshot.trim()) {
+    return;
+  }
+  const delta = derivePartialDelta({
+    previous: params.streamState.reasoning.snapshot,
+    next: params.snapshot
+  });
+  params.streamState.reasoning.snapshot = params.snapshot;
+  if (!delta) {
+    return;
+  }
+  await sendReasoningDeltaEvent({
+    account: params.account,
+    sessionId: params.sessionId,
+    streamState: params.streamState,
+    delta,
+    text: params.snapshot,
+    context: "reasoning.delta"
+  });
+  params.streamState.reasoning.deltaCount += 1;
+}
+async function persistQueuedCompletedParts(params) {
+  if (params.parts.length === 0) {
+    return;
+  }
+  const runId = params.streamState.currentRunId;
+  if (!runId) {
+    for (const part of params.parts) {
+      await sendMessageToSider({
+        account: params.account,
+        sessionId: params.sessionId,
+        parts: [part]
+      });
+    }
+    return;
+  }
+  enqueueCompletedParts({
+    runId,
+    parts: params.parts,
+    sessionKey: params.streamState.sessionKey,
+    sessionId: params.sessionId,
+    accountId: params.account.accountId
+  });
+  await flushQueuedPartsExceptTailForRun({
+    runId,
+    account: params.account,
+    sessionId: params.sessionId,
+    context: params.context
+  });
+}
+function resolvePreferredDeferredFinalText(params) {
+  const fallbackText = (resolvePendingFinalTextForRun(params.runId) || resolveFallbackFinalText(params.streamState)).trim();
+  if (!hasTextParts(params.baseParts)) {
+    return fallbackText;
+  }
+  return "";
+}
+async function finalizeQueuedRunMessages(params) {
+  const runId = params.streamState.currentRunId;
+  if (!runId) {
+    if (params.parts.length === 0) {
+      return false;
+    }
+    for (let index = 0; index < params.parts.length; index += 1) {
+      const part = params.parts[index];
+      await sendMessageToSider({
+        account: params.account,
+        sessionId: params.sessionId,
+        parts: [part]
+      });
+    }
+    params.streamState.persistedFinalText = true;
+    return true;
+  }
+  if (params.parts.length > 0) {
+    enqueueCompletedParts({
+      runId,
+      parts: params.parts,
+      sessionKey: params.streamState.sessionKey,
+      sessionId: params.sessionId,
+      accountId: params.account.accountId
+    });
+  }
+  await flushQueuedPartsExceptTailForRun({
+    runId,
+    account: params.account,
+    sessionId: params.sessionId,
+    context: `${params.context}.except_tail`
+  });
+  const persisted = await flushFinalQueuedPartForRun({
+    runId,
+    account: params.account,
+    sessionId: params.sessionId,
+    stopReason: params.stopReason,
+    context: `${params.context}.final_tail`
+  });
+  if (persisted) {
+    params.streamState.persistedFinalText = true;
+  }
+  return persisted;
+}
+async function deliverReplyPayloadToSider(params) {
+  const payloadText = typeof params.payload.text === "string" ? params.payload.text : "";
+  const payloadMediaUrls = resolveOutboundMediaUrls(params.payload);
+  if (params.kind === "block") {
+    const delta = payloadText;
+    if (delta.length > 0) {
+      params.streamState.answer.blockDeltaCount += 1;
+      if (params.streamState.answer.streamDeltaMode !== "partial") {
+        if (params.streamState.answer.streamDeltaMode === "undecided") {
+          params.streamState.answer.streamDeltaMode = "block";
+        }
+        mergeBlockTextIntoStreamState({
+          streamState: params.streamState,
+          text: delta
+        });
+        await sendStreamingDeltaEvent({
+          account: params.account,
+          sessionId: params.sessionId,
+          streamState: params.streamState,
+          delta,
+          text: params.streamState.answer.accumulatedBlockText,
+          context: "stream.delta.block"
+        });
+      } else {
+        logDebug("skip block stream delta because partial streaming mode is active", {
+          accountId: params.account.accountId,
+          sessionId: params.sessionId,
+          deltaLength: delta.length,
+          partialDeltaCount: params.streamState.answer.partialDeltaCount,
+          streamDeltaMode: params.streamState.answer.streamDeltaMode
+        });
+      }
+    }
+    if (payloadMediaUrls.length === 0) {
+      return;
+    }
+    logDebug("block payload contains media; sending persisted sider message", {
+      accountId: params.account.accountId,
+      sessionId: params.sessionId,
+      mediaCount: payloadMediaUrls.length,
+      hasText: delta.length > 0
+    });
+  }
+  if (params.kind === "final") {
+    await flushStreamEventQueue(params.streamState);
+    if (!params.streamState.answer.active && params.streamState.answer.blockDeltaCount === 0) {
+      const finalText = payloadText;
+      if (finalText.length > 0) {
+        logDebug("no block delta observed; sending synthetic stream events from final payload", {
+          accountId: params.account.accountId,
+          sessionId: params.sessionId,
+          textLength: finalText.length
+        });
+        params.streamState.answer.accumulatedBlockText = finalText;
+        if (params.streamState.answer.assistantSeq <= 0) {
+          params.streamState.answer.assistantSeq = 1;
+        }
+        params.streamState.answer.fallbackAssistantSeq = params.streamState.answer.assistantSeq;
+        params.streamState.answer.fallbackCurrentText = finalText;
+        await sendStreamingDeltaEvent({
+          account: params.account,
+          sessionId: params.sessionId,
+          streamState: params.streamState,
+          delta: finalText,
+          text: finalText,
+          context: "stream.delta.final-fallback"
+        });
+      }
+    }
+    await closeStreamingSessionIfActive({
+      account: params.account,
+      sessionId: params.sessionId,
+      streamState: params.streamState,
+      reason: "final",
+      context: "stream.done"
+    });
+    params.streamState.pendingFinalPayloads.push(params.payload);
+    return;
+  }
+  const { parts: baseParts } = await buildSiderPartsFromReplyPayload({
+    account: params.account,
+    sessionId: params.sessionId,
+    payload: params.payload,
+    mediaLocalRoots: params.mediaLocalRoots
+  });
+  if (baseParts.length === 0) {
+    return;
+  }
+  const completedParts = params.kind === "block" ? baseParts.filter((part) => part.type !== "core.text") : baseParts;
+  if (completedParts.length === 0) {
+    return;
+  }
+  logDebug("queueing sider outbound message parts from payload", {
+    accountId: params.account.accountId,
+    sessionId: params.sessionId,
+    kind: params.kind,
+    partTypes: completedParts.map((part) => part.type),
+    mediaCount: payloadMediaUrls.length
+  });
+  await persistQueuedCompletedParts({
+    account: params.account,
+    sessionId: params.sessionId,
+    streamState: params.streamState,
+    parts: completedParts,
+    context: `payload.${params.kind}`
+  });
+}
+async function persistDeferredFinalReplyPayloadToSider(params) {
+  const { parts: baseParts } = await buildSiderPartsFromReplyPayload({
+    account: params.account,
+    sessionId: params.sessionId,
+    payload: params.payload,
+    mediaLocalRoots: params.mediaLocalRoots
+  });
+  const selectedFinalText = resolvePreferredDeferredFinalText({
+    streamState: params.streamState,
+    runId: params.streamState.currentRunId,
+    baseParts
+  });
+  const messageContext = buildPendingMessageContextForRun({
+    accountId: params.account.accountId,
+    runId: params.streamState.currentRunId,
+    includeFinalThinking: true
+  });
+  const parts = hasTextParts(baseParts) ? [...messageContext.parts, ...baseParts] : [
+    ...messageContext.parts,
+    ...selectedFinalText ? [buildTextPart(selectedFinalText)] : [],
+    ...baseParts
+  ];
+  logDebug("finalizing deferred sider outbound message parts from payload", {
+    accountId: params.account.accountId,
+    sessionId: params.sessionId,
+    runId: params.streamState.currentRunId,
+    partTypes: parts.map((part) => part.type),
+    selectedFinalTextLength: selectedFinalText.length
+  });
+  const cleanupRunId = messageContext.runId ?? params.streamState.currentRunId;
+  await finalizeQueuedRunMessages({
+    account: params.account,
+    sessionId: params.sessionId,
+    parts,
+    streamState: params.streamState,
+    stopReason: messageContext.stopReason,
+    context: "final.payload"
+  });
+  consumePendingMessageContextForRun({
+    runId: cleanupRunId,
+    consumeFinalThinking: true
+  });
+  cleanupSiderRunAfterReply({
+    streamState: params.streamState,
+    runId: cleanupRunId
+  });
+}
+async function persistStandaloneReplyPayloadToSider(params) {
+  const { parts } = await buildSiderPartsFromReplyPayload({
+    account: params.account,
+    sessionId: params.sessionId,
+    payload: params.payload,
+    mediaLocalRoots: params.mediaLocalRoots
+  });
+  if (parts.length === 0) {
+    return;
+  }
+  logDebug("sending standalone deferred final payload to sider", {
+    accountId: params.account.accountId,
+    sessionId: params.sessionId,
+    partTypes: parts.map((part) => part.type),
+    isError: params.payload.isError === true
+  });
+  await sendMessageToSider({
+    account: params.account,
+    sessionId: params.sessionId,
+    parts
+  });
+}
+export {
+  cleanupSiderRunAfterReply,
+  closeReasoningSessionIfActive,
+  closeStreamingSessionIfActive,
+  commitCurrentStreamTextToFallbackPrefix,
+  deliverReplyPayloadToSider,
+  derivePartialDelta,
+  enqueueStreamEventTask,
+  finalizeQueuedRunMessages,
+  flushStreamEventQueue,
+  handleReasoningSnapshot,
+  handleStreamingPartialSnapshot,
+  mergeBlockTextIntoStreamState,
+  openReasoningSessionIfNeeded,
+  openStreamingSessionIfNeeded,
+  persistDeferredFinalReplyPayloadToSider,
+  persistStandaloneReplyPayloadToSider,
+  resetAllFallbackTextState,
+  resetCurrentStreamTextState,
+  resetReasoningStreamState,
+  resolveCurrentStreamVisibleText,
+  resolveFallbackFinalText,
+  rotateAssistantMessageFallbackState,
+  sendReasoningDeltaEvent,
+  sendStreamingDeltaEvent
+};