@sider-ai/chrome-openclaw-sider 1.0.31

package/dist/src/channel-util.js

@@ -0,0 +1,604 @@
+import { resolveChannelMediaMaxBytes } from "openclaw/plugin-sdk/media-runtime";
+import { formatAuthorizationHeader, resolveSiderApiUrl } from "./auth.js";
+import {
+  DEFAULT_MEDIA_SAVE_MAX_BYTES,
+  DEFAULT_STRUCTURED_PAYLOAD_MAX_CHARS
+} from "./channel-types.js";
+import { getSiderRuntime } from "./channel-runtime.js";
+import { SIDER_CHANNEL_ID } from "./config.js";
+import { SIDER_PLUGIN_VERSION, SIDER_USER_AGENT } from "./user-agent.js";
+function hasFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function addUsageTotals(target, next) {
+  if (!next) {
+    return;
+  }
+  for (const field of ["input", "output", "cacheRead", "cacheWrite", "total"]) {
+    const value = next[field];
+    if (typeof value === "number" && Number.isFinite(value)) {
+      target[field] = (target[field] ?? 0) + value;
+    }
+  }
+}
+function hasUsageTotals(usage) {
+  if (!usage) {
+    return false;
+  }
+  return hasFiniteNumber(usage.input) || hasFiniteNumber(usage.output) || hasFiniteNumber(usage.cacheRead) || hasFiniteNumber(usage.cacheWrite) || hasFiniteNumber(usage.total);
+}
+function firstUsageCount(...values) {
+  for (const v of values) {
+    if (typeof v === "number" && Number.isFinite(v)) {
+      return Math.max(0, v);
+    }
+  }
+  return void 0;
+}
+function toJsonSafeValue(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(JSON.stringify(value));
+  } catch {
+    return String(value);
+  }
+}
+function clipText(text, maxChars = DEFAULT_STRUCTURED_PAYLOAD_MAX_CHARS) {
+  if (text.length <= maxChars) {
+    return text;
+  }
+  return `${text.slice(0, maxChars)}...`;
+}
+function appendStructuredPayloadField(payload, fieldName, value, maxChars = DEFAULT_STRUCTURED_PAYLOAD_MAX_CHARS) {
+  const safeValue = toJsonSafeValue(value);
+  if (safeValue === void 0) {
+    return;
+  }
+  let serialized = "";
+  try {
+    serialized = JSON.stringify(safeValue);
+  } catch {
+    serialized = String(safeValue);
+  }
+  if (!serialized) {
+    return;
+  }
+  if (serialized.length <= maxChars) {
+    payload[fieldName] = safeValue;
+    return;
+  }
+  payload[`${fieldName}_preview`] = clipText(serialized, maxChars);
+  payload[`${fieldName}_truncated`] = true;
+}
+function extractToolResultText(result) {
+  const record = toRecord(result);
+  const fromPartRecord = (part) => {
+    const candidateKeys = ["text", "content", "message", "output", "stdout"];
+    for (const key of candidateKeys) {
+      const value = part[key];
+      if (typeof value === "string" && value.trim()) {
+        return clipText(value.trim(), 4e3);
+      }
+    }
+    const nestedText = typeof part.text === "string" ? part.text : typeof part.value === "string" ? part.value : typeof part.output_text === "string" ? part.output_text : void 0;
+    if (nestedText?.trim()) {
+      return clipText(nestedText.trim(), 4e3);
+    }
+    return "";
+  };
+  const fromContentArray = (value) => {
+    if (!Array.isArray(value)) {
+      return "";
+    }
+    const chunks = [];
+    for (const item of value) {
+      if (typeof item === "string" && item.trim()) {
+        chunks.push(item.trim());
+        continue;
+      }
+      const part = toRecord(item);
+      if (!part) {
+        continue;
+      }
+      const text = fromPartRecord(part);
+      if (text) {
+        chunks.push(text);
+      }
+    }
+    return chunks.length > 0 ? clipText(chunks.join("\n\n"), 4e3) : "";
+  };
+  if (!record) {
+    return fromContentArray(result);
+  }
+  const direct = fromPartRecord(record);
+  if (direct) {
+    return direct;
+  }
+  const contentText = fromContentArray(record.content) || fromContentArray(record.message) || fromContentArray(record.output);
+  if (contentText) {
+    return contentText;
+  }
+  return "";
+}
+function collectMediaUrlStrings(value, sink, seen) {
+  if (!value) {
+    return;
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed && !seen.has(trimmed)) {
+      seen.add(trimmed);
+      sink.push(trimmed);
+    }
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      collectMediaUrlStrings(item, sink, seen);
+    }
+  }
+}
+function extractToolResultMediaUrls(result) {
+  const visited = [];
+  const seen = /* @__PURE__ */ new Set();
+  const record = toRecord(result);
+  if (!record) {
+    return visited;
+  }
+  const pools = [record];
+  const detailsCandidate = toRecord(record.details);
+  if (detailsCandidate) {
+    pools.push(detailsCandidate);
+  }
+  for (const pool of pools) {
+    const entry = pool;
+    collectMediaUrlStrings(entry.source, visited, seen);
+    collectMediaUrlStrings(entry.source_url, visited, seen);
+    collectMediaUrlStrings(entry.sourceUrl, visited, seen);
+    collectMediaUrlStrings(entry.source_path, visited, seen);
+    collectMediaUrlStrings(entry.sourcePath, visited, seen);
+    collectMediaUrlStrings(entry.download_url, visited, seen);
+    collectMediaUrlStrings(entry.downloadUrl, visited, seen);
+    collectMediaUrlStrings(entry.path, visited, seen);
+    const files = entry.files;
+    if (Array.isArray(files)) {
+      for (const file of files) {
+        const fileRecord = toRecord(file);
+        if (!fileRecord) {
+          continue;
+        }
+        collectMediaUrlStrings(fileRecord.source, visited, seen);
+        collectMediaUrlStrings(fileRecord.source_url, visited, seen);
+        collectMediaUrlStrings(fileRecord.sourceUrl, visited, seen);
+        collectMediaUrlStrings(fileRecord.source_path, visited, seen);
+        collectMediaUrlStrings(fileRecord.sourcePath, visited, seen);
+        collectMediaUrlStrings(fileRecord.download_url, visited, seen);
+        collectMediaUrlStrings(fileRecord.downloadUrl, visited, seen);
+        collectMediaUrlStrings(fileRecord.path, visited, seen);
+      }
+    }
+  }
+  return visited;
+}
+function toRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  return value;
+}
+function getSocketCloseInfo(closeInfo) {
+  if (!closeInfo || typeof closeInfo !== "object") {
+    return {};
+  }
+  return {
+    code: typeof closeInfo.code === "number" ? closeInfo.code : void 0,
+    reason: typeof closeInfo.reason === "string" ? closeInfo.reason : Buffer.isBuffer(closeInfo.reason) ? closeInfo.reason.toString("utf8") : void 0,
+    wasClean: typeof closeInfo.wasClean === "boolean" ? closeInfo.wasClean : void 0
+  };
+}
+function describeSocketClose(closeInfo) {
+  const { code, reason, wasClean } = getSocketCloseInfo(closeInfo);
+  const parts = [];
+  if (typeof code === "number") {
+    parts.push(`code=${code}`);
+  }
+  if (typeof reason === "string" && reason) {
+    parts.push(`reason=${reason}`);
+  }
+  if (typeof wasClean === "boolean") {
+    parts.push(`clean=${wasClean}`);
+  }
+  return parts.length > 0 ? ` (${parts.join(", ")})` : "";
+}
+function decodeBase64AttachmentBuffer(raw) {
+  const normalized = raw.trim();
+  if (!normalized) {
+    throw new Error("sider sendAttachment requires non-empty buffer");
+  }
+  const buffer = Buffer.from(normalized, "base64");
+  if (buffer.length === 0) {
+    throw new Error("sider sendAttachment requires valid non-empty base64 buffer");
+  }
+  return buffer;
+}
+async function updateSiderSessionTitle(params) {
+  const sessionId = params.sessionId.trim();
+  if (!sessionId) {
+    throw new Error("sider updateSessionTitle requires non-empty sessionId");
+  }
+  const title = params.title.trim();
+  if (!title) {
+    throw new Error("sider updateSessionTitle requires non-empty title");
+  }
+  const url = resolveSiderApiUrl(`/v1/sessions/${encodeURIComponent(sessionId)}`);
+  const response = await fetch(url, {
+    method: "PATCH",
+    headers: {
+      Authorization: formatAuthorizationHeader(params.authorization),
+      "Content-Type": "application/json",
+      "User-Agent": SIDER_USER_AGENT
+    },
+    body: JSON.stringify({ title })
+  });
+  if (!response.ok) {
+    let detail = "";
+    try {
+      const text = (await response.text()).trim();
+      if (text) {
+        detail = `: ${text}`;
+      }
+    } catch {
+    }
+    throw new Error(
+      `sider updateSessionTitle failed (${response.status} ${response.statusText})${detail}`
+    );
+  }
+}
+async function persistInlineAttachmentBuffer(params) {
+  const configuredMaxBytes = resolveChannelMediaMaxBytes({
+    cfg: params.cfg,
+    accountId: params.accountId,
+    resolveChannelLimitMb: () => void 0
+  });
+  const maxBytes = Math.max(
+    params.buffer.length,
+    configuredMaxBytes ?? 0,
+    DEFAULT_MEDIA_SAVE_MAX_BYTES
+  );
+  return await getSiderRuntime().channel.media.saveMediaBuffer(
+    params.buffer,
+    params.contentType,
+    "outbound",
+    maxBytes,
+    params.fileName
+  );
+}
+function parseTextFromPart(part) {
+  if (part.type !== "core.text") {
+    return null;
+  }
+  const payload = toRecord(part.payload);
+  if (payload?.text && typeof payload.text === "string") {
+    const text = payload.text.trim();
+    return text || null;
+  }
+  if (typeof part.payload === "string") {
+    const text = part.payload.trim();
+    return text || null;
+  }
+  return null;
+}
+function collectTextPartValues(parts) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const part of parts) {
+    const text = parseTextFromPart(part);
+    if (text) {
+      seen.add(text);
+    }
+  }
+  return seen;
+}
+function filterDuplicateTextParts(params) {
+  const seenTexts = params.seenTexts ?? /* @__PURE__ */ new Set();
+  const duplicateTexts = [];
+  const parts = [];
+  for (const part of params.parts) {
+    const text = parseTextFromPart(part);
+    if (!text) {
+      parts.push(part);
+      continue;
+    }
+    if (seenTexts.has(text)) {
+      duplicateTexts.push(text);
+      continue;
+    }
+    seenTexts.add(text);
+    parts.push(part);
+  }
+  return {
+    parts,
+    duplicateTexts,
+    seenTexts
+  };
+}
+function parseMediaFromPart(part) {
+  if (part.type !== "core.media" && part.type !== "core.file") {
+    return null;
+  }
+  const payload = toRecord(part.payload);
+  if (!payload) {
+    return null;
+  }
+  const readString = (value) => {
+    if (typeof value !== "string") {
+      return void 0;
+    }
+    const trimmed = value.trim();
+    return trimmed || void 0;
+  };
+  const url = readString(payload.download_url) ?? readString(payload.downloadUrl) ?? readString(payload.url) ?? readString(payload.resource_url) ?? readString(payload.resourceUrl) ?? readString(payload.media_url) ?? readString(payload.mediaUrl);
+  const objectKey = readString(payload.object_key) ?? readString(payload.objectKey);
+  const fileId = readString(payload.file_id) ?? readString(payload.fileId);
+  if (!url && !objectKey && !fileId) {
+    return null;
+  }
+  const mimeType = readString(payload.mime) ?? readString(payload.mime_type) ?? readString(payload.mimeType) ?? readString(payload.content_type) ?? readString(payload.contentType);
+  const fileName = readString(payload.name) ?? readString(payload.file_name) ?? readString(payload.fileName);
+  return {
+    ...url ? { url } : {},
+    ...objectKey ? { objectKey } : {},
+    ...fileId ? { fileId } : {},
+    ...mimeType ? { mimeType } : {},
+    ...fileName ? { fileName } : {}
+  };
+}
+function describeInboundMediaReference(item) {
+  if (item.url?.trim()) {
+    return item.url.trim();
+  }
+  if (item.objectKey?.trim()) {
+    return `sider-object-key:${item.objectKey.trim()}`;
+  }
+  if (item.fileId?.trim()) {
+    return `sider-file-id:${item.fileId.trim()}`;
+  }
+  return void 0;
+}
+function buildEventMeta(params) {
+  return {
+    channel: SIDER_CHANNEL_ID,
+    account_id: params.accountId,
+    plugin_version: SIDER_PLUGIN_VERSION,
+    schema_version: 1
+  };
+}
+function formatUsageForMessageMeta(usage) {
+  if (!hasUsageTotals(usage)) {
+    return void 0;
+  }
+  const result = {};
+  if (usage.input !== void 0) result.input = usage.input;
+  if (usage.output !== void 0) result.output = usage.output;
+  if (usage.cacheRead !== void 0) result.cache_read = usage.cacheRead;
+  if (usage.cacheWrite !== void 0) result.cache_write = usage.cacheWrite;
+  if (usage.total !== void 0) result.total = usage.total;
+  return result;
+}
+function parseUsageTotals(value) {
+  const record = toRecord(value);
+  if (!record) {
+    return void 0;
+  }
+  const cacheDetails = toRecord(record.prompt_tokens_details) ?? toRecord(record.promptTokensDetails);
+  const input = firstUsageCount(record.input, record.input_tokens, record.inputTokens);
+  const output = firstUsageCount(record.output, record.output_tokens, record.outputTokens);
+  const cacheRead = firstUsageCount(
+    record.cacheRead,
+    record.cache_read,
+    record.cache_read_input_tokens,
+    cacheDetails?.cached_tokens
+  );
+  const cacheWrite = firstUsageCount(
+    record.cacheWrite,
+    record.cache_write,
+    record.cache_creation_input_tokens
+  );
+  const total = firstUsageCount(record.total, record.total_tokens, record.totalTokens);
+  const usage = {};
+  if (input !== void 0) usage.input = input;
+  if (output !== void 0) usage.output = output;
+  if (cacheRead !== void 0) usage.cacheRead = cacheRead;
+  if (cacheWrite !== void 0) usage.cacheWrite = cacheWrite;
+  if (total !== void 0) {
+    usage.total = total;
+  } else if (hasUsageTotals(usage)) {
+    usage.total = (usage.input ?? 0) + (usage.output ?? 0) + (usage.cacheRead ?? 0) + (usage.cacheWrite ?? 0);
+  }
+  return hasUsageTotals(usage) ? usage : void 0;
+}
+function choosePreferredUsageTotals(...candidates) {
+  return candidates.find((c) => c && hasUsageTotals(c));
+}
+function parseUsageFromAssistantLike(value) {
+  const record = toRecord(value);
+  if (!record) {
+    return void 0;
+  }
+  const meta = toRecord(record.meta);
+  const agentMeta = toRecord(meta?.agentMeta) ?? toRecord(meta?.agent_meta) ?? toRecord(record.agentMeta) ?? toRecord(record.agent_meta);
+  return choosePreferredUsageTotals(
+    parseUsageTotals(record.usage),
+    parseUsageTotals(meta?.usage),
+    parseUsageTotals(meta?.lastCallUsage),
+    parseUsageTotals(meta?.last_call_usage),
+    parseUsageTotals(agentMeta?.usage),
+    parseUsageTotals(agentMeta?.lastCallUsage),
+    parseUsageTotals(agentMeta?.last_call_usage)
+  );
+}
+function buildMessageMeta(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;
+  }
+  if (params.stopReason) {
+    meta.stop_reason = params.stopReason;
+  }
+  const usage = formatUsageForMessageMeta(params.runState?.usage);
+  if (usage) {
+    meta.usage = usage;
+  }
+  return meta;
+}
+function isAbortedAssistantStopReason(stopReason) {
+  return stopReason?.trim().toLowerCase() === "aborted";
+}
+function parseAssistantOutput(lastAssistant) {
+  const assistant = toRecord(lastAssistant);
+  if (!assistant) {
+    return null;
+  }
+  const content = Array.isArray(assistant.content) ? assistant.content : [];
+  const thinkingChunks = [];
+  const toolCalls = [];
+  const seenToolCalls = /* @__PURE__ */ new Set();
+  const pushToolCall = (candidate) => {
+    const dedupeKey = `${candidate.toolCallId?.trim() || ""}::${candidate.toolName?.trim() || ""}`;
+    if (seenToolCalls.has(dedupeKey)) {
+      return;
+    }
+    seenToolCalls.add(dedupeKey);
+    toolCalls.push({
+      toolName: candidate.toolName?.trim() || void 0,
+      toolCallId: candidate.toolCallId?.trim() || void 0,
+      toolArgs: candidate.toolArgs
+    });
+  };
+  for (const item of content) {
+    const part = toRecord(item);
+    if (!part) {
+      continue;
+    }
+    const partType = typeof part.type === "string" ? part.type.trim() : "";
+    if (partType === "thinking" || partType === "reasoning" || partType === "reasoning_text") {
+      const thinking = typeof part.thinking === "string" ? part.thinking.trim() : "";
+      const fallbackText = typeof part.text === "string" ? part.text.trim() : "";
+      const resolvedThinking = thinking || fallbackText;
+      if (resolvedThinking) {
+        thinkingChunks.push(resolvedThinking);
+      }
+      continue;
+    }
+    if (partType !== "toolCall" && partType !== "toolUse" && partType !== "tool_call" && partType !== "tool_use" && partType !== "tool-call" && partType !== "tool-use" && partType !== "functionCall" && partType !== "function_call" && partType !== "function-call" && partType !== "output_tool_call") {
+      continue;
+    }
+    const fn = toRecord(part.function);
+    const toolName = typeof part.toolName === "string" ? part.toolName.trim() : typeof part.name === "string" ? part.name.trim() : typeof fn?.name === "string" ? fn.name.trim() : "";
+    const toolCallId = typeof part.toolCallId === "string" ? part.toolCallId.trim() : typeof part.toolUseId === "string" ? part.toolUseId.trim() : typeof part.callId === "string" ? part.callId.trim() : typeof part.id === "string" ? part.id.trim() : void 0;
+    const rawArguments = typeof fn?.arguments === "string" ? (() => {
+      try {
+        return JSON.parse(fn.arguments);
+      } catch {
+        return fn.arguments;
+      }
+    })() : fn?.arguments;
+    pushToolCall({
+      toolName: toolName || void 0,
+      toolCallId: toolCallId || void 0,
+      toolArgs: rawArguments ?? part.arguments ?? part.input ?? part.args ?? part.parameters
+    });
+  }
+  const topLevelToolCalls = Array.isArray(assistant.tool_calls) ? assistant.tool_calls : [];
+  for (const item of topLevelToolCalls) {
+    const part = toRecord(item);
+    if (!part) {
+      continue;
+    }
+    const fn = toRecord(part.function);
+    const rawArguments = typeof fn?.arguments === "string" ? (() => {
+      try {
+        return JSON.parse(fn.arguments);
+      } catch {
+        return fn.arguments;
+      }
+    })() : fn?.arguments;
+    pushToolCall({
+      toolName: typeof fn?.name === "string" ? fn.name : typeof part.toolName === "string" ? part.toolName : void 0,
+      toolCallId: typeof part.id === "string" ? part.id : typeof part.toolCallId === "string" ? part.toolCallId : typeof part.toolUseId === "string" ? part.toolUseId : void 0,
+      toolArgs: rawArguments ?? part.arguments ?? part.input ?? part.args ?? part.parameters
+    });
+  }
+  const stopReason = typeof assistant.stopReason === "string" ? assistant.stopReason.trim() : "";
+  const fallbackThinking = typeof assistant.reasoning_content === "string" ? assistant.reasoning_content.trim() : "";
+  return {
+    stopReason: stopReason || void 0,
+    thinkingText: thinkingChunks.join("\n\n").trim() || fallbackThinking || void 0,
+    toolCalls
+  };
+}
+function mergeTextSegments(previous, next) {
+  if (!next) {
+    return previous;
+  }
+  if (!previous) {
+    return next;
+  }
+  if (next === previous) {
+    return previous;
+  }
+  if (next.startsWith(previous)) {
+    return next;
+  }
+  if (previous.startsWith(next) || previous.includes(next)) {
+    return previous;
+  }
+  if (next.includes(previous)) {
+    return next;
+  }
+  const maxOverlap = Math.min(previous.length, next.length);
+  for (let overlap = maxOverlap; overlap > 0; overlap -= 1) {
+    if (previous.endsWith(next.slice(0, overlap))) {
+      return previous + next.slice(overlap);
+    }
+  }
+  return previous + next;
+}
+export {
+  addUsageTotals,
+  appendStructuredPayloadField,
+  buildEventMeta,
+  buildMessageMeta,
+  choosePreferredUsageTotals,
+  clipText,
+  collectTextPartValues,
+  decodeBase64AttachmentBuffer,
+  describeInboundMediaReference,
+  describeSocketClose,
+  extractToolResultMediaUrls,
+  extractToolResultText,
+  filterDuplicateTextParts,
+  firstUsageCount,
+  formatUsageForMessageMeta,
+  getSocketCloseInfo,
+  hasFiniteNumber,
+  hasUsageTotals,
+  isAbortedAssistantStopReason,
+  mergeTextSegments,
+  parseAssistantOutput,
+  parseMediaFromPart,
+  parseTextFromPart,
+  parseUsageFromAssistantLike,
+  parseUsageTotals,
+  persistInlineAttachmentBuffer,
+  toJsonSafeValue,
+  toRecord,
+  updateSiderSessionTitle
+};

package/dist/src/channel.d.ts

@@ -0,0 +1,14 @@
+import { ChannelPlugin } from 'openclaw/plugin-sdk';
+import { R as ResolvedSiderAccount } from '../account-cW9SLuNu.js';
+export { setSiderRuntime } from './channel-runtime.js';
+export { emitSiderToolHookEvent, recordSiderAgentEnd, recordSiderLlmOutputUsage, recordSiderPersistedAgentMessage } from './channel-hooks.js';
+import 'openclaw/plugin-sdk/setup';
+import './auth.js';
+import 'openclaw/plugin-sdk/plugin-entry';
+import 'openclaw/plugin-sdk/config-runtime';
+import 'ws';
+import './channel-types.js';
+
+declare const siderPlugin: ChannelPlugin<ResolvedSiderAccount>;
+
+export { siderPlugin };