@chrysb/alphaclaw 0.9.16 → 0.9.18

package/lib/public/js/lib/thinking-levels.js

@@ -0,0 +1,37 @@
+const kThinkingLevelLabelOverrides = {
+  off: "Off",
+  on: "On",
+  minimal: "Minimal",
+  low: "Low",
+  medium: "Medium",
+  high: "High",
+  adaptive: "Adaptive",
+  xhigh: "Extra high",
+  max: "Maximum",
+};
+
+export const formatThinkingLevelLabel = (levelId = "") => {
+  const normalized = String(levelId || "").trim().toLowerCase();
+  if (!normalized) return "";
+  if (kThinkingLevelLabelOverrides[normalized]) {
+    return kThinkingLevelLabelOverrides[normalized];
+  }
+  return normalized
+    .split(/[-_]/g)
+    .filter(Boolean)
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join(" ");
+};
+
+export const formatInheritedThinkingLabel = (levelId = "") => {
+  const label = formatThinkingLevelLabel(levelId);
+  return label ? `Inherited: ${label}` : "Inherited";
+};
+
+export const shouldShowThinkingLevelSelect = (levels = []) => {
+  const normalized = (Array.isArray(levels) ? levels : [])
+    .map((entry) => String(entry?.id || entry || "").trim().toLowerCase())
+    .filter(Boolean);
+  if (normalized.length === 0) return false;
+  return !(normalized.length === 1 && normalized[0] === "off");
+};

package/lib/server/agents/agents.js

@@ -1,4 +1,5 @@
 const path = require("path");
+const { normalizeThinkingDefaultValue } = require("../openclaw-thinking");
 
 const {
   kDefaultAgentId,
@@ -42,11 +43,25 @@ const toReadableAgent = (agent = {}) => ({
 });
 
 const createAgentsDomain = ({ fsImpl, OPENCLAW_DIR }) => {
-  const listAgents = () => {
-    const cfg = withNormalizedAgentsConfig({
+  const readAgentsConfig = () =>
+    withNormalizedAgentsConfig({
       OPENCLAW_DIR,
       cfg: loadConfig({ fsImpl, OPENCLAW_DIR }),
     });
+
+  const getAgentDefaults = () => {
+    const cfg = readAgentsConfig();
+    const thinkingDefault = cfg.agents?.defaults?.thinkingDefault;
+    return {
+      thinkingDefault:
+        typeof thinkingDefault === "string" && thinkingDefault.trim()
+          ? thinkingDefault.trim()
+          : null,
+    };
+  };
+
+  const listAgents = () => {
+    const cfg = readAgentsConfig();
     return (cfg.agents?.list || []).map((entry) => toReadableAgent(entry));
   };
 
@@ -131,12 +146,9 @@ const createAgentsDomain = ({ fsImpl, OPENCLAW_DIR }) => {
     return toReadableAgent(nextAgent);
   };
 
-  const updateAgent = (agentId, patch = {}) => {
+  const updateAgent = async (agentId, patch = {}) => {
     const normalized = String(agentId || "").trim();
-    const cfg = withNormalizedAgentsConfig({
-      OPENCLAW_DIR,
-      cfg: loadConfig({ fsImpl, OPENCLAW_DIR }),
-    });
+    const cfg = readAgentsConfig();
     const index = cfg.agents.list.findIndex((entry) => entry.id === normalized);
     if (index < 0) throw new Error(`Agent "${normalized}" not found`);
     const current = cfg.agents.list[index];
@@ -188,6 +200,19 @@ const createAgentsDomain = ({ fsImpl, OPENCLAW_DIR }) => {
         delete next.tools;
       }
     }
+    if (patch.thinkingDefault !== undefined) {
+      if (patch.thinkingDefault === null) {
+        delete next.thinkingDefault;
+      } else {
+        const normalizedThinking = await normalizeThinkingDefaultValue(
+          patch.thinkingDefault,
+        );
+        if (!normalizedThinking) {
+          throw new Error("Invalid thinkingDefault value");
+        }
+        next.thinkingDefault = normalizedThinking;
+      }
+    }
     cfg.agents.list[index] = next;
     saveConfig({ fsImpl, OPENCLAW_DIR, config: cfg });
     return toReadableAgent(next);
@@ -253,6 +278,7 @@ const createAgentsDomain = ({ fsImpl, OPENCLAW_DIR }) => {
   return {
     listAgents,
     getAgent,
+    getAgentDefaults,
     getAgentWorkspaceSize,
     createAgent,
     updateAgent,

package/lib/server/agents/channels.js

@@ -270,7 +270,7 @@ const createChannelsDomain = ({
 
       const previousConfig = cloneJson(cfg);
       try {
-        onProgress({ phase: "restarting", label: "Rebooting..." });
+        onProgress({ phase: "configuring", label: "Configuring..." });
         writeEnvFile(nextEnvVars);
         reloadEnv();
         assertActiveChannelTokenEnvVars({
@@ -280,7 +280,6 @@ const createChannelsDomain = ({
           }),
           envVars: nextEnvVars,
         });
-        await restartGateway();
         const pluginEnabledCfg = withNormalizedAgentsConfig({
           OPENCLAW_DIR,
           cfg: loadConfig({ fsImpl, OPENCLAW_DIR }),
@@ -374,6 +373,8 @@ const createChannelsDomain = ({
               "Could not bind channel account",
           );
         }
+        onProgress({ phase: "restarting", label: "Rebooting..." });
+        await restartGateway();
       } catch (error) {
         try {
           await clawCmd(
@@ -760,6 +761,7 @@ const createChannelsDomain = ({
       }
 
       cleanupChannelAccountPairingFiles({ provider, accountId });
+      await restartGateway();
       return { ok: true };
     }
 

package/lib/server/alphaclaw-config.js

@@ -0,0 +1,99 @@
+const fs = require("fs");
+const path = require("path");
+
+const kConfigFileName = "alphaclaw.json";
+const kDefaultAlphaclawConfig = Object.freeze({
+  features: Object.freeze({
+    openaiCompatApi: Object.freeze({
+      enabled: false,
+    }),
+  }),
+});
+
+const resolveAlphaclawConfigPath = ({ openclawDir } = {}) =>
+  path.join(openclawDir || process.cwd(), kConfigFileName);
+
+const normalizeOpenAiCompatApiFeature = (feature = {}) => ({
+  ...(feature && typeof feature === "object" ? feature : {}),
+  enabled: feature?.enabled === true,
+});
+
+const normalizeAlphaclawConfig = (raw = {}) => {
+  const base = raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
+  const features =
+    base.features && typeof base.features === "object" && !Array.isArray(base.features)
+      ? base.features
+      : {};
+  return {
+    ...base,
+    features: {
+      ...features,
+      openaiCompatApi: normalizeOpenAiCompatApiFeature(features.openaiCompatApi),
+    },
+  };
+};
+
+const readAlphaclawConfig = ({
+  fsModule = fs,
+  openclawDir,
+  fallback = kDefaultAlphaclawConfig,
+} = {}) => {
+  try {
+    const configPath = resolveAlphaclawConfigPath({ openclawDir });
+    const raw = fsModule.readFileSync(configPath, "utf8");
+    return normalizeAlphaclawConfig(JSON.parse(raw));
+  } catch {
+    return normalizeAlphaclawConfig(fallback);
+  }
+};
+
+const writeAlphaclawConfig = ({
+  fsModule = fs,
+  openclawDir,
+  config,
+  spacing = 2,
+} = {}) => {
+  const configPath = resolveAlphaclawConfigPath({ openclawDir });
+  fsModule.mkdirSync(path.dirname(configPath), { recursive: true });
+  const normalized = normalizeAlphaclawConfig(config);
+  fsModule.writeFileSync(configPath, `${JSON.stringify(normalized, null, spacing)}\n`);
+  return normalized;
+};
+
+const isOpenAiCompatApiEnabled = (options = {}) =>
+  readAlphaclawConfig(options).features.openaiCompatApi.enabled === true;
+
+const updateOpenAiCompatApiFeature = ({
+  fsModule = fs,
+  openclawDir,
+  enabled,
+} = {}) => {
+  const current = readAlphaclawConfig({ fsModule, openclawDir });
+  const next = normalizeAlphaclawConfig({
+    ...current,
+    features: {
+      ...current.features,
+      openaiCompatApi: {
+        ...current.features.openaiCompatApi,
+        enabled: enabled === true,
+      },
+    },
+  });
+  const changed =
+    current.features.openaiCompatApi.enabled !== next.features.openaiCompatApi.enabled;
+  return {
+    config: writeAlphaclawConfig({ fsModule, openclawDir, config: next }),
+    changed,
+  };
+};
+
+module.exports = {
+  kConfigFileName,
+  kDefaultAlphaclawConfig,
+  isOpenAiCompatApiEnabled,
+  normalizeAlphaclawConfig,
+  readAlphaclawConfig,
+  resolveAlphaclawConfigPath,
+  updateOpenAiCompatApiFeature,
+  writeAlphaclawConfig,
+};

package/lib/server/chat-ws.js

@@ -6,7 +6,7 @@ const kEnvRefPattern = /^\$\{([A-Z0-9_]+)\}$/i;
 const kConnectTimeoutMs = 8000;
 const kHistoryTimeoutMs = 12000;
 const kGatewayReqTimeoutMs = 15000;
-const kGatewayProtocolVersion = 3;
+const kGatewayProtocolVersion = 4;
 // Gateway method auth (see OpenClaw method-scopes): chat.history needs operator.read;
 // chat.send / chat.abort need operator.write. Align with CLI_DEFAULT_OPERATOR_SCOPES plus admin.
 const kGatewayChatBridgeScopes = [
@@ -283,6 +283,9 @@ const sanitizeError = (error) => {
   ) {
     return "Gateway authentication failed. Verify OPENCLAW_GATEWAY_TOKEN matches the gateway.";
   }
+  if (lower.includes("protocol mismatch")) {
+    return "Chat cannot connect to the gateway (protocol version mismatch). Update AlphaClaw to match your OpenClaw version.";
+  }
   if (lower.includes("method not found") || lower.includes("unknown method")) {
     return "This gateway build does not support chat APIs. Update OpenClaw.";
   }

package/lib/server/constants.js

@@ -54,6 +54,22 @@ const kLoginMaxLockMs = parsePositiveInt(
   process.env.LOGIN_RATE_MAX_LOCK_MS,
   15 * 60 * 1000,
 );
+const kLoginGlobalWindowMs = parsePositiveInt(
+  process.env.LOGIN_RATE_GLOBAL_WINDOW_MS,
+  kLoginWindowMs,
+);
+const kLoginGlobalMaxAttempts = parsePositiveInt(
+  process.env.LOGIN_RATE_GLOBAL_MAX_ATTEMPTS,
+  Math.max(kLoginMaxAttempts * 5, 25),
+);
+const kLoginGlobalBaseLockMs = parsePositiveInt(
+  process.env.LOGIN_RATE_GLOBAL_BASE_LOCK_MS,
+  kLoginBaseLockMs,
+);
+const kLoginGlobalMaxLockMs = parsePositiveInt(
+  process.env.LOGIN_RATE_GLOBAL_MAX_LOCK_MS,
+  kLoginMaxLockMs,
+);
 const kLoginCleanupIntervalMs = parsePositiveInt(
   process.env.LOGIN_RATE_CLEANUP_INTERVAL_MS,
   60 * 1000,
@@ -65,6 +81,45 @@ const kLoginStateTtlMs = Math.max(
   ),
   kLoginMaxLockMs,
 );
+const kOpenAiCompatApiRateWindowMs = parsePositiveInt(
+  process.env.OPENAI_COMPAT_API_RATE_WINDOW_MS,
+  kLoginWindowMs,
+);
+const kOpenAiCompatApiRateMaxAttempts = parsePositiveInt(
+  process.env.OPENAI_COMPAT_API_RATE_MAX_ATTEMPTS,
+  10,
+);
+const kOpenAiCompatApiRateBaseLockMs = parsePositiveInt(
+  process.env.OPENAI_COMPAT_API_RATE_BASE_LOCK_MS,
+  kLoginBaseLockMs,
+);
+const kOpenAiCompatApiRateMaxLockMs = parsePositiveInt(
+  process.env.OPENAI_COMPAT_API_RATE_MAX_LOCK_MS,
+  kLoginMaxLockMs,
+);
+const kOpenAiCompatApiRateGlobalWindowMs = parsePositiveInt(
+  process.env.OPENAI_COMPAT_API_RATE_GLOBAL_WINDOW_MS,
+  kOpenAiCompatApiRateWindowMs,
+);
+const kOpenAiCompatApiRateGlobalMaxAttempts = parsePositiveInt(
+  process.env.OPENAI_COMPAT_API_RATE_GLOBAL_MAX_ATTEMPTS,
+  Math.max(kOpenAiCompatApiRateMaxAttempts * 10, 100),
+);
+const kOpenAiCompatApiRateGlobalBaseLockMs = parsePositiveInt(
+  process.env.OPENAI_COMPAT_API_RATE_GLOBAL_BASE_LOCK_MS,
+  kOpenAiCompatApiRateBaseLockMs,
+);
+const kOpenAiCompatApiRateGlobalMaxLockMs = parsePositiveInt(
+  process.env.OPENAI_COMPAT_API_RATE_GLOBAL_MAX_LOCK_MS,
+  kOpenAiCompatApiRateMaxLockMs,
+);
+const kOpenAiCompatApiRateStateTtlMs = Math.max(
+  parsePositiveInt(
+    process.env.OPENAI_COMPAT_API_RATE_STATE_TTL_MS,
+    Math.max(kOpenAiCompatApiRateWindowMs, kOpenAiCompatApiRateMaxLockMs) * 3,
+  ),
+  kOpenAiCompatApiRateMaxLockMs,
+);
 
 const kOnboardingModelProviders = new Set([
   "anthropic",
@@ -92,6 +147,11 @@ const kOnboardingModelProviders = new Set([
   "vllm",
 ]);
 const kMinimalFallbackOnboardingModels = [
+  {
+    key: "anthropic/claude-opus-4-8",
+    provider: "anthropic",
+    label: "Claude Opus 4.8",
+  },
   {
     key: "anthropic/claude-opus-4-7",
     provider: "anthropic",
@@ -445,8 +505,21 @@ module.exports = {
   kLoginMaxAttempts,
   kLoginBaseLockMs,
   kLoginMaxLockMs,
+  kLoginGlobalWindowMs,
+  kLoginGlobalMaxAttempts,
+  kLoginGlobalBaseLockMs,
+  kLoginGlobalMaxLockMs,
   kLoginCleanupIntervalMs,
   kLoginStateTtlMs,
+  kOpenAiCompatApiRateWindowMs,
+  kOpenAiCompatApiRateMaxAttempts,
+  kOpenAiCompatApiRateBaseLockMs,
+  kOpenAiCompatApiRateMaxLockMs,
+  kOpenAiCompatApiRateGlobalWindowMs,
+  kOpenAiCompatApiRateGlobalMaxAttempts,
+  kOpenAiCompatApiRateGlobalBaseLockMs,
+  kOpenAiCompatApiRateGlobalMaxLockMs,
+  kOpenAiCompatApiRateStateTtlMs,
   kOnboardingModelProviders,
   kFallbackOnboardingModels,
   kVersionCacheTtlMs,

package/lib/server/cost-utils.js

@@ -13,6 +13,8 @@ const kClaudeOpus47Pricing = {
 };
 
 const kGlobalModelPricing = {
+  "claude-opus-4-8": kClaudeOpus47Pricing,
+  "claude-opus-4.8": kClaudeOpus47Pricing,
   "claude-opus-4-7": kClaudeOpus47Pricing,
   "claude-opus-4.7": kClaudeOpus47Pricing,
   "claude-opus-4-6": {

package/lib/server/db/auth/index.js

@@ -0,0 +1,147 @@
+const fs = require("fs");
+const path = require("path");
+const { DatabaseSync } = require("node:sqlite");
+const { createSchema } = require("./schema");
+
+let db = null;
+
+const ensureDb = () => {
+  if (!db) throw new Error("Auth DB not initialized");
+  return db;
+};
+
+const closeAuthDb = () => {
+  if (!db) return;
+  const database = db;
+  db = null;
+  database.close();
+};
+
+const initAuthDb = ({ rootDir }) => {
+  closeAuthDb();
+  const dbDir = path.join(rootDir, "db");
+  fs.mkdirSync(dbDir, { recursive: true });
+  const dbPath = path.join(dbDir, "auth.db");
+  db = new DatabaseSync(dbPath);
+  db.exec("PRAGMA busy_timeout = 5000");
+  createSchema(db);
+  return { path: dbPath };
+};
+
+const toStateModel = (row) => {
+  if (!row) return null;
+  return {
+    attempts: Number(row.attempts || 0),
+    windowStart: Number(row.window_start || 0),
+    lockUntil: Number(row.lock_until || 0),
+    failStreak: Number(row.fail_streak || 0),
+    lastSeenAt: Number(row.last_seen_at || 0),
+  };
+};
+
+const createLoginThrottleStore = () => ({
+  get: (stateKey) => {
+    const row = ensureDb()
+      .prepare(
+        `
+          SELECT
+            attempts,
+            window_start,
+            lock_until,
+            fail_streak,
+            last_seen_at
+          FROM login_throttle_states
+          WHERE state_key = $state_key
+          LIMIT 1
+        `,
+      )
+      .get({ $state_key: String(stateKey || "") });
+    return toStateModel(row);
+  },
+
+  set: (stateKey, state) => {
+    ensureDb()
+      .prepare(
+        `
+          INSERT INTO login_throttle_states (
+            state_key,
+            attempts,
+            window_start,
+            lock_until,
+            fail_streak,
+            last_seen_at
+          ) VALUES (
+            $state_key,
+            $attempts,
+            $window_start,
+            $lock_until,
+            $fail_streak,
+            $last_seen_at
+          )
+          ON CONFLICT(state_key) DO UPDATE SET
+            attempts = excluded.attempts,
+            window_start = excluded.window_start,
+            lock_until = excluded.lock_until,
+            fail_streak = excluded.fail_streak,
+            last_seen_at = excluded.last_seen_at
+        `,
+      )
+      .run({
+        $state_key: String(stateKey || ""),
+        $attempts: Number(state?.attempts || 0),
+        $window_start: Number(state?.windowStart || 0),
+        $lock_until: Number(state?.lockUntil || 0),
+        $fail_streak: Number(state?.failStreak || 0),
+        $last_seen_at: Number(state?.lastSeenAt || 0),
+      });
+  },
+
+  delete: (stateKey) => {
+    ensureDb()
+      .prepare(
+        `
+          DELETE FROM login_throttle_states
+          WHERE state_key = $state_key
+        `,
+      )
+      .run({ $state_key: String(stateKey || "") });
+  },
+
+  entries: () =>
+    ensureDb()
+      .prepare(
+        `
+          SELECT
+            state_key,
+            attempts,
+            window_start,
+            lock_until,
+            fail_streak,
+            last_seen_at
+          FROM login_throttle_states
+        `,
+      )
+      .all()
+      .map((row) => [String(row.state_key || ""), toStateModel(row)]),
+
+  runExclusive: (callback) => {
+    const database = ensureDb();
+    database.exec("BEGIN IMMEDIATE");
+    try {
+      const result = callback();
+      database.exec("COMMIT");
+      return result;
+    } catch (err) {
+      try {
+        database.exec("ROLLBACK");
+      } catch {}
+      throw err;
+    }
+  },
+});
+
+module.exports = {
+  initAuthDb,
+  closeAuthDb,
+  createLoginThrottleStore,
+};

package/lib/server/db/auth/schema.js

@@ -0,0 +1,17 @@
+const createSchema = (db) => {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS login_throttle_states (
+      state_key TEXT PRIMARY KEY,
+      attempts INTEGER NOT NULL DEFAULT 0,
+      window_start INTEGER NOT NULL,
+      lock_until INTEGER NOT NULL DEFAULT 0,
+      fail_streak INTEGER NOT NULL DEFAULT 0,
+      last_seen_at INTEGER NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_login_throttle_states_last_seen
+      ON login_throttle_states(last_seen_at);
+  `);
+};
+
+module.exports = { createSchema };