@sider-ai/chrome-openclaw-sider 1.0.31

package/dist/src/channel-session-model.js

@@ -0,0 +1,244 @@
+function normalizeOptionalString(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function normalizeKey(value) {
+  return normalizeOptionalString(value)?.toLowerCase() ?? "";
+}
+function resolvePrimaryStringValue(value) {
+  if (typeof value === "string") {
+    return normalizeOptionalString(value);
+  }
+  if (!value || typeof value !== "object") {
+    return void 0;
+  }
+  return normalizeOptionalString(value.primary);
+}
+function parseModelRef(raw, fallbackProvider) {
+  const trimmed = normalizeOptionalString(raw);
+  if (!trimmed) {
+    return void 0;
+  }
+  const slashIndex = trimmed.indexOf("/");
+  if (slashIndex > 0 && slashIndex < trimmed.length - 1) {
+    const provider = trimmed.slice(0, slashIndex).trim();
+    const model = trimmed.slice(slashIndex + 1).trim();
+    if (provider && model) {
+      return { provider, model };
+    }
+  }
+  const fallback = normalizeOptionalString(fallbackProvider);
+  if (!fallback) {
+    return void 0;
+  }
+  return { provider: fallback, model: trimmed };
+}
+function resolveConfiguredModelAlias(cfg, raw) {
+  const models = cfg.agents?.defaults?.models;
+  if (!models || typeof models !== "object") {
+    return void 0;
+  }
+  const wanted = normalizeKey(raw);
+  if (!wanted) {
+    return void 0;
+  }
+  const exactAliasMatches = [];
+  const bareIdMatches = [];
+  for (const [modelRef, entry] of Object.entries(models)) {
+    const parsed = parseModelRef(modelRef);
+    if (!parsed) {
+      continue;
+    }
+    const alias = normalizeKey(entry?.alias);
+    if (alias && alias === wanted) {
+      exactAliasMatches.push(parsed);
+      continue;
+    }
+    const bareId = normalizeKey(parsed.model);
+    if (bareId && bareId === wanted) {
+      bareIdMatches.push(parsed);
+    }
+  }
+  if (exactAliasMatches.length === 1) {
+    return exactAliasMatches[0];
+  }
+  if (exactAliasMatches.length > 1) {
+    return void 0;
+  }
+  return bareIdMatches.length === 1 ? bareIdMatches[0] : void 0;
+}
+function resolveConfiguredDefaultModel(cfg, agentId) {
+  const normalizedAgentId = normalizeKey(agentId);
+  const agentRaw = cfg.agents?.list?.find((entry) => normalizeKey(entry?.id) === normalizedAgentId)?.model ?? void 0;
+  const raw = resolvePrimaryStringValue(agentRaw) ?? resolvePrimaryStringValue(cfg.agents?.defaults?.model);
+  if (!raw) {
+    return void 0;
+  }
+  return parseModelRef(raw) ?? resolveConfiguredModelAlias(cfg, raw);
+}
+function normalizeStoredOverride(params) {
+  const providerOverride = normalizeOptionalString(params.providerOverride);
+  const modelOverrideRaw = normalizeOptionalString(params.modelOverride);
+  if (!providerOverride || !modelOverrideRaw) {
+    return {
+      providerOverride,
+      modelOverride: modelOverrideRaw
+    };
+  }
+  const prefix = `${providerOverride.toLowerCase()}/`;
+  return {
+    providerOverride,
+    modelOverride: modelOverrideRaw.toLowerCase().startsWith(prefix) ? modelOverrideRaw.slice(providerOverride.length + 1).trim() || modelOverrideRaw : modelOverrideRaw
+  };
+}
+function formatModelRef(model) {
+  return `${model.provider}/${model.model}`;
+}
+function sameModelRef(left, right) {
+  if (!left || !right) {
+    return false;
+  }
+  return normalizeKey(left.provider) === normalizeKey(right.provider) && left.model === right.model;
+}
+function resolveManagedOverrideModel(entry) {
+  const normalized = normalizeStoredOverride({
+    providerOverride: entry.providerOverride,
+    modelOverride: entry.modelOverride
+  });
+  if (normalizeKey(entry.modelOverrideSource) !== "auto") {
+    return void 0;
+  }
+  const model = normalized.modelOverride;
+  if (!model) {
+    return void 0;
+  }
+  return parseModelRef(model, normalized.providerOverride);
+}
+function resolveRuntimeModel(entry, cfg) {
+  const runtimeModel = normalizeOptionalString(entry.model);
+  if (!runtimeModel) {
+    return void 0;
+  }
+  const runtimeProvider = normalizeOptionalString(entry.modelProvider);
+  return parseModelRef(runtimeModel, runtimeProvider) ?? (runtimeProvider ? { provider: runtimeProvider, model: runtimeModel } : void 0) ?? resolveConfiguredModelAlias(cfg, runtimeModel);
+}
+function hasLegacyOrUserOverride(entry) {
+  const hasOverride = Boolean(normalizeOptionalString(entry.providerOverride)) || Boolean(normalizeOptionalString(entry.modelOverride));
+  if (!hasOverride) {
+    return false;
+  }
+  return normalizeKey(entry.modelOverrideSource) !== "auto";
+}
+function clearManagedModelState(entry) {
+  let changed = false;
+  for (const key of [
+    "providerOverride",
+    "modelOverride",
+    "modelOverrideSource",
+    "modelProvider",
+    "model",
+    "contextTokens"
+  ]) {
+    if (entry[key] !== void 0) {
+      delete entry[key];
+      changed = true;
+    }
+  }
+  if (changed) {
+    entry.updatedAt = Date.now();
+  }
+  return changed;
+}
+async function mutateSessionEntry(params) {
+  const store = params.runtime.agent.session.loadSessionStore(params.storePath, {
+    skipCache: true
+  });
+  const entry = store[params.sessionKey];
+  if (!entry) {
+    return false;
+  }
+  const changed = params.mutate(entry);
+  if (!changed) {
+    return false;
+  }
+  await params.runtime.agent.session.saveSessionStore(params.storePath, store);
+  return true;
+}
+async function maybeResetSiderSessionToCurrentDefaultModel(params) {
+  const sessionKey = normalizeOptionalString(params.sessionKey);
+  if (!sessionKey) {
+    return { changed: false, reason: "missing-session-key" };
+  }
+  const defaultModel = resolveConfiguredDefaultModel(params.cfg, params.agentId);
+  if (!defaultModel) {
+    return { changed: false, reason: "default-model-unresolved" };
+  }
+  const storePath = params.runtime.agent.session.resolveStorePath(params.cfg.session?.store, {
+    agentId: params.agentId
+  });
+  const store = params.runtime.agent.session.loadSessionStore(storePath, {
+    skipCache: true
+  });
+  const entry = store[sessionKey];
+  if (!entry) {
+    return { changed: false, reason: "session-missing" };
+  }
+  if (entry.liveModelSwitchPending === true) {
+    return { changed: false, reason: "live-switch-pending" };
+  }
+  if (hasLegacyOrUserOverride(entry)) {
+    return { changed: false, reason: "preserve-user-override" };
+  }
+  const autoOverride = resolveManagedOverrideModel(entry);
+  if (autoOverride && !sameModelRef(autoOverride, defaultModel)) {
+    const previousModel2 = formatModelRef(autoOverride);
+    const changed2 = await mutateSessionEntry({
+      runtime: params.runtime,
+      storePath,
+      sessionKey,
+      mutate: (mutableEntry) => {
+        if (mutableEntry.liveModelSwitchPending === true || hasLegacyOrUserOverride(mutableEntry)) {
+          return false;
+        }
+        return clearManagedModelState(mutableEntry);
+      }
+    });
+    return changed2 ? {
+      changed: true,
+      reason: "auto-override",
+      previousModel: previousModel2,
+      defaultModel: formatModelRef(defaultModel)
+    } : { changed: false, reason: "auto-override-noop" };
+  }
+  const runtimeModel = resolveRuntimeModel(entry, params.cfg);
+  if (!runtimeModel || sameModelRef(runtimeModel, defaultModel)) {
+    return { changed: false, reason: runtimeModel ? "runtime-aligned" : "runtime-missing" };
+  }
+  const previousModel = formatModelRef(runtimeModel);
+  const changed = await mutateSessionEntry({
+    runtime: params.runtime,
+    storePath,
+    sessionKey,
+    mutate: (mutableEntry) => {
+      if (mutableEntry.liveModelSwitchPending === true || hasLegacyOrUserOverride(mutableEntry)) {
+        return false;
+      }
+      if (resolveManagedOverrideModel(mutableEntry)) {
+        return false;
+      }
+      return clearManagedModelState(mutableEntry);
+    }
+  });
+  return changed ? {
+    changed: true,
+    reason: "runtime-model",
+    previousModel,
+    defaultModel: formatModelRef(defaultModel)
+  } : { changed: false, reason: "runtime-noop" };
+}
+export {
+  maybeResetSiderSessionToCurrentDefaultModel
+};

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

@@ -0,0 +1,153 @@
+import * as openclaw_plugin_sdk from 'openclaw/plugin-sdk';
+import { R as ResolvedSiderAccount } from '../account-cW9SLuNu.js';
+import 'openclaw/plugin-sdk/setup';
+import './auth.js';
+import 'openclaw/plugin-sdk/plugin-entry';
+import 'openclaw/plugin-sdk/config-runtime';
+
+declare const siderChannelPluginCommon: {
+    meta: {
+        id: string;
+        label: string;
+        selectionLabel: string;
+        docsPath: string;
+        docsLabel: string;
+        blurb: string;
+        aliases: "sider"[];
+        order: number;
+    };
+    setupWizard: openclaw_plugin_sdk.ChannelSetupWizard;
+    setup: openclaw_plugin_sdk.ChannelSetupAdapter;
+    capabilities: {
+        chatTypes: "direct"[];
+        threads: false;
+        media: true;
+        blockStreaming: true;
+    };
+    configSchema: {
+        schema: {
+            type: string;
+            additionalProperties: boolean;
+            properties: {
+                accounts: {
+                    type: string;
+                    additionalProperties: {
+                        type: string;
+                        additionalProperties: boolean;
+                        properties: {
+                            readonly enabled: {
+                                readonly type: "boolean";
+                            };
+                            readonly name: {
+                                readonly type: "string";
+                            };
+                            readonly setupToken: {
+                                readonly type: "string";
+                            };
+                            readonly token: {
+                                readonly type: "string";
+                            };
+                            readonly autoTitle: {
+                                readonly oneOf: readonly [{
+                                    readonly type: "boolean";
+                                }, {
+                                    readonly type: "object";
+                                    readonly additionalProperties: false;
+                                    readonly properties: {
+                                        readonly enabled: {
+                                            readonly type: "boolean";
+                                        };
+                                        readonly prompt: {
+                                            readonly type: "string";
+                                        };
+                                    };
+                                }];
+                            };
+                            readonly defaultTo: {
+                                readonly type: "string";
+                            };
+                            readonly connectTimeoutMs: {
+                                readonly type: "number";
+                                readonly minimum: 1;
+                            };
+                            readonly sendTimeoutMs: {
+                                readonly type: "number";
+                                readonly minimum: 1;
+                            };
+                            readonly reconnectDelayMs: {
+                                readonly type: "number";
+                                readonly minimum: 1;
+                            };
+                        };
+                    };
+                };
+                enabled: {
+                    readonly type: "boolean";
+                };
+                name: {
+                    readonly type: "string";
+                };
+                setupToken: {
+                    readonly type: "string";
+                };
+                token: {
+                    readonly type: "string";
+                };
+                autoTitle: {
+                    readonly oneOf: readonly [{
+                        readonly type: "boolean";
+                    }, {
+                        readonly type: "object";
+                        readonly additionalProperties: false;
+                        readonly properties: {
+                            readonly enabled: {
+                                readonly type: "boolean";
+                            };
+                            readonly prompt: {
+                                readonly type: "string";
+                            };
+                        };
+                    }];
+                };
+                defaultTo: {
+                    readonly type: "string";
+                };
+                connectTimeoutMs: {
+                    readonly type: "number";
+                    readonly minimum: 1;
+                };
+                sendTimeoutMs: {
+                    readonly type: "number";
+                    readonly minimum: 1;
+                };
+                reconnectDelayMs: {
+                    readonly type: "number";
+                    readonly minimum: 1;
+                };
+            };
+        };
+    };
+    reload: {
+        configPrefixes: string[];
+    };
+    config: {
+        listAccountIds: (cfg: openclaw_plugin_sdk.OpenClawConfig) => string[];
+        resolveAccount: (cfg: openclaw_plugin_sdk.OpenClawConfig, accountId: string | null | undefined) => ResolvedSiderAccount;
+        defaultAccountId: () => string;
+        isConfigured: (account: ResolvedSiderAccount) => boolean;
+        describeAccount: (account: ResolvedSiderAccount) => {
+            accountId: string;
+            enabled: boolean;
+            configured: boolean;
+            name: string;
+            baseUrl: string;
+            defaultTo: string | undefined;
+        };
+        resolveDefaultTo: ({ cfg, accountId }: {
+            cfg: openclaw_plugin_sdk.OpenClawConfig;
+            accountId?: string | null;
+        }) => string | undefined;
+    };
+};
+
+export { siderChannelPluginCommon };

package/dist/src/channel-shared.js

@@ -0,0 +1,96 @@
+import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/account-id";
+import {
+  isSiderAccountBootstrappable,
+  listSiderAccountIds,
+  resolveSiderAccount,
+  siderSetupWizard
+} from "./account.js";
+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";
+import { siderSetupAdapter } from "./setup-core.js";
+const siderAccountConfigProperties = {
+  enabled: { type: "boolean" },
+  name: { type: "string" },
+  setupToken: { type: "string" },
+  token: { type: "string" },
+  autoTitle: {
+    oneOf: [
+      { type: "boolean" },
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          enabled: { type: "boolean" },
+          prompt: { type: "string" }
+        }
+      }
+    ]
+  },
+  defaultTo: { type: "string" },
+  connectTimeoutMs: { type: "number", minimum: 1 },
+  sendTimeoutMs: { type: "number", minimum: 1 },
+  reconnectDelayMs: { type: "number", minimum: 1 }
+};
+const siderChannelPluginCommon = {
+  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
+  },
+  setupWizard: siderSetupWizard,
+  setup: siderSetupAdapter,
+  capabilities: {
+    chatTypes: ["direct"],
+    threads: false,
+    media: true,
+    blockStreaming: true
+  },
+  configSchema: {
+    schema: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        ...siderAccountConfigProperties,
+        accounts: {
+          type: "object",
+          additionalProperties: {
+            type: "object",
+            additionalProperties: false,
+            properties: siderAccountConfigProperties
+          }
+        }
+      }
+    }
+  },
+  reload: { configPrefixes: [`channels.${SIDER_CHANNEL_ID}`] },
+  config: {
+    listAccountIds: (cfg) => listSiderAccountIds(cfg),
+    resolveAccount: (cfg, accountId) => resolveSiderAccount(cfg, accountId),
+    defaultAccountId: () => DEFAULT_ACCOUNT_ID,
+    isConfigured: (account) => account.configured || isSiderAccountBootstrappable(account),
+    describeAccount: (account) => ({
+      accountId: account.accountId,
+      enabled: account.enabled,
+      configured: account.configured,
+      name: account.name,
+      baseUrl: account.gatewayUrl,
+      defaultTo: account.defaultTo
+    }),
+    resolveDefaultTo: ({ cfg, accountId }) => resolveSiderAccount(cfg, accountId).defaultTo
+  }
+};
+export {
+  siderChannelPluginCommon
+};

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

@@ -0,0 +1,93 @@
+import { R as ResolvedSiderAccount } from '../account-cW9SLuNu.js';
+import { SiderPart, SiderSessionBinding, SiderRunState } from './channel-types.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';
+import 'ws';
+
+declare function normalizeSessionBindingKey(raw?: string): string | undefined;
+declare function pruneSiderSessionBindings(now?: number): void;
+declare function rememberSiderSessionBinding(params: {
+    sessionKey?: string;
+    account: ResolvedSiderAccount;
+    sessionId: string;
+}): void;
+declare function resolveSiderSessionBinding(sessionKey?: string): SiderSessionBinding | undefined;
+declare function resolveSiderBindingByTarget(params: {
+    accountId: string;
+    sessionId: string;
+}): {
+    sessionKey: string;
+    binding: SiderSessionBinding;
+} | undefined;
+declare function pruneSiderRunStates(now?: number): void;
+declare function getOrCreateSiderRunState(runId: string): SiderRunState;
+declare function resolveSiderRunState(runId?: string): SiderRunState | undefined;
+declare function discardSiderRunState(runId?: string): void;
+declare function updateSiderRunStateContext(params: {
+    runId: string;
+    sessionKey?: string;
+    sessionId?: string;
+    accountId?: string;
+    provider?: string;
+    model?: string;
+    managedByReplyPipeline?: boolean;
+}): SiderRunState;
+declare function resolveRelayCallIdForToolEvent(params: {
+    binding: SiderSessionBinding;
+    phase: "start" | "end" | "error";
+    toolCallId?: string;
+}): string;
+declare function clearRelayCallIdForToolEvent(params: {
+    binding: SiderSessionBinding;
+    callId: string;
+    toolCallId?: string;
+}): void;
+declare function hasTextParts(parts: readonly SiderPart[]): boolean;
+declare function enqueueCompletedParts(params: {
+    runId?: string;
+    parts: readonly SiderPart[];
+    sessionKey?: string;
+    sessionId?: string;
+    accountId?: string;
+    provider?: string;
+    model?: string;
+}): void;
+declare function resolvePendingFinalTextForRun(runId?: string): string;
+declare function buildPendingMessageContextForRun(params: {
+    accountId: string;
+    runId?: string;
+    includeFinalThinking?: boolean;
+}): {
+    parts: SiderPart[];
+    meta?: Record<string, unknown>;
+    runId?: string;
+    stopReason?: string;
+};
+declare function consumePendingMessageContextForRun(params: {
+    runId?: string;
+    consumeFinalThinking?: boolean;
+}): void;
+declare function scheduleQueuedPartFlush(params: {
+    runId?: string;
+    context: string;
+}): Promise<void>;
+declare function flushQueuedPartsExceptTailForRun(params: {
+    runId?: string;
+    account: ResolvedSiderAccount;
+    sessionId: string;
+    context: string;
+}): Promise<void>;
+declare function flushFinalQueuedPartForRun(params: {
+    runId?: string;
+    account: ResolvedSiderAccount;
+    sessionId: string;
+    stopReason?: string;
+    context: string;
+}): Promise<boolean>;
+declare function dropQueuedTailOnAbort(runId?: string): void;
+declare function clearBindingRunId(sessionKey?: string, runId?: string): void;
+
+export { buildPendingMessageContextForRun, clearBindingRunId, clearRelayCallIdForToolEvent, consumePendingMessageContextForRun, discardSiderRunState, dropQueuedTailOnAbort, enqueueCompletedParts, flushFinalQueuedPartForRun, flushQueuedPartsExceptTailForRun, getOrCreateSiderRunState, hasTextParts, normalizeSessionBindingKey, pruneSiderRunStates, pruneSiderSessionBindings, rememberSiderSessionBinding, resolvePendingFinalTextForRun, resolveRelayCallIdForToolEvent, resolveSiderBindingByTarget, resolveSiderRunState, resolveSiderSessionBinding, scheduleQueuedPartFlush, updateSiderRunStateContext };