chrome-openclaw-sider 1.0.2 → 1.0.26

package/dist/src/channel-state.js

@@ -0,0 +1,471 @@
+import {
+  SIDER_RUN_STATE_MAX,
+  SIDER_RUN_STATE_TTL_MS,
+  SIDER_SESSION_BINDING_MAX,
+  SIDER_SESSION_BINDING_TTL_MS
+} from "./channel-types.js";
+import { buildThinkingPart } from "./channel-builders.js";
+import { sendMessageToSider, sendSiderMessageBestEffort } from "./channel-relay.js";
+import { logWarn, siderRunStates, siderSessionBindings } from "./channel-runtime.js";
+import { buildEventMeta, buildMessageMeta, parseTextFromPart } from "./channel-util.js";
+function normalizeSessionBindingKey(raw) {
+  const key = raw?.trim().toLowerCase();
+  return key || void 0;
+}
+function pruneSiderSessionBindings(now = Date.now()) {
+  for (const [key, binding] of siderSessionBindings) {
+    if (now - binding.lastSeenAt > SIDER_SESSION_BINDING_TTL_MS) {
+      siderSessionBindings.delete(key);
+    }
+  }
+  if (siderSessionBindings.size <= SIDER_SESSION_BINDING_MAX) {
+    return;
+  }
+  const sorted = [...siderSessionBindings.entries()].sort(
+    (a, b) => a[1].lastSeenAt - b[1].lastSeenAt
+  );
+  const overflow = siderSessionBindings.size - SIDER_SESSION_BINDING_MAX;
+  for (let index = 0; index < overflow; index += 1) {
+    const key = sorted[index]?.[0];
+    if (key) {
+      siderSessionBindings.delete(key);
+    }
+  }
+}
+function rememberSiderSessionBinding(params) {
+  const key = normalizeSessionBindingKey(params.sessionKey);
+  if (!key) {
+    return;
+  }
+  const now = Date.now();
+  const existing = siderSessionBindings.get(key);
+  if (existing) {
+    existing.account = params.account;
+    existing.sessionId = params.sessionId;
+    existing.lastSeenAt = now;
+    existing.currentRunId = void 0;
+    pruneSiderSessionBindings(now);
+    return;
+  }
+  siderSessionBindings.set(key, {
+    account: params.account,
+    sessionId: params.sessionId,
+    lastSeenAt: now,
+    toolSeq: 0,
+    currentRunId: void 0,
+    currentToolCallId: void 0,
+    callIdByToolCallId: /* @__PURE__ */ new Map()
+  });
+  pruneSiderSessionBindings(now);
+}
+function resolveSiderSessionBinding(sessionKey) {
+  const key = normalizeSessionBindingKey(sessionKey);
+  if (!key) {
+    return void 0;
+  }
+  const binding = siderSessionBindings.get(key);
+  if (!binding) {
+    return void 0;
+  }
+  binding.lastSeenAt = Date.now();
+  return binding;
+}
+function resolveSiderBindingByTarget(params) {
+  const accountId = params.accountId.trim();
+  const sessionId = params.sessionId.trim();
+  if (!accountId || !sessionId) {
+    return void 0;
+  }
+  for (const [sessionKey, binding] of siderSessionBindings) {
+    if (binding.account.accountId === accountId && binding.sessionId === sessionId) {
+      binding.lastSeenAt = Date.now();
+      return { sessionKey, binding };
+    }
+  }
+  return void 0;
+}
+function pruneSiderRunStates(now = Date.now()) {
+  for (const [runId, state] of siderRunStates) {
+    if (now - state.updatedAt > SIDER_RUN_STATE_TTL_MS) {
+      siderRunStates.delete(runId);
+    }
+  }
+  if (siderRunStates.size <= SIDER_RUN_STATE_MAX) {
+    return;
+  }
+  const sorted = [...siderRunStates.entries()].sort((a, b) => a[1].updatedAt - b[1].updatedAt);
+  const overflow = siderRunStates.size - SIDER_RUN_STATE_MAX;
+  for (let index = 0; index < overflow; index += 1) {
+    const runId = sorted[index]?.[0];
+    if (runId) {
+      siderRunStates.delete(runId);
+    }
+  }
+}
+function touchRunState(runState) {
+  runState.updatedAt = Date.now();
+  pruneSiderRunStates(runState.updatedAt);
+}
+function appendRunFlushTask(runState, task) {
+  const taskPromise = runState.messageFlushChain.then(task);
+  runState.messageFlushChain = taskPromise.then(
+    () => void 0,
+    (error) => {
+      logWarn("sider queued message flush failed", {
+        runId: runState.runId,
+        error: String(error)
+      });
+    }
+  );
+  return taskPromise;
+}
+function buildBaseMessageMetaForRun(params) {
+  const meta = buildEventMeta({ accountId: params.accountId });
+  if (params.runState.runId) {
+    meta.run_id = params.runState.runId;
+  }
+  if (params.runState.provider) {
+    meta.provider = params.runState.provider;
+  }
+  if (params.runState.model) {
+    meta.model = params.runState.model;
+  }
+  return meta;
+}
+function nextAggregationForRun(runState, final) {
+  const aggregation = {
+    id: runState.aggregationId,
+    index: runState.nextAggregationIndex,
+    final
+  };
+  runState.nextAggregationIndex += 1;
+  return aggregation;
+}
+function takeQueuedPartsExceptTail(runState) {
+  if (runState.queuedMessageParts.length <= 1) {
+    return [];
+  }
+  const parts = runState.queuedMessageParts.slice(0, -1);
+  runState.queuedMessageParts = runState.queuedMessageParts.slice(-1);
+  return parts;
+}
+function resolveRunFlushTarget(runState) {
+  const binding = resolveSiderSessionBinding(runState.sessionKey);
+  const account = binding?.account;
+  const sessionId = (runState.sessionId ?? binding?.sessionId)?.trim();
+  const accountId = (runState.accountId ?? binding?.account.accountId)?.trim();
+  if (!account || !sessionId || !accountId) {
+    return void 0;
+  }
+  runState.sessionId = sessionId;
+  runState.accountId = accountId;
+  return { account, sessionId, accountId };
+}
+async function flushQueuedPartsExceptTailBestEffort(params) {
+  while (true) {
+    const runState = resolveSiderRunState(params.runId);
+    if (!runState) {
+      return;
+    }
+    const target = resolveRunFlushTarget(runState);
+    if (!target) {
+      return;
+    }
+    const parts = takeQueuedPartsExceptTail(runState);
+    if (parts.length === 0) {
+      return;
+    }
+    touchRunState(runState);
+    for (const part of parts) {
+      const latestRunState = resolveSiderRunState(params.runId);
+      if (!latestRunState) {
+        return;
+      }
+      await sendSiderMessageBestEffort({
+        account: target.account,
+        sessionId: target.sessionId,
+        parts: [part],
+        aggregation: nextAggregationForRun(latestRunState, false),
+        meta: buildBaseMessageMetaForRun({
+          accountId: target.accountId,
+          runState: latestRunState
+        }),
+        context: params.context
+      });
+    }
+  }
+}
+function getOrCreateSiderRunState(runId) {
+  const now = Date.now();
+  const existing = siderRunStates.get(runId);
+  if (existing) {
+    existing.updatedAt = now;
+    pruneSiderRunStates(now);
+    return existing;
+  }
+  const created = {
+    runId,
+    aggregationId: crypto.randomUUID(),
+    nextAggregationIndex: 0,
+    usage: {},
+    queuedMessageParts: [],
+    messageFlushChain: Promise.resolve(),
+    flushScheduled: false,
+    updatedAt: now
+  };
+  siderRunStates.set(runId, created);
+  pruneSiderRunStates(now);
+  return created;
+}
+function resolveSiderRunState(runId) {
+  if (!runId) {
+    return void 0;
+  }
+  const state = siderRunStates.get(runId);
+  if (!state) {
+    return void 0;
+  }
+  touchRunState(state);
+  return state;
+}
+function discardSiderRunState(runId) {
+  if (!runId) {
+    return;
+  }
+  siderRunStates.delete(runId);
+}
+function updateSiderRunStateContext(params) {
+  const runState = getOrCreateSiderRunState(params.runId);
+  runState.sessionKey = normalizeSessionBindingKey(params.sessionKey) ?? runState.sessionKey;
+  if (params.sessionId?.trim()) {
+    runState.sessionId = params.sessionId.trim();
+  }
+  if (params.accountId?.trim()) {
+    runState.accountId = params.accountId.trim();
+  }
+  if (typeof params.provider === "string" && params.provider.trim()) {
+    runState.provider = params.provider.trim();
+  }
+  if (typeof params.model === "string" && params.model.trim()) {
+    runState.model = params.model.trim();
+  }
+  touchRunState(runState);
+  return runState;
+}
+function resolveRelayCallIdForToolEvent(params) {
+  if (params.toolCallId) {
+    const existing = params.binding.callIdByToolCallId.get(params.toolCallId);
+    if (existing) {
+      params.binding.currentToolCallId = existing;
+      return existing;
+    }
+    const created = crypto.randomUUID();
+    params.binding.callIdByToolCallId.set(params.toolCallId, created);
+    params.binding.currentToolCallId = created;
+    return created;
+  }
+  if (params.phase === "start" || !params.binding.currentToolCallId) {
+    params.binding.currentToolCallId = crypto.randomUUID();
+  }
+  return params.binding.currentToolCallId;
+}
+function clearRelayCallIdForToolEvent(params) {
+  if (params.toolCallId) {
+    params.binding.callIdByToolCallId.delete(params.toolCallId);
+  }
+  if (params.binding.currentToolCallId === params.callId) {
+    params.binding.currentToolCallId = void 0;
+  }
+}
+function hasTextParts(parts) {
+  return parts.some((part) => parseTextFromPart(part) !== null);
+}
+function enqueueCompletedParts(params) {
+  if (!params.runId || params.parts.length === 0) {
+    return;
+  }
+  const runState = updateSiderRunStateContext({
+    runId: params.runId,
+    sessionKey: params.sessionKey,
+    sessionId: params.sessionId,
+    accountId: params.accountId,
+    provider: params.provider,
+    model: params.model
+  });
+  runState.queuedMessageParts.push(...params.parts);
+  touchRunState(runState);
+}
+function resolvePendingFinalTextForRun(runId) {
+  return resolveSiderRunState(runId)?.pendingFinalText?.trim() ?? "";
+}
+function buildPendingMessageContextForRun(params) {
+  const runState = resolveSiderRunState(params.runId);
+  const parts = [];
+  if (params.includeFinalThinking && runState?.pendingFinalThinking) {
+    parts.push(buildThinkingPart(runState.pendingFinalThinking));
+  }
+  return {
+    parts,
+    meta: runState ? buildMessageMeta({
+      accountId: params.accountId,
+      runState,
+      stopReason: params.includeFinalThinking ? runState.pendingFinalStopReason : void 0
+    }) : void 0,
+    runId: runState?.runId,
+    stopReason: params.includeFinalThinking ? runState?.pendingFinalStopReason : void 0
+  };
+}
+function consumePendingMessageContextForRun(params) {
+  const runState = resolveSiderRunState(params.runId);
+  if (!runState || !params.consumeFinalThinking) {
+    return;
+  }
+  runState.pendingFinalText = void 0;
+  runState.pendingFinalThinking = void 0;
+  runState.pendingFinalStopReason = void 0;
+  touchRunState(runState);
+}
+function scheduleQueuedPartFlush(params) {
+  const runState = resolveSiderRunState(params.runId);
+  if (!runState) {
+    return Promise.resolve();
+  }
+  if (runState.flushScheduled) {
+    return runState.messageFlushChain;
+  }
+  runState.flushScheduled = true;
+  return appendRunFlushTask(runState, async () => {
+    try {
+      await flushQueuedPartsExceptTailBestEffort({
+        runId: runState.runId,
+        context: params.context
+      });
+    } finally {
+      const latestRunState = resolveSiderRunState(runState.runId);
+      if (latestRunState) {
+        latestRunState.flushScheduled = false;
+      }
+    }
+  });
+}
+function flushQueuedPartsExceptTailForRun(params) {
+  const runState = resolveSiderRunState(params.runId);
+  if (!runState) {
+    return Promise.resolve();
+  }
+  return appendRunFlushTask(runState, async () => {
+    const parts = takeQueuedPartsExceptTail(runState);
+    if (parts.length === 0) {
+      return;
+    }
+    touchRunState(runState);
+    for (const part of parts) {
+      const latestRunState = resolveSiderRunState(runState.runId);
+      if (!latestRunState) {
+        return;
+      }
+      await sendMessageToSider({
+        account: params.account,
+        sessionId: params.sessionId,
+        parts: [part],
+        aggregation: nextAggregationForRun(latestRunState, false),
+        meta: buildBaseMessageMetaForRun({
+          accountId: params.account.accountId,
+          runState: latestRunState
+        })
+      });
+    }
+  });
+}
+function flushFinalQueuedPartForRun(params) {
+  const runState = resolveSiderRunState(params.runId);
+  if (!runState) {
+    return Promise.resolve(false);
+  }
+  return appendRunFlushTask(runState, async () => {
+    const earlyParts = takeQueuedPartsExceptTail(runState);
+    for (const part of earlyParts) {
+      const latestRunState2 = resolveSiderRunState(runState.runId);
+      if (!latestRunState2) {
+        return false;
+      }
+      await sendMessageToSider({
+        account: params.account,
+        sessionId: params.sessionId,
+        parts: [part],
+        aggregation: nextAggregationForRun(latestRunState2, false),
+        meta: buildBaseMessageMetaForRun({
+          accountId: params.account.accountId,
+          runState: latestRunState2
+        })
+      });
+    }
+    const latestRunState = resolveSiderRunState(runState.runId);
+    if (!latestRunState) {
+      return false;
+    }
+    const finalPart = latestRunState.queuedMessageParts.shift();
+    if (!finalPart) {
+      return false;
+    }
+    latestRunState.queuedMessageParts = [];
+    await sendMessageToSider({
+      account: params.account,
+      sessionId: params.sessionId,
+      parts: [finalPart],
+      aggregation: nextAggregationForRun(latestRunState, true),
+      meta: buildMessageMeta({
+        accountId: params.account.accountId,
+        runState: latestRunState,
+        stopReason: params.stopReason
+      })
+    });
+    touchRunState(latestRunState);
+    return true;
+  });
+}
+function dropQueuedTailOnAbort(runId) {
+  const runState = resolveSiderRunState(runId);
+  if (!runState) {
+    return;
+  }
+  runState.queuedMessageParts = [];
+  runState.flushScheduled = false;
+  touchRunState(runState);
+}
+function clearBindingRunId(sessionKey, runId) {
+  if (!sessionKey || !runId) {
+    return;
+  }
+  const binding = resolveSiderSessionBinding(sessionKey);
+  if (!binding) {
+    return;
+  }
+  if (binding.currentRunId === runId) {
+    binding.currentRunId = void 0;
+  }
+}
+export {
+  buildPendingMessageContextForRun,
+  clearBindingRunId,
+  clearRelayCallIdForToolEvent,
+  consumePendingMessageContextForRun,
+  discardSiderRunState,
+  dropQueuedTailOnAbort,
+  enqueueCompletedParts,
+  flushFinalQueuedPartForRun,
+  flushQueuedPartsExceptTailForRun,
+  getOrCreateSiderRunState,
+  hasTextParts,
+  normalizeSessionBindingKey,
+  pruneSiderRunStates,
+  pruneSiderSessionBindings,
+  rememberSiderSessionBinding,
+  resolvePendingFinalTextForRun,
+  resolveRelayCallIdForToolEvent,
+  resolveSiderBindingByTarget,
+  resolveSiderRunState,
+  resolveSiderSessionBinding,
+  scheduleQueuedPartFlush,
+  updateSiderRunStateContext
+};

package/dist/src/channel-streaming.d.ts

@@ -0,0 +1,117 @@
+import { SiderStreamState, SiderPart, SiderRealtimeLaneState } from './channel-types.js';
+import { ResolvedSiderAccount } from './account.js';
+import { ReplyPayload } from 'openclaw/plugin-sdk';
+import 'ws';
+import 'openclaw/plugin-sdk/setup';
+import './auth.js';
+import 'openclaw/plugin-sdk/plugin-entry';
+import './auto-title.js';
+
+declare function cleanupSiderRunAfterReply(params: {
+    streamState: SiderStreamState;
+    runId?: string;
+    resetFallbackText?: boolean;
+}): void;
+declare function openStreamingSessionIfNeeded(params: {
+    account: ResolvedSiderAccount;
+    sessionId: string;
+    laneState: SiderRealtimeLaneState;
+}): Promise<void>;
+declare function openReasoningSessionIfNeeded(params: {
+    account: ResolvedSiderAccount;
+    sessionId: string;
+    laneState: SiderRealtimeLaneState;
+}): Promise<void>;
+declare function sendStreamingDeltaEvent(params: {
+    account: ResolvedSiderAccount;
+    sessionId: string;
+    streamState: SiderStreamState;
+    delta: string;
+    text: string;
+    context: string;
+}): Promise<void>;
+declare function sendReasoningDeltaEvent(params: {
+    account: ResolvedSiderAccount;
+    sessionId: string;
+    streamState: SiderStreamState;
+    delta: string;
+    text: string;
+    context: string;
+}): Promise<void>;
+declare function closeStreamingSessionIfActive(params: {
+    account: ResolvedSiderAccount;
+    sessionId: string;
+    streamState: SiderStreamState;
+    reason: "final" | "interrupted";
+    context: string;
+}): Promise<void>;
+declare function closeReasoningSessionIfActive(params: {
+    account: ResolvedSiderAccount;
+    sessionId: string;
+    streamState: SiderStreamState;
+    reason: "final" | "interrupted";
+    context: string;
+}): Promise<void>;
+declare function enqueueStreamEventTask(params: {
+    streamState: SiderStreamState;
+    task: () => Promise<void>;
+}): Promise<void>;
+declare function flushStreamEventQueue(streamState: SiderStreamState): Promise<void>;
+declare function derivePartialDelta(params: {
+    previous: string;
+    next: string;
+}): string;
+declare function mergeBlockTextIntoStreamState(params: {
+    streamState: SiderStreamState;
+    text: string;
+}): void;
+declare function resolveCurrentStreamVisibleText(streamState: SiderStreamState): string;
+declare function resolveFallbackFinalText(streamState: SiderStreamState): string;
+declare function commitCurrentStreamTextToFallbackPrefix(streamState: SiderStreamState): void;
+declare function rotateAssistantMessageFallbackState(streamState: SiderStreamState): void;
+declare function resetCurrentStreamTextState(streamState: SiderStreamState): void;
+declare function resetAllFallbackTextState(streamState: SiderStreamState): void;
+declare function resetReasoningStreamState(streamState: SiderStreamState): void;
+declare function handleStreamingPartialSnapshot(params: {
+    account: ResolvedSiderAccount;
+    sessionId: string;
+    streamState: SiderStreamState;
+    snapshot: string;
+}): Promise<void>;
+declare function handleReasoningSnapshot(params: {
+    account: ResolvedSiderAccount;
+    sessionId: string;
+    streamState: SiderStreamState;
+    snapshot: string;
+}): Promise<void>;
+declare function finalizeQueuedRunMessages(params: {
+    account: ResolvedSiderAccount;
+    sessionId: string;
+    streamState: SiderStreamState;
+    parts: SiderPart[];
+    stopReason?: string;
+    context: string;
+}): Promise<boolean>;
+declare function deliverReplyPayloadToSider(params: {
+    account: ResolvedSiderAccount;
+    sessionId: string;
+    streamState: SiderStreamState;
+    payload: ReplyPayload;
+    kind: "tool" | "block" | "final";
+    mediaLocalRoots?: readonly string[];
+}): Promise<void>;
+declare function persistDeferredFinalReplyPayloadToSider(params: {
+    account: ResolvedSiderAccount;
+    sessionId: string;
+    streamState: SiderStreamState;
+    payload: ReplyPayload;
+    mediaLocalRoots?: readonly string[];
+}): Promise<void>;
+declare function persistStandaloneReplyPayloadToSider(params: {
+    account: ResolvedSiderAccount;
+    sessionId: string;
+    payload: ReplyPayload;
+    mediaLocalRoots?: readonly string[];
+}): Promise<void>;
+
+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 };