chrome-openclaw-sider 1.0.2 → 1.0.26

package/dist/src/channel-builders.js

@@ -0,0 +1,238 @@
+import {
+  hasFiniteNumber,
+  appendStructuredPayloadField,
+  extractToolResultMediaUrls,
+  extractToolResultText,
+  buildEventMeta,
+  toJsonSafeValue
+} from "./channel-util.js";
+const SOURCE_PATH_PREFIX_RE = /^(\/|\.\/|\.\.\/|~\/|[A-Za-z]:[\\/]|\\\\)/;
+const SOURCE_SCHEME_RE = /^[a-zA-Z][a-zA-Z0-9+.-]*:/;
+function isPathLikeSource(value) {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return false;
+  }
+  return SOURCE_PATH_PREFIX_RE.test(trimmed) || !SOURCE_SCHEME_RE.test(trimmed);
+}
+function buildSourceFields(source) {
+  const trimmed = source?.trim();
+  if (!trimmed) {
+    return {};
+  }
+  return {
+    media_url: trimmed,
+    ...isPathLikeSource(trimmed) ? { source_path: trimmed } : { source_url: trimmed }
+  };
+}
+function buildThinkingPart(text) {
+  return {
+    type: "thinking",
+    spec_version: 1,
+    payload: { text }
+  };
+}
+function buildTextPart(text) {
+  return {
+    type: "core.text",
+    spec_version: 1,
+    payload: { text }
+  };
+}
+function buildToolCallPart(params) {
+  const payload = {
+    call_id: params.callId,
+    ...params.toolName ? { tool_name: params.toolName } : {},
+    ...params.toolCallId ? { tool_call_id: params.toolCallId } : {},
+    ...params.runId ? { run_id: params.runId } : {}
+  };
+  appendStructuredPayloadField(payload, "tool_args", params.toolArgs);
+  return {
+    type: "tool.call",
+    spec_version: 1,
+    payload
+  };
+}
+function buildToolResultPart(params) {
+  const text = extractToolResultText(params.result);
+  const safeToolArgs = toJsonSafeValue(params.toolArgs);
+  const safeResult = toJsonSafeValue(params.result);
+  const payload = {
+    call_id: params.callId,
+    ...params.toolName ? { tool_name: params.toolName } : {},
+    ...params.toolCallId ? { tool_call_id: params.toolCallId } : {},
+    ...params.runId ? { run_id: params.runId } : {},
+    ...params.error ? { error: params.error } : {},
+    ...hasFiniteNumber(params.durationMs) ? { duration_ms: params.durationMs } : {},
+    ...text ? { text } : {},
+    ...safeToolArgs !== void 0 ? { tool_args: safeToolArgs } : {},
+    ...safeResult !== void 0 ? { result: safeResult } : {},
+    has_text: text.length > 0,
+    is_error: Boolean(params.error)
+  };
+  return {
+    type: "tool.result",
+    spec_version: 1,
+    payload
+  };
+}
+function buildTypingEvent(params) {
+  return {
+    eventType: "typing",
+    payload: {
+      on: params.state === "typing",
+      state: params.state,
+      session_id: params.sessionId,
+      ts: Date.now()
+    },
+    meta: buildEventMeta({ accountId: params.accountId })
+  };
+}
+function buildStreamingStartEvent(params) {
+  return {
+    eventType: "stream.start",
+    payload: {
+      session_id: params.sessionId,
+      stream_id: params.streamId,
+      ts: Date.now()
+    },
+    meta: buildEventMeta({ accountId: params.accountId })
+  };
+}
+function buildStreamingDeltaEvent(params) {
+  return {
+    eventType: "stream.delta",
+    payload: {
+      session_id: params.sessionId,
+      stream_id: params.streamId,
+      seq: params.seq,
+      delta: params.delta,
+      text: params.text,
+      done: false,
+      chunk_chars: params.delta.length,
+      ts: Date.now()
+    },
+    meta: buildEventMeta({ accountId: params.accountId })
+  };
+}
+function buildStreamingDoneEvent(params) {
+  return {
+    eventType: "stream.done",
+    payload: {
+      session_id: params.sessionId,
+      stream_id: params.streamId,
+      seq: params.seq,
+      done: true,
+      reason: params.reason,
+      ts: Date.now()
+    },
+    meta: buildEventMeta({ accountId: params.accountId })
+  };
+}
+function buildReasoningStartEvent(params) {
+  return {
+    eventType: "reasoning.start",
+    payload: {
+      session_id: params.sessionId,
+      stream_id: params.streamId,
+      ts: Date.now()
+    },
+    meta: buildEventMeta({ accountId: params.accountId })
+  };
+}
+function buildReasoningDeltaEvent(params) {
+  return {
+    eventType: "reasoning.delta",
+    payload: {
+      session_id: params.sessionId,
+      stream_id: params.streamId,
+      seq: params.seq,
+      delta: params.delta,
+      text: params.text,
+      done: false,
+      chunk_chars: params.delta.length,
+      ts: Date.now()
+    },
+    meta: buildEventMeta({ accountId: params.accountId })
+  };
+}
+function buildReasoningDoneEvent(params) {
+  return {
+    eventType: "reasoning.done",
+    payload: {
+      session_id: params.sessionId,
+      stream_id: params.streamId,
+      seq: params.seq,
+      done: true,
+      reason: params.reason,
+      ts: Date.now()
+    },
+    meta: buildEventMeta({ accountId: params.accountId })
+  };
+}
+function buildToolCallEvent(params) {
+  return {
+    eventType: "tool.call",
+    payload: {
+      session_id: params.sessionId,
+      seq: params.seq,
+      call_id: params.callId,
+      phase: params.phase,
+      tool_name: params.toolName,
+      tool_call_id: params.toolCallId,
+      run_id: params.runId,
+      session_key: params.sessionKey,
+      tool_args: params.toolArgs,
+      error: params.error,
+      duration_ms: params.durationMs,
+      ts: Date.now()
+    },
+    meta: buildEventMeta({ accountId: params.accountId })
+  };
+}
+function buildToolResultEvent(params) {
+  const text = extractToolResultText(params.result);
+  const mediaUrls = extractToolResultMediaUrls(params.result);
+  const safeResult = toJsonSafeValue(params.result);
+  const safeToolArgs = toJsonSafeValue(params.toolArgs);
+  return {
+    eventType: "tool.result",
+    payload: {
+      session_id: params.sessionId,
+      seq: params.seq,
+      call_id: params.callId,
+      tool_name: params.toolName,
+      tool_call_id: params.toolCallId,
+      run_id: params.runId,
+      session_key: params.sessionKey,
+      tool_args: safeToolArgs,
+      result: safeResult,
+      error: params.error,
+      duration_ms: params.durationMs,
+      text,
+      has_text: text.trim().length > 0,
+      media_urls: mediaUrls,
+      media_count: mediaUrls.length,
+      is_error: Boolean(params.error),
+      ts: Date.now()
+    },
+    meta: buildEventMeta({ accountId: params.accountId })
+  };
+}
+export {
+  buildReasoningDeltaEvent,
+  buildReasoningDoneEvent,
+  buildReasoningStartEvent,
+  buildSourceFields,
+  buildStreamingDeltaEvent,
+  buildStreamingDoneEvent,
+  buildStreamingStartEvent,
+  buildTextPart,
+  buildThinkingPart,
+  buildToolCallEvent,
+  buildToolCallPart,
+  buildToolResultEvent,
+  buildToolResultPart,
+  buildTypingEvent,
+  isPathLikeSource
+};

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

@@ -0,0 +1,30 @@
+import { SiderToolHookPayload } from './channel-types.js';
+import 'openclaw/plugin-sdk';
+import './account.js';
+import 'openclaw/plugin-sdk/setup';
+import './auth.js';
+import 'openclaw/plugin-sdk/plugin-entry';
+import './auto-title.js';
+import 'ws';
+
+declare function recordSiderPersistedAgentMessage(params: {
+    sessionKey?: string;
+    message: unknown;
+}): void;
+declare function recordSiderAgentEnd(params: {
+    messages?: unknown[];
+    error?: string;
+    runId?: string;
+    success: boolean;
+}): void;
+declare function recordSiderLlmOutputUsage(params: {
+    sessionKey?: string;
+    runId?: string;
+    provider?: string;
+    model?: string;
+    usage?: unknown;
+    lastAssistant?: unknown;
+}): void;
+declare function emitSiderToolHookEvent(params: SiderToolHookPayload): Promise<void>;
+
+export { emitSiderToolHookEvent, recordSiderAgentEnd, recordSiderLlmOutputUsage, recordSiderPersistedAgentMessage };

package/dist/src/channel-hooks.js

@@ -0,0 +1,331 @@
+import { extractAssistantText } from "openclaw/plugin-sdk/agent-runtime";
+import {
+  buildTextPart,
+  buildThinkingPart,
+  buildToolCallEvent,
+  buildToolCallPart,
+  buildToolResultEvent,
+  buildToolResultPart
+} from "./channel-builders.js";
+import { sendSiderEventBestEffort } from "./channel-relay.js";
+import { logDebug, logWarn } from "./channel-runtime.js";
+import {
+  clearRelayCallIdForToolEvent,
+  enqueueCompletedParts,
+  normalizeSessionBindingKey,
+  resolveRelayCallIdForToolEvent,
+  resolveSiderRunState,
+  resolveSiderSessionBinding,
+  scheduleQueuedPartFlush,
+  updateSiderRunStateContext
+} from "./channel-state.js";
+import {
+  addUsageTotals,
+  choosePreferredUsageTotals,
+  hasUsageTotals,
+  parseAssistantOutput,
+  parseUsageFromAssistantLike,
+  parseUsageTotals,
+  toRecord
+} from "./channel-util.js";
+function recordSiderPersistedAgentMessage(params) {
+  const binding = resolveSiderSessionBinding(params.sessionKey);
+  const runId = binding?.currentRunId;
+  if (!runId) {
+    return;
+  }
+  const message = toRecord(params.message);
+  if (!message) {
+    return;
+  }
+  const role = typeof message.role === "string" ? message.role.trim() : "";
+  if (role !== "assistant") {
+    return;
+  }
+  const runState = updateSiderRunStateContext({
+    runId,
+    sessionKey: params.sessionKey,
+    sessionId: binding?.sessionId,
+    accountId: binding?.account.accountId,
+    provider: typeof message.provider === "string" ? message.provider : void 0,
+    model: typeof message.model === "string" ? message.model : void 0
+  });
+  const directUsage = parseUsageTotals(message.usage);
+  if (directUsage && hasUsageTotals(directUsage)) {
+    addUsageTotals(runState.usage, directUsage);
+  } else if (!hasUsageTotals(runState.usage)) {
+    const fallbackUsage = parseUsageFromAssistantLike(message);
+    if (fallbackUsage && hasUsageTotals(fallbackUsage)) {
+      runState.usage = fallbackUsage;
+    }
+  }
+  const parsed = parseAssistantOutput(message);
+  if (!parsed) {
+    return;
+  }
+  const assistantText = extractAssistantText(message).trim() || void 0;
+  const stopReason = parsed.stopReason?.trim();
+  const stopReasonLower = stopReason?.toLowerCase();
+  const shouldTreatAsToolUseMessage = stopReasonLower === "tooluse" || parsed.toolCalls.length > 0 && stopReasonLower !== "error" && stopReasonLower !== "aborted" && !assistantText;
+  if (shouldTreatAsToolUseMessage) {
+    const parts = [];
+    if (parsed.thinkingText) {
+      parts.push(buildThinkingPart(parsed.thinkingText));
+    }
+    if (assistantText) {
+      parts.push(buildTextPart(assistantText));
+    }
+    if (binding) {
+      for (const toolCall of parsed.toolCalls) {
+        const callId = resolveRelayCallIdForToolEvent({
+          binding,
+          phase: "start",
+          toolCallId: toolCall.toolCallId
+        });
+        parts.push(
+          buildToolCallPart({
+            callId,
+            toolName: toolCall.toolName,
+            toolCallId: toolCall.toolCallId,
+            runId,
+            toolArgs: toolCall.toolArgs
+          })
+        );
+      }
+    }
+    enqueueCompletedParts({
+      runId,
+      parts,
+      sessionKey: params.sessionKey,
+      sessionId: binding?.sessionId,
+      accountId: binding?.account.accountId,
+      provider: runState.provider,
+      model: runState.model
+    });
+    void scheduleQueuedPartFlush({
+      runId,
+      context: "before_message_write.tool_use"
+    });
+    return;
+  }
+  if (parsed.toolCalls.length > 0) {
+    logDebug("treat assistant message with tool calls as final sider message", {
+      runId,
+      sessionKey: params.sessionKey,
+      stopReason: parsed.stopReason,
+      textLength: assistantText?.length ?? 0,
+      toolCallCount: parsed.toolCalls.length
+    });
+  }
+  runState.pendingFinalText = assistantText;
+  runState.pendingFinalThinking = parsed.thinkingText;
+  runState.pendingFinalStopReason = parsed.stopReason;
+}
+function recordSiderAgentEnd(params) {
+  if (params.success || !params.runId) {
+    return;
+  }
+  logDebug("observed unsuccessful agent_end; final sider message remains enabled", {
+    runId: params.runId,
+    error: params.error?.trim() || void 0,
+    messageCount: params.messages?.length ?? 0
+  });
+}
+function recordSiderLlmOutputUsage(params) {
+  const binding = resolveSiderSessionBinding(params.sessionKey);
+  const runId = params.runId || binding?.currentRunId;
+  if (!runId) {
+    return;
+  }
+  const existingRunState = resolveSiderRunState(runId);
+  if (!existingRunState && binding?.currentRunId !== runId) {
+    logDebug("skip llm_output sider usage update: run already cleaned up", {
+      runId,
+      sessionKey: params.sessionKey,
+      provider: params.provider,
+      model: params.model
+    });
+    return;
+  }
+  const runState = existingRunState ?? updateSiderRunStateContext({
+    runId,
+    sessionKey: params.sessionKey,
+    sessionId: binding?.sessionId,
+    accountId: binding?.account.accountId
+  });
+  updateSiderRunStateContext({
+    runId,
+    sessionKey: params.sessionKey,
+    sessionId: binding?.sessionId,
+    accountId: binding?.account.accountId,
+    provider: params.provider,
+    model: params.model
+  });
+  const parsed = choosePreferredUsageTotals(
+    parseUsageTotals(params.usage),
+    parseUsageFromAssistantLike(params.lastAssistant)
+  );
+  if (parsed && hasUsageTotals(parsed)) {
+    runState.usage = parsed;
+  }
+}
+async function emitSiderToolHookEvent(params) {
+  const binding = resolveSiderSessionBinding(params.sessionKey);
+  if (!binding) {
+    logDebug("skip sider tool hook event: session binding not found", {
+      sessionKey: params.sessionKey,
+      toolName: params.toolName,
+      toolCallId: params.toolCallId,
+      phase: params.phase
+    });
+    return;
+  }
+  if (params.runId) {
+    binding.currentRunId = params.runId;
+  }
+  const normalizedToolName = (params.toolName ?? "").trim().toLowerCase();
+  const toolArgs = toRecord(params.params);
+  const currentSessionKey = normalizeSessionBindingKey(params.sessionKey);
+  const targetSessionKeyRaw = typeof toolArgs?.sessionKey === "string" ? toolArgs.sessionKey : void 0;
+  const targetSessionKey = normalizeSessionBindingKey(targetSessionKeyRaw);
+  const hasAttachmentLikeArgs = Boolean(
+    toolArgs && [
+      "attachments",
+      "attachment",
+      "media",
+      "mediaUrl",
+      "mediaUrls",
+      "file",
+      "files",
+      "buffer",
+      "content",
+      "contentBase64"
+    ].some((field) => Object.prototype.hasOwnProperty.call(toolArgs, field))
+  );
+  if (normalizedToolName === "sessions_send" && params.phase === "start") {
+    if (hasAttachmentLikeArgs) {
+      logWarn("sider observed sessions_send with attachment-like args; sessions_send only forwards text/message args", {
+        accountId: binding.account.accountId,
+        sessionId: binding.sessionId,
+        runId: params.runId,
+        sessionKey: params.sessionKey,
+        targetSessionKey: targetSessionKeyRaw,
+        toolCallId: params.toolCallId
+      });
+    }
+    if (currentSessionKey && targetSessionKey && currentSessionKey === targetSessionKey) {
+      logWarn("sider observed sessions_send targeting current session; this often times out while current run is still active", {
+        accountId: binding.account.accountId,
+        sessionId: binding.sessionId,
+        runId: params.runId,
+        sessionKey: params.sessionKey,
+        targetSessionKey: targetSessionKeyRaw,
+        toolCallId: params.toolCallId
+      });
+    }
+  }
+  const callId = resolveRelayCallIdForToolEvent({
+    binding,
+    phase: params.phase,
+    toolCallId: params.toolCallId
+  });
+  if (params.phase === "start") {
+    binding.toolSeq += 1;
+    const toolCallEvent = buildToolCallEvent({
+      sessionId: binding.sessionId,
+      accountId: binding.account.accountId,
+      seq: binding.toolSeq,
+      callId,
+      phase: "start",
+      toolName: params.toolName,
+      toolCallId: params.toolCallId,
+      runId: params.runId,
+      sessionKey: params.sessionKey,
+      toolArgs: params.params,
+      error: params.error,
+      durationMs: params.durationMs
+    });
+    await sendSiderEventBestEffort({
+      account: binding.account,
+      sessionId: binding.sessionId,
+      event: toolCallEvent,
+      context: "tool.call.hook.start"
+    });
+  }
+  if (params.phase !== "start") {
+    if (normalizedToolName === "sessions_send") {
+      const resultRecord = toRecord(params.result);
+      const status = typeof resultRecord?.status === "string" ? resultRecord.status.trim().toLowerCase() : "";
+      if (status === "timeout") {
+        logWarn("sider observed sessions_send timeout", {
+          accountId: binding.account.accountId,
+          sessionId: binding.sessionId,
+          runId: params.runId,
+          sessionKey: params.sessionKey,
+          targetSessionKey: targetSessionKeyRaw,
+          toolCallId: params.toolCallId,
+          error: params.error,
+          durationMs: params.durationMs,
+          selfTargeted: Boolean(currentSessionKey && targetSessionKey && currentSessionKey === targetSessionKey),
+          hasAttachmentLikeArgs
+        });
+      }
+    }
+    binding.toolSeq += 1;
+    const toolResultEvent = buildToolResultEvent({
+      sessionId: binding.sessionId,
+      accountId: binding.account.accountId,
+      seq: binding.toolSeq,
+      callId,
+      toolName: params.toolName,
+      toolCallId: params.toolCallId,
+      runId: params.runId,
+      sessionKey: params.sessionKey,
+      toolArgs: params.params,
+      result: params.result,
+      error: params.error,
+      durationMs: params.durationMs
+    });
+    await sendSiderEventBestEffort({
+      account: binding.account,
+      sessionId: binding.sessionId,
+      event: toolResultEvent,
+      context: `tool.result.hook.${params.phase}`
+    });
+    if (params.runId) {
+      enqueueCompletedParts({
+        runId: params.runId,
+        parts: [
+          buildToolResultPart({
+            callId,
+            toolName: params.toolName,
+            toolCallId: params.toolCallId,
+            runId: params.runId,
+            toolArgs: params.params,
+            result: params.result,
+            error: params.error,
+            durationMs: params.durationMs
+          })
+        ],
+        sessionKey: params.sessionKey,
+        sessionId: binding.sessionId,
+        accountId: binding.account.accountId
+      });
+      void scheduleQueuedPartFlush({
+        runId: params.runId,
+        context: `tool.result.hook.${params.phase}`
+      });
+    }
+    clearRelayCallIdForToolEvent({
+      binding,
+      callId,
+      toolCallId: params.toolCallId
+    });
+  }
+}
+export {
+  emitSiderToolHookEvent,
+  recordSiderAgentEnd,
+  recordSiderLlmOutputUsage,
+  recordSiderPersistedAgentMessage
+};

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

@@ -0,0 +1,34 @@
+import { OpenClawConfig } from 'openclaw/plugin-sdk';
+import { ResolvedSiderAccount } from './account.js';
+import { SiderRelayMonitorRegistration, SiderMonitorLogger, SiderInboundRealtimeMessage } from './channel-types.js';
+import 'openclaw/plugin-sdk/setup';
+import './auth.js';
+import 'openclaw/plugin-sdk/plugin-entry';
+import './auto-title.js';
+import 'ws';
+
+declare function monitorSiderSession(params: {
+    cfg: OpenClawConfig;
+    account: ResolvedSiderAccount;
+    abortSignal: AbortSignal;
+    log?: SiderMonitorLogger;
+    onInboundMessage: (params: {
+        cfg: OpenClawConfig;
+        account: ResolvedSiderAccount;
+        event: SiderInboundRealtimeMessage;
+    }) => Promise<void>;
+}): Promise<void>;
+declare function launchManagedRelayMonitor(registration: SiderRelayMonitorRegistration): void;
+declare function runManagedSiderRelayMonitor(params: {
+    cfg: OpenClawConfig;
+    account: ResolvedSiderAccount;
+    abortSignal: AbortSignal;
+    log?: SiderMonitorLogger;
+    onInboundMessage: (params: {
+        cfg: OpenClawConfig;
+        account: ResolvedSiderAccount;
+        event: SiderInboundRealtimeMessage;
+    }) => Promise<void>;
+}): Promise<void>;
+
+export { launchManagedRelayMonitor, monitorSiderSession, runManagedSiderRelayMonitor };