@sider-ai/chrome-openclaw-sider 1.0.31

package/dist/src/channel.js

@@ -0,0 +1,834 @@
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk/account-id";
+import { jsonResult, readStringParam } from "openclaw/plugin-sdk/agent-runtime";
+import { createChannelReplyPipeline } from "openclaw/plugin-sdk/channel-reply-pipeline";
+import {
+  loadConfig,
+  writeConfigFile
+} from "openclaw/plugin-sdk/config-runtime";
+import { getAgentScopedMediaLocalRoots } from "openclaw/plugin-sdk/media-runtime";
+import {
+  formatTextWithAttachmentLinks,
+  resolveOutboundMediaUrls
+} from "openclaw/plugin-sdk/reply-payload";
+import {
+  describeSiderAccountConfigurationError,
+  extractSiderToolSend,
+  isSiderAccountBootstrappable,
+  listSiderAccountIds,
+  looksLikeSiderTargetId,
+  normalizeSiderMessagingTarget,
+  resolveManagedSiderAccount,
+  resolveOutboundSessionId,
+  resolveSiderAccount
+} from "./account.js";
+import {
+  isFirstTurnInSiderSession,
+  resolveAutoTitleConfig,
+  scheduleSiderAutoTitleUpdate
+} from "./channel-auto-title.js";
+import {
+  maybeResetSiderSessionToCurrentDefaultModel
+} from "./channel-session-model.js";
+import {
+  SIDER_CHANNEL_ID,
+  SIDER_PUSH_TOOL_ERROR_WARNINGS,
+  SIDER_TOOL_ERROR_WARNING_TEXT_RE
+} from "./config.js";
+import { resolveInboundSiderMedia } from "./inbound-media.js";
+import {
+  buildOptimisticSiderPartFromInlineAttachment
+} from "./media-upload.js";
+import {
+  applySiderSetupAccountConfig,
+  createSiderPairingPendingUpdateReporter,
+  formatSiderPairingInstructions,
+  requestSiderPairing,
+  SiderPairingExpiredError,
+  waitForSiderPairing
+} from "./setup-core.js";
+import { siderChannelPluginCommon } from "./channel-shared.js";
+import {
+  getSiderRuntime,
+  logDebug,
+  logError,
+  logInfo,
+  logWarn,
+  siderOutboundLogger
+} from "./channel-runtime.js";
+import {
+  parseTextFromPart,
+  parseMediaFromPart,
+  describeInboundMediaReference,
+  decodeBase64AttachmentBuffer,
+  persistInlineAttachmentBuffer
+} from "./channel-util.js";
+import {
+  rememberSiderSessionBinding,
+  resolveSiderSessionBinding,
+  buildPendingMessageContextForRun,
+  consumePendingMessageContextForRun,
+  resolvePendingFinalTextForRun,
+  updateSiderRunStateContext
+} from "./channel-state.js";
+import { buildTextPart } from "./channel-builders.js";
+import {
+  dispatchSiderParts,
+  handleSiderSendAction,
+  sendToSider
+} from "./channel-send.js";
+import { buildSendMediaResult } from "./channel-send-result.js";
+import { acquireSiderTyping, releaseSiderTyping } from "./channel-typing.js";
+import {
+  deliverReplyPayloadToSider,
+  persistDeferredFinalReplyPayloadToSider,
+  persistStandaloneReplyPayloadToSider,
+  enqueueStreamEventTask,
+  flushStreamEventQueue,
+  handleStreamingPartialSnapshot,
+  handleReasoningSnapshot,
+  closeStreamingSessionIfActive,
+  closeReasoningSessionIfActive,
+  commitCurrentStreamTextToFallbackPrefix,
+  resetCurrentStreamTextState,
+  resetReasoningStreamState,
+  rotateAssistantMessageFallbackState,
+  resolveFallbackFinalText,
+  cleanupSiderRunAfterReply,
+  finalizeQueuedRunMessages
+} from "./channel-streaming.js";
+import { runManagedSiderRelayMonitor } from "./channel-monitor.js";
+import { setSiderRuntime } from "./channel-runtime.js";
+import {
+  recordSiderPersistedAgentMessage,
+  recordSiderLlmOutputUsage,
+  recordSiderAgentEnd,
+  emitSiderToolHookEvent
+} from "./channel-hooks.js";
+async function handleInboundRealtimeMessage(params) {
+  const { cfg, account, event } = params;
+  const core = getSiderRuntime();
+  const runtimeConfigApi = core.config;
+  const currentCfg = runtimeConfigApi.current?.() ?? runtimeConfigApi.loadConfig?.() ?? loadConfig() ?? cfg;
+  const sessionId = typeof event.session_id === "string" ? event.session_id.trim() : "";
+  if (!sessionId) {
+    return;
+  }
+  if ((event.source_role ?? "").toLowerCase() === "relay") {
+    return;
+  }
+  const parts = Array.isArray(event.parts) ? event.parts : [];
+  const textChunks = [];
+  const mediaItems = [];
+  for (const part of parts) {
+    const text = parseTextFromPart(part);
+    if (text) {
+      textChunks.push(text);
+      continue;
+    }
+    const media = parseMediaFromPart(part);
+    if (media) {
+      mediaItems.push(media);
+    }
+  }
+  const rawText = textChunks.join("\n").trim();
+  const mediaUrls = mediaItems.map((item) => item.url).filter((item) => Boolean(item));
+  const parsedMediaTypes = mediaItems.map((item) => item.mimeType).filter((item) => Boolean(item));
+  const hasControlCommand = rawText ? core.channel.text.hasControlCommand(rawText, currentCfg) : false;
+  const shouldComputeCommandAuthorized = rawText ? core.channel.commands.shouldComputeCommandAuthorized(rawText, currentCfg) : false;
+  const commandAuthorized = shouldComputeCommandAuthorized ? core.channel.commands.resolveCommandAuthorizedFromAuthorizers({
+    useAccessGroups: currentCfg.commands?.useAccessGroups !== false,
+    authorizers: [{ configured: true, allowed: true }]
+  }) : void 0;
+  if (!rawText && mediaItems.length === 0) {
+    logDebug("drop inbound sider message: no text/media", {
+      accountId: account.accountId,
+      sessionId,
+      messageId: event.message_id,
+      partTypes: parts.map((part) => part.type)
+    });
+    return;
+  }
+  if (hasControlCommand) {
+    logInfo("sider control command inbound", {
+      accountId: account.accountId,
+      sessionId,
+      messageId: event.message_id,
+      commandAuthorized
+    });
+    logDebug("detected sider control command", {
+      accountId: account.accountId,
+      sessionId,
+      messageId: event.message_id,
+      commandBody: rawText,
+      shouldComputeCommandAuthorized,
+      commandAuthorized
+    });
+  }
+  const resolvedInboundMedia = await resolveInboundSiderMedia({
+    runtime: core,
+    cfg: currentCfg,
+    accountId: account.accountId,
+    mediaItems,
+    gatewayUrl: account.gatewayUrl,
+    token: account.token,
+    requestTimeoutMs: account.sendTimeoutMs,
+    logger: siderOutboundLogger
+  });
+  const unresolvedMediaUrls = resolvedInboundMedia.unresolvedMedia.map((item) => item.url).filter((item) => Boolean(item));
+  const unresolvedMediaRefs = resolvedInboundMedia.unresolvedMedia.map((item) => describeInboundMediaReference(item)).filter((item) => Boolean(item));
+  if (resolvedInboundMedia.unresolvedMedia.length > 0) {
+    logWarn("sider inbound media fallback to attachment url", {
+      accountId: account.accountId,
+      sessionId,
+      unresolvedCount: resolvedInboundMedia.unresolvedMedia.length,
+      unresolvedMediaRefs
+    });
+  }
+  const bodyForAgent = formatTextWithAttachmentLinks(rawText, unresolvedMediaRefs);
+  const mediaPayload = resolvedInboundMedia.mediaPayload;
+  const route = core.channel.routing.resolveAgentRoute({
+    cfg: currentCfg,
+    channel: SIDER_CHANNEL_ID,
+    accountId: account.accountId,
+    peer: {
+      kind: "direct",
+      id: sessionId
+    }
+  });
+  const to = `session:${sessionId}`;
+  const mediaLocalRoots = getAgentScopedMediaLocalRoots(currentCfg, route.agentId);
+  const timestamp = typeof event.created_at === "number" && Number.isFinite(event.created_at) ? event.created_at : Date.now();
+  const envelopeBody = core.channel.reply.formatAgentEnvelope({
+    channel: "Sider",
+    from: sessionId,
+    timestamp,
+    envelope: core.channel.reply.resolveEnvelopeFormatOptions(currentCfg),
+    body: bodyForAgent
+  });
+  const ctxPayload = core.channel.reply.finalizeInboundContext({
+    Body: envelopeBody,
+    BodyForAgent: bodyForAgent,
+    RawBody: bodyForAgent,
+    CommandBody: rawText,
+    BodyForCommands: rawText,
+    From: `${SIDER_CHANNEL_ID}:client:${sessionId}`,
+    To: to,
+    SessionKey: route.sessionKey,
+    AccountId: route.accountId,
+    ChatType: "direct",
+    ConversationLabel: sessionId,
+    SenderId: "client",
+    SenderName: "client",
+    Provider: SIDER_CHANNEL_ID,
+    Surface: SIDER_CHANNEL_ID,
+    MessageSid: typeof event.message_id === "string" ? event.message_id : void 0,
+    Timestamp: timestamp,
+    WasMentioned: true,
+    OriginatingChannel: SIDER_CHANNEL_ID,
+    OriginatingTo: to,
+    ...mediaPayload,
+    ...event.meta || {},
+    MediaUrl: mediaPayload.MediaUrl || (unresolvedMediaUrls.length > 0 ? unresolvedMediaUrls[0] : void 0),
+    MediaUrls: mediaPayload.MediaUrls || (unresolvedMediaUrls.length > 0 ? unresolvedMediaUrls : void 0),
+    MediaType: mediaPayload.MediaType || parsedMediaTypes[0],
+    MediaTypes: mediaPayload.MediaTypes || (parsedMediaTypes.length > 0 ? parsedMediaTypes : void 0),
+    CommandAuthorized: commandAuthorized
+  });
+  rememberSiderSessionBinding({
+    sessionKey: ctxPayload.SessionKey ?? route.sessionKey,
+    account,
+    sessionId
+  });
+  const storePath = core.channel.session.resolveStorePath(currentCfg.session?.store, {
+    agentId: route.agentId
+  });
+  const autoTitleConfig = resolveAutoTitleConfig(account.config.autoTitle);
+  const autoTitleUserMessage = rawText.slice(0, 500).trim();
+  let shouldAutoTitleAfterReply = false;
+  if (autoTitleConfig && autoTitleUserMessage) {
+    try {
+      shouldAutoTitleAfterReply = isFirstTurnInSiderSession({
+        cfg: currentCfg,
+        agentId: route.agentId,
+        sessionKey: ctxPayload.SessionKey ?? route.sessionKey
+      });
+    } catch (error) {
+      logWarn("sider auto-title first-turn detection failed", {
+        accountId: account.accountId,
+        sessionId,
+        error: String(error)
+      });
+    }
+  }
+  try {
+    const modelReset = await maybeResetSiderSessionToCurrentDefaultModel({
+      runtime: core,
+      cfg: currentCfg,
+      agentId: route.agentId,
+      sessionKey: ctxPayload.SessionKey ?? route.sessionKey
+    });
+    if (modelReset.changed) {
+      logInfo("sider session model reset to current default", {
+        accountId: account.accountId,
+        sessionId,
+        agentId: route.agentId,
+        sessionKey: ctxPayload.SessionKey ?? route.sessionKey,
+        reason: modelReset.reason,
+        previousModel: modelReset.previousModel,
+        defaultModel: modelReset.defaultModel
+      });
+    } else {
+      logDebug("sider session model reset skipped", {
+        accountId: account.accountId,
+        sessionId,
+        agentId: route.agentId,
+        sessionKey: ctxPayload.SessionKey ?? route.sessionKey,
+        reason: modelReset.reason
+      });
+    }
+  } catch (error) {
+    logWarn("sider session model reset failed", {
+      accountId: account.accountId,
+      sessionId,
+      agentId: route.agentId,
+      sessionKey: ctxPayload.SessionKey ?? route.sessionKey,
+      error: String(error)
+    });
+  }
+  await core.channel.session.recordInboundSession({
+    storePath,
+    sessionKey: ctxPayload.SessionKey ?? route.sessionKey,
+    ctx: ctxPayload,
+    onRecordError: (err) => {
+      logWarn("sider failed to record session", {
+        error: String(err)
+      });
+    }
+  });
+  const { onModelSelected, ...prefixOptions } = createChannelReplyPipeline({
+    cfg: currentCfg,
+    agentId: route.agentId,
+    channel: SIDER_CHANNEL_ID,
+    accountId: account.accountId
+  });
+  logDebug("dispatching sider inbound message", {
+    accountId: account.accountId,
+    sessionId,
+    messageId: event.message_id,
+    routeSessionKey: route.sessionKey,
+    hasControlCommand,
+    commandAuthorized,
+    textLength: rawText.length,
+    mediaCount: mediaUrls.length,
+    mediaDownloadedCount: mediaPayload.MediaPaths?.length ?? 0,
+    mediaDownloadFailedCount: resolvedInboundMedia.unresolvedMedia.length
+  });
+  const streamState = {
+    answer: {
+      active: false,
+      streamId: void 0,
+      seq: 0,
+      blockDeltaCount: 0,
+      partialDeltaCount: 0,
+      streamDeltaMode: "undecided",
+      partialSnapshot: "",
+      accumulatedBlockText: "",
+      assistantSeq: 0,
+      fallbackAssistantSeq: 0,
+      fallbackTextSource: "none",
+      fallbackCurrentText: "",
+      fallbackTextPrefix: ""
+    },
+    reasoning: {
+      active: false,
+      streamId: void 0,
+      seq: 0,
+      snapshot: "",
+      deltaCount: 0
+    },
+    persistedFinalText: false,
+    pendingFinalPayloads: [],
+    sessionKey: ctxPayload.SessionKey ?? route.sessionKey,
+    currentRunId: void 0,
+    streamEventQueue: Promise.resolve()
+  };
+  acquireSiderTyping({ account, sessionId });
+  let dispatchCompleted = false;
+  let dispatchError;
+  try {
+    try {
+      await core.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+        ctx: ctxPayload,
+        cfg: currentCfg,
+        dispatcherOptions: {
+          ...prefixOptions,
+          deliver: async (payload, info) => {
+            logDebug("-> deliver: ", payload, info);
+            if (payload.isCompactionNotice === true) {
+              logDebug("skip sider deliver: compaction notice", { accountId: account.accountId, sessionId, kind: info.kind });
+              return;
+            }
+            if (payload.isError === true && !SIDER_PUSH_TOOL_ERROR_WARNINGS && typeof payload.text === "string" && SIDER_TOOL_ERROR_WARNING_TEXT_RE.test(payload.text)) {
+              return;
+            }
+            logDebug("sider dispatch deliver payload", {
+              accountId: account.accountId,
+              sessionId,
+              kind: info.kind,
+              hasText: typeof payload.text === "string" && payload.text.length > 0,
+              mediaCount: resolveOutboundMediaUrls(payload).length
+            });
+            await deliverReplyPayloadToSider({ account, sessionId, streamState, payload, kind: info.kind, mediaLocalRoots });
+          },
+          onError: (err, info) => {
+            logError(`sider ${info.kind} reply failed`, { error: String(err) });
+          }
+        },
+        replyOptions: {
+          disableBlockStreaming: false,
+          onAgentRunStart: (runId) => {
+            streamState.currentRunId = runId;
+            const binding = resolveSiderSessionBinding(streamState.sessionKey);
+            if (binding) {
+              binding.currentRunId = runId;
+            }
+            updateSiderRunStateContext({
+              runId,
+              sessionKey: streamState.sessionKey,
+              sessionId,
+              accountId: account.accountId,
+              managedByReplyPipeline: true
+            });
+          },
+          onAssistantMessageStart: () => {
+            rotateAssistantMessageFallbackState(streamState);
+          },
+          onPartialReply: async (payload) => {
+            const snapshot = typeof payload.text === "string" ? payload.text : "";
+            if (!snapshot || streamState.answer.streamDeltaMode === "block") {
+              return;
+            }
+            if (streamState.answer.streamDeltaMode === "undecided") {
+              streamState.answer.streamDeltaMode = "partial";
+            }
+            await enqueueStreamEventTask({
+              streamState,
+              task: () => handleStreamingPartialSnapshot({ account, sessionId, streamState, snapshot })
+            });
+          },
+          onReasoningStream: async (payload) => {
+            const snapshot = typeof payload.text === "string" ? payload.text : "";
+            if (!snapshot.trim()) {
+              return;
+            }
+            await enqueueStreamEventTask({
+              streamState,
+              task: () => handleReasoningSnapshot({ account, sessionId, streamState, snapshot })
+            });
+          },
+          onReasoningEnd: async () => {
+            await enqueueStreamEventTask({
+              streamState,
+              task: async () => {
+                await closeReasoningSessionIfActive({ account, sessionId, streamState, reason: "final", context: "reasoning.done" });
+                resetReasoningStreamState(streamState);
+              }
+            });
+          },
+          onCompactionStart: async () => {
+            await flushStreamEventQueue(streamState);
+            commitCurrentStreamTextToFallbackPrefix(streamState);
+            await closeStreamingSessionIfActive({ account, sessionId, streamState, reason: "interrupted", context: "stream.done.compaction-start" });
+            resetCurrentStreamTextState(streamState);
+            await closeReasoningSessionIfActive({ account, sessionId, streamState, reason: "interrupted", context: "reasoning.done.compaction-start" });
+            resetReasoningStreamState(streamState);
+            logDebug("sider stream state reset for compaction", {
+              accountId: account.accountId,
+              sessionId,
+              fallbackPrefixLength: streamState.answer.fallbackTextPrefix.length,
+              reasoningTextLength: streamState.reasoning.snapshot.length
+            });
+          },
+          onModelSelected
+        }
+      });
+      dispatchCompleted = true;
+      logDebug("completed sider inbound dispatch", { accountId: account.accountId, sessionId, messageId: event.message_id });
+    } catch (err) {
+      dispatchError = err;
+    } finally {
+      await flushStreamEventQueue(streamState);
+      const streamEndedNormally = dispatchCompleted;
+      await closeStreamingSessionIfActive({
+        account,
+        sessionId,
+        streamState,
+        reason: streamEndedNormally ? "final" : "interrupted",
+        context: streamEndedNormally ? "stream.done.dispatch-end" : "stream.done.interrupted"
+      });
+      await closeReasoningSessionIfActive({
+        account,
+        sessionId,
+        streamState,
+        reason: streamEndedNormally ? "final" : "interrupted",
+        context: streamEndedNormally ? "reasoning.done.dispatch-end" : "reasoning.done.interrupted"
+      });
+      streamState.answer.blockDeltaCount = 0;
+      resetReasoningStreamState(streamState);
+    }
+    if (!dispatchCompleted) {
+      const selectedFinalText = resolvePendingFinalTextForRun(streamState.currentRunId) || resolveFallbackFinalText(streamState).trim();
+      const messageContext = buildPendingMessageContextForRun({
+        accountId: account.accountId,
+        runId: streamState.currentRunId,
+        includeFinalThinking: true
+      });
+      const cleanupRunId = messageContext.runId ?? streamState.currentRunId;
+      const finalParts = [
+        ...messageContext.parts,
+        ...selectedFinalText ? [buildTextPart(selectedFinalText)] : []
+      ];
+      if (finalParts.length > 0 || cleanupRunId) {
+        logDebug("dispatch ended with interruption; finalizing current assistant text", {
+          accountId: account.accountId,
+          sessionId,
+          runId: cleanupRunId,
+          finalTextLength: selectedFinalText.length,
+          partTypes: finalParts.map((part) => part.type)
+        });
+        await finalizeQueuedRunMessages({
+          account,
+          sessionId,
+          streamState,
+          parts: finalParts,
+          stopReason: messageContext.stopReason,
+          context: "final.interrupted"
+        });
+        consumePendingMessageContextForRun({
+          runId: cleanupRunId,
+          consumeFinalThinking: true
+        });
+        cleanupSiderRunAfterReply({ streamState, runId: cleanupRunId });
+      } else {
+        cleanupSiderRunAfterReply({ streamState, runId: streamState.currentRunId });
+      }
+      if (dispatchError) {
+        throw dispatchError;
+      }
+      return;
+    }
+    const pendingFinalPayloads = [...streamState.pendingFinalPayloads];
+    streamState.pendingFinalPayloads = [];
+    if (pendingFinalPayloads.length > 0) {
+      const pendingRunFinalText = resolvePendingFinalTextForRun(streamState.currentRunId).trim();
+      const fallbackFinalText = (pendingRunFinalText || resolveFallbackFinalText(streamState)).trim();
+      let primaryFinalPayloadIndex = pendingFinalPayloads.findIndex(
+        (payload) => payload.isError !== true
+      );
+      const fallbackMatchingPayloadIndex = primaryFinalPayloadIndex < 0 && fallbackFinalText.length > 0 ? pendingFinalPayloads.findIndex((payload) => {
+        const payloadText = typeof payload.text === "string" ? payload.text.trim() : "";
+        return payloadText.length > 0 && payloadText === fallbackFinalText;
+      }) : -1;
+      if (primaryFinalPayloadIndex < 0 && fallbackMatchingPayloadIndex >= 0) {
+        primaryFinalPayloadIndex = fallbackMatchingPayloadIndex;
+        logDebug("promoting matching final payload as primary sider message", {
+          accountId: account.accountId,
+          sessionId,
+          runId: streamState.currentRunId,
+          primaryFinalPayloadIndex,
+          isError: pendingFinalPayloads[primaryFinalPayloadIndex]?.isError === true,
+          textLength: fallbackFinalText.length
+        });
+      }
+      const shouldSynthesizePrimaryFinal = primaryFinalPayloadIndex < 0 && fallbackFinalText.length > 0 && (pendingRunFinalText.length > 0 || streamState.answer.fallbackTextSource !== "final_payload");
+      if (!shouldSynthesizePrimaryFinal && primaryFinalPayloadIndex < 0) {
+        logDebug("skipping synthetic primary final message for payload-derived fallback", {
+          accountId: account.accountId,
+          sessionId,
+          runId: streamState.currentRunId,
+          fallbackTextSource: streamState.answer.fallbackTextSource,
+          fallbackTextLength: fallbackFinalText.length,
+          pendingFinalPayloadCount: pendingFinalPayloads.length
+        });
+        primaryFinalPayloadIndex = 0;
+      }
+      if (shouldSynthesizePrimaryFinal) {
+        const messageContext = buildPendingMessageContextForRun({
+          accountId: account.accountId,
+          runId: streamState.currentRunId,
+          includeFinalThinking: true
+        });
+        const cleanupRunId = messageContext.runId ?? streamState.currentRunId;
+        const finalParts = [
+          ...messageContext.parts,
+          ...fallbackFinalText ? [buildTextPart(fallbackFinalText)] : []
+        ];
+        if (finalParts.length > 0 || cleanupRunId) {
+          logDebug("synthesizing primary final message before standalone error payloads", {
+            accountId: account.accountId,
+            sessionId,
+            runId: cleanupRunId,
+            finalTextLength: fallbackFinalText.length,
+            extraFinalPayloadCount: pendingFinalPayloads.length
+          });
+          await finalizeQueuedRunMessages({
+            account,
+            sessionId,
+            streamState,
+            parts: finalParts,
+            stopReason: messageContext.stopReason,
+            context: "final.synthetic_primary"
+          });
+          consumePendingMessageContextForRun({
+            runId: cleanupRunId,
+            consumeFinalThinking: true
+          });
+          cleanupSiderRunAfterReply({ streamState, runId: cleanupRunId });
+        }
+      }
+      for (let index = 0; index < pendingFinalPayloads.length; index += 1) {
+        const payload = pendingFinalPayloads[index];
+        if (!shouldSynthesizePrimaryFinal && index === primaryFinalPayloadIndex) {
+          await persistDeferredFinalReplyPayloadToSider({
+            account,
+            sessionId,
+            streamState,
+            payload,
+            mediaLocalRoots
+          });
+          continue;
+        }
+        await persistStandaloneReplyPayloadToSider({
+          account,
+          sessionId,
+          payload,
+          mediaLocalRoots
+        });
+      }
+    }
+    if (!streamState.persistedFinalText) {
+      const selectedFinalText = resolvePendingFinalTextForRun(streamState.currentRunId) || resolveFallbackFinalText(streamState).trim();
+      const messageContext = buildPendingMessageContextForRun({
+        accountId: account.accountId,
+        runId: streamState.currentRunId,
+        includeFinalThinking: true
+      });
+      const cleanupRunId = messageContext.runId ?? streamState.currentRunId;
+      const finalParts = [
+        ...messageContext.parts,
+        ...selectedFinalText ? [buildTextPart(selectedFinalText)] : []
+      ];
+      if (finalParts.length > 0 || cleanupRunId) {
+        logDebug(
+          selectedFinalText ? "no final payload observed; finalizing current assistant text" : "no final payload observed; flushing queued tail as final message",
+          {
+            accountId: account.accountId,
+            sessionId,
+            runId: cleanupRunId,
+            finalTextLength: selectedFinalText.length,
+            partTypes: finalParts.map((part) => part.type)
+          }
+        );
+        await finalizeQueuedRunMessages({
+          account,
+          sessionId,
+          streamState,
+          parts: finalParts,
+          stopReason: messageContext.stopReason,
+          context: selectedFinalText ? "final.text_fallback" : "final.queued_tail"
+        });
+        consumePendingMessageContextForRun({
+          runId: cleanupRunId,
+          consumeFinalThinking: true
+        });
+        cleanupSiderRunAfterReply({ streamState, runId: cleanupRunId });
+      } else {
+        cleanupSiderRunAfterReply({ streamState, runId: streamState.currentRunId });
+      }
+    }
+    if (streamState.persistedFinalText && shouldAutoTitleAfterReply && autoTitleConfig) {
+      scheduleSiderAutoTitleUpdate({
+        cfg: currentCfg,
+        account,
+        sessionId,
+        userMessage: autoTitleUserMessage,
+        prompt: autoTitleConfig.prompt,
+        agentId: route.agentId
+      });
+    }
+  } finally {
+    releaseSiderTyping({ account, sessionId });
+  }
+}
+const siderPlugin = {
+  id: SIDER_CHANNEL_ID,
+  ...siderChannelPluginCommon,
+  agentPrompt: {
+    messageToolHints: () => [
+      "- Sider targeting: omit `to` to reply in the current conversation (auto-inferred).",
+      "- To send an existing image or file to the current user, prefer the message tool with action='send' and set 'media' to a local file path or a remote HTTPS URL. You do not need to specify 'to' \u2014 the current conversation recipient is used automatically.",
+      "- IMPORTANT: Use action='send' for files/images. action='sendAttachment' is limited.",
+      "- When the user asks you to find an image from the web, use a web search or browser tool to find a suitable image URL, then send it using the message tool with 'media' set to that HTTPS image URL \u2014 do NOT download the image first.",
+      "- If the user asks you to download, export, or otherwise produce a file, send the resulting file to the user with the message tool. Do not stop at describing the file or giving its path.",
+      // "- If you call image_generate, the generated image is sent to the user automatically. Do not send the same image again with the message tool unless the user explicitly asks for a separate resend.",
+      "- IMPORTANT: When generating or saving a file to send, always use an absolute path (e.g. /tmp/photo.png), never a relative path like ./photo.png. Relative paths cannot be resolved and the file will not be delivered."
+    ]
+  },
+  streaming: {
+    blockStreamingCoalesceDefaults: { minChars: 1200, idleMs: 900 }
+  },
+  actions: {
+    describeMessageTool: ({ cfg }) => {
+      const hasConfigured = listSiderAccountIds(cfg).some((accountId) => {
+        const account = resolveSiderAccount(cfg, accountId);
+        return account.configured || isSiderAccountBootstrappable(account);
+      });
+      return hasConfigured ? { actions: ["send"] } : null;
+    },
+    supportsAction: ({ action }) => action === "send",
+    extractToolSend: ({ args }) => extractSiderToolSend(args),
+    handleAction: async ({ action, params, cfg, accountId, mediaLocalRoots }) => {
+      logDebug(">> handleAction:", action, params);
+      if (action === "send") {
+        return jsonResult(
+          await handleSiderSendAction({
+            cfg,
+            accountId,
+            params,
+            mediaLocalRoots
+          })
+        );
+      }
+      if (action !== "sendAttachment") {
+        throw new Error(`sider action ${action} is not supported`);
+      }
+      const account = await resolveManagedSiderAccount({ cfg, accountId });
+      if (!account.configured) {
+        throw new Error(describeSiderAccountConfigurationError(account));
+      }
+      const to = readStringParam(params, "to", { required: true });
+      const rawBuffer = readStringParam(params, "buffer", { trim: false, required: true });
+      const contentType = readStringParam(params, "contentType", { trim: false }) ?? readStringParam(params, "mimeType", { trim: false });
+      const fileName = readStringParam(params, "filename", { trim: false }) ?? void 0;
+      const sessionId = resolveOutboundSessionId({ account, to });
+      const buffer = decodeBase64AttachmentBuffer(rawBuffer);
+      const savedAttachment = await persistInlineAttachmentBuffer({
+        cfg,
+        accountId,
+        buffer,
+        contentType: contentType ?? void 0,
+        fileName
+      });
+      const resolvedContentType = contentType ?? savedAttachment.contentType ?? void 0;
+      const resolvedFileName = fileName ?? savedAttachment.path;
+      const preparedAttachment = await buildOptimisticSiderPartFromInlineAttachment({
+        account,
+        sessionId,
+        buffer,
+        contentType: resolvedContentType,
+        fileName: resolvedFileName,
+        source: resolvedFileName
+      });
+      const sendParts = [preparedAttachment.part];
+      const attachmentResult = await buildSendMediaResult({
+        account,
+        sessionId,
+        part: preparedAttachment.part,
+        source: savedAttachment.path,
+        path: savedAttachment.path
+      });
+      await dispatchSiderParts({
+        account,
+        sessionId,
+        parts: sendParts,
+        deferredUploads: preparedAttachment.deferredUpload ? [preparedAttachment.deferredUpload] : [],
+        allowMergeActiveRun: true,
+        context: "action.sendAttachment"
+      });
+      return jsonResult(attachmentResult);
+    }
+  },
+  outbound: {
+    deliveryMode: "direct",
+    sendText: async ({ cfg, accountId, to, text, mediaLocalRoots }) => {
+      logDebug("-> sendText:", text);
+      const result = await sendToSider({ cfg, accountId, to, text, mediaLocalRoots, errorHint: "sider sendText requires non-empty text" });
+      return { channel: SIDER_CHANNEL_ID, messageId: result.messageId, conversationId: result.conversationId };
+    },
+    sendMedia: async ({ cfg, accountId, to, text, mediaUrl, mediaLocalRoots }) => {
+      logDebug("-> sendMedia:", text, mediaUrl);
+      const result = await sendToSider({ cfg, accountId, to, text, mediaUrl, mediaLocalRoots, errorHint: "sider sendMedia requires text and/or mediaUrl" });
+      return { channel: SIDER_CHANNEL_ID, messageId: result.messageId, conversationId: result.conversationId };
+    }
+  },
+  gateway: {
+    startAccount: async (ctx) => {
+      const account = await resolveManagedSiderAccount({ cfg: ctx.cfg, accountId: ctx.accountId });
+      if (!account.configured) {
+        throw new Error(describeSiderAccountConfigurationError(account));
+      }
+      ctx.log?.info(`[${account.accountId}] starting sider relay monitor (${account.gatewayUrl}, relayId=${account.relayId})`);
+      await runManagedSiderRelayMonitor({
+        cfg: ctx.cfg,
+        account,
+        abortSignal: ctx.abortSignal,
+        log: ctx.log,
+        onInboundMessage: handleInboundRealtimeMessage
+      });
+      ctx.log?.info(`[${account.accountId}] sider relay monitor watcher stopped`);
+    }
+  },
+  auth: {
+    login: async ({ accountId, runtime }) => {
+      const resolvedAccountId = normalizeAccountId(accountId) ?? DEFAULT_ACCOUNT_ID;
+      for (; ; ) {
+        const pairing = await requestSiderPairing();
+        runtime.log(
+          formatSiderPairingInstructions({ pairingCode: pairing.pairingCode, leadLine: "One more step to connect:" })
+        );
+        const reportPendingUpdate = createSiderPairingPendingUpdateReporter({
+          pairingCode: pairing.pairingCode,
+          report: (message) => {
+            runtime.log(message);
+          }
+        });
+        try {
+          const paired = await waitForSiderPairing({
+            pairing,
+            onPending: reportPendingUpdate,
+            onRetryableError: (message) => {
+              runtime.log(message);
+            }
+          });
+          const latestCfg = loadConfig();
+          const nextCfg = applySiderSetupAccountConfig({ cfg: latestCfg, accountId: resolvedAccountId, input: { token: paired.token } });
+          await writeConfigFile(nextCfg);
+          runtime.log("Connected! You can now chat with me in the browser Side Panel.");
+          return;
+        } catch (error) {
+          if (error instanceof SiderPairingExpiredError) {
+            runtime.log("Pairing code expired.");
+            runtime.log("Generating a new code...");
+            continue;
+          }
+          throw error;
+        }
+      }
+    }
+  },
+  messaging: {
+    normalizeTarget: normalizeSiderMessagingTarget,
+    targetResolver: {
+      looksLikeId: looksLikeSiderTargetId,
+      hint: "session:<sessionId> (or raw <sessionId>)"
+    }
+  }
+};
+export {
+  emitSiderToolHookEvent,
+  recordSiderAgentEnd,
+  recordSiderLlmOutputUsage,
+  recordSiderPersistedAgentMessage,
+  setSiderRuntime,
+  siderPlugin
+};