@sider-ai/chrome-openclaw-sider 1.0.31

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

@@ -0,0 +1,30 @@
+import { SiderToolHookPayload } from './channel-types.js';
+import 'openclaw/plugin-sdk';
+import '../account-cW9SLuNu.js';
+import 'openclaw/plugin-sdk/setup';
+import './auth.js';
+import 'openclaw/plugin-sdk/plugin-entry';
+import 'openclaw/plugin-sdk/config-runtime';
+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,380 @@
+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 {
+  clearBindingRunId,
+  clearRelayCallIdForToolEvent,
+  discardSiderRunState,
+  enqueueCompletedParts,
+  flushFinalQueuedPartForRun,
+  flushQueuedPartsExceptTailForRun,
+  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 (stopReasonLower === "tooluse" && parsed.toolCalls.length === 0) {
+    const content = Array.isArray(message.content) ? message.content : [];
+    logDebug("assistant toolUse message contained no parsed sider tool calls", {
+      runId,
+      sessionKey: params.sessionKey,
+      contentTypes: content.map((item) => {
+        const part = toRecord(item);
+        return typeof part?.type === "string" ? part.type : typeof item;
+      }),
+      contentLength: content.length
+    });
+  }
+  if (shouldTreatAsToolUseMessage) {
+    const parts = [];
+    if (parsed.thinkingText) {
+      parts.push(buildThinkingPart(parsed.thinkingText));
+    }
+    if (assistantText) {
+      parts.push(buildTextPart(assistantText));
+    }
+    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 effectiveRunId = params.runId ?? binding.currentRunId;
+  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: effectiveRunId,
+      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"
+    });
+    enqueueCompletedParts({
+      runId: effectiveRunId,
+      parts: [
+        buildToolCallPart({
+          callId,
+          toolName: params.toolName,
+          toolCallId: params.toolCallId,
+          runId: effectiveRunId,
+          toolArgs: params.params
+        })
+      ],
+      sessionKey: params.sessionKey,
+      sessionId: binding.sessionId,
+      accountId: binding.account.accountId
+    });
+    void scheduleQueuedPartFlush({
+      runId: effectiveRunId,
+      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: effectiveRunId,
+          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: effectiveRunId,
+      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 (effectiveRunId) {
+      enqueueCompletedParts({
+        runId: effectiveRunId,
+        parts: [
+          buildToolResultPart({
+            callId,
+            toolName: params.toolName,
+            toolCallId: params.toolCallId,
+            runId: effectiveRunId,
+            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: effectiveRunId,
+        context: `tool.result.hook.${params.phase}`
+      });
+      const runState = resolveSiderRunState(effectiveRunId);
+      if (runState && !runState.managedByReplyPipeline) {
+        await flushQueuedPartsExceptTailForRun({
+          runId: effectiveRunId,
+          account: binding.account,
+          sessionId: binding.sessionId,
+          context: `tool.result.hook.${params.phase}.standalone.except_tail`
+        });
+        const finalized = await flushFinalQueuedPartForRun({
+          runId: effectiveRunId,
+          account: binding.account,
+          sessionId: binding.sessionId,
+          context: `tool.result.hook.${params.phase}.standalone.final_tail`
+        });
+        logDebug("finalized standalone sider tool run message tail", {
+          runId: effectiveRunId,
+          sessionKey: params.sessionKey,
+          toolName: params.toolName,
+          toolCallId: params.toolCallId,
+          finalized
+        });
+        clearBindingRunId(params.sessionKey, effectiveRunId);
+        discardSiderRunState(effectiveRunId);
+      }
+    } else {
+      logDebug("skip sider tool result message part enqueue: run id unavailable", {
+        sessionKey: params.sessionKey,
+        toolName: params.toolName,
+        toolCallId: params.toolCallId,
+        phase: 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 { R as ResolvedSiderAccount } from '../account-cW9SLuNu.js';
+import { SiderRelayMonitorRegistration, SiderMonitorLogger, SiderInboundRealtimeMessage } from './channel-types.js';
+import 'openclaw/plugin-sdk/setup';
+import './auth.js';
+import 'openclaw/plugin-sdk/plugin-entry';
+import 'openclaw/plugin-sdk/config-runtime';
+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 };