@rei-standard/amsg-server 2.6.0-next.1 → 2.6.0-next.3

package/dist/{chunk-S5DV7AUH.cjs → chunk-L7WMM33Q.cjs}

@@ -106,10 +106,10 @@ function validateScheduleMessagePayload(payload) {
       };
     }
     if (hasMessages) {
-      const err = validateLlmMessagesArray(payload.messages);
-      if (err) {
+      const err2 = validateLlmMessagesArray(payload.messages);
+      if (err2) {
         return {
-          error: { code: "INVALID_PARAMETERS", message: err, details: { invalidFields: ["messages"] } },
+          error: { code: "INVALID_PARAMETERS", message: err2, details: { invalidFields: ["messages"] } },
           hasCompletePrompt: false,
           hasMessages: true
         };
@@ -162,53 +162,127 @@ function validateScheduleMessagePayload(payload) {
   return { valid: true };
 }
 
+// src/server/lib/webcrypto-utils.js
+
+var TEXT_ENCODER = new TextEncoder();
+var TEXT_DECODER = new TextDecoder("utf-8", { fatal: false });
+function utf8(str) {
+  return TEXT_ENCODER.encode(String(str));
+}
+function utf8Decode(buf) {
+  return TEXT_DECODER.decode(_amsgshared.toUint8.call(void 0, buf));
+}
+function bytesToBase64(buf) {
+  const bytes = _amsgshared.toUint8.call(void 0, buf);
+  let bin = "";
+  for (let i = 0; i < bytes.length; i++) {
+    bin += String.fromCharCode(bytes[i]);
+  }
+  return typeof btoa === "function" ? btoa(bin) : Buffer.from(bin, "binary").toString("base64");
+}
+function bytesToBase64Url(buf) {
+  return bytesToBase64(buf).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+}
+function bytesToHex(buf) {
+  const bytes = _amsgshared.toUint8.call(void 0, buf);
+  let out = "";
+  for (let i = 0; i < bytes.length; i++) {
+    out += bytes[i].toString(16).padStart(2, "0");
+  }
+  return out;
+}
+function hexToBytes(hex) {
+  const out = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < out.length; i++) {
+    out[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+  }
+  return out;
+}
+function jsonToBase64Url(value) {
+  return bytesToBase64Url(utf8(JSON.stringify(value)));
+}
+function randomUUID() {
+  return globalThis.crypto.randomUUID();
+}
+function randomBytes(n) {
+  const out = new Uint8Array(n);
+  globalThis.crypto.getRandomValues(out);
+  return out;
+}
+
 // src/server/lib/encryption.js
-var _crypto = require('crypto');
-function deriveUserEncryptionKey(userId, masterKey) {
-  return _crypto.createHash.call(void 0, "sha256").update(masterKey + userId).digest("hex").slice(0, 64);
+var base64ToBytes = _amsgshared.base64UrlToBytes;
+var TAG_LENGTH_BYTES = 16;
+function importAesKey(hexKey, usage) {
+  return globalThis.crypto.subtle.importKey(
+    "raw",
+    hexToBytes(hexKey),
+    { name: "AES-GCM" },
+    false,
+    [usage]
+  );
 }
-function decryptPayload(encryptedPayload, encryptionKey) {
+async function aesGcmSeal(hexKey, iv, plaintextBytes) {
+  const key = await importAesKey(hexKey, "encrypt");
+  const sealed = new Uint8Array(await globalThis.crypto.subtle.encrypt(
+    { name: "AES-GCM", iv, tagLength: TAG_LENGTH_BYTES * 8 },
+    key,
+    plaintextBytes
+  ));
+  return {
+    ciphertext: sealed.slice(0, sealed.length - TAG_LENGTH_BYTES),
+    authTag: sealed.slice(sealed.length - TAG_LENGTH_BYTES)
+  };
+}
+async function aesGcmOpen(hexKey, iv, ciphertext, authTag) {
+  const key = await importAesKey(hexKey, "decrypt");
+  const tagBits = authTag.length * 8;
+  const tagLength = tagBits >= 96 && tagBits <= 128 ? tagBits : 128;
+  const plain = await globalThis.crypto.subtle.decrypt(
+    { name: "AES-GCM", iv, tagLength },
+    key,
+    _amsgshared.concatBytes.call(void 0, ciphertext, authTag)
+  );
+  return new Uint8Array(plain);
+}
+async function deriveUserEncryptionKey(userId, masterKey) {
+  const digest = await globalThis.crypto.subtle.digest("SHA-256", utf8(masterKey + userId));
+  return bytesToHex(new Uint8Array(digest)).slice(0, 64);
+}
+async function decryptPayload(encryptedPayload, encryptionKey) {
   const { iv, authTag, encryptedData } = encryptedPayload;
-  const decipher = _crypto.createDecipheriv.call(void 0, 
-    "aes-256-gcm",
-    Buffer.from(encryptionKey, "hex"),
-    Buffer.from(iv, "base64")
+  const plain = await aesGcmOpen(
+    encryptionKey,
+    base64ToBytes(iv),
+    base64ToBytes(encryptedData),
+    base64ToBytes(authTag)
   );
-  decipher.setAuthTag(Buffer.from(authTag, "base64"));
-  const decrypted = Buffer.concat([
-    decipher.update(Buffer.from(encryptedData, "base64")),
-    decipher.final()
-  ]);
-  return JSON.parse(decrypted.toString("utf8"));
-}
-function encryptPayload(payload, encryptionKey) {
+  return JSON.parse(utf8Decode(plain));
+}
+async function encryptPayload(payload, encryptionKey) {
   const plaintext = typeof payload === "string" ? payload : JSON.stringify(payload);
-  const iv = _crypto.randomBytes.call(void 0, 12);
-  const cipher = _crypto.createCipheriv.call(void 0, "aes-256-gcm", Buffer.from(encryptionKey, "hex"), iv);
-  const encrypted = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
-  const authTag = cipher.getAuthTag();
+  const iv = randomBytes(12);
+  const { ciphertext, authTag } = await aesGcmSeal(encryptionKey, iv, utf8(plaintext));
   return {
-    iv: iv.toString("base64"),
-    authTag: authTag.toString("base64"),
-    encryptedData: encrypted.toString("base64")
+    iv: bytesToBase64(iv),
+    authTag: bytesToBase64(authTag),
+    encryptedData: bytesToBase64(ciphertext)
   };
 }
-function encryptForStorage(text, encryptionKey) {
-  const iv = _crypto.randomBytes.call(void 0, 16);
-  const cipher = _crypto.createCipheriv.call(void 0, "aes-256-gcm", Buffer.from(encryptionKey, "hex"), iv);
-  const encrypted = cipher.update(text, "utf8", "hex") + cipher.final("hex");
-  const authTag = cipher.getAuthTag();
-  return `${iv.toString("hex")}:${authTag.toString("hex")}:${encrypted}`;
+async function encryptForStorage(text, encryptionKey) {
+  const iv = randomBytes(16);
+  const { ciphertext, authTag } = await aesGcmSeal(encryptionKey, iv, utf8(text));
+  return `${bytesToHex(iv)}:${bytesToHex(authTag)}:${bytesToHex(ciphertext)}`;
 }
-function decryptFromStorage(encryptedText, encryptionKey) {
+async function decryptFromStorage(encryptedText, encryptionKey) {
   const [ivHex, authTagHex, encryptedDataHex] = encryptedText.split(":");
-  const decipher = _crypto.createDecipheriv.call(void 0, 
-    "aes-256-gcm",
-    Buffer.from(encryptionKey, "hex"),
-    Buffer.from(ivHex, "hex")
+  const plain = await aesGcmOpen(
+    encryptionKey,
+    hexToBytes(ivHex),
+    hexToBytes(encryptedDataHex),
+    hexToBytes(authTagHex)
   );
-  decipher.setAuthTag(Buffer.from(authTagHex, "hex"));
-  return decipher.update(encryptedDataHex, "hex", "utf8") + decipher.final("utf8");
+  return utf8Decode(plain);
 }
 
 // src/server/lib/request.js
@@ -300,7 +374,7 @@ function createGetUserKeyHandler(ctx) {
       body: {
         success: true,
         data: {
-          userKey: deriveUserEncryptionKey(userId, masterKey),
+          userKey: await deriveUserEncryptionKey(userId, masterKey),
           version: 1
         }
       }
@@ -309,9 +383,6 @@ function createGetUserKeyHandler(ctx) {
   return { GET };
 }
 
-// src/server/handlers/schedule-message.js
-
-
 // src/server/lib/db-errors.js
 function isUniqueViolation(error) {
   if (!error || typeof error !== "object") return false;
@@ -329,8 +400,269 @@ function isUniqueViolation(error) {
 
 
 
-var DEFAULT_SPLIT_REGEX = /([。！？!?]+)/;
+// src/server/lib/llm.js
+async function callLlm(payload, options = {}) {
+  const requireContent = options.requireContent !== false;
+  const timeoutMs = typeof options.timeoutMs === "number" && Number.isFinite(options.timeoutMs) && options.timeoutMs > 0 ? options.timeoutMs : 3e5;
+  const normalizedApiUrl = normalizeAiApiUrl(payload.apiUrl);
+  const requestBody = buildAiRequestBody(payload);
+  const aiResponse = await fetch(normalizedApiUrl, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${payload.apiKey}`
+    },
+    body: JSON.stringify(requestBody),
+    signal: AbortSignal.timeout(timeoutMs)
+  });
+  if (!aiResponse.ok) {
+    if (aiResponse.status === 405) {
+      throw new Error(
+        `AI API error: 405 Method Not Allowed. apiUrl must point to a full chat endpoint (for example: /chat/completions). Received: ${normalizedApiUrl}`
+      );
+    }
+    throw new Error(
+      `AI API error: ${aiResponse.status} ${aiResponse.statusText || "Unknown Error"}. Request URL: ${normalizedApiUrl}`
+    );
+  }
+  const aiData = await aiResponse.json();
+  const rawContent = _optionalChain([aiData, 'optionalAccess', _2 => _2.choices, 'optionalAccess', _3 => _3[0], 'optionalAccess', _4 => _4.message, 'optionalAccess', _5 => _5.content]);
+  if (requireContent && (typeof rawContent !== "string" || !rawContent.trim())) {
+    throw new Error("AI API error: response missing choices[0].message.content");
+  }
+  return { response: aiData, content: typeof rawContent === "string" ? rawContent.trim() : "" };
+}
+function buildAiRequestBody(payload) {
+  const llmMessages = Array.isArray(payload.messages) && payload.messages.length > 0 ? payload.messages : [{ role: "user", content: payload.completePrompt }];
+  const requestBody = {
+    model: payload.primaryModel,
+    messages: llmMessages
+  };
+  if (payload.temperature !== void 0 && payload.temperature !== null) {
+    requestBody.temperature = payload.temperature;
+  } else if (!Array.isArray(payload.messages)) {
+    requestBody.temperature = 0.8;
+  }
+  if (payload.maxTokens === void 0 || payload.maxTokens === null) {
+    return requestBody;
+  }
+  if (!Number.isInteger(payload.maxTokens) || payload.maxTokens <= 0) {
+    throw new Error("Invalid maxTokens: maxTokens must be a positive integer when provided.");
+  }
+  requestBody.max_tokens = payload.maxTokens;
+  return requestBody;
+}
+function normalizeAiApiUrl(apiUrl) {
+  if (typeof apiUrl !== "string" || !apiUrl.trim()) {
+    throw new Error(
+      "Invalid apiUrl: apiUrl is required. Please provide a chat endpoint URL (for example: https://api.openai.com or https://api.openai.com/v1/chat/completions)."
+    );
+  }
+  const trimmedApiUrl = apiUrl.trim();
+  let parsedUrl;
+  try {
+    parsedUrl = new URL(trimmedApiUrl);
+  } catch (e3) {
+    throw new Error(
+      `Invalid apiUrl: "${apiUrl}". Please provide a valid absolute URL.`
+    );
+  }
+  let path = parsedUrl.pathname.replace(/\/+$/, "") || "/";
+  if (/\/chat\/completions$/.test(path)) {
+  } else if (path === "/") {
+    path = "/v1/chat/completions";
+  } else if (/\/v\d+$/.test(path)) {
+    path = `${path}/chat/completions`;
+  }
+  parsedUrl.pathname = path;
+  return parsedUrl.toString();
+}
+
+// src/server/lib/agentic-fire.js
+
+
+
+
+
+
+var DEFAULT_MAX_TOOL_ITERATIONS = 5;
+var DEFAULT_TOTAL_TIMEOUT_MS = 24e4;
 var SLEEP_BETWEEN_MESSAGES_MS = 1500;
+var CREDENTIAL_PAYLOAD_KEYS = /* @__PURE__ */ new Set(["apiKey", "pushSubscription"]);
+var defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function taskNeedsLlm(decryptedPayload) {
+  const type = decryptedPayload.messageType;
+  if (type === "prompted" || type === "auto") return true;
+  if (type === "instant") {
+    return !!(decryptedPayload.apiUrl && decryptedPayload.apiKey && decryptedPayload.primaryModel);
+  }
+  return false;
+}
+function buildHookTask(task, decryptedPayload) {
+  const safe = {};
+  for (const [key, value] of Object.entries(decryptedPayload)) {
+    if (!CREDENTIAL_PAYLOAD_KEYS.has(key)) safe[key] = value;
+  }
+  return Object.freeze({
+    ...safe,
+    id: _nullishCoalesce(task.id, () => ( null)),
+    uuid: _nullishCoalesce(task.uuid, () => ( null)),
+    nextSendAt: _nullishCoalesce(task.next_send_at, () => ( null)),
+    retryCount: _nullishCoalesce(task.retry_count, () => ( 0))
+  });
+}
+function normalizeBeforeFireResult(result) {
+  if (Array.isArray(result)) {
+    return { messages: result };
+  }
+  if (result && typeof result === "object" && Array.isArray(result.messages)) {
+    return {
+      messages: result.messages,
+      maxToolIterations: result.maxToolIterations,
+      totalTimeoutMs: result.totalTimeoutMs
+    };
+  }
+  throw new TypeError(
+    "AGENTIC_BAD_BEFORE_FIRE: onBeforeFire must return ChatMessage[] | { messages, maxToolIterations?, totalTimeoutMs? } | null"
+  );
+}
+function firstPositiveInt(values, fallback) {
+  for (const v of values) {
+    if (Number.isInteger(v) && v > 0) return v;
+  }
+  return fallback;
+}
+function firstPositiveNumber(values, fallback) {
+  for (const v of values) {
+    if (typeof v === "number" && Number.isFinite(v) && v > 0) return v;
+  }
+  return fallback;
+}
+async function runAgenticFire({ task, decryptedPayload, userKey, ctx }) {
+  const hooks = ctx.hooks;
+  if (typeof hooks.onLLMOutput !== "function") {
+    throw new Error("AGENTIC_CONFIG_ERROR: hooks.onBeforeFire requires hooks.onLLMOutput to classify LLM rounds");
+  }
+  const nowFn = typeof ctx._agenticNow === "function" ? ctx._agenticNow : Date.now;
+  const sleep = typeof ctx._agenticSleep === "function" ? ctx._agenticSleep : defaultSleep;
+  const readState = async (namespace) => {
+    if (typeof namespace !== "string" || !namespace.trim()) {
+      throw new TypeError("readState(namespace) requires a non-empty string");
+    }
+    if (!ctx.db || typeof ctx.db.getClientState !== "function") return [];
+    const rows = await ctx.db.getClientState(task.user_id, namespace);
+    return Promise.all(rows.map(async (row) => ({
+      namespace: row.namespace,
+      key: row.key,
+      value: await decryptFromStorage(row.value, userKey),
+      updatedAt: row.updated_at
+    })));
+  };
+  const fireCtx = Object.freeze({
+    task: buildHookTask(task, decryptedPayload),
+    userId: task.user_id,
+    readState,
+    now: new Date(nowFn())
+  });
+  const before = await hooks.onBeforeFire(fireCtx);
+  if (before == null) return { handled: false };
+  const normalized = normalizeBeforeFireResult(before);
+  const maxToolIterations = firstPositiveInt(
+    [normalized.maxToolIterations, ctx.maxToolIterations],
+    DEFAULT_MAX_TOOL_ITERATIONS
+  );
+  const totalTimeoutMs = firstPositiveNumber(
+    [normalized.totalTimeoutMs, ctx.totalTimeoutMs],
+    DEFAULT_TOTAL_TIMEOUT_MS
+  );
+  const deadline = nowFn() + totalTimeoutMs;
+  const sessionId = task.id != null ? `sess_task_${task.id}` : `sess_${randomUUID()}`;
+  let messages = normalized.messages.slice();
+  for (let iteration = 0; iteration < maxToolIterations; iteration++) {
+    if (nowFn() >= deadline) {
+      throw new Error(`AGENTIC_TOTAL_TIMEOUT: fire chain exceeded ${totalTimeoutMs}ms after ${iteration} LLM round(s)`);
+    }
+    const roundTimeoutMs = Math.max(1, Math.min(3e5, deadline - nowFn()));
+    const { response: llmResponse } = await callLlm(
+      { ...decryptedPayload, messages },
+      { requireContent: false, timeoutMs: roundTimeoutMs }
+    );
+    const assistantMessage = _amsgshared.extractAssistantMessage.call(void 0, llmResponse);
+    messages = [...messages, assistantMessage];
+    const sessionCtx = _amsgshared.buildSessionContext.call(void 0, {
+      sessionId,
+      messages,
+      llmResponse,
+      iteration,
+      contactName: decryptedPayload.contactName,
+      avatarUrl: decryptedPayload.avatarUrl || void 0,
+      charId: decryptedPayload.charId,
+      metadata: decryptedPayload.metadata
+    });
+    const decision = await hooks.onLLMOutput(sessionCtx);
+    _amsgshared.assertValidDecision.call(void 0, decision, { inlineToolCalls: true });
+    if (decision.decision === "continue") {
+      messages = decision.nextHistory.slice();
+      continue;
+    }
+    if (decision.decision === "skip-push") {
+      return { handled: true, result: { success: true, messagesSent: 0, status: "skipped", iterations: iteration + 1 } };
+    }
+    if (decision.decision === "finish") {
+      const messagesSent = await sendHookPushPayloads(decision.pushPayloads, decryptedPayload, ctx, sessionId, task, sleep);
+      return { handled: true, result: { success: true, messagesSent, status: "finished", iterations: iteration + 1 } };
+    }
+    const toolCalls = _amsgshared.extractToolCallsFromDecision.call(void 0, decision);
+    if (toolCalls.length === 0) {
+      throw new Error("AGENTIC_EMPTY_TOOL_REQUEST: tool-request decision carried no toolCalls (neither decision.toolCalls nor pushPayloads[].toolCalls)");
+    }
+    if (typeof hooks.executeToolCalls !== "function") {
+      throw new Error("AGENTIC_CONFIG_ERROR: onLLMOutput returned tool-request but hooks.executeToolCalls is not configured");
+    }
+    if (iteration === maxToolIterations - 1) {
+      break;
+    }
+    let toolResults;
+    try {
+      toolResults = await hooks.executeToolCalls(toolCalls, sessionCtx);
+      if (!Array.isArray(toolResults)) {
+        throw new TypeError('executeToolCalls must resolve to an array of { tool_call_id, role: "tool", content }');
+      }
+    } catch (error) {
+      toolResults = toolCalls.map((toolCall) => ({
+        tool_call_id: toolCall && typeof toolCall === "object" && typeof toolCall.id === "string" ? toolCall.id : "",
+        role: "tool",
+        content: `Tool execution failed: ${_nullishCoalesce(_optionalChain([error, 'optionalAccess', _6 => _6.message]), () => ( String(error)))}`
+      }));
+    }
+    const assistantWithTools = Array.isArray(assistantMessage.tool_calls) && assistantMessage.tool_calls.length > 0 ? assistantMessage : { ...assistantMessage, tool_calls: toolCalls };
+    messages = [...messages.slice(0, -1), assistantWithTools, ...toolResults];
+  }
+  throw new Error(`AGENTIC_LOOP_EXCEEDED: no finish/skip-push decision within ${maxToolIterations} LLM round(s)`);
+}
+async function sendHookPushPayloads(pushPayloads, decryptedPayload, ctx, sessionId, task, sleep) {
+  if (!ctx.vapid || !ctx.vapid.email || !ctx.vapid.publicKey || !ctx.vapid.privateKey) {
+    throw new Error("VAPID configuration missing - push notifications cannot be sent");
+  }
+  const pushSubscription = decryptedPayload.pushSubscription;
+  const total = pushPayloads.length;
+  const messageIdBase = task.id != null ? `msg_task_${task.id}` : `msg_${randomUUID()}`;
+  for (let i = 0; i < total; i++) {
+    const push = { ...pushPayloads[i] };
+    if (typeof push.messageId !== "string" || !push.messageId) push.messageId = `${messageIdBase}_hook_${i}`;
+    if (typeof push.sessionId !== "string" || !push.sessionId) push.sessionId = sessionId;
+    if (typeof push.timestamp !== "string" || !push.timestamp) push.timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    push.messageIndex = i + 1;
+    push.totalMessages = total;
+    await ctx.webpush.sendNotification(pushSubscription, JSON.stringify(push));
+    if (i < total - 1) await sleep(SLEEP_BETWEEN_MESSAGES_MS);
+  }
+  return total;
+}
+
+// src/server/lib/message-processor.js
+var DEFAULT_SPLIT_REGEX = /([。！？!?]+)/;
+var SLEEP_BETWEEN_MESSAGES_MS2 = 1500;
 function splitOnceByRegex(chunk, regex) {
   const out = chunk.split(regex).reduce((acc, part, i, arr) => {
     if (i % 2 === 0 && part.trim()) {
@@ -356,8 +688,12 @@ async function processSingleMessage(task, ctx, providedMasterKey) {
     if (!masterKey) {
       return { success: false, messagesSent: 0, error: "TENANT_MASTER_KEY_MISSING" };
     }
-    const userKey = deriveUserEncryptionKey(task.user_id, masterKey);
-    const decryptedPayload = JSON.parse(decryptFromStorage(task.encrypted_payload, userKey));
+    const userKey = await deriveUserEncryptionKey(task.user_id, masterKey);
+    const decryptedPayload = JSON.parse(await decryptFromStorage(task.encrypted_payload, userKey));
+    if (ctx.hooks && typeof ctx.hooks.onBeforeFire === "function" && taskNeedsLlm(decryptedPayload)) {
+      const agentic = await runAgenticFire({ task, decryptedPayload, userKey, ctx });
+      if (agentic.handled) return agentic.result;
+    }
     let messageContent;
     let llmResponse = null;
     if (decryptedPayload.messageType === "fixed") {
@@ -365,7 +701,7 @@ async function processSingleMessage(task, ctx, providedMasterKey) {
     } else if (decryptedPayload.messageType === "instant") {
       const hasPrompt = !!decryptedPayload.completePrompt || Array.isArray(decryptedPayload.messages) && decryptedPayload.messages.length > 0;
       if (hasPrompt && decryptedPayload.apiUrl && decryptedPayload.apiKey && decryptedPayload.primaryModel) {
-        const aiResult = await _callAI(decryptedPayload);
+        const aiResult = await callLlm(decryptedPayload);
         messageContent = aiResult.content;
         llmResponse = aiResult.response;
       } else if (decryptedPayload.userMessage) {
@@ -374,7 +710,7 @@ async function processSingleMessage(task, ctx, providedMasterKey) {
         throw new Error("Invalid instant message: no content source available");
       }
     } else if (decryptedPayload.messageType === "prompted" || decryptedPayload.messageType === "auto") {
-      const aiResult = await _callAI(decryptedPayload);
+      const aiResult = await callLlm(decryptedPayload);
       messageContent = aiResult.content;
       llmResponse = aiResult.response;
     } else {
@@ -389,12 +725,12 @@ async function processSingleMessage(task, ctx, providedMasterKey) {
       throw new Error("VAPID configuration missing - push notifications cannot be sent");
     }
     const pushSubscription = decryptedPayload.pushSubscription;
-    const sessionId = task.id != null ? `sess_task_${task.id}` : `sess_${_crypto.randomUUID.call(void 0, )}`;
+    const sessionId = task.id != null ? `sess_task_${task.id}` : `sess_${randomUUID()}`;
     const source = decryptedPayload.messageType === "instant" ? "instant" : "scheduled";
     const messageSubtype = decryptedPayload.messageSubtype || "chat";
     const avatarUrl = decryptedPayload.avatarUrl || null;
     const metadata = decryptedPayload.metadata || {};
-    const messageIdBase = task.id != null ? `msg_task_${task.id}` : `msg_${_crypto.randomUUID.call(void 0, )}_instant`;
+    const messageIdBase = task.id != null ? `msg_task_${task.id}` : `msg_${randomUUID()}_instant`;
     if (reasoning) {
       const reasoningPush = _amsgshared.buildReasoningPush.call(void 0, {
         messageType: decryptedPayload.messageType,
@@ -410,7 +746,7 @@ async function processSingleMessage(task, ctx, providedMasterKey) {
         metadata
       });
       await ctx.webpush.sendNotification(pushSubscription, JSON.stringify(reasoningPush));
-      await new Promise((resolve) => setTimeout(resolve, SLEEP_BETWEEN_MESSAGES_MS));
+      await new Promise((resolve) => setTimeout(resolve, SLEEP_BETWEEN_MESSAGES_MS2));
     }
     for (let i = 0; i < messages.length; i++) {
       const contentPush = _amsgshared.buildContentPush.call(void 0, {
@@ -431,7 +767,7 @@ async function processSingleMessage(task, ctx, providedMasterKey) {
       });
       await ctx.webpush.sendNotification(pushSubscription, JSON.stringify(contentPush));
       if (i < messages.length - 1) {
-        await new Promise((resolve) => setTimeout(resolve, SLEEP_BETWEEN_MESSAGES_MS));
+        await new Promise((resolve) => setTimeout(resolve, SLEEP_BETWEEN_MESSAGES_MS2));
       }
     }
     return { success: true, messagesSent: messages.length };
@@ -501,80 +837,6 @@ async function processMessagesByUuid(uuid, ctx, maxRetries = 2, userId, provided
     return { success: true, messagesSent: result.messagesSent, retriesUsed: retryCount };
   }
 }
-async function _callAI(payload) {
-  const normalizedApiUrl = normalizeAiApiUrl(payload.apiUrl);
-  const requestBody = buildAiRequestBody(payload);
-  const aiResponse = await fetch(normalizedApiUrl, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      "Authorization": `Bearer ${payload.apiKey}`
-    },
-    body: JSON.stringify(requestBody),
-    signal: AbortSignal.timeout(3e5)
-  });
-  if (!aiResponse.ok) {
-    if (aiResponse.status === 405) {
-      throw new Error(
-        `AI API error: 405 Method Not Allowed. apiUrl must point to a full chat endpoint (for example: /chat/completions). Received: ${normalizedApiUrl}`
-      );
-    }
-    throw new Error(
-      `AI API error: ${aiResponse.status} ${aiResponse.statusText || "Unknown Error"}. Request URL: ${normalizedApiUrl}`
-    );
-  }
-  const aiData = await aiResponse.json();
-  const content = _optionalChain([aiData, 'optionalAccess', _2 => _2.choices, 'optionalAccess', _3 => _3[0], 'optionalAccess', _4 => _4.message, 'optionalAccess', _5 => _5.content]);
-  if (typeof content !== "string" || !content.trim()) {
-    throw new Error("AI API error: response missing choices[0].message.content");
-  }
-  return { response: aiData, content: content.trim() };
-}
-function buildAiRequestBody(payload) {
-  const llmMessages = Array.isArray(payload.messages) && payload.messages.length > 0 ? payload.messages : [{ role: "user", content: payload.completePrompt }];
-  const requestBody = {
-    model: payload.primaryModel,
-    messages: llmMessages
-  };
-  if (payload.temperature !== void 0 && payload.temperature !== null) {
-    requestBody.temperature = payload.temperature;
-  } else if (!Array.isArray(payload.messages)) {
-    requestBody.temperature = 0.8;
-  }
-  if (payload.maxTokens === void 0 || payload.maxTokens === null) {
-    return requestBody;
-  }
-  if (!Number.isInteger(payload.maxTokens) || payload.maxTokens <= 0) {
-    throw new Error("Invalid maxTokens: maxTokens must be a positive integer when provided.");
-  }
-  requestBody.max_tokens = payload.maxTokens;
-  return requestBody;
-}
-function normalizeAiApiUrl(apiUrl) {
-  if (typeof apiUrl !== "string" || !apiUrl.trim()) {
-    throw new Error(
-      "Invalid apiUrl: apiUrl is required. Please provide a chat endpoint URL (for example: https://api.openai.com or https://api.openai.com/v1/chat/completions)."
-    );
-  }
-  const trimmedApiUrl = apiUrl.trim();
-  let parsedUrl;
-  try {
-    parsedUrl = new URL(trimmedApiUrl);
-  } catch (e3) {
-    throw new Error(
-      `Invalid apiUrl: "${apiUrl}". Please provide a valid absolute URL.`
-    );
-  }
-  let path = parsedUrl.pathname.replace(/\/+$/, "") || "/";
-  if (/\/chat\/completions$/.test(path)) {
-  } else if (path === "/") {
-    path = "/v1/chat/completions";
-  } else if (/\/v\d+$/.test(path)) {
-    path = `${path}/chat/completions`;
-  }
-  parsedUrl.pathname = path;
-  return parsedUrl.toString();
-}
 
 // src/server/handlers/schedule-message.js
 function createScheduleMessageHandler(ctx) {
@@ -606,10 +868,10 @@ function createScheduleMessageHandler(ctx) {
       return { status: 400, body: { success: false, error: parsedBody.error } };
     }
     const encryptedBody = parsedBody.data;
+    const userKey = await deriveUserEncryptionKey(userId, masterKey);
     let payload;
     try {
-      const userKey2 = deriveUserEncryptionKey(userId, masterKey);
-      payload = decryptPayload(encryptedBody, userKey2);
+      payload = await decryptPayload(encryptedBody, userKey);
     } catch (error) {
       if (error instanceof SyntaxError) {
         return { status: 400, body: { success: false, error: { code: "INVALID_PAYLOAD_FORMAT", message: "\u89E3\u5BC6\u540E\u7684\u6570\u636E\u4E0D\u662F\u6709\u6548 JSON" } } };
@@ -627,8 +889,7 @@ function createScheduleMessageHandler(ctx) {
     if (!validationResult.valid) {
       return { status: 400, body: { success: false, error: { code: validationResult.errorCode, message: validationResult.errorMessage, details: validationResult.details } } };
     }
-    const taskUuid = payload.uuid || _crypto.randomUUID.call(void 0, );
-    const userKey = deriveUserEncryptionKey(userId, masterKey);
+    const taskUuid = payload.uuid || randomUUID();
     const fullTaskData = {
       contactName: payload.contactName,
       avatarUrl: payload.avatarUrl || null,
@@ -654,7 +915,7 @@ function createScheduleMessageHandler(ctx) {
       pushSubscription: payload.pushSubscription,
       metadata: payload.metadata || {}
     };
-    const encryptedPayload = encryptForStorage(JSON.stringify(fullTaskData), userKey);
+    const encryptedPayload = await encryptForStorage(JSON.stringify(fullTaskData), userKey);
     if (payload.messageType === "instant") {
       if (!ctx.vapid.email || !ctx.vapid.publicKey || !ctx.vapid.privateKey) {
         return {
@@ -808,8 +1069,8 @@ async function runScheduledTick(ctx) {
       return;
     }
     try {
-      const userKey = deriveUserEncryptionKey(task.user_id, masterKey);
-      const decryptedPayload = JSON.parse(decryptFromStorage(task.encrypted_payload, userKey));
+      const userKey = await deriveUserEncryptionKey(task.user_id, masterKey);
+      const decryptedPayload = JSON.parse(await decryptFromStorage(task.encrypted_payload, userKey));
       if (decryptedPayload.recurrenceType === "none") {
         await db.deleteTaskById(task.id);
         results.deletedOnceOffTasks++;
@@ -896,10 +1157,10 @@ function createUpdateMessageHandler(ctx) {
       return { status: 400, body: { success: false, error: parsedBody.error } };
     }
     const encryptedBody = parsedBody.data;
-    const userKey = deriveUserEncryptionKey(userId, masterKey);
+    const userKey = await deriveUserEncryptionKey(userId, masterKey);
     let updates;
     try {
-      updates = decryptPayload(encryptedBody, userKey);
+      updates = await decryptPayload(encryptedBody, userKey);
     } catch (_error) {
       return { status: 400, body: { success: false, error: { code: "DECRYPTION_FAILED", message: "\u8BF7\u6C42\u4F53\u89E3\u5BC6\u5931\u8D25" } } };
     }
@@ -948,7 +1209,7 @@ function createUpdateMessageHandler(ctx) {
       }
       return { status: 409, body: { success: false, error: { code: "TASK_ALREADY_COMPLETED", message: "\u4EFB\u52A1\u5DF2\u5B8C\u6210\u6216\u5DF2\u5931\u8D25\uFF0C\u65E0\u6CD5\u66F4\u65B0" } } };
     }
-    const existingData = JSON.parse(decryptFromStorage(existingTask.encrypted_payload, userKey));
+    const existingData = JSON.parse(await decryptFromStorage(existingTask.encrypted_payload, userKey));
     const promptUpdates = {};
     if (updates.completePrompt) {
       promptUpdates.completePrompt = updates.completePrompt;
@@ -971,7 +1232,7 @@ function createUpdateMessageHandler(ctx) {
       // string fields above are.
       ...Object.prototype.hasOwnProperty.call(updates, "splitPattern") && { splitPattern: _nullishCoalesce(updates.splitPattern, () => ( null)) }
     };
-    const encryptedPayload = encryptForStorage(JSON.stringify(updatedData), userKey);
+    const encryptedPayload = await encryptForStorage(JSON.stringify(updatedData), userKey);
     const extraFields = updates.nextSendAt ? { next_send_at: updates.nextSendAt } : void 0;
     const result = await db.updateTaskByUuid(taskUuid, userId, encryptedPayload, extraFields);
     if (!result) {
@@ -1064,9 +1325,9 @@ function createMessagesHandler(ctx) {
       return { status: 400, body: { success: false, error: { code: "INVALID_PARAMETERS", message: "offset \u53C2\u6570\u65E0\u6548\uFF0C\u5FC5\u987B\u4E3A\u975E\u8D1F\u6574\u6570" } } };
     }
     const { tasks, total } = await db.listTasks(userId, { status, limit, offset });
-    const userKey = deriveUserEncryptionKey(userId, masterKey);
-    const decryptedTasks = tasks.map((task) => {
-      const decrypted = JSON.parse(decryptFromStorage(task.encrypted_payload, userKey));
+    const userKey = await deriveUserEncryptionKey(userId, masterKey);
+    const decryptedTasks = await Promise.all(tasks.map(async (task) => {
+      const decrypted = JSON.parse(await decryptFromStorage(task.encrypted_payload, userKey));
       return {
         id: task.id,
         uuid: task.uuid,
@@ -1080,12 +1341,12 @@ function createMessagesHandler(ctx) {
         createdAt: task.created_at,
         updatedAt: task.updated_at
       };
-    });
+    }));
     const responsePayload = {
       tasks: decryptedTasks,
       pagination: { total, limit, offset, hasMore: offset + limit < total }
     };
-    const encryptedResponse = encryptPayload(responsePayload, userKey);
+    const encryptedResponse = await encryptPayload(responsePayload, userKey);
     return {
       status: 200,
       body: {
@@ -1155,6 +1416,16 @@ var SQLITE_INDEXES = [
     critical: true
   }
 ];
+var CLIENT_STATE_TABLE_SQL = `
+  CREATE TABLE IF NOT EXISTS client_state (
+    user_id TEXT NOT NULL,
+    namespace TEXT NOT NULL,
+    key TEXT NOT NULL,
+    value TEXT NOT NULL,
+    updated_at INTEGER NOT NULL,
+    PRIMARY KEY (user_id, namespace, key)
+  )
+`;
 
 // src/server/adapters/d1.js
 var UPDATABLE_COLUMNS = /* @__PURE__ */ new Set([
@@ -1187,6 +1458,7 @@ var D1Adapter = class {
   }
   async initSchema() {
     await this._db.prepare(SQLITE_TABLE_SQL).run();
+    await this._db.prepare(CLIENT_STATE_TABLE_SQL).run();
     const indexResults = [];
     for (const index of SQLITE_INDEXES) {
       try {
@@ -1213,6 +1485,7 @@ var D1Adapter = class {
   }
   async dropSchema() {
     await this._db.prepare("DROP TABLE IF EXISTS scheduled_messages").run();
+    await this._db.prepare("DROP TABLE IF EXISTS client_state").run();
   }
   async createTask(params) {
     const now = this._now();
@@ -1341,6 +1614,77 @@ var D1Adapter = class {
     ).bind(uuid, userId).first();
     return row ? row.status : null;
   }
+  // ── client_state (single-user cloud state mirror) ──────────────────────
+  /**
+   * Batch upsert. Last-write-wins per (namespace, key): an entry older
+   * than the stored row (updatedAt strictly lower) is skipped; equal or
+   * newer overwrites. Values arrive pre-encrypted (the handler encrypts).
+   *
+   * Uses D1's batch() — one network round trip for the whole set (implicit
+   * transaction). The client calls this endpoint inside its few-seconds
+   * background window, so N sequential round trips could eat the whole
+   * window. Bindings without batch() (e.g. the sqlite test shim, custom
+   * adapters) fall back to a sequential loop.
+   *
+   * @param {string} userId
+   * @param {Array<{ namespace: string, key: string, value: string, updatedAt: number }>} entries
+   * @returns {Promise<{ upserted: number, skipped: number }>}
+   */
+  async upsertClientState(userId, entries) {
+    const UPSERT_SQL = `INSERT INTO client_state (user_id, namespace, key, value, updated_at)
+       VALUES (?, ?, ?, ?, ?)
+       ON CONFLICT (user_id, namespace, key) DO UPDATE SET
+         value = excluded.value,
+         updated_at = excluded.updated_at
+       WHERE excluded.updated_at >= client_state.updated_at`;
+    let results;
+    if (typeof this._db.batch === "function") {
+      const statements = entries.map(
+        (entry) => this._db.prepare(UPSERT_SQL).bind(userId, entry.namespace, entry.key, entry.value, entry.updatedAt)
+      );
+      results = await this._db.batch(statements);
+    } else {
+      results = [];
+      for (const entry of entries) {
+        results.push(
+          await this._db.prepare(UPSERT_SQL).bind(userId, entry.namespace, entry.key, entry.value, entry.updatedAt).run()
+        );
+      }
+    }
+    let upserted = 0;
+    let skipped = 0;
+    for (const res of results) {
+      if (res.meta.changes > 0) upserted++;
+      else skipped++;
+    }
+    return { upserted, skipped };
+  }
+  /**
+   * All entries of one namespace (values still encrypted).
+   *
+   * @param {string} userId
+   * @param {string} namespace
+   * @returns {Promise<Array<{ namespace: string, key: string, value: string, updated_at: number }>>}
+   */
+  async getClientState(userId, namespace) {
+    const res = await this._db.prepare(
+      `SELECT namespace, key, value, updated_at
+       FROM client_state
+       WHERE user_id = ? AND namespace = ?
+       ORDER BY key ASC`
+    ).bind(userId, namespace).all();
+    return res.results || [];
+  }
+  /**
+   * Wipe every entry of this user.
+   *
+   * @param {string} userId
+   * @returns {Promise<number>} rows deleted
+   */
+  async clearClientState(userId) {
+    const res = await this._db.prepare("DELETE FROM client_state WHERE user_id = ?").bind(userId).run();
+    return res.meta.changes || 0;
+  }
 };
 function createD1Adapter(db) {
   if (!db || typeof db.prepare !== "function") {
@@ -1454,6 +1798,131 @@ function createVapidPublicKeyHandler(ctx) {
   return { GET };
 }
 
+// src/server/handlers/client-state.js
+var MAX_STATE_VALUE_BYTES = 200 * 1024;
+var MAX_STATE_ENTRIES_PER_REQUEST = 200;
+var MAX_NAMESPACE_CHARS = 128;
+var MAX_KEY_CHARS = 256;
+var utf82 = new TextEncoder();
+function err(status, code, message, details) {
+  const error = details === void 0 ? { code, message } : { code, message, details };
+  return { status, body: { success: false, error } };
+}
+function requireUserId(headers) {
+  const userId = getHeader(headers, "x-user-id");
+  if (!userId) return { error: err(400, "USER_ID_REQUIRED", "\u7F3A\u5C11\u7528\u6237\u6807\u8BC6\u7B26") };
+  if (!isValidUUIDv4(userId)) return { error: err(400, "INVALID_USER_ID_FORMAT", "X-User-Id \u5FC5\u987B\u662F UUID v4 \u683C\u5F0F") };
+  return { userId };
+}
+function validateEntry(entry, index) {
+  if (!isPlainObject(entry)) return err(400, "INVALID_STATE_ENTRY", `entries[${index}] \u5FC5\u987B\u662F\u5BF9\u8C61`);
+  if (typeof entry.namespace !== "string" || !entry.namespace.trim() || entry.namespace.length > MAX_NAMESPACE_CHARS) {
+    return err(400, "INVALID_STATE_NAMESPACE", `entries[${index}].namespace \u5FC5\u987B\u662F 1-${MAX_NAMESPACE_CHARS} \u5B57\u7B26\u7684\u5B57\u7B26\u4E32`);
+  }
+  if (typeof entry.key !== "string" || !entry.key.trim() || entry.key.length > MAX_KEY_CHARS) {
+    return err(400, "INVALID_STATE_KEY", `entries[${index}].key \u5FC5\u987B\u662F 1-${MAX_KEY_CHARS} \u5B57\u7B26\u7684\u5B57\u7B26\u4E32`);
+  }
+  if (typeof entry.value !== "string") {
+    return err(400, "INVALID_STATE_VALUE", `entries[${index}].value \u5FC5\u987B\u662F\u5B57\u7B26\u4E32\uFF08\u5BBF\u4E3B\u81EA\u884C\u5E8F\u5217\u5316\uFF09`);
+  }
+  const bytes = utf82.encode(entry.value).length;
+  if (bytes > MAX_STATE_VALUE_BYTES) {
+    return err(413, "STATE_VALUE_TOO_LARGE", `entries[${index}].value \u8D85\u8FC7\u5355\u6761\u4E0A\u9650`, { index, key: entry.key, bytes, maxBytes: MAX_STATE_VALUE_BYTES });
+  }
+  if (!Number.isInteger(entry.updatedAt) || entry.updatedAt <= 0) {
+    return err(400, "INVALID_STATE_UPDATED_AT", `entries[${index}].updatedAt \u5FC5\u987B\u662F\u6B63\u6574\u6570\uFF08epoch \u6BEB\u79D2\uFF09`);
+  }
+  return null;
+}
+function createClientStateHandler(ctx) {
+  async function PUT(headers, body) {
+    const tenantResult = await ctx.tenantManager.resolveTenant(headers);
+    if (!tenantResult.ok) return tenantResult.error;
+    const { db, masterKey } = tenantResult.context;
+    if (getHeader(headers, "x-payload-encrypted") !== "true") {
+      return err(400, "ENCRYPTION_REQUIRED", "\u8BF7\u6C42\u4F53\u5FC5\u987B\u52A0\u5BC6");
+    }
+    const gate = requireUserId(headers);
+    if (gate.error) return gate.error;
+    const { userId } = gate;
+    if (getHeader(headers, "x-encryption-version") !== "1") {
+      return err(400, "UNSUPPORTED_ENCRYPTION_VERSION", "\u52A0\u5BC6\u7248\u672C\u4E0D\u652F\u6301");
+    }
+    const parsedBody = parseEncryptedBody(body);
+    if (!parsedBody.ok) return { status: 400, body: { success: false, error: parsedBody.error } };
+    const userKey = await deriveUserEncryptionKey(userId, masterKey);
+    let payload;
+    try {
+      payload = await decryptPayload(parsedBody.data, userKey);
+    } catch (error) {
+      if (error instanceof SyntaxError) {
+        return err(400, "INVALID_PAYLOAD_FORMAT", "\u89E3\u5BC6\u540E\u7684\u6570\u636E\u4E0D\u662F\u6709\u6548 JSON");
+      }
+      return err(400, "DECRYPTION_FAILED", "\u8BF7\u6C42\u4F53\u89E3\u5BC6\u5931\u8D25");
+    }
+    if (!isPlainObject(payload)) return err(400, "INVALID_PAYLOAD_FORMAT", "\u89E3\u5BC6\u540E\u7684\u6570\u636E\u5FC5\u987B\u662F JSON \u5BF9\u8C61");
+    const entries = payload.entries;
+    if (!Array.isArray(entries) || entries.length === 0) {
+      return err(400, "INVALID_STATE_ENTRIES", "entries \u5FC5\u987B\u662F\u975E\u7A7A\u6570\u7EC4");
+    }
+    if (entries.length > MAX_STATE_ENTRIES_PER_REQUEST) {
+      return err(400, "TOO_MANY_STATE_ENTRIES", `\u5355\u6B21\u6700\u591A ${MAX_STATE_ENTRIES_PER_REQUEST} \u6761`, { count: entries.length });
+    }
+    for (let i = 0; i < entries.length; i++) {
+      const invalid = validateEntry(entries[i], i);
+      if (invalid) return invalid;
+    }
+    if (typeof db.upsertClientState !== "function") {
+      return err(501, "CLIENT_STATE_NOT_SUPPORTED", "\u5F53\u524D\u6570\u636E\u5E93\u9002\u914D\u5668\u4E0D\u652F\u6301 client_state");
+    }
+    const encryptedEntries = await Promise.all(entries.map(async (entry) => ({
+      namespace: entry.namespace,
+      key: entry.key,
+      value: await encryptForStorage(entry.value, userKey),
+      updatedAt: entry.updatedAt
+    })));
+    const { upserted, skipped } = await db.upsertClientState(userId, encryptedEntries);
+    return { status: 200, body: { success: true, data: { upserted, skipped } } };
+  }
+  async function GET(url, headers) {
+    const tenantResult = await ctx.tenantManager.resolveTenant(headers);
+    if (!tenantResult.ok) return tenantResult.error;
+    const { db, masterKey } = tenantResult.context;
+    const gate = requireUserId(headers);
+    if (gate.error) return gate.error;
+    const { userId } = gate;
+    const namespace = new URL(url, "https://dummy").searchParams.get("namespace") || "";
+    if (!namespace.trim()) return err(400, "NAMESPACE_REQUIRED", "\u5FC5\u987B\u63D0\u4F9B namespace \u67E5\u8BE2\u53C2\u6570");
+    if (typeof db.getClientState !== "function") {
+      return err(501, "CLIENT_STATE_NOT_SUPPORTED", "\u5F53\u524D\u6570\u636E\u5E93\u9002\u914D\u5668\u4E0D\u652F\u6301 client_state");
+    }
+    const userKey = await deriveUserEncryptionKey(userId, masterKey);
+    const rows = await db.getClientState(userId, namespace);
+    const decrypted = await Promise.all(rows.map(async (row) => ({
+      namespace: row.namespace,
+      key: row.key,
+      value: await decryptFromStorage(row.value, userKey),
+      updatedAt: row.updated_at
+    })));
+    const encryptedResponse = await encryptPayload({ namespace, entries: decrypted }, userKey);
+    return { status: 200, body: { success: true, encrypted: true, version: 1, data: encryptedResponse } };
+  }
+  async function DELETE(url, headers) {
+    const tenantResult = await ctx.tenantManager.resolveTenant(headers);
+    if (!tenantResult.ok) return tenantResult.error;
+    const { db } = tenantResult.context;
+    const gate = requireUserId(headers);
+    if (gate.error) return gate.error;
+    const { userId } = gate;
+    if (typeof db.clearClientState !== "function") {
+      return err(501, "CLIENT_STATE_NOT_SUPPORTED", "\u5F53\u524D\u6570\u636E\u5E93\u9002\u914D\u5668\u4E0D\u652F\u6301 client_state");
+    }
+    const deleted = await db.clearClientState(userId);
+    return { status: 200, body: { success: true, data: { deleted } } };
+  }
+  return { PUT, GET, DELETE };
+}
+
 // src/server/single-user.js
 function createSingleUserServer(config) {
   if (!config || !config.db) throw new Error("[amsg-server single-user] config.db is required");
@@ -1471,7 +1940,13 @@ function createSingleUserServer(config) {
       privateKey: vapid.privateKey || ""
     },
     webpush: config.webpush || null,
-    tenantManager
+    tenantManager,
+    // Fire-time hooks (optional): the in-server instant path fires through
+    // processMessagesByUuid with this ctx, so instant-type tasks can take
+    // the agentic path too.
+    hooks: config.hooks || null,
+    maxToolIterations: config.maxToolIterations,
+    totalTimeoutMs: config.totalTimeoutMs
   };
   return {
     ctx,
@@ -1482,36 +1957,12 @@ function createSingleUserServer(config) {
       updateMessage: createUpdateMessageHandler(ctx),
       cancelMessage: createCancelMessageHandler(ctx),
       messages: createMessagesHandler(ctx),
-      vapidPublicKey: createVapidPublicKeyHandler(ctx)
+      vapidPublicKey: createVapidPublicKeyHandler(ctx),
+      clientState: createClientStateHandler(ctx)
     }
   };
 }
 
-// src/server/lib/webcrypto-utils.js
-
-var TEXT_ENCODER = new TextEncoder();
-var TEXT_DECODER = new TextDecoder("utf-8", { fatal: false });
-function utf8(str) {
-  return TEXT_ENCODER.encode(String(str));
-}
-function bytesToBase64Url(buf) {
-  const bytes = _amsgshared.toUint8.call(void 0, buf);
-  let bin = "";
-  for (let i = 0; i < bytes.length; i++) {
-    bin += String.fromCharCode(bytes[i]);
-  }
-  const b64 = typeof btoa === "function" ? btoa(bin) : Buffer.from(bin, "binary").toString("base64");
-  return b64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
-}
-function jsonToBase64Url(value) {
-  return bytesToBase64Url(utf8(JSON.stringify(value)));
-}
-function randomBytes2(n) {
-  const out = new Uint8Array(n);
-  globalThis.crypto.getRandomValues(out);
-  return out;
-}
-
 // src/server/lib/webpush-webcrypto.js
 
 var KEY_INFO_PREFIX = utf8("WebPush: info\0");
@@ -1561,12 +2012,12 @@ async function sendWebPush({ subscription, payload, vapid, ttl, fetch: fetchImpl
   });
   if (!res.ok) {
     const text = await safeReadText(res);
-    const err = new Error(
+    const err2 = new Error(
       `Web Push delivery failed: ${res.status} ${res.statusText || ""}${text ? ` \u2014 ${text}` : ""}`
     );
-    err.code = "PUSH_SEND_FAILED";
-    err.statusCode = res.status;
-    throw err;
+    err2.code = "PUSH_SEND_FAILED";
+    err2.statusCode = res.status;
+    throw err2;
   }
   return {
     statusCode: res.status,
@@ -1599,7 +2050,7 @@ async function encryptPushPayload({ plaintext, uaPublicKey, authSecret }) {
   );
   const keyInfo = _amsgshared.concatBytes.call(void 0, KEY_INFO_PREFIX, uaPublicKey, asPublicRaw);
   const ikm = await hkdfSha256(authSecret, ecdhSecret, keyInfo, 32);
-  const salt = randomBytes2(16);
+  const salt = randomBytes(16);
   const cekBytes = await hkdfSha256(salt, ikm, CEK_INFO, 16);
   const cek = await globalThis.crypto.subtle.importKey(
     "raw",
@@ -1773,6 +2224,12 @@ function createSingleUserCloudflareWorker(buildConfig) {
         result = await server.handlers.cancelMessage.DELETE(url, headers);
       } else if (method === "GET" && pathname.endsWith("/vapid-public-key")) {
         result = await server.handlers.vapidPublicKey.GET(url, headers);
+      } else if (method === "PUT" && pathname.endsWith("/client-state")) {
+        result = await server.handlers.clientState.PUT(headers, await request.text());
+      } else if (method === "GET" && pathname.endsWith("/client-state")) {
+        result = await server.handlers.clientState.GET(url, headers);
+      } else if (method === "DELETE" && pathname.endsWith("/client-state")) {
+        result = await server.handlers.clientState.DELETE(url, headers);
       } else {
         result = { status: 404, body: { success: false, error: { code: "NOT_FOUND", message: "Unknown route" } } };
       }
@@ -1790,7 +2247,17 @@ function createSingleUserCloudflareWorker(buildConfig) {
       return;
     }
     try {
-      await runScheduledTick({ db: cfg.db, masterKey: cfg.masterKey, vapid, webpush: cfg.webpush });
+      await runScheduledTick({
+        db: cfg.db,
+        masterKey: cfg.masterKey,
+        vapid,
+        webpush: cfg.webpush,
+        // Fire-time hooks (optional; see lib/agentic-fire.js). runScheduledTick
+        // spreads its ctx into processSingleMessage, so these ride along.
+        hooks: cfg.hooks || null,
+        maxToolIterations: cfg.maxToolIterations,
+        totalTimeoutMs: cfg.totalTimeoutMs
+      });
     } catch (error) {
       console.error("[amsg single-user] scheduled(): tick failed:", error && error.message);
     }