@sider-ai/chrome-openclaw-sider 1.0.31

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

@@ -0,0 +1,209 @@
+import { OpenClawConfig, ReplyPayload, ChannelPlugin } from 'openclaw/plugin-sdk';
+import { R as ResolvedSiderAccount } from '../account-cW9SLuNu.js';
+import { WebSocket } from 'ws';
+import 'openclaw/plugin-sdk/setup';
+import './auth.js';
+import 'openclaw/plugin-sdk/plugin-entry';
+import 'openclaw/plugin-sdk/config-runtime';
+
+type ChannelMeta = ChannelPlugin["meta"];
+declare const DEFAULT_MEDIA_SAVE_MAX_BYTES: number;
+declare const DEFAULT_MEDIA_UPLOAD_SKIP_MAX_BYTES: number;
+declare const DEFAULT_MONITOR_KEEPALIVE_MS = 10000;
+declare const DEFAULT_MONITOR_PONG_TIMEOUT_MS = 30000;
+declare const DEFAULT_STRUCTURED_PAYLOAD_MAX_CHARS = 12000;
+declare const SIDER_SESSION_BINDING_TTL_MS: number;
+declare const SIDER_SESSION_BINDING_MAX = 512;
+declare const SIDER_RUN_STATE_TTL_MS: number;
+declare const SIDER_RUN_STATE_MAX = 1024;
+type SiderPart = {
+    id?: string;
+    type: string;
+    spec_version?: number;
+    payload?: unknown;
+    meta?: unknown;
+};
+type SiderAggregation = {
+    id: string;
+    index: number;
+    final: boolean;
+};
+type SiderInboundAck = {
+    type: "ack";
+    session_id?: string;
+    id?: string;
+    client_req_id?: string;
+};
+type SiderInboundRealtimeMessage = {
+    type: "message";
+    session_id?: string;
+    message_id?: string;
+    source_role?: string;
+    created_at?: number;
+    aggregation?: SiderAggregation;
+    parts?: SiderPart[];
+    meta?: Record<string, unknown>;
+};
+type SiderInboundRealtimeEvent = {
+    type: "event";
+    session_id?: string;
+    event_id?: string;
+    event_type?: string;
+    source_role?: string;
+    created_at?: number;
+    payload?: unknown;
+    meta?: unknown;
+};
+type SiderSampleEvent = {
+    eventType: string;
+    payload: Record<string, unknown>;
+    meta?: Record<string, unknown>;
+};
+type SiderUsageTotals = {
+    input?: number;
+    output?: number;
+    cacheRead?: number;
+    cacheWrite?: number;
+    total?: number;
+};
+type SiderParsedToolCall = {
+    toolName?: string;
+    toolCallId?: string;
+    toolArgs?: unknown;
+};
+type SiderParsedAssistantOutput = {
+    stopReason?: string;
+    thinkingText?: string;
+    toolCalls: SiderParsedToolCall[];
+};
+type SiderRunState = {
+    runId: string;
+    aggregationId: string;
+    nextAggregationIndex: number;
+    managedByReplyPipeline: boolean;
+    sessionKey?: string;
+    sessionId?: string;
+    accountId?: string;
+    provider?: string;
+    model?: string;
+    usage: SiderUsageTotals;
+    queuedMessageParts: SiderPart[];
+    messageFlushChain: Promise<void>;
+    flushScheduled: boolean;
+    pendingFinalText?: string;
+    pendingFinalThinking?: string;
+    pendingFinalStopReason?: string;
+    updatedAt: number;
+};
+type SiderRealtimeLaneState = {
+    active: boolean;
+    streamId?: string;
+    seq: number;
+};
+type SiderAnswerRealtimeLaneState = SiderRealtimeLaneState & {
+    blockDeltaCount: number;
+    partialDeltaCount: number;
+    streamDeltaMode: "undecided" | "partial" | "block";
+    partialSnapshot: string;
+    accumulatedBlockText: string;
+    assistantSeq: number;
+    fallbackAssistantSeq: number;
+    fallbackTextSource: "none" | "stream" | "final_payload";
+    fallbackCurrentText: string;
+    fallbackTextPrefix: string;
+};
+type SiderReasoningRealtimeLaneState = SiderRealtimeLaneState & {
+    snapshot: string;
+    deltaCount: number;
+};
+type SiderStreamState = {
+    answer: SiderAnswerRealtimeLaneState;
+    reasoning: SiderReasoningRealtimeLaneState;
+    persistedFinalText: boolean;
+    pendingFinalPayloads: ReplyPayload[];
+    sessionKey?: string;
+    currentRunId?: string;
+    streamEventQueue: Promise<void>;
+};
+type SiderSessionBinding = {
+    account: ResolvedSiderAccount;
+    sessionId: string;
+    lastSeenAt: number;
+    toolSeq: number;
+    currentRunId?: string;
+    currentToolCallId?: string;
+    callIdByToolCallId: Map<string, string>;
+};
+type SiderToolHookPayload = {
+    sessionKey?: string;
+    phase: "start" | "end" | "error";
+    toolName?: string;
+    toolCallId?: string;
+    runId?: string;
+    params?: Record<string, unknown>;
+    result?: unknown;
+    error?: string;
+    durationMs?: number;
+};
+type SiderInboundReplaced = {
+    type: "replaced";
+    reason?: string;
+};
+type SiderInboundPing = {
+    type: "ping";
+};
+type SiderInboundPong = {
+    type: "pong";
+};
+type SiderInboundFrame = SiderInboundAck | SiderInboundRealtimeMessage | SiderInboundRealtimeEvent | SiderInboundReplaced | SiderInboundPing | SiderInboundPong;
+type SiderPendingAck = {
+    sessionId: string;
+    clientReqId?: string;
+    timeout: ReturnType<typeof setTimeout>;
+    resolve: (id: string) => void;
+    reject: (err: Error) => void;
+};
+type SiderRelaySocketReadyWaiter = {
+    timeout: ReturnType<typeof setTimeout>;
+    resolve: (ws: WebSocket) => void;
+    reject: (err: Error) => void;
+};
+type SiderRelaySocketState = {
+    ws: WebSocket | null;
+    accountSignature?: string;
+    relayId?: string;
+    pendingAcksBySession: Map<string, SiderPendingAck[]>;
+    pendingAcksByClientReqId: Map<string, SiderPendingAck>;
+    readyWaiters: Set<SiderRelaySocketReadyWaiter>;
+};
+type SiderMonitorLogger = {
+    info: (msg: string) => void;
+    warn: (msg: string) => void;
+    error: (msg: string) => void;
+};
+type SiderInboundMessageHandler = (params: {
+    cfg: OpenClawConfig;
+    account: ResolvedSiderAccount;
+    event: SiderInboundRealtimeMessage;
+}) => Promise<void>;
+type SiderRelayMonitorRegistration = {
+    cfg: OpenClawConfig;
+    account: ResolvedSiderAccount;
+    monitorSignature: string;
+    subscribers: Set<string>;
+    controller: AbortController;
+    runner: Promise<void>;
+    restartRequested: boolean;
+    log?: SiderMonitorLogger;
+    onInboundMessage?: SiderInboundMessageHandler;
+};
+type ParsedInboundMedia = {
+    url?: string;
+    mimeType?: string;
+    fileName?: string;
+    objectKey?: string;
+    fileId?: string;
+};
+declare const meta: ChannelMeta;
+
+export { DEFAULT_MEDIA_SAVE_MAX_BYTES, DEFAULT_MEDIA_UPLOAD_SKIP_MAX_BYTES, DEFAULT_MONITOR_KEEPALIVE_MS, DEFAULT_MONITOR_PONG_TIMEOUT_MS, DEFAULT_STRUCTURED_PAYLOAD_MAX_CHARS, type ParsedInboundMedia, SIDER_RUN_STATE_MAX, SIDER_RUN_STATE_TTL_MS, SIDER_SESSION_BINDING_MAX, SIDER_SESSION_BINDING_TTL_MS, type SiderAggregation, type SiderAnswerRealtimeLaneState, type SiderInboundAck, type SiderInboundFrame, type SiderInboundMessageHandler, type SiderInboundPing, type SiderInboundPong, type SiderInboundRealtimeEvent, type SiderInboundRealtimeMessage, type SiderInboundReplaced, type SiderMonitorLogger, type SiderParsedAssistantOutput, type SiderParsedToolCall, type SiderPart, type SiderPendingAck, type SiderRealtimeLaneState, type SiderReasoningRealtimeLaneState, type SiderRelayMonitorRegistration, type SiderRelaySocketReadyWaiter, type SiderRelaySocketState, type SiderRunState, type SiderSampleEvent, type SiderSessionBinding, type SiderStreamState, type SiderToolHookPayload, type SiderUsageTotals, meta };

package/dist/src/channel-types.js

@@ -0,0 +1,40 @@
+import {
+  SIDER_CHANNEL_ALIASES,
+  SIDER_CHANNEL_BLURB,
+  SIDER_CHANNEL_DOCS_LABEL,
+  SIDER_CHANNEL_DOCS_PATH,
+  SIDER_CHANNEL_ID,
+  SIDER_CHANNEL_LABEL,
+  SIDER_CHANNEL_SELECTION_LABEL
+} from "./config.js";
+const DEFAULT_MEDIA_SAVE_MAX_BYTES = 20 * 1024 * 1024 * 1024;
+const DEFAULT_MEDIA_UPLOAD_SKIP_MAX_BYTES = 1024 * 1024 * 1024;
+const DEFAULT_MONITOR_KEEPALIVE_MS = 1e4;
+const DEFAULT_MONITOR_PONG_TIMEOUT_MS = 3e4;
+const DEFAULT_STRUCTURED_PAYLOAD_MAX_CHARS = 12e3;
+const SIDER_SESSION_BINDING_TTL_MS = 6 * 60 * 60 * 1e3;
+const SIDER_SESSION_BINDING_MAX = 512;
+const SIDER_RUN_STATE_TTL_MS = 6 * 60 * 60 * 1e3;
+const SIDER_RUN_STATE_MAX = 1024;
+const meta = {
+  id: SIDER_CHANNEL_ID,
+  label: SIDER_CHANNEL_LABEL,
+  selectionLabel: SIDER_CHANNEL_SELECTION_LABEL,
+  docsPath: SIDER_CHANNEL_DOCS_PATH,
+  docsLabel: SIDER_CHANNEL_DOCS_LABEL,
+  blurb: SIDER_CHANNEL_BLURB,
+  aliases: [...SIDER_CHANNEL_ALIASES],
+  order: 97
+};
+export {
+  DEFAULT_MEDIA_SAVE_MAX_BYTES,
+  DEFAULT_MEDIA_UPLOAD_SKIP_MAX_BYTES,
+  DEFAULT_MONITOR_KEEPALIVE_MS,
+  DEFAULT_MONITOR_PONG_TIMEOUT_MS,
+  DEFAULT_STRUCTURED_PAYLOAD_MAX_CHARS,
+  SIDER_RUN_STATE_MAX,
+  SIDER_RUN_STATE_TTL_MS,
+  SIDER_SESSION_BINDING_MAX,
+  SIDER_SESSION_BINDING_TTL_MS,
+  meta
+};

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

@@ -0,0 +1,17 @@
+import { R as ResolvedSiderAccount } from '../account-cW9SLuNu.js';
+import 'openclaw/plugin-sdk/setup';
+import './auth.js';
+import 'openclaw/plugin-sdk';
+import 'openclaw/plugin-sdk/plugin-entry';
+import 'openclaw/plugin-sdk/config-runtime';
+
+declare function acquireSiderTyping(params: {
+    account: ResolvedSiderAccount;
+    sessionId: string;
+}): void;
+declare function releaseSiderTyping(params: {
+    account: ResolvedSiderAccount;
+    sessionId: string;
+}): void;
+
+export { acquireSiderTyping, releaseSiderTyping };

package/dist/src/channel-typing.js

@@ -0,0 +1,79 @@
+import { buildTypingEvent } from "./channel-builders.js";
+import { sendSiderEventBestEffort } from "./channel-relay.js";
+import { logWarn } from "./channel-runtime.js";
+const KEEPALIVE_INTERVAL_MS = 2500;
+const states = /* @__PURE__ */ new Map();
+const resolveKey = (accountId, sessionId) => `${accountId}:${sessionId}`;
+function fireTyping(state, typingState, context) {
+  const event = buildTypingEvent({
+    state: typingState,
+    sessionId: state.sessionId,
+    accountId: state.account.accountId
+  });
+  void sendSiderEventBestEffort({
+    account: state.account,
+    sessionId: state.sessionId,
+    event,
+    context
+  }).catch(
+    (err) => logWarn(`sider ${context} failed`, {
+      accountId: state.account.accountId,
+      sessionId: state.sessionId,
+      error: String(err)
+    })
+  );
+}
+function acquireSiderTyping(params) {
+  const accountId = params.account.accountId;
+  const sessionId = params.sessionId;
+  if (!accountId || !sessionId) {
+    return;
+  }
+  const key = resolveKey(accountId, sessionId);
+  let state = states.get(key);
+  if (!state) {
+    state = {
+      key,
+      account: params.account,
+      sessionId,
+      refCount: 0
+    };
+    states.set(key, state);
+  } else {
+    state.account = params.account;
+  }
+  state.refCount += 1;
+  if (state.refCount === 1) {
+    fireTyping(state, "typing", "typing.start");
+    state.keepaliveTimer = setInterval(
+      () => fireTyping(state, "typing", "typing.keepalive"),
+      KEEPALIVE_INTERVAL_MS
+    );
+  }
+}
+function releaseSiderTyping(params) {
+  const accountId = params.account.accountId;
+  const sessionId = params.sessionId;
+  if (!accountId || !sessionId) {
+    return;
+  }
+  const key = resolveKey(accountId, sessionId);
+  const state = states.get(key);
+  if (!state || state.refCount <= 0) {
+    return;
+  }
+  state.refCount -= 1;
+  if (state.refCount > 0) {
+    return;
+  }
+  if (state.keepaliveTimer) {
+    clearInterval(state.keepaliveTimer);
+    state.keepaliveTimer = void 0;
+  }
+  fireTyping(state, "idle", "typing.stop");
+  states.delete(state.key);
+}
+export {
+  acquireSiderTyping,
+  releaseSiderTyping
+};

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

@@ -0,0 +1,78 @@
+import { OpenClawConfig } from 'openclaw/plugin-sdk';
+import { SiderUsageTotals, SiderRunState, SiderPart, ParsedInboundMedia, SiderParsedAssistantOutput } from './channel-types.js';
+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 hasFiniteNumber(value: unknown): value is number;
+declare function addUsageTotals(target: SiderUsageTotals, next?: SiderUsageTotals): void;
+declare function hasUsageTotals(usage?: SiderUsageTotals): boolean;
+declare function firstUsageCount(...values: unknown[]): number | undefined;
+declare function toJsonSafeValue(value: unknown): unknown;
+declare function clipText(text: string, maxChars?: number): string;
+declare function appendStructuredPayloadField(payload: Record<string, unknown>, fieldName: string, value: unknown, maxChars?: number): void;
+declare function extractToolResultText(result: unknown): string;
+declare function extractToolResultMediaUrls(result: unknown): string[];
+declare function toRecord(value: unknown): Record<string, unknown> | null;
+declare function getSocketCloseInfo(closeInfo?: {
+    code?: number;
+    reason?: string | Buffer;
+    wasClean?: boolean;
+}): {
+    code?: number;
+    reason?: string;
+    wasClean?: boolean;
+};
+declare function describeSocketClose(closeInfo?: {
+    code?: number;
+    reason?: string | Buffer;
+    wasClean?: boolean;
+}): string;
+declare function decodeBase64AttachmentBuffer(raw: string): Buffer;
+declare function updateSiderSessionTitle(params: {
+    sessionId: string;
+    title: string;
+    authorization: string;
+}): Promise<void>;
+declare function persistInlineAttachmentBuffer(params: {
+    cfg: OpenClawConfig;
+    accountId?: string | null;
+    buffer: Buffer;
+    contentType?: string;
+    fileName?: string;
+}): Promise<{
+    path: string;
+    contentType?: string;
+}>;
+declare function parseTextFromPart(part: SiderPart): string | null;
+declare function collectTextPartValues(parts: readonly SiderPart[]): Set<string>;
+declare function filterDuplicateTextParts(params: {
+    parts: readonly SiderPart[];
+    seenTexts?: Set<string>;
+}): {
+    parts: SiderPart[];
+    duplicateTexts: string[];
+    seenTexts: Set<string>;
+};
+declare function parseMediaFromPart(part: SiderPart): ParsedInboundMedia | null;
+declare function describeInboundMediaReference(item: ParsedInboundMedia): string | undefined;
+declare function buildEventMeta(params: {
+    accountId: string;
+}): Record<string, unknown>;
+declare function formatUsageForMessageMeta(usage?: SiderUsageTotals): Record<string, unknown> | undefined;
+declare function parseUsageTotals(value: unknown): SiderUsageTotals | undefined;
+declare function choosePreferredUsageTotals(...candidates: Array<SiderUsageTotals | undefined>): SiderUsageTotals | undefined;
+declare function parseUsageFromAssistantLike(value: unknown): SiderUsageTotals | undefined;
+declare function buildMessageMeta(params: {
+    accountId: string;
+    runState?: SiderRunState;
+    stopReason?: string;
+}): Record<string, unknown>;
+declare function isAbortedAssistantStopReason(stopReason?: string): boolean;
+declare function parseAssistantOutput(lastAssistant: unknown): SiderParsedAssistantOutput | null;
+declare function mergeTextSegments(previous: string, next: string): string;
+
+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 };