@xisui-pa/chatserver 1.0.0 → 1.1.0

package/dist/index.js

@@ -3405,6 +3405,7 @@ const reference_1 = __webpack_require__(1117);
 const registry_3 = __webpack_require__(418);
 const api_1 = __webpack_require__(2981);
 const image_generation_1 = __webpack_require__(3376);
+const type_guards_1 = __webpack_require__(3012);
 /**
  * Values used when the config file does not specify an option.
  */
@@ -3451,12 +3452,6 @@ async function writeDefaultConfig(configPath) {
     await node_fs_1.promises.mkdir(node_path_1.default.dirname(configPath), { recursive: true });
     await node_fs_1.promises.writeFile(configPath, `${JSON.stringify(exports.DEFAULT_CONFIG, null, 2)}\n`, 'utf8');
 }
-/**
- * Returns true for plain JSON objects (not null, arrays, or primitives).
- */
-function isPlainObject(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
 /**
  * Warns about keys that are not part of the schema.
  */
@@ -3470,28 +3465,28 @@ function warnUnknownKeys(record, known, where) {
  * Normalizes filter fields from either a shorthand string or an object.
  */
 function parseSpecFields(value, where) {
-    if (typeof value === 'string') {
+    if ((0, type_guards_1.isString)(value)) {
         if (value.trim() === '') {
             throw new ConfigError(`${where} must not be empty.`);
         }
         return { type: value.trim(), options: {} };
     }
-    if (!isPlainObject(value)) {
+    if (!(0, type_guards_1.isRecord)(value)) {
         throw new ConfigError(`${where} must be a string or an object with a "type" and optional "options".`);
     }
     warnUnknownKeys(value, ['type', 'model', 'options'], where);
-    if (typeof value.type !== 'string' || value.type.trim() === '') {
+    if (!(0, type_guards_1.isString)(value.type) || value.type.trim() === '') {
         throw new ConfigError(`${where}: "type" must be a non-empty string.`);
     }
     const options = value.options ?? {};
-    if (!isPlainObject(options)) {
+    if (!(0, type_guards_1.isRecord)(options)) {
         throw new ConfigError(`${where}: "options" must be an object.`);
     }
     return { type: value.type.trim(), options };
 }
 /** Validates the syntax of a model reference without reading models.json. */
 function modelReference(value, where) {
-    if (typeof value !== 'string' || !value.trim()) {
+    if (!(0, type_guards_1.isString)(value) || !value.trim()) {
         throw new ConfigError(`${where} must be a non-empty <provider>/<model id> reference.`);
     }
     const reference = value.trim();
@@ -3514,7 +3509,7 @@ function imageDimensionLimit(value, fallback, where) {
 }
 /** Parses the chat transport and its bound reply model. */
 function parseMessagerSpec(value, where) {
-    if (!isPlainObject(value)) {
+    if (!(0, type_guards_1.isRecord)(value)) {
         throw new ConfigError(`${where} must be an object with "name", "replier", and optional "options".`);
     }
     if (Object.hasOwn(value, 'tools')) {
@@ -3522,39 +3517,39 @@ function parseMessagerSpec(value, where) {
     }
     warnUnknownKeys(value, ['name', 'replier', 'persona', 'memoryTokenLimit', 'mainAccount', 'localTools', 'apiTools',
         'imageGeneration', 'imageWidthLimit', 'imageHeightLimit', 'dailyImageGenLimit', 'options'], where);
-    if (typeof value.name !== 'string' || !value.name.trim()) {
+    if (!(0, type_guards_1.isString)(value.name) || !value.name.trim()) {
         throw new ConfigError(`${where}: "name" must be a non-empty registered messager name.`);
     }
     const name = value.name.trim();
     if (value.persona !== undefined &&
-        (typeof value.persona !== 'string' || !value.persona.trim())) {
+        (!(0, type_guards_1.isString)(value.persona) || !value.persona.trim())) {
         throw new ConfigError(`${where}.persona must be a non-empty string.`);
     }
     const persona = value.persona?.trim();
     const memoryTokenLimit = value.memoryTokenLimit;
-    if (memoryTokenLimit !== undefined && (typeof memoryTokenLimit !== 'number' || !Number.isInteger(memoryTokenLimit) ||
+    if (memoryTokenLimit !== undefined && (!(0, type_guards_1.isNumber)(memoryTokenLimit) || !Number.isInteger(memoryTokenLimit) ||
         memoryTokenLimit < limit_1.MIN_MEMORY_TOKEN_LIMIT || memoryTokenLimit > limit_1.MAX_MEMORY_TOKEN_LIMIT)) {
         throw new ConfigError(`${where}.memoryTokenLimit must be an integer between ${limit_1.MIN_MEMORY_TOKEN_LIMIT} and ${limit_1.MAX_MEMORY_TOKEN_LIMIT}.`);
     }
     if (value.mainAccount !== undefined &&
-        (typeof value.mainAccount !== 'string' || !value.mainAccount.trim())) {
+        (!(0, type_guards_1.isString)(value.mainAccount) || !value.mainAccount.trim())) {
         throw new ConfigError(`${where}.mainAccount must be a non-empty sender ID.`);
     }
     const mainAccount = value.mainAccount?.trim();
-    if (value.imageGeneration !== undefined && typeof value.imageGeneration !== 'boolean') {
+    if (value.imageGeneration !== undefined && !(0, type_guards_1.isBoolean)(value.imageGeneration)) {
         throw new ConfigError(`${where}.imageGeneration must be a boolean.`);
     }
     const imageWidthLimit = imageDimensionLimit(value.imageWidthLimit, limit_1.DEFAULT_IMAGE_WIDTH_LIMIT, `${where}.imageWidthLimit`);
     const imageHeightLimit = imageDimensionLimit(value.imageHeightLimit, limit_1.DEFAULT_IMAGE_HEIGHT_LIMIT, `${where}.imageHeightLimit`);
     const dailyImageGenLimit = value.dailyImageGenLimit === undefined ? limit_1.DEFAULT_DAILY_IMAGE_GEN_LIMIT : value.dailyImageGenLimit;
-    if (typeof dailyImageGenLimit !== 'number' || !Number.isSafeInteger(dailyImageGenLimit) || dailyImageGenLimit < 0) {
+    if (!(0, type_guards_1.isNumber)(dailyImageGenLimit) || !Number.isSafeInteger(dailyImageGenLimit) || dailyImageGenLimit < 0) {
         throw new ConfigError(`${where}.dailyImageGenLimit must be a nonnegative safe integer.`);
     }
     if (!(0, registry_2.hasMessager)(name)) {
         throw new ConfigError(`${where}: unknown messager "${name}". Available: ${(0, registry_2.listMessagers)().join(', ')}.`);
     }
     const options = value.options ?? {};
-    if (!isPlainObject(options)) {
+    if (!(0, type_guards_1.isRecord)(options)) {
         throw new ConfigError(`${where}: "options" must be an object.`);
     }
     let localTools;
@@ -3587,16 +3582,16 @@ function parseFilterSpec(value, where) {
             `Available: ${(0, registry_1.listFilters)().join(', ')}.`);
     }
     if (filter.type === 'model') {
-        return { ...filter, model: modelReference(isPlainObject(value) ? value.model : undefined, `${where}.model`) };
+        return { ...filter, model: modelReference((0, type_guards_1.isRecord)(value) ? value.model : undefined, `${where}.model`) };
     }
-    if (isPlainObject(value) && value.model !== undefined) {
+    if ((0, type_guards_1.isRecord)(value) && value.model !== undefined) {
         throw new ConfigError(`${where}: "model" is only supported for type "model".`);
     }
     return filter;
 }
 /** Validates the STT implementation, required model, and optional conversion command. */
 function parseSttSpec(value, where) {
-    if (!isPlainObject(value)) {
+    if (!(0, type_guards_1.isRecord)(value)) {
         throw new ConfigError(`${where} must be an object with type "model"; replace old string STT references with { "type": "model", "model": "provider/model-id" }.`);
     }
     warnUnknownKeys(value, ['type', 'model', 'audioConversionCmd'], where);
@@ -3604,7 +3599,7 @@ function parseSttSpec(value, where) {
         throw new ConfigError(`${where}.type must be "model".`);
     }
     const model = modelReference(value.model, `${where}.model`);
-    if (value.audioConversionCmd !== undefined && (typeof value.audioConversionCmd !== 'string' ||
+    if (value.audioConversionCmd !== undefined && (!(0, type_guards_1.isString)(value.audioConversionCmd) ||
         !value.audioConversionCmd.trim() || !value.audioConversionCmd.includes('{input}') || !value.audioConversionCmd.includes('{output}'))) {
         throw new ConfigError(`${where}.audioConversionCmd must be a nonempty command containing {input} and {output}.`);
     }
@@ -3612,13 +3607,13 @@ function parseSttSpec(value, where) {
 }
 /** Keeps application-controlled speech fields out of provider-specific options. */
 function parseTtsSpec(value, where) {
-    if (!isPlainObject(value) || value.type !== 'model') {
+    if (!(0, type_guards_1.isRecord)(value) || value.type !== 'model') {
         throw new ConfigError(`${where} must be an object with type "model".`);
     }
     warnUnknownKeys(value, ['type', 'model', 'options'], where);
     const model = modelReference(value.model, `${where}.model`);
     const options = value.options === undefined ? {} : value.options;
-    if (!isPlainObject(options)) {
+    if (!(0, type_guards_1.isRecord)(options)) {
         throw new ConfigError(`${where}.options must be an object.`);
     }
     for (const key of ['model', 'input', 'response_format', 'stream_format']) {
@@ -3633,7 +3628,7 @@ function parseTtsSpec(value, where) {
  */
 function parseChat(value, index) {
     const where = `chats[${index}]`;
-    if (!isPlainObject(value)) {
+    if (!(0, type_guards_1.isRecord)(value)) {
         throw new ConfigError(`${where} must be an object.`);
     }
     warnUnknownKeys(value, ['messager', 'filters', 'stt', 'tts'], where);
@@ -3651,7 +3646,7 @@ function parseChat(value, index) {
  * Validates a parsed JSON value and merges it over the defaults.
  */
 function validateConfig(input, configPath) {
-    if (typeof input !== 'object' || input === null || Array.isArray(input)) {
+    if (!(0, type_guards_1.isRecord)(input)) {
         throw new ConfigError(`${configPath} must contain a JSON object.`);
     }
     const record = input;
@@ -3722,6 +3717,7 @@ const node_path_1 = __importDefault(__webpack_require__(6760));
 const limit_1 = __webpack_require__(9258);
 const images_1 = __webpack_require__(454);
 const input_budget_1 = __webpack_require__(6280);
+const type_guards_1 = __webpack_require__(3012);
 /** Rejects URLs and malformed data instead of fetching arbitrary locations. */
 function validateDataUrl(value) {
     const match = /^data:image\/(?:png|jpeg|gif|webp);base64,(.+)$/.exec(value);
@@ -3851,17 +3847,17 @@ class ConversationImageStore {
                 throw new Error('Image cache file exceeds the size limit.');
             }
             const value = JSON.parse(await node_fs_1.promises.readFile(filePath, 'utf8'));
-            if (value?.version !== 1 || !value.images || typeof value.images !== 'object' || Array.isArray(value.images)) {
+            if (value?.version !== 1 || !(0, type_guards_1.isRecord)(value.images)) {
                 throw new Error('Expected a version 1 image cache file.');
             }
             const images = Object.create(null);
             const now = Date.now();
             for (const [id, image] of Object.entries(value.images)) {
                 if (!image || image.id !== id || !id || id.length > limit_1.MAX_MEMORY_ID_CHARS ||
-                    typeof image.messageId !== 'string' || !image.messageId || image.messageId.length > limit_1.MAX_MEMORY_ID_CHARS ||
-                    typeof image.senderId !== 'string' || typeof image.timestamp !== 'string' ||
-                    !Number.isFinite(Date.parse(image.timestamp)) || typeof image.dataUrl !== 'string' ||
-                    (image.senderName !== undefined && typeof image.senderName !== 'string') ||
+                    !(0, type_guards_1.isString)(image.messageId) || !image.messageId || image.messageId.length > limit_1.MAX_MEMORY_ID_CHARS ||
+                    !(0, type_guards_1.isString)(image.senderId) || !(0, type_guards_1.isString)(image.timestamp) ||
+                    !Number.isFinite(Date.parse(image.timestamp)) || !(0, type_guards_1.isString)(image.dataUrl) ||
+                    (image.senderName !== undefined && !(0, type_guards_1.isString)(image.senderName)) ||
                     (image.origin !== undefined && image.origin !== 'generated') ||
                     (image.origin === 'generated'
                         ? !['pending', 'sent', 'failed'].includes(image.deliveryStatus ?? '')
@@ -3944,22 +3940,23 @@ exports.ConversationImageStore = ConversationImageStore;
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.parseMemoryUpdates = parseMemoryUpdates;
 const limit_1 = __webpack_require__(9258);
+const type_guards_1 = __webpack_require__(3012);
 /** Validates model output before any memory changes can reach the filesystem. */
 function parseMemoryUpdates(value) {
-    if (typeof value !== 'object' || value === null || Array.isArray(value) ||
+    if (!(0, type_guards_1.isRecord)(value) ||
         !('notes' in value) || !Array.isArray(value.notes) || value.notes.length > limit_1.MAX_MEMORY_NOTES_PER_UPDATE ||
         !('forget' in value) || !Array.isArray(value.forget) || value.forget.length > limit_1.MAX_MEMORY_FORGET_IDS ||
-        !value.forget.every((id) => typeof id === 'string' && id.length <= limit_1.MAX_MEMORY_ID_CHARS)) {
+        !value.forget.every((id) => (0, type_guards_1.isString)(id) && id.length <= limit_1.MAX_MEMORY_ID_CHARS)) {
         throw new Error('Reply model memoryUpdates must contain notes and forget arrays.');
     }
     const notes = value.notes.map((note) => {
-        if (typeof note !== 'object' || note === null || Array.isArray(note) ||
-            !('kind' in note) || typeof note.kind !== 'string' ||
+        if (!(0, type_guards_1.isRecord)(note) ||
+            !('kind' in note) || !(0, type_guards_1.isString)(note.kind) ||
             !['summary', 'fact', 'question', 'inference'].includes(note.kind) ||
-            !('text' in note) || typeof note.text !== 'string' || !note.text.trim() || note.text.length > limit_1.MAX_MEMORY_NOTE_CHARS ||
+            !('text' in note) || !(0, type_guards_1.isString)(note.text) || !note.text.trim() || note.text.length > limit_1.MAX_MEMORY_NOTE_CHARS ||
             !('sourceIds' in note) || !Array.isArray(note.sourceIds) ||
             note.sourceIds.length === 0 || note.sourceIds.length > limit_1.MAX_MEMORY_SOURCE_IDS ||
-            !note.sourceIds.every((id) => typeof id === 'string' && id.length > 0 && id.length <= limit_1.MAX_MEMORY_ID_CHARS)) {
+            !note.sourceIds.every((id) => (0, type_guards_1.isString)(id) && id.length > 0 && id.length <= limit_1.MAX_MEMORY_ID_CHARS)) {
             throw new Error('Each memory note needs a kind, nonempty text, and valid sourceIds.');
         }
         return {
@@ -3989,12 +3986,9 @@ const node_crypto_1 = __webpack_require__(7598);
 const node_fs_1 = __webpack_require__(3024);
 const node_path_1 = __importDefault(__webpack_require__(6760));
 const tokens_1 = __webpack_require__(4956);
-/** Checks disk data before it can become prompt context. */
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
+const type_guards_1 = __webpack_require__(3012);
 function isTimestamp(value) {
-    return typeof value === 'string' && Number.isFinite(Date.parse(value));
+    return (0, type_guards_1.isString)(value) && Number.isFinite(Date.parse(value));
 }
 /** Keeps cache links bounded and supports memory files written before image generation. */
 function imageIds(value) {
@@ -4002,20 +3996,20 @@ function imageIds(value) {
         return undefined;
     }
     if (!Array.isArray(value) || value.length > limit_1.MAX_CACHED_IMAGES_PER_CONVERSATION ||
-        !value.every((id) => typeof id === 'string' && id.length > 0 && id.length <= limit_1.MAX_MEMORY_ID_CHARS)) {
+        !value.every((id) => (0, type_guards_1.isString)(id) && id.length > 0 && id.length <= limit_1.MAX_MEMORY_ID_CHARS)) {
         throw new Error('Invalid stored reply image IDs.');
     }
     return [...new Set(value)];
 }
 /** Parses only supported fields; expiry is always derived from source time. */
 function parseFile(value) {
-    if (!isRecord(value) || value.version !== 1 || !Array.isArray(value.notes) || !Array.isArray(value.replies)) {
+    if (!(0, type_guards_1.isRecord)(value) || value.version !== 1 || !Array.isArray(value.notes) || !Array.isArray(value.replies)) {
         throw new Error('Expected a version 1 conversation memory file.');
     }
     const notes = value.notes.map((note) => {
-        if (!isRecord(note) || typeof note.id !== 'string' || note.id.length > limit_1.MAX_MEMORY_ID_CHARS ||
-            typeof note.kind !== 'string' || !['summary', 'fact', 'question', 'inference'].includes(note.kind) ||
-            typeof note.text !== 'string' || !isTimestamp(note.sourceTimestamp)) {
+        if (!(0, type_guards_1.isRecord)(note) || !(0, type_guards_1.isString)(note.id) || note.id.length > limit_1.MAX_MEMORY_ID_CHARS ||
+            !(0, type_guards_1.isString)(note.kind) || !['summary', 'fact', 'question', 'inference'].includes(note.kind) ||
+            !(0, type_guards_1.isString)(note.text) || !isTimestamp(note.sourceTimestamp)) {
             throw new Error('Invalid stored memory note.');
         }
         return {
@@ -4027,10 +4021,10 @@ function parseFile(value) {
         };
     });
     const replies = value.replies.map((reply) => {
-        if (!isRecord(reply) || typeof reply.id !== 'string' || reply.id.length > limit_1.MAX_MEMORY_ID_CHARS ||
-            typeof reply.text !== 'string' || !isTimestamp(reply.sentAt) ||
-            (reply.channel !== undefined && typeof reply.channel !== 'string') ||
-            (reply.direct !== undefined && typeof reply.direct !== 'boolean')) {
+        if (!(0, type_guards_1.isRecord)(reply) || !(0, type_guards_1.isString)(reply.id) || reply.id.length > limit_1.MAX_MEMORY_ID_CHARS ||
+            !(0, type_guards_1.isString)(reply.text) || !isTimestamp(reply.sentAt) ||
+            (reply.channel !== undefined && !(0, type_guards_1.isString)(reply.channel)) ||
+            (reply.direct !== undefined && !(0, type_guards_1.isBoolean)(reply.direct))) {
             throw new Error('Invalid stored sent reply.');
         }
         return {
@@ -4364,11 +4358,12 @@ exports.IgnoreFile = IgnoreFile;
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.IgnoreSenderFilter = void 0;
 const interface_1 = __webpack_require__(2590);
+const type_guards_1 = __webpack_require__(3012);
 /**
  * Distinguishes a dynamic source from a fixed list of sender IDs.
  */
 function isSenderIdSource(value) {
-    return typeof value.getSenderIds === 'function';
+    return (0, type_guards_1.isFunction)(value.getSenderIds);
 }
 /**
  * Removes listed senders from snapshots and denies only when no incoming sources remain.
@@ -4535,6 +4530,7 @@ const node_path_1 = __importDefault(__webpack_require__(6760));
 const ignore_file_1 = __webpack_require__(5230);
 const ignore_sender_1 = __webpack_require__(2977);
 const model_1 = __webpack_require__(6488);
+const type_guards_1 = __webpack_require__(3012);
 const factories = new Map();
 /**
  * Registers a filter implementation under a config-file name.
@@ -4572,7 +4568,7 @@ function stringArrayOption(options, key, label) {
     if (value === undefined) {
         return undefined;
     }
-    if (!Array.isArray(value) || !value.every((item) => typeof item === 'string')) {
+    if (!Array.isArray(value) || !value.every((item) => (0, type_guards_1.isString)(item))) {
         throw new Error(`${label}: option "${key}" must be an array of strings.`);
     }
     return value;
@@ -4585,7 +4581,7 @@ function stringOption(options, key, label) {
     if (value === undefined) {
         return undefined;
     }
-    if (typeof value !== 'string') {
+    if (!(0, type_guards_1.isString)(value)) {
         throw new Error(`${label}: option "${key}" must be a string.`);
     }
     return value;
@@ -4796,8 +4792,8 @@ var __webpack_unused_export__;
 
 // Keep matching config schema defaults and bounds in sync when changing them here.
 __webpack_unused_export__ = ({ value: true });
-exports.WECHAT_VOICE_CANCEL_TIMEOUT_MS = exports.WECHAT_VOICE_JOB_POLL_MS = exports.WECHAT_VOICE_JOB_TIMEOUT_MS = exports.MAX_TTS_INPUT_CHARS = exports.MAX_VOICE_PADDING_MS = exports.MIN_VOICE_PADDING_MS = exports.AUDIO_CLEANUP_RETRY_DELAY_MS = exports.AUDIO_CLEANUP_RETRIES = exports.AUDIO_CONVERSION_STDERR_CHARS = exports.AUDIO_CONVERSION_TIMEOUT_MS = exports.MAX_TRANSCRIPT_CHARS = exports.MEDIA_RESPONSE_OVERHEAD_BYTES = exports.MAX_MEDIA_ATTEMPTS = exports.CACHED_IMAGE_REFERENCE_TOKENS = exports.MAX_IMAGE_CACHE_FILE_BYTES = exports.MAX_CACHED_IMAGES_PER_CONVERSATION = exports.MAX_IMAGES_PER_SNAPSHOT = exports.MAX_ENCODED_AUDIO_BYTES = exports.MAX_AUDIO_BYTES = exports.MAX_ENCODED_IMAGE_BYTES = exports.MAX_IMAGE_BYTES = exports.DEFAULT_DAILY_IMAGE_GEN_LIMIT = exports.DEFAULT_IMAGE_HEIGHT_LIMIT = exports.DEFAULT_IMAGE_WIDTH_LIMIT = exports.MAX_MEMORY_ID_CHARS = exports.MAX_MEMORY_SOURCE_IDS = exports.MAX_MEMORY_FORGET_IDS = exports.MAX_MEMORY_NOTES_PER_UPDATE = exports.MAX_MEMORY_NOTE_CHARS = exports.MEMORY_NOTE_TOKENS = exports.MAX_MEMORY_FILE_BYTES = exports.MEMORY_CLEANUP_INTERVAL_MS = exports.MEMORY_RETENTION_MS = exports.MAX_MEMORY_TOKEN_LIMIT = exports.MIN_MEMORY_TOKEN_LIMIT = exports.DEFAULT_MEMORY_TOKEN_LIMIT = exports.HARD_REPLY_TOKEN_LIMIT = exports.SOFT_REPLY_TOKEN_LIMIT = exports.TRUNCATION_MARKER_TOKENS = exports.IMAGE_TOKEN_RESERVE = exports.TOOL_RESULT_TOKENS = exports.MODEL_INPUT_TOKENS = exports.MESSAGER_CONTEXT_TOKENS = exports.SENDER_NAME_TOKENS = exports.CONVERSATION_ID_TOKENS = exports.MIN_MESSAGE_TEXT_TOKENS = exports.MESSAGE_TEXT_TOKENS = exports.MAX_MESSAGES_PER_SNAPSHOT = exports.CONVERSATION_METADATA_TOKENS = exports.CONVERSATION_TEXT_TOKENS = void 0;
-exports.MAX_TIMEZONE_CHARS = exports.MAX_CALCULATE_ARGUMENTS = exports.MAX_CALCULATE_TOKENS = exports.MAX_CALCULATE_EXPRESSION_CHARS = exports.MAX_SEARCH_TITLE_CHARS = exports.MAX_SEARCH_SNIPPET_CHARS = exports.MAX_SEARCH_QUERY_CHARS = exports.MAX_SEARCH_RESULTS = exports.MAX_WEB_TITLE_CHARS = exports.MAX_HTML_NODES = exports.WEB_TRUNCATION_THRESHOLD_CHARS = exports.MAX_WEB_TEXT_CHARS = exports.MAX_READ_URL_CHARS = exports.MAX_WEB_REDIRECTS = exports.WEB_REQUEST_TIMEOUT_MS = exports.MAX_WEB_DECODED_BYTES = exports.MAX_WEB_DOWNLOAD_BYTES = exports.MAX_TOOL_OUTPUT_CHARS = exports.MAX_TOOL_ARGUMENT_CHARS = exports.IGNORE_FILE_RELOAD_INTERVAL_MS = exports.WECHAT_MESSAGE_PAGE_SIZE = exports.WECHAT_CHAT_PAGE_SIZE = exports.WECHAT_MAX_BACKOFF_EXPONENT = exports.WECHAT_BUNDLE_GAP_MS = exports.WECHAT_REQUEST_TIMEOUT_MS = exports.WECHAT_POLL_INTERVAL_MS = exports.PENDING_MEDIA_RETRY_DELAY_MS = exports.MAX_PENDING_MEDIA_RETRIES = exports.MAX_REPLY_DELAY_MS = exports.MIN_REPLY_DELAY_MS = __webpack_unused_export__ = __webpack_unused_export__ = exports.MAX_MODEL_TOOL_CALLS = exports.MODEL_RETRY_DELAY_MS = exports.MAX_MODEL_RETRIES = exports.DEFAULT_MODEL_TIMEOUT_MS = exports.MAX_TIMER_MS = void 0;
+exports.MAX_TIMER_MS = exports.WECHAT_SEND_CANCEL_TIMEOUT_MS = exports.WECHAT_SEND_TIMEOUT_MS = exports.MAX_TTS_INPUT_CHARS = exports.MAX_VOICE_PADDING_MS = exports.MIN_VOICE_PADDING_MS = exports.AUDIO_CLEANUP_RETRY_DELAY_MS = exports.AUDIO_CLEANUP_RETRIES = exports.AUDIO_CONVERSION_STDERR_CHARS = exports.AUDIO_CONVERSION_TIMEOUT_MS = exports.MAX_TRANSCRIPT_CHARS = __webpack_unused_export__ = exports.MAX_MEDIA_ATTEMPTS = exports.CACHED_IMAGE_REFERENCE_TOKENS = exports.MAX_IMAGE_CACHE_FILE_BYTES = exports.MAX_CACHED_IMAGES_PER_CONVERSATION = exports.MAX_IMAGES_PER_SNAPSHOT = exports.MAX_ENCODED_AUDIO_BYTES = exports.MAX_AUDIO_BYTES = exports.MAX_ENCODED_IMAGE_BYTES = exports.MAX_IMAGE_BYTES = exports.DEFAULT_DAILY_IMAGE_GEN_LIMIT = exports.DEFAULT_IMAGE_HEIGHT_LIMIT = exports.DEFAULT_IMAGE_WIDTH_LIMIT = exports.MAX_MEMORY_ID_CHARS = exports.MAX_MEMORY_SOURCE_IDS = exports.MAX_MEMORY_FORGET_IDS = exports.MAX_MEMORY_NOTES_PER_UPDATE = exports.MAX_MEMORY_NOTE_CHARS = exports.MEMORY_NOTE_TOKENS = exports.MAX_MEMORY_FILE_BYTES = exports.MEMORY_CLEANUP_INTERVAL_MS = exports.MEMORY_RETENTION_MS = exports.MAX_MEMORY_TOKEN_LIMIT = exports.MIN_MEMORY_TOKEN_LIMIT = exports.DEFAULT_MEMORY_TOKEN_LIMIT = exports.HARD_REPLY_TOKEN_LIMIT = exports.SOFT_REPLY_TOKEN_LIMIT = exports.TRUNCATION_MARKER_TOKENS = exports.IMAGE_TOKEN_RESERVE = exports.TOOL_RESULT_TOKENS = exports.MODEL_INPUT_TOKENS = exports.MESSAGER_CONTEXT_TOKENS = exports.SENDER_NAME_TOKENS = exports.CONVERSATION_ID_TOKENS = exports.MIN_MESSAGE_TEXT_TOKENS = exports.MESSAGE_TEXT_TOKENS = exports.MAX_MESSAGES_PER_SNAPSHOT = exports.CONVERSATION_METADATA_TOKENS = exports.CONVERSATION_TEXT_TOKENS = void 0;
+exports.MAX_TIMEZONE_CHARS = exports.MAX_CALCULATE_ARGUMENTS = exports.MAX_CALCULATE_TOKENS = exports.MAX_CALCULATE_EXPRESSION_CHARS = exports.MAX_SEARCH_TITLE_CHARS = exports.MAX_SEARCH_SNIPPET_CHARS = exports.MAX_SEARCH_QUERY_CHARS = exports.MAX_SEARCH_RESULTS = exports.MAX_WEB_TITLE_CHARS = exports.MAX_HTML_NODES = exports.WEB_TRUNCATION_THRESHOLD_CHARS = exports.MAX_WEB_TEXT_CHARS = exports.MAX_READ_URL_CHARS = exports.MAX_WEB_REDIRECTS = exports.WEB_REQUEST_TIMEOUT_MS = exports.MAX_WEB_DECODED_BYTES = exports.MAX_WEB_DOWNLOAD_BYTES = exports.MAX_TOOL_OUTPUT_CHARS = exports.MAX_TOOL_ARGUMENT_CHARS = exports.IGNORE_FILE_RELOAD_INTERVAL_MS = exports.WECHAT_RECENT_MESSAGE_LIMIT = exports.MAX_SSE_ERROR_BYTES = exports.MAX_SSE_FRAME_CHARS = exports.MAX_SSE_LINE_CHARS = exports.WECHAT_MAX_EVENT_CURSOR = exports.WECHAT_NAME_MISS_TTL_MS = exports.WECHAT_NAME_TTL_MS = exports.WECHAT_NAME_CACHE_SIZE = exports.WECHAT_MAX_BACKOFF_EXPONENT = exports.WECHAT_READER_CANCEL_TIMEOUT_MS = exports.WECHAT_REQUEST_TIMEOUT_MS = exports.WECHAT_RECONNECT_INTERVAL_MS = exports.PENDING_MEDIA_RETRY_DELAY_MS = exports.MAX_PENDING_MEDIA_RETRIES = exports.MAX_REPLY_DELAY_MS = exports.MIN_REPLY_DELAY_MS = __webpack_unused_export__ = __webpack_unused_export__ = exports.MAX_MODEL_TOOL_CALLS = exports.MODEL_RETRY_DELAY_MS = exports.MAX_MODEL_RETRIES = exports.DEFAULT_MODEL_TIMEOUT_MS = void 0;
 // Model input and conversation snapshots.
 /**
  * Budget calculations with the current values:
@@ -4863,8 +4859,8 @@ exports.MAX_MEMORY_NOTES_PER_UPDATE = 20;
 exports.MAX_MEMORY_FORGET_IDS = 50;
 /** Maximum supporting source IDs per proposed memory note. */
 exports.MAX_MEMORY_SOURCE_IDS = 64;
-/** Maximum characters in a stored memory ID or cited source ID. */
-exports.MAX_MEMORY_ID_CHARS = 128;
+/** Maximum characters in memory, source, and cached image IDs; accommodates encoded WeChat IDs. */
+exports.MAX_MEMORY_ID_CHARS = 1_024;
 // Images, voice input, and local audio conversion.
 /** Default maximum generated image width in pixels. */
 exports.DEFAULT_IMAGE_WIDTH_LIMIT = 1024;
@@ -4891,7 +4887,7 @@ exports.CACHED_IMAGE_REFERENCE_TOKENS = 1_000;
 /** Maximum download attempts per image or voice source. */
 exports.MAX_MEDIA_ATTEMPTS = 3;
 /** Extra JSON response bytes allowed around base64 media. */
-exports.MEDIA_RESPONSE_OVERHEAD_BYTES = 64 * 1_024;
+__webpack_unused_export__ = 64 * 1_024;
 /** Maximum characters accepted from a speech-to-text model. */
 exports.MAX_TRANSCRIPT_CHARS = 32_000;
 /** Default deadline for a local audio conversion command. */
@@ -4908,17 +4904,15 @@ exports.MIN_VOICE_PADDING_MS = 500;
 exports.MAX_VOICE_PADDING_MS = 2_000;
 /** Maximum characters submitted to a speech synthesis endpoint. */
 exports.MAX_TTS_INPUT_CHARS = 4_096;
-/** Maximum wait for a WeChat voice job to confirm delivery. */
-exports.WECHAT_VOICE_JOB_TIMEOUT_MS = 180_000;
-/** Interval between status checks of a submitted WeChat voice job. */
-exports.WECHAT_VOICE_JOB_POLL_MS = 1_000;
-/** Deadline for a best-effort voice-job cancellation after failure or shutdown. */
-exports.WECHAT_VOICE_CANCEL_TIMEOUT_MS = 5_000;
+/** Maximum wait for one WeChat text send or media job to confirm delivery. */
+exports.WECHAT_SEND_TIMEOUT_MS = 180_000;
+/** Deadline for a best-effort send or job cancellation after failure or shutdown. */
+exports.WECHAT_SEND_CANCEL_TIMEOUT_MS = 5_000;
 // Model requests, pacing, and transport defaults.
-/** Largest duration supported by Node timers; a platform bound. */
-exports.MAX_TIMER_MS = 2_147_483_647;
+/** Maximum configured timeout or timer delay: one hour. */
+exports.MAX_TIMER_MS = 60 * 60 * 1_000;
 /** Default provider deadline for generation and transcription requests. */
-exports.DEFAULT_MODEL_TIMEOUT_MS = 180_000;
+exports.DEFAULT_MODEL_TIMEOUT_MS = 300_000;
 /** Retries after the initial attempt of a complete model generation. */
 exports.MAX_MODEL_RETRIES = 3;
 /** Delay between complete model-generation retries. */
@@ -4937,18 +4931,30 @@ exports.MAX_REPLY_DELAY_MS = 180_000;
 exports.MAX_PENDING_MEDIA_RETRIES = 2;
 /** Initial delay for pending-media retries; doubles on each retry. */
 exports.PENDING_MEDIA_RETRY_DELAY_MS = 30_000;
-/** Default delay after a completed WeChat poll. */
-exports.WECHAT_POLL_INTERVAL_MS = 30_000;
-/** Default deadline for each WeChat REST request. */
+/** Default base delay before reconnecting an interrupted WeChat event stream. */
+exports.WECHAT_RECONNECT_INTERVAL_MS = 1_000;
+/** Default deadline for each WeChat REST request and SSE connect/idle wait. */
 exports.WECHAT_REQUEST_TIMEOUT_MS = 30_000;
-/** Default maximum timestamp gap for adjacent same-sender bundles. */
-exports.WECHAT_BUNDLE_GAP_MS = 20_000;
-/** Maximum exponent used by WeChat polling failure backoff. */
+/** Maximum wait for a WeChat stream reader to acknowledge cancellation. */
+exports.WECHAT_READER_CANCEL_TIMEOUT_MS = 100;
+/** Maximum exponent used by WeChat event-stream reconnect backoff. */
 exports.WECHAT_MAX_BACKOFF_EXPONENT = 6;
-/** Chat rows requested per WeChat API page. */
-exports.WECHAT_CHAT_PAGE_SIZE = 100;
-/** Message rows requested per WeChat API page. */
-exports.WECHAT_MESSAGE_PAGE_SIZE = 50;
+/** Maximum cached WeChat contact and group-member display names. */
+exports.WECHAT_NAME_CACHE_SIZE = 1_000;
+/** Lifetime of a successfully resolved WeChat display name. */
+exports.WECHAT_NAME_TTL_MS = 10 * 60_000;
+/** Lifetime of a failed or empty WeChat display-name lookup. */
+exports.WECHAT_NAME_MISS_TTL_MS = 60_000;
+/** Largest signed 64-bit event cursor accepted from the WeChat daemon. */
+exports.WECHAT_MAX_EVENT_CURSOR = 9223372036854775807n;
+/** Maximum characters buffered for one unterminated SSE line. */
+exports.MAX_SSE_LINE_CHARS = 1_048_576;
+/** Maximum characters accepted in one SSE data payload. */
+exports.MAX_SSE_FRAME_CHARS = 1_048_576;
+/** Maximum bytes read from a rejected SSE response body. */
+exports.MAX_SSE_ERROR_BYTES = 16_384;
+/** Recent live message IDs retained for replay deduplication; cursors are the primary guard. */
+exports.WECHAT_RECENT_MESSAGE_LIMIT = 2_000;
 /** Default interval between ignore-file reload checks; zero disables caching. */
 exports.IGNORE_FILE_RELOAD_INTERVAL_MS = 1_000;
 // Tool execution and web content.
@@ -5001,6 +5007,7 @@ exports.MAX_TIMEZONE_CHARS = 100;
 var __webpack_unused_export__;
 
 __webpack_unused_export__ = ({ value: true });
+exports.audioExtension = audioExtension;
 exports.audioFile = audioFile;
 const limit_1 = __webpack_require__(9258);
 const media_1 = __webpack_require__(2358);
@@ -5009,12 +5016,21 @@ const formats = {
     wav: 'audio/wav', ogg: 'audio/ogg', flac: 'audio/flac',
     m4a: 'audio/mp4', mp4: 'audio/mp4', webm: 'audio/webm'
 };
+/** Maps an upstream audio MIME type to the extension used for STT uploads. */
+function audioExtension(mimeType) {
+    const type = mimeType.split(';')[0].trim().toLowerCase();
+    const extension = Object.keys(formats).find((key) => formats[key] === type);
+    if (extension === undefined) {
+        throw new media_1.MediaUnavailableError(`Unsupported voice MIME type "${mimeType}"; agent-wechat must provide decoded WAV or another supported audio format.`);
+    }
+    return extension;
+}
 /** Decodes supported upstream audio without writing files or attempting local conversion. */
 function audioFile(data, format, id) {
     const extension = format.toLowerCase();
     const mimeType = formats[extension];
     if (!Object.hasOwn(formats, extension)) {
-        throw new media_1.MediaUnavailableError(`Unsupported voice format "${format}"; agent-wechat must convert SILK to MP3.`);
+        throw new media_1.MediaUnavailableError(`Unsupported voice format "${format}"; agent-wechat must provide decoded WAV or another supported audio format.`);
     }
     if (!data || data.length > limit_1.MAX_ENCODED_AUDIO_BYTES || data.length % 4 !== 0 || !/^[A-Za-z0-9+/]+={0,2}$/.test(data)) {
         throw new media_1.MediaUnavailableError(`Voice data must be valid base64 no larger than ${limit_1.MAX_AUDIO_BYTES / (1024 * 1024)} MiB.`);
@@ -5156,6 +5172,7 @@ exports.createMessager = createMessager;
 const node_fs_1 = __webpack_require__(3024);
 const node_path_1 = __importDefault(__webpack_require__(6760));
 const wechat_1 = __webpack_require__(6146);
+const type_guards_1 = __webpack_require__(3012);
 const factories = new Map();
 /**
  * Registers a messager implementation under a config-file name.
@@ -5187,25 +5204,25 @@ function createMessager(name, options, context) {
 }
 registerMessager('wechat', (options, context) => {
     const label = `messager "wechat" (chat "${context.chatName}")`;
-    const known = ['baseUrl', 'tokenEnv', 'tokenFile', 'chatIds', 'pollIntervalMs', 'timeoutMs', 'bundleGapMs'];
+    const known = ['baseUrl', 'accountId', 'tokenEnv', 'tokenFile', 'chatIds', 'reconnectIntervalMs', 'timeoutMs'];
     for (const key of Object.keys(options)) {
         if (!known.includes(key)) {
             throw new Error(`${label}: unknown option "${key}".`);
         }
     }
-    for (const key of ['baseUrl', 'tokenEnv', 'tokenFile']) {
+    for (const key of ['baseUrl', 'accountId', 'tokenEnv', 'tokenFile']) {
         if (options[key] !== undefined &&
-            (typeof options[key] !== 'string' || options[key].trim() === '')) {
+            (!(0, type_guards_1.isString)(options[key]) || options[key].trim() === '')) {
             throw new Error(`${label}: option "${key}" must be a non-empty string.`);
         }
     }
-    for (const key of ['pollIntervalMs', 'timeoutMs', 'bundleGapMs']) {
-        if (options[key] !== undefined && typeof options[key] !== 'number') {
+    for (const key of ['reconnectIntervalMs', 'timeoutMs']) {
+        if (options[key] !== undefined && !(0, type_guards_1.isNumber)(options[key])) {
             throw new Error(`${label}: option "${key}" must be a number.`);
         }
     }
     if (options.chatIds !== undefined && (!Array.isArray(options.chatIds) ||
-        !options.chatIds.every((id) => typeof id === 'string' && id.trim() !== ''))) {
+        !options.chatIds.every((id) => (0, type_guards_1.isString)(id) && id.trim() !== ''))) {
         throw new Error(`${label}: option "chatIds" must be an array of non-empty strings.`);
     }
     const tokenEnv = options.tokenEnv ?? 'AGENT_WECHAT_TOKEN';
@@ -5218,13 +5235,13 @@ registerMessager('wechat', (options, context) => {
     }
     return new wechat_1.WechatMessagerAdapter(token, {
         baseUrl: options.baseUrl,
+        accountId: options.accountId,
         chatIds: options.chatIds === undefined ? undefined : [...new Set([
                 ...options.chatIds,
                 ...(context.mainAccount === undefined ? [] : [context.mainAccount])
             ])],
-        pollIntervalMs: options.pollIntervalMs,
-        timeoutMs: options.timeoutMs,
-        bundleGapMs: options.bundleGapMs
+        reconnectIntervalMs: options.reconnectIntervalMs,
+        timeoutMs: options.timeoutMs
     });
 });
 
@@ -5244,25 +5261,35 @@ const promises_1 = __webpack_require__(8500);
 const images_1 = __webpack_require__(454);
 const audio_1 = __webpack_require__(796);
 const media_1 = __webpack_require__(2358);
-/** Never pass raw image/voice message XML to models as the message body. */
+const type_guards_1 = __webpack_require__(3012);
+const DIRECTIONS = new Set(['incoming', 'outgoing']);
+const SEND_STATES = new Set(['queued', 'submitting', 'accepted', 'failed', 'needs_review', 'cancelled']);
+const JOB_STATES = new Set([
+    'queued', 'running', 'accepted', 'failed', 'needs_review', 'cancelled', 'expired', 'unsupported'
+]);
+const TERMINAL_STATES = new Set(['failed', 'needs_review', 'cancelled', 'expired', 'unsupported']);
+const IMAGE_VARIANTS = ['original', 'standard', 'thumbnail'];
+const VOICE_VARIANTS = ['normal', 'encoded'];
+const EVENT_CURSOR_PATTERN = /^(0|[1-9][0-9]{0,18})$/;
+/** Trims one optional name field; blank values never win. */
+function trimmedName(value) {
+    return (0, type_guards_1.isString)(value) ? value.trim() || undefined : undefined;
+}
+/** Never pass raw image/voice message content to models as the message body. */
 function messageText(message) {
-    return message.type === 3 ? '[Image]' : message.type === 34 ? '[Voice]' : message.content;
-}
-/** The API resolves contact remarks/nicknames separately from the stable sender ID. */
-function displayName(message) {
-    return typeof message.senderName === 'string' ? message.senderName.trim() || undefined : undefined;
+    return message.type === 3 ? '[Image]' : message.type === 34 ? '[Voice]' : message.body ?? '';
 }
-/** Retains HTTP status for media retry classification without retaining response bodies. */
-class WechatRequestError extends Error {
-    status;
-    constructor(status, endpoint) {
-        super(`WeChat ${endpoint.split('?')[0]} returned HTTP ${status}.`);
-        this.status = status;
+/** Resolves a message time; a null or unparsable value cannot be ordered against the cutoff. */
+function messageTime(message) {
+    if (message.createdAt === null) {
+        return undefined;
     }
+    const time = Date.parse(message.createdAt);
+    return Number.isFinite(time) ? time : undefined;
 }
-/** Checks REST payloads before using their fields. */
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
+/** List routes may include tombstones for rows removed since the first page. */
+function isTombstone(value) {
+    return (0, type_guards_1.isRecord)(value) && value.deleted === true && (0, type_guards_1.isString)(value.id);
 }
 /** Validates a positive duration, including values supplied programmatically. */
 function duration(value, fallback, label) {
@@ -5272,28 +5299,322 @@ function duration(value, fallback, label) {
     }
     return result;
 }
-/** Receives text and lazy media references by polling agent-wechat; never listens on a port. */
+/** Parses one account entry from the list or single-account route. */
+function parseAccount(value) {
+    if (!(0, type_guards_1.isRecord)(value) || !(0, type_guards_1.isString)(value.id) || !value.id ||
+        !(0, type_guards_1.isBoolean)(value.authenticated)) {
+        throw new Error('Unexpected WeChat account entry.');
+    }
+    const username = (0, type_guards_1.isString)(value.ownUsername) ? value.ownUsername.trim() : '';
+    return { id: value.id, authenticated: value.authenticated,
+        ...(username ? { ownUsername: username } : {}) };
+}
+/** Event cursors are decimal i64 strings and may exceed Number.MAX_SAFE_INTEGER. */
+function parseEventCursor(value, label) {
+    if (!(0, type_guards_1.isString)(value) || !EVENT_CURSOR_PATTERN.test(value) ||
+        BigInt(value) > limit_1.WECHAT_MAX_EVENT_CURSOR) {
+        throw new Error(`Unexpected WeChat ${label}.`);
+    }
+    return value;
+}
+/** True when `cursor` is already covered by the checkpoint, so a replay must be skipped. */
+function cursorCovered(cursor, checkpoint) {
+    return checkpoint !== undefined && BigInt(cursor) <= BigInt(checkpoint);
+}
+/** Parses the daemon's `{ items, nextCursor }` page shape and optional event high-water. */
+function parsePage(value, label) {
+    if (!(0, type_guards_1.isRecord)(value) || !Array.isArray(value.items) ||
+        !(value.nextCursor === null || (0, type_guards_1.isString)(value.nextCursor)) ||
+        !(value.asOfEventCursor === undefined || (0, type_guards_1.isString)(value.asOfEventCursor))) {
+        throw new Error(`Unexpected WeChat ${label} response.`);
+    }
+    return {
+        items: value.items,
+        nextCursor: value.nextCursor,
+        ...(value.asOfEventCursor === undefined
+            ? {}
+            : { asOfEventCursor: parseEventCursor(value.asOfEventCursor, `${label} event cursor`) })
+    };
+}
+/** Parses the readable fields of one saved message. */
+function parseMessage(value, account, threadId) {
+    if (!(0, type_guards_1.isRecord)(value) || !(0, type_guards_1.isString)(value.id) || !value.id ||
+        value.accountId !== account || value.threadId !== threadId ||
+        !(value.senderId === null || (0, type_guards_1.isString)(value.senderId)) ||
+        !(0, type_guards_1.isNumber)(value.type) || !Number.isSafeInteger(value.type) ||
+        !(value.direction === null || ((0, type_guards_1.isString)(value.direction) && DIRECTIONS.has(value.direction))) ||
+        !(value.body === null || (0, type_guards_1.isString)(value.body)) ||
+        !(value.createdAt === null || (0, type_guards_1.isString)(value.createdAt))) {
+        throw new Error('Unexpected WeChat message fields.');
+    }
+    if (value.createdAt !== null && !Number.isFinite(Date.parse(value.createdAt))) {
+        throw new Error('Unexpected WeChat message time.');
+    }
+    return {
+        id: value.id,
+        accountId: value.accountId,
+        threadId: value.threadId,
+        senderId: value.senderId,
+        type: value.type,
+        direction: value.direction,
+        body: value.body,
+        createdAt: value.createdAt
+    };
+}
+/** Parses one attachment copy; tombstones are ignored. */
+function parseMediaAsset(value, account, messageId) {
+    if (isTombstone(value)) {
+        return undefined;
+    }
+    // Another account's or another message's attachment is never ours to fetch.
+    if ((0, type_guards_1.isRecord)(value) && (value.accountId !== account || value.messageId !== messageId)) {
+        return undefined;
+    }
+    if (!(0, type_guards_1.isRecord)(value) || !(0, type_guards_1.isString)(value.id) || !value.id ||
+        !(0, type_guards_1.isString)(value.kind) || !(0, type_guards_1.isString)(value.variant) ||
+        !(0, type_guards_1.isString)(value.state) || !(0, type_guards_1.isBoolean)(value.retryable) ||
+        !(value.actualVariant === null || value.actualVariant === undefined || (0, type_guards_1.isString)(value.actualVariant)) ||
+        !(value.contentType === null || value.contentType === undefined || (0, type_guards_1.isString)(value.contentType))) {
+        throw new Error('Unexpected WeChat media asset fields.');
+    }
+    return {
+        id: value.id,
+        kind: value.kind,
+        variant: value.variant,
+        actualVariant: value.actualVariant ?? null,
+        state: value.state,
+        contentType: value.contentType ?? null,
+        retryable: value.retryable
+    };
+}
+/** Media copy preference for the best available quality of each supported kind. */
+function variantRank(kind, asset) {
+    const order = kind === 'image' ? IMAGE_VARIANTS : VOICE_VARIANTS;
+    const variant = asset.actualVariant ?? asset.variant;
+    const index = order.indexOf(variant);
+    return index === -1 ? order.length : index;
+}
+/** Client media errors are terminal; timeouts and rate limits remain retryable. */
+function isTerminalMediaStatus(status) {
+    return status >= 400 && status < 500 && status !== 408 && status !== 429;
+}
+/**
+ * Cancels one reader without letting an unresponsive source block shutdown, then
+ * releases the lock when the pending read has settled.
+ */
+async function cancelBounded(reader, wait) {
+    let timer;
+    const deadline = new Promise((resolve) => {
+        timer = setTimeout(() => resolve('timeout'), wait);
+    });
+    try {
+        await Promise.race([reader.cancel().catch(() => 'cancelled'), deadline]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+    try {
+        reader.releaseLock();
+    }
+    catch {
+        // A still-pending read holds the lock; the response is discarded either way.
+    }
+}
+/** Reads at most `maxBytes` of a response body, bounded by a deadline and optional abort. */
+async function readBoundedText(response, maxBytes, timeout, signal) {
+    if (response.body === null) {
+        return '';
+    }
+    const reader = response.body.getReader();
+    if (signal?.aborted === true) {
+        await cancelBounded(reader, limit_1.WECHAT_READER_CANCEL_TIMEOUT_MS);
+        return undefined;
+    }
+    const chunks = [];
+    let size = 0;
+    let timer;
+    let resolveDeadline = () => { };
+    const deadline = new Promise((resolve) => {
+        resolveDeadline = () => resolve('aborted');
+        timer = setTimeout(() => resolve('timeout'), timeout);
+        signal?.addEventListener('abort', resolveDeadline, { once: true });
+    });
+    try {
+        while (true) {
+            const next = await Promise.race([reader.read(), deadline]);
+            if (next === 'timeout' || next === 'aborted') {
+                return undefined;
+            }
+            if (next.done) {
+                break;
+            }
+            size += next.value.byteLength;
+            if (size > maxBytes) {
+                return undefined;
+            }
+            chunks.push(next.value);
+        }
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        clearTimeout(timer);
+        signal?.removeEventListener('abort', resolveDeadline);
+        await cancelBounded(reader, limit_1.WECHAT_READER_CANCEL_TIMEOUT_MS);
+    }
+    return Buffer.concat(chunks).toString('utf8');
+}
+/** Retains HTTP status for media retry classification without retaining response bodies. */
+class WechatRequestError extends Error {
+    status;
+    constructor(status, endpoint) {
+        super(`WeChat ${endpoint.split('?')[0]} returned HTTP ${status}.`);
+        this.status = status;
+    }
+}
+/** The daemon no longer retains events after the supplied cursor. */
+class EventCursorExpiredError extends Error {
+    constructor() {
+        super('WeChat event cursor expired.');
+    }
+}
+/** The daemon account or signed-in username changed while an event was in flight. */
+class AccountChangedError extends Error {
+}
+/**
+ * Incremental SSE parser. UTF-8 decoding happens before this class, so chunks may
+ * split lines but never characters; only complete frames are returned.
+ */
+class SseParser {
+    buffer = '';
+    data = [];
+    dataChars = 0;
+    id;
+    event;
+    /** The previous chunk ended with CR, so a leading LF completes that CRLF. */
+    pendingCr = false;
+    /** Appends decoded text and returns every frame completed by it. */
+    push(value) {
+        let chunk = value;
+        if (this.pendingCr) {
+            this.pendingCr = false;
+            if (chunk.startsWith('\n')) {
+                chunk = chunk.slice(1);
+            }
+        }
+        this.buffer += chunk;
+        const frames = [];
+        let start = 0;
+        let index = 0;
+        while (index < this.buffer.length) {
+            const character = this.buffer[index];
+            if (character !== '\n' && character !== '\r') {
+                index += 1;
+                continue;
+            }
+            if (index - start > limit_1.MAX_SSE_LINE_CHARS) {
+                throw new Error('WeChat event stream line exceeded its size limit.');
+            }
+            const line = this.buffer.slice(start, index);
+            if (character === '\r' && index === this.buffer.length - 1) {
+                // A CRLF may be split across chunks; the terminator already applied.
+                this.pendingCr = true;
+                index += 1;
+            }
+            else {
+                index += character === '\r' && this.buffer[index + 1] === '\n' ? 2 : 1;
+            }
+            const frame = this.line(line);
+            if (frame !== undefined) {
+                frames.push(frame);
+            }
+            start = index;
+        }
+        this.buffer = this.buffer.slice(start);
+        if (this.buffer.length > limit_1.MAX_SSE_LINE_CHARS) {
+            throw new Error('WeChat event stream line exceeded its size limit.');
+        }
+        return frames;
+    }
+    /** Consumes one line without dispatching anything until a blank line arrives. */
+    line(line) {
+        if (line === '') {
+            return this.dispatch();
+        }
+        if (line.startsWith(':')) {
+            // A comment is also the daemon's 15-second keepalive.
+            return undefined;
+        }
+        const colon = line.indexOf(':');
+        const field = colon === -1 ? line : line.slice(0, colon);
+        let value = colon === -1 ? '' : line.slice(colon + 1);
+        if (value.startsWith(' ')) {
+            value = value.slice(1);
+        }
+        if (field === 'data') {
+            this.dataChars += value.length + (this.data.length === 0 ? 0 : 1);
+            if (this.dataChars > limit_1.MAX_SSE_FRAME_CHARS) {
+                throw new Error('WeChat event frame exceeded its size limit.');
+            }
+            this.data.push(value);
+        }
+        else if (field === 'id') {
+            if (!value.includes('\u0000')) {
+                this.id = value;
+            }
+        }
+        else if (field === 'event') {
+            this.event = value;
+        }
+        return undefined;
+    }
+    dispatch() {
+        if (this.data.length === 0 && this.event === undefined) {
+            this.id = undefined;
+            return undefined;
+        }
+        const frame = {
+            data: this.data.join('\n'),
+            ...(this.id === undefined ? {} : { id: this.id }),
+            ...(this.event === undefined ? {} : { event: this.event })
+        };
+        this.data = [];
+        this.dataChars = 0;
+        this.id = undefined;
+        this.event = undefined;
+        return frame;
+    }
+}
+/** Receives text and lazy media references from agent-wechat's event stream; never listens on a port. */
 class WechatMessagerAdapter {
     options;
     name = 'wechat';
     baseUrl;
-    interval;
+    reconnect;
     timeout;
-    bundleGap;
-    cursors = new Map();
-    chatFailures = new Map();
     operations = new Set();
+    names = new Map();
+    /** Recent live message IDs, bounded; the SSE cursor checkpoint is the primary dedupe. */
+    seen = new Set();
+    /** Nonterminal outbound operations waiting for a matching event-stream update. */
+    pending = new Map();
     token;
     account;
+    selfUsername;
     handler;
     startedAt = 0;
-    timer;
-    polling;
+    streamAbort = new AbortController();
+    streaming;
     sending = Promise.resolve();
+    after;
+    attempted = false;
     failures = 0;
-    lastSuccessfulPollAt;
-    lastPollError;
-    lastPollErrorAt;
+    lastEventAt;
+    lastStreamConnectedAt;
+    lastStreamActivityAt;
+    lastError;
+    lastErrorAt;
     constructor(token, options = {}) {
         this.options = options;
         this.token = token.trim();
@@ -5305,502 +5626,1189 @@ class WechatMessagerAdapter {
             url.search || url.hash) {
             throw new Error('WeChat baseUrl must be an HTTP(S) URL without credentials, query, or fragment.');
         }
-        this.baseUrl = url.toString().replace(/\/+$/, '');
-        this.interval = duration(options.pollIntervalMs, limit_1.WECHAT_POLL_INTERVAL_MS, 'pollIntervalMs');
+        const root = url.toString().replace(/\/+$/, '');
+        // The convention is the server root; strip a supplied `/v1` so no route becomes `/v1/v1`.
+        this.baseUrl = root.endsWith('/v1') ? root.slice(0, -3) : root;
+        this.reconnect = duration(options.reconnectIntervalMs, limit_1.WECHAT_RECONNECT_INTERVAL_MS, 'reconnectIntervalMs');
         this.timeout = duration(options.timeoutMs, limit_1.WECHAT_REQUEST_TIMEOUT_MS, 'timeoutMs');
-        this.bundleGap = options.bundleGapMs === 0 ? 0 : duration(options.bundleGapMs, limit_1.WECHAT_BUNDLE_GAP_MS, 'bundleGapMs');
+        if (options.accountId !== undefined && !options.accountId.trim()) {
+            throw new Error('WeChat accountId must be a non-empty daemon account ID.');
+        }
     }
+    /** Resolves the configured account, then starts authenticated event streaming. */
     async start(handler) {
         if (this.handler !== undefined) {
             throw new Error('WeChat adapter is already started.');
         }
+        this.resetState();
+        this.streamAbort = new AbortController();
         this.startedAt = Date.now();
-        this.cursors.clear();
-        this.chatFailures.clear();
-        this.failures = 0;
-        this.lastSuccessfulPollAt = undefined;
-        this.lastPollError = undefined;
-        this.lastPollErrorAt = undefined;
         this.handler = handler;
         try {
-            this.account = await this.readAccount();
+            this.adoptAccount(await this.readAccount(), true);
         }
         catch (error) {
             this.handler = undefined;
             throw error;
         }
-        this.schedule(this.interval);
+        // The long-lived stream stays in the background so a transient daemon failure
+        // cannot prevent the server from starting.
+        this.streaming = this.streamLoop().catch((error) => {
+            if (this.handler !== undefined) {
+                console.error('[wechat] event stream stopped unexpectedly:', error);
+            }
+        });
     }
-    /** Aborts outstanding requests and waits for polling and queued sends to finish. */
+    /** Aborts stream reads and backoff sleeps, then waits for processing and sends to finish. */
     async stop() {
         this.handler = undefined;
-        clearTimeout(this.timer);
+        this.streamAbort.abort();
         for (const controller of this.operations) {
             controller.abort();
         }
-        await Promise.allSettled([this.polling, this.sending]);
-        this.cursors.clear();
-        this.chatFailures.clear();
+        await Promise.allSettled([this.streaming, this.sending]);
+        this.streaming = undefined;
+        this.rejectPending('WeChat adapter stopped before delivery was confirmed.');
+        this.names.clear();
+        this.seen.clear();
+        this.after = undefined;
         this.account = undefined;
+        this.selfUsername = undefined;
     }
     /** Serializes deliveries; the server schedules the delay before building its snapshot. */
     reply(message, reply, signal) {
         const send = this.sending.then(async () => {
             this.requireActiveAccount(message);
             signal?.throwIfAborted();
-            const chatId = reply.direct ? message.senderId : reply.channel ?? message.channel;
-            if (!chatId) {
-                throw new Error('WeChat reply requires a destination chat ID.');
-            }
-            if (reply.images !== undefined && reply.images.length > 0) {
-                if (reply.voice || reply.audio !== undefined) {
-                    throw new Error('WeChat image replies cannot also contain voice audio.');
-                }
-                // Validate all attachments before sending any part of the reply.
-                const images = reply.images.map((image) => {
-                    const data = Buffer.from(image.data).toString('base64');
-                    const url = (0, images_1.imageDataUrl)(data);
-                    const mimeType = url.slice(5, url.indexOf(';'));
-                    if (mimeType !== image.mimeType) {
-                        throw new Error('WeChat image MIME type does not match its bytes.');
-                    }
-                    return { data, mimeType };
-                });
-                for (const [index, image] of images.entries()) {
+            // Fix the originating origin so a later switch cannot retarget this delivery.
+            const account = this.accountId;
+            const accountPath = this.accountPath;
+            const destination = reply.direct ? message.senderId : reply.channel ?? message.channel;
+            if (!destination) {
+                throw new Error('WeChat reply requires a destination thread ID.');
+            }
+            // Validate every attachment before uploading or sending any part of the reply.
+            const images = (reply.images ?? []).map((image) => this.validateImage(image));
+            if (images.length > 0 && (reply.voice || reply.audio !== undefined)) {
+                throw new Error('WeChat image replies cannot also contain voice audio.');
+            }
+            const voice = reply.voice ? this.validateVoice(reply.audio) : undefined;
+            if (images.length > 0) {
+                // The v2 API has no combined image/text send; a caption is a separate text send.
+                for (const image of images) {
                     this.requireActiveAccount(message);
                     signal?.throwIfAborted();
-                    const result = await this.request('/api/messages/send', {
-                        chatId, image, ...(index === 0 && reply.text.trim() ? { text: reply.text } : {})
-                    }, signal);
-                    if (!isRecord(result) || result.success !== true) {
-                        throw new Error('WeChat rejected the image send. Check the agent-server logs.');
-                    }
+                    await this.sendMedia(message, account, accountPath, destination, 'image', image, signal);
                 }
-                return;
-            }
-            if (reply.voice) {
-                if (reply.audio === undefined) {
-                    throw new Error('Voice reply requires synthesized audio.');
+                if (reply.text.trim()) {
+                    await this.sendText(message, account, accountPath, destination, reply.text, signal);
                 }
-                await this.sendVoice(message, chatId, reply.audio, signal);
                 return;
             }
-            const result = await this.request('/api/messages/send', { chatId, text: reply.text }, signal);
-            if (!isRecord(result) || result.success !== true) {
-                throw new Error('WeChat rejected the message send. Check the agent-server logs.');
+            if (voice !== undefined) {
+                await this.sendMedia(message, account, accountPath, destination, 'voice', voice, signal);
+                return;
             }
+            await this.sendText(message, account, accountPath, destination, reply.text, signal);
         });
         // A failed attempt must not poison the queue or cause an automatic retry.
         this.sending = send.catch(() => { });
         return send;
     }
-    /** One idempotent upload; success means the agent confirmed the voice job completed. */
-    async sendVoice(message, chatId, audio, signal) {
-        if (!audio.data.byteLength || audio.data.byteLength > limit_1.MAX_AUDIO_BYTES) {
-            throw new Error('Voice reply audio is empty or exceeds the audio size limit.');
+    getStatus() {
+        return {
+            active: this.handler !== undefined,
+            lastEventAt: this.lastEventAt,
+            lastStreamConnectedAt: this.lastStreamConnectedAt,
+            lastStreamActivityAt: this.lastStreamActivityAt,
+            consecutiveFailures: this.failures,
+            lastError: this.lastError,
+            lastErrorAt: this.lastErrorAt
+        };
+    }
+    /** Daemon account ID, never the signed-in contact username. */
+    get accountId() {
+        if (this.account === undefined) {
+            throw new Error('WeChat adapter is not started.');
+        }
+        return this.account;
+    }
+    get accountPath() {
+        return `/v1/accounts/${encodeURIComponent(this.accountId)}`;
+    }
+    resetState() {
+        this.rejectPending('WeChat adapter restarted before delivery was confirmed.');
+        this.names.clear();
+        this.seen.clear();
+        this.after = undefined;
+        this.attempted = false;
+        this.failures = 0;
+        this.lastEventAt = undefined;
+        this.lastStreamConnectedAt = undefined;
+        this.lastStreamActivityAt = undefined;
+        this.lastError = undefined;
+        this.lastErrorAt = undefined;
+    }
+    /** Applies a resolved account, clearing session state when the daemon ID or identity changes. */
+    adoptAccount(account, initial = false) {
+        if (account.id === this.account && account.ownUsername === this.selfUsername) {
+            return;
+        }
+        // Pending sends belong to the old identity; settle them instead of resolving a
+        // different account's event or leaving their callers until the full deadline.
+        this.rejectPending('WeChat account changed before delivery was confirmed.');
+        this.account = account.id;
+        this.selfUsername = account.ownUsername;
+        if (!initial) {
+            // A switch or re-login resets the startup cutoff so the new identity does not
+            // inherit another account's event cursor or message window.
+            this.startedAt = Date.now();
+        }
+        this.names.clear();
+        this.seen.clear();
+        this.after = undefined;
+    }
+    requireActiveAccount(message) {
+        this.requireAccount(message.metadata?.wechatAccount, message.metadata?.wechatUsername);
+    }
+    /**
+     * Both the daemon account and the signed-in identity must match the active session.
+     * There is no bypass for a missing username: an origin without a recorded WeChat
+     * username cannot be proven to belong to the current login.
+     */
+    requireAccount(account, username) {
+        if (this.handler === undefined || this.selfUsername === undefined ||
+            !(0, type_guards_1.isString)(account) || account !== this.account ||
+            !(0, type_guards_1.isString)(username) || username !== this.selfUsername) {
+            throw new Error('WeChat adapter is stopped or the originating account has changed.');
+        }
+    }
+    /** The daemon account and signed-in username currently backing this adapter. */
+    get identity() {
+        return { account: this.account, username: this.selfUsername };
+    }
+    /**
+     * Rejects work whose captured login is no longer active. The same daemon account can be
+     * re-logged into a different WeChat identity, so the signed-in username is compared too.
+     */
+    requireIdentity(origin) {
+        if (this.handler === undefined || this.account !== origin.account ||
+            this.selfUsername !== origin.username) {
+            throw new AccountChangedError();
         }
+    }
+    /** Reads the configured account or requires exactly one authenticated account. */
+    async readAccount() {
+        const configured = this.options.accountId?.trim();
+        if (configured !== undefined) {
+            let entry;
+            try {
+                entry = await this.request(`/v1/accounts/${encodeURIComponent(configured)}`);
+            }
+            catch (error) {
+                if (error instanceof WechatRequestError && error.status === 404) {
+                    throw new Error(`WeChat account "${configured}" is not visible to this token.`);
+                }
+                throw error;
+            }
+            const account = parseAccount(entry);
+            this.requireUsable(account, configured);
+            return account;
+        }
+        const body = await this.request('/v1/accounts');
+        if (!(0, type_guards_1.isRecord)(body) || !Array.isArray(body.items)) {
+            throw new Error('Unexpected WeChat accounts response.');
+        }
+        const authenticated = body.items.map(parseAccount).filter((item) => item.authenticated);
+        if (authenticated.length === 0) {
+            throw new Error('WeChat has no authenticated account. Log in using agent-wechat first.');
+        }
+        if (authenticated.length > 1) {
+            throw new Error(`WeChat has ${authenticated.length} authenticated accounts ` +
+                `(${authenticated.map((item) => item.id).join(', ')}); set messager.options.accountId.`);
+        }
+        this.requireUsable(authenticated[0], 'selected');
+        return authenticated[0];
+    }
+    requireUsable(account, requested) {
+        if (!account.authenticated) {
+            throw new Error(`WeChat account "${requested}" is not authenticated. Log in using agent-wechat first.`);
+        }
+        if (account.ownUsername === undefined) {
+            throw new Error(`WeChat account "${requested}" does not report a signed-in username.`);
+        }
+    }
+    /**
+     * Keeps one authenticated event stream open. Startup and an expired cursor both rebase
+     * on one current-tail lookup; events missed after expiry are intentionally skipped.
+     * Reconnects resume from the last checkpoint, and every failed attempt backs off.
+     */
+    async streamLoop() {
+        while (this.handler !== undefined) {
+            try {
+                if (this.attempted) {
+                    this.adoptAccount(await this.readAccount());
+                }
+                this.attempted = true;
+                if (this.after === undefined) {
+                    // Capture the login first: a switch or shutdown during the lookup means the
+                    // tail it returns belongs to a session this loop must not use.
+                    this.after = await this.readCurrentCursor(this.identity);
+                }
+                if (this.handler === undefined) {
+                    return;
+                }
+                await this.streamOnce();
+                if (this.handler === undefined) {
+                    return;
+                }
+                throw new Error('WeChat event stream closed.');
+            }
+            catch (error) {
+                if (this.handler === undefined) {
+                    return;
+                }
+                if (error instanceof AccountChangedError) {
+                    // A switch restarts the stream promptly, still under the capped backoff so a
+                    // login that keeps failing revalidation cannot spin.
+                    await this.backoff();
+                    continue;
+                }
+                this.recordFailure(error);
+                if (error instanceof EventCursorExpiredError) {
+                    // The daemon no longer retains events after this cursor. Rebase at the current
+                    // tail and intentionally skip the missed window instead of replaying history.
+                    // Repeated expiry still backs off because every expiry records a failure.
+                    this.after = undefined;
+                    console.warn('[wechat] event cursor expired; resuming at the current tail.');
+                }
+                if (this.handler !== undefined) {
+                    await this.backoff();
+                }
+            }
+        }
+    }
+    /** Reads one page only for its `asOfEventCursor`, seeding or rebasing the checkpoint. */
+    async readCurrentCursor(origin) {
+        const page = parsePage(await this.request(`${this.accountPath}/threads?limit=1`), 'threads');
+        // A switch or shutdown during the lookup invalidates this tail and this attempt.
+        this.requireIdentity(origin);
+        if (page.asOfEventCursor === undefined) {
+            throw new Error('WeChat thread listing did not report an event cursor.');
+        }
+        return page.asOfEventCursor;
+    }
+    /** Opens the event stream and dispatches complete frames sequentially. */
+    async streamOnce() {
+        if (this.handler === undefined) {
+            return;
+        }
+        if (this.after === undefined) {
+            throw new Error('WeChat event stream has no checkpoint.');
+        }
+        const checkpoint = parseEventCursor(this.after, 'event cursor');
         const controller = new AbortController();
-        const cancel = () => controller.abort();
-        signal?.addEventListener('abort', cancel, { once: true });
-        if (signal?.aborted) {
+        this.operations.add(controller);
+        let connectTimer;
+        let idleTimer;
+        let reason;
+        const expire = (label) => {
+            reason = label;
             controller.abort();
+        };
+        connectTimer = setTimeout(() => expire('connect timed out'), this.timeout);
+        try {
+            const response = await fetch(`${this.baseUrl}${this.accountPath}/events/stream?after=${encodeURIComponent(checkpoint)}`, {
+                headers: { Authorization: `Bearer ${this.token}`, Accept: 'text/event-stream' },
+                signal: controller.signal
+            });
+            clearTimeout(connectTimer);
+            connectTimer = undefined;
+            if (!response.ok) {
+                const detail = await this.streamError(response, controller.signal);
+                if (detail.code === 'event_cursor_expired') {
+                    throw new EventCursorExpiredError();
+                }
+                throw new Error(`WeChat event stream returned HTTP ${response.status}` +
+                    `${detail.message === undefined ? '.' : `: ${detail.message}`}`);
+            }
+            const contentType = (response.headers.get('content-type') ?? '').toLowerCase();
+            if (response.body === null || !contentType.includes('text/event-stream')) {
+                throw new Error('Unexpected WeChat event stream response.');
+            }
+            this.lastStreamConnectedAt = new Date().toISOString();
+            this.lastStreamActivityAt = this.lastStreamConnectedAt;
+            // A reconnect can miss updates while detached. Read each pending operation once;
+            // this is fire-and-forget so frame dispatch never waits on a status read.
+            this.reconcilePending();
+            const reader = response.body.getReader();
+            const parser = new SseParser();
+            const decoder = new TextDecoder();
+            const resetIdle = () => {
+                if (idleTimer !== undefined) {
+                    clearTimeout(idleTimer);
+                }
+                idleTimer = setTimeout(() => expire('idle wait timed out'), this.timeout);
+            };
+            resetIdle();
+            try {
+                while (this.handler !== undefined) {
+                    const chunk = await reader.read();
+                    if (chunk.done) {
+                        break;
+                    }
+                    resetIdle();
+                    this.noteStreamActivity();
+                    for (const frame of parser.push(decoder.decode(chunk.value, { stream: true }))) {
+                        // Reading and dispatching may outlast the idle deadline; heartbeat comments
+                        // stay queued in the socket and the next read refreshes the deadline.
+                        if (idleTimer !== undefined) {
+                            clearTimeout(idleTimer);
+                            idleTimer = undefined;
+                        }
+                        await this.commitFrame(frame);
+                        if (this.handler === undefined) {
+                            return;
+                        }
+                        resetIdle();
+                    }
+                }
+                if (this.handler === undefined) {
+                    return;
+                }
+                for (const frame of parser.push(decoder.decode())) {
+                    await this.commitFrame(frame);
+                }
+            }
+            finally {
+                // Close the connection when dispatch or protocol handling fails so the
+                // reconnect can replay the uncheckpointed event from the prior cursor.
+                await reader.cancel().catch(() => { });
+                reader.releaseLock();
+            }
+            if (reason !== undefined) {
+                throw new Error(`WeChat event stream ${reason}.`);
+            }
+        }
+        catch (error) {
+            if (reason !== undefined && this.handler !== undefined) {
+                throw new Error(`WeChat event stream ${reason}.`);
+            }
+            throw error;
+        }
+        finally {
+            clearTimeout(connectTimer);
+            clearTimeout(idleTimer);
+            this.operations.delete(controller);
+        }
+    }
+    /** Handles one complete SSE frame, then checkpoints its cursor. */
+    async commitFrame(frame) {
+        if (frame.event !== undefined && frame.event !== 'message') {
+            if (frame.event !== 'error') {
+                // Named events other than errors carry no messages and are not checkpoints.
+                return;
+            }
+            let code;
+            try {
+                const value = JSON.parse(frame.data);
+                if ((0, type_guards_1.isRecord)(value) && (0, type_guards_1.isRecord)(value.error) && (0, type_guards_1.isString)(value.error.code)) {
+                    code = value.error.code;
+                }
+            }
+            catch {
+                // An unreadable error frame is still a failed stream.
+            }
+            if (code === 'event_cursor_expired') {
+                throw new EventCursorExpiredError();
+            }
+            throw new Error(`WeChat event stream error${code === undefined ? '' : `: ${code}`}.`);
+        }
+        const cursor = parseEventCursor(frame.id, 'event cursor');
+        let value;
+        try {
+            value = JSON.parse(frame.data);
+        }
+        catch {
+            throw new Error('Unexpected WeChat event payload.');
+        }
+        if (!(0, type_guards_1.isRecord)(value) || !(0, type_guards_1.isString)(value.kind) || !value.kind ||
+            !(0, type_guards_1.isRecord)(value.data) || parseEventCursor(value.cursor, 'event cursor') !== cursor) {
+            throw new Error('Unexpected WeChat event payload.');
+        }
+        // A reconnect replays from the prior checkpoint; already-covered cursors are
+        // skipped and the checkpoint never moves backwards.
+        if (cursorCovered(cursor, this.after)) {
+            return;
+        }
+        const origin = this.identity;
+        await this.handleEvent({ cursor, kind: value.kind, data: value.data });
+        // A switch, re-login, or shutdown while the event was handled invalidates this
+        // reader: its cursor belongs to the previous login, and any frame still queued
+        // behind it may describe the previous account's conversation. Drop the connection
+        // so the loop tail-bootstraps the new login instead of checkpointing stale state.
+        this.requireIdentity(origin);
+        if (this.after === undefined) {
+            throw new AccountChangedError();
+        }
+        this.after = cursor;
+        // Only a successfully handled event proves the receive path is healthy.
+        this.failures = 0;
+    }
+    /** Applies one validated event. Unknown or unrelated kinds are checkpointed and ignored. */
+    async handleEvent(event) {
+        if (event.kind === 'message.committed') {
+            await this.handleCommittedMessage(event);
+        }
+        else if (event.kind === 'account.updated') {
+            this.adoptAccount(await this.readAccount());
+        }
+        else if (event.kind === 'send.updated') {
+            this.handleSendUpdated(event.data);
+        }
+        else if (event.kind === 'job.updated') {
+            this.handleJobUpdated(event.data);
+        }
+    }
+    /**
+     * Confirms a text waiter from `send.updated`. Media jobs also publish this kind with a
+     * MediaJob payload, which carries `kind`/job fields and no text `destination`, so it can
+     * never settle a text waiter even if an ID collides.
+     */
+    handleSendUpdated(data) {
+        const id = data.id;
+        if (!(0, type_guards_1.isString)(id) || !id || data.kind !== undefined) {
+            return;
+        }
+        const pending = this.pending.get(`send\u0000${id}`);
+        if (pending === undefined || pending.family !== 'send' ||
+            data.accountId !== pending.account || data.destination !== pending.threadId ||
+            this.account !== pending.account || this.selfUsername !== pending.username ||
+            !(0, type_guards_1.isString)(data.state) || !SEND_STATES.has(data.state)) {
+            return;
+        }
+        this.applyOutcome(pending, data.state, (0, type_guards_1.isString)(data.errorCode) ? data.errorCode : undefined);
+    }
+    /** Confirms a media waiter from `job.updated`; other job kinds, threads, and IDs are ignored. */
+    handleJobUpdated(data) {
+        const id = data.id;
+        if (!(0, type_guards_1.isString)(id) || !id) {
+            return;
+        }
+        const pending = this.pending.get(`job\u0000${id}`);
+        if (pending === undefined || pending.family !== 'job' ||
+            data.accountId !== pending.account || data.kind !== 'send' ||
+            data.threadId !== pending.threadId ||
+            this.account !== pending.account || this.selfUsername !== pending.username ||
+            !(0, type_guards_1.isString)(data.state) || !JOB_STATES.has(data.state)) {
+            return;
+        }
+        this.applyOutcome(pending, data.state, (0, type_guards_1.isString)(data.reason) ? data.reason : undefined);
+    }
+    /** Reads one committed message, filters it, and delivers it as its own live turn. */
+    async handleCommittedMessage(event) {
+        const messageId = event.data.messageId;
+        const threadId = event.data.threadId;
+        if (!(0, type_guards_1.isString)(messageId) || !messageId ||
+            !(0, type_guards_1.isString)(threadId) || !threadId) {
+            throw new Error('Unexpected WeChat message event.');
+        }
+        // Filter before any message read so ignored threads cost no requests.
+        if (this.options.chatIds !== undefined && !this.options.chatIds.includes(threadId)) {
+            return;
+        }
+        if (this.seenMessage(threadId, messageId)) {
+            return;
+        }
+        const account = this.accountId;
+        let value;
+        try {
+            value = await this.request(`${this.accountPath}/messages/${encodeURIComponent(messageId)}`);
+        }
+        catch (error) {
+            if (error instanceof WechatRequestError && (error.status === 404 || error.status === 410)) {
+                // The row was deleted before this event could be read. That is terminal for this
+                // event only: remember its ID so the checkpoint advances and later events are not
+                // stalled behind it until the daemon's retention window closes.
+                this.rememberId(threadId, messageId);
+                this.lastEventAt = new Date().toISOString();
+                console.warn(`[wechat] skipping message ${messageId} in ${threadId}: ` +
+                    `the daemon no longer has the row (HTTP ${error.status}).`);
+                return;
+            }
+            // Transient and authorization failures stay replayable from the same checkpoint.
+            throw error;
+        }
+        if (this.handler === undefined) {
+            return;
+        }
+        if (account !== this.account) {
+            throw new AccountChangedError();
+        }
+        const message = parseMessage(value, account, threadId);
+        if (message.id !== messageId) {
+            throw new Error('Unexpected WeChat message event identity.');
+        }
+        const time = messageTime(message);
+        // A live event never consults a per-thread watermark, so distinct IDs with equal or
+        // out-of-order source times are not dropped. The startup cutoff still applies, and an
+        // undated row cannot be ordered against it, so it is skipped.
+        if (time !== undefined && time >= this.startedAt && this.eligible(message)) {
+            await this.deliverMessage(threadId, message);
+        }
+        // Ineligible or pre-startup source messages are intentional skips, but remembering
+        // their IDs prevents a replay from reading or delivering them again.
+        this.rememberId(threadId, messageId);
+        this.lastEventAt = new Date().toISOString();
+    }
+    /** Only text, image, and voice messages from a known direction are deliverable. */
+    eligible(message) {
+        const supported = (message.type === 1 && (message.body ?? '') !== '') ||
+            message.type === 3 || message.type === 34;
+        if (!supported) {
+            return false;
+        }
+        return message.direction === 'outgoing'
+            ? this.selfUsername !== undefined
+            : message.direction === 'incoming' && message.senderId !== null;
+    }
+    /** Reads a small error body under its own deadline, bounded by `maxBytes`. */
+    async streamError(response, signal) {
+        const text = await readBoundedText(response, limit_1.MAX_SSE_ERROR_BYTES, this.timeout, signal);
+        if (text === undefined) {
+            return {};
+        }
+        try {
+            const value = JSON.parse(text);
+            if (!(0, type_guards_1.isRecord)(value) || !(0, type_guards_1.isRecord)(value.error)) {
+                return {};
+            }
+            return {
+                ...((0, type_guards_1.isString)(value.error.code) ? { code: value.error.code } : {}),
+                ...((0, type_guards_1.isString)(value.error.message) ? { message: value.error.message } : {})
+            };
+        }
+        catch {
+            return {};
+        }
+    }
+    /**
+     * Marks transport activity. Backoff is not reset here: a stream that connects and
+     * receives keepalives but keeps failing to handle an event must back off further.
+     */
+    noteStreamActivity() {
+        this.lastStreamActivityAt = new Date().toISOString();
+    }
+    recordFailure(error) {
+        this.failures += 1;
+        this.lastError = error instanceof Error ? error.message : 'Unknown WeChat stream error';
+        this.lastErrorAt = new Date().toISOString();
+        console.error('[wechat] event stream failed:', this.lastError);
+    }
+    /** Sleeps with capped exponential backoff; only stop() may interrupt the wait. */
+    async backoff() {
+        const exponent = Math.min(Math.max(0, this.failures - 1), limit_1.WECHAT_MAX_BACKOFF_EXPONENT);
+        const wait = Math.min(limit_1.MAX_TIMER_MS, this.reconnect * 2 ** exponent);
+        try {
+            await (0, promises_1.setTimeout)(wait, undefined, { signal: this.streamAbort.signal });
+        }
+        catch (error) {
+            if (this.streamAbort.signal.aborted) {
+                return;
+            }
+            // An unexpected timer failure must end the loop rather than spin reconnecting.
+            throw error;
+        }
+    }
+    /** Delivers one live message as its own turn, preserving the source for metadata consumers. */
+    async deliverMessage(threadId, message) {
+        const self = message.direction === 'outgoing';
+        const sender = self ? this.selfUsername : message.senderId;
+        if (sender === undefined || sender === null) {
+            return false;
+        }
+        const account = this.accountId;
+        const username = this.selfUsername;
+        // Display names are context only: a failed lookup must not drop the message, and a
+        // name never replaces a sender ID. In a chatroom the account's own nickname is useful
+        // context too, so self messages resolve under the same precedence.
+        const senderName = self && !threadId.endsWith('@chatroom')
+            ? undefined
+            : await this.displayName(threadId, sender);
+        if (this.handler === undefined) {
+            return false;
+        }
+        const text = messageText(message);
+        this.handler({
+            text,
+            senderId: sender,
+            senderName,
+            isSelf: self,
+            timestamp: message.createdAt ?? undefined,
+            channel: threadId,
+            messages: [{
+                    id: `message:${message.id}`,
+                    text,
+                    senderId: sender,
+                    senderName,
+                    isSelf: self,
+                    timestamp: message.createdAt ?? undefined,
+                    images: message.type === 3 ? [{
+                            id: `image:${message.id}`,
+                            load: (signal) => this.loadImage(message.id, account, username, signal)
+                        }] : undefined,
+                    audio: message.type === 34 ? {
+                        id: `voice:${message.id}`,
+                        load: (signal) => this.loadAudio(message.id, account, username, signal)
+                    } : undefined
+                }],
+            metadata: {
+                ...message,
+                content: text,
+                wechatAccount: account,
+                wechatUsername: this.selfUsername,
+                messageIds: [message.id],
+                firstTimestamp: message.createdAt,
+                lastTimestamp: message.createdAt,
+                messages: [message]
+            }
+        });
+        return true;
+    }
+    /** Remembers one recent message ID; the SSE cursor checkpoint is the primary dedupe. */
+    rememberId(threadId, messageId) {
+        const key = `${threadId}\u0000${messageId}`;
+        if (this.seen.has(key)) {
+            return;
+        }
+        this.seen.add(key);
+        while (this.seen.size > limit_1.WECHAT_RECENT_MESSAGE_LIMIT) {
+            const oldest = this.seen.values().next().value;
+            if (oldest === undefined) {
+                break;
+            }
+            this.seen.delete(oldest);
+        }
+    }
+    /** Whether a recent live message was already delivered or intentionally skipped. */
+    seenMessage(threadId, messageId) {
+        return this.seen.has(`${threadId}\u0000${messageId}`);
+    }
+    /**
+     * Cached sender name: the sender's own chatroom nickname, else the contact label.
+     *
+     * A native member label already resolves friend remark over WeChat nickname, so a
+     * chatroom nickname is the only extra level. Absent, unconfirmed, blank, or failed
+     * member reads fall through to the contact route; no name ever drops a message.
+     */
+    async displayName(threadId, senderId) {
+        const key = `${threadId}\u0000${senderId}`;
+        const cached = this.names.get(key);
+        if (cached !== undefined && cached.expires > Date.now()) {
+            return cached.name;
+        }
+        let name = threadId.endsWith('@chatroom')
+            ? await this.lookupName('group member name', () => this.groupMemberName(threadId, senderId), senderId)
+            : undefined;
+        // The chatroom nickname outranks every other name, so the contact is a fallback.
+        name ??= await this.lookupName('contact name', () => this.contactName(senderId), senderId);
+        if (this.names.size >= limit_1.WECHAT_NAME_CACHE_SIZE && !this.names.has(key)) {
+            const oldest = this.names.keys().next().value;
+            if (oldest !== undefined) {
+                this.names.delete(oldest);
+            }
+        }
+        this.names.set(key, { ...(name === undefined ? {} : { name }),
+            expires: Date.now() + (name === undefined ? limit_1.WECHAT_NAME_MISS_TTL_MS : limit_1.WECHAT_NAME_TTL_MS) });
+        return name;
+    }
+    /** Runs one cached name read; a failure is logged and yields no name. */
+    async lookupName(label, read, senderId) {
+        try {
+            return await read();
+        }
+        catch (error) {
+            console.warn(`[wechat] ${label} lookup failed for ${senderId}:`, error instanceof Error ? error.message : error);
+            return undefined;
         }
-        this.operations.add(controller);
-        const timer = setTimeout(cancel, limit_1.WECHAT_VOICE_JOB_TIMEOUT_MS);
-        let jobId;
-        let terminal = false;
+    }
+    /** Reads a chatroom member's own nickname and its upstream-resolved label. */
+    async groupMemberName(groupId, username) {
+        let result;
         try {
-            controller.signal.throwIfAborted();
-            const form = new FormData();
-            form.set('chatId', chatId);
-            form.set('audio', new Blob([new Uint8Array(audio.data)], { type: audio.mimeType }), audio.filename);
-            let job = await this.request('/api/messages/voice', form, controller.signal, undefined, { 'Idempotency-Key': (0, node_crypto_1.randomUUID)() });
-            while (true) {
-                if (!isRecord(job) || typeof job.jobId !== 'string' || !job.jobId ||
-                    typeof job.status !== 'string' || job.chatId !== chatId || job.accountId !== this.account ||
-                    jobId !== undefined && jobId !== job.jobId) {
-                    throw new Error('Unexpected WeChat voice job response.');
-                }
-                jobId = job.jobId;
-                this.requireActiveAccount(message);
-                controller.signal.throwIfAborted();
-                terminal = ['completed', 'failed', 'needs_review', 'cancelled'].includes(job.status);
-                if (job.status === 'completed') {
-                    return;
-                }
-                if (terminal) {
-                    throw new Error(`WeChat voice job ${jobId} ${job.status}${typeof job.error === 'string' ? `: ${job.error}` : ''}. Delivery will not be retried.`);
-                }
-                await (0, promises_1.setTimeout)(limit_1.WECHAT_VOICE_JOB_POLL_MS, undefined, { signal: controller.signal });
-                this.requireActiveAccount(message);
-                job = await this.request(`/api/messages/voice/${encodeURIComponent(jobId)}`, undefined, controller.signal);
-            }
+            result = await this.request(`${this.accountPath}/groups/${encodeURIComponent(groupId)}` +
+                `/members/${encodeURIComponent(username)}`);
         }
         catch (error) {
-            if (jobId !== undefined && !terminal) {
-                try {
-                    await this.request(`/api/messages/voice/${encodeURIComponent(jobId)}/cancel`, {}, AbortSignal.timeout(limit_1.WECHAT_VOICE_CANCEL_TIMEOUT_MS));
-                }
-                catch (cancelError) {
-                    console.warn(`[wechat] unable to cancel voice job ${jobId}:`, cancelError instanceof Error ? cancelError.message : cancelError);
-                }
-            }
-            if (controller.signal.aborted) {
-                throw new Error(`WeChat voice job cancelled or exceeded ${limit_1.WECHAT_VOICE_JOB_TIMEOUT_MS} ms; delivery may be unconfirmed and will not be retried.`);
+            if (error instanceof WechatRequestError && isTerminalMediaStatus(error.status)) {
+                return undefined;
             }
             throw error;
         }
-        finally {
-            clearTimeout(timer);
-            signal?.removeEventListener('abort', cancel);
-            this.operations.delete(controller);
+        if (!(0, type_guards_1.isRecord)(result) || !(0, type_guards_1.isString)(result.state) ||
+            !(result.member === null || (0, type_guards_1.isRecord)(result.member))) {
+            throw new Error('Unexpected WeChat group member response.');
         }
-    }
-    requireActiveAccount(message) {
-        this.requireAccount(message.metadata?.wechatAccount);
-    }
-    requireAccount(account) {
-        if (this.handler === undefined || typeof account !== 'string' || account !== this.account) {
-            throw new Error('WeChat adapter is stopped or the originating account has changed.');
+        const member = result.member;
+        if (result.state !== 'present' || !(0, type_guards_1.isRecord)(member)) {
+            return undefined;
+        }
+        // `roomDisplayName` is this chatroom's nickname for the member. `displayName` is the
+        // label upstream already resolved from the friend remark, then the WeChat nickname.
+        if (![member.roomDisplayName, member.displayName].every((value) => value === undefined || value === null || (0, type_guards_1.isString)(value))) {
+            throw new Error('Unexpected WeChat group member fields.');
         }
+        return trimmedName(member.roomDisplayName) ?? trimmedName(member.displayName);
     }
-    /** Requests media only when the server processes its conversation, never during polling. */
-    async loadImage(chatId, localId, account, signal) {
-        this.requireAccount(account);
+    /** Reads a contact's friend remark and label, falling back to the raw WeChat nickname. */
+    async contactName(username) {
         let result;
         try {
-            result = await this.request(`/api/messages/${encodeURIComponent(chatId)}/media/${localId}?quality=best`, undefined, signal, limit_1.MAX_ENCODED_IMAGE_BYTES + limit_1.MEDIA_RESPONSE_OVERHEAD_BYTES);
+            result = await this.request(`${this.accountPath}/contacts/${encodeURIComponent(username)}`);
         }
         catch (error) {
-            if (error instanceof media_1.MediaUnavailableError) {
-                throw new images_1.ImageUnavailableError(error.message);
-            }
-            if (error instanceof WechatRequestError && error.status >= 400 && error.status < 500 &&
-                error.status !== 408 && error.status !== 429) {
-                throw new images_1.ImageUnavailableError('WeChat image media is unavailable.');
+            if (error instanceof WechatRequestError && isTerminalMediaStatus(error.status)) {
+                return undefined;
             }
             throw error;
         }
-        this.requireAccount(account);
-        if (!isRecord(result) || typeof result.type !== 'string') {
-            throw new Error('Unexpected WeChat image media response.');
+        if (!(0, type_guards_1.isRecord)(result) || ![result.remark, result.displayName, result.nickname].every((value) => value === undefined || value === null || (0, type_guards_1.isString)(value))) {
+            throw new Error('Unexpected WeChat contact response.');
         }
-        if (result.type !== 'image' || result.data === undefined || result.data === null) {
-            if (result.retryable === true || (result.type === 'pending' && result.retryable !== false)) {
-                return { status: 'pending' };
-            }
-            return { status: 'unavailable' };
-        }
-        if (typeof result.data !== 'string') {
-            throw new images_1.ImageUnavailableError('WeChat image data must be a base64 string.');
+        // The label is usually the friend remark, but upstream tests its fields for emptiness
+        // without trimming, so a whitespace-only remark can mask a real nickname. Falling back
+        // to the raw nickname keeps the WeChat-wide name available for those contacts.
+        return trimmedName(result.remark) ?? trimmedName(result.displayName) ??
+            trimmedName(result.nickname);
+    }
+    /** Account-scoped route built from a captured account ID, never a mutable current one. */
+    pathFor(account) {
+        return `/v1/accounts/${encodeURIComponent(account)}`;
+    }
+    /** Requests image bytes only when the server processes its conversation. */
+    async loadImage(messageId, account, username, signal) {
+        this.requireAccount(account, username);
+        const origin = { account: account, path: this.pathFor(account) };
+        const selection = await this.selectMedia(origin, messageId, 'image', signal);
+        if (selection.status !== 'ready') {
+            return selection;
         }
+        this.requireAccount(account, username);
         try {
-            return { status: 'ready', dataUrl: (0, images_1.imageDataUrl)(result.data) };
+            const content = await this.mediaContent(origin.path, selection.asset.id, limit_1.MAX_IMAGE_BYTES, signal);
+            this.requireAccount(account, username);
+            try {
+                return { status: 'ready', dataUrl: (0, images_1.imageDataUrl)(content.bytes.toString('base64')) };
+            }
+            catch (error) {
+                throw new images_1.ImageUnavailableError(error instanceof Error ? error.message : 'Invalid WeChat image data.');
+            }
         }
-        catch {
-            return { status: 'unavailable' };
+        catch (error) {
+            if (error instanceof media_1.MediaUnavailableError) {
+                throw error instanceof images_1.ImageUnavailableError ? error : new images_1.ImageUnavailableError(error.message);
+            }
+            if (error instanceof WechatRequestError && isTerminalMediaStatus(error.status)) {
+                throw new images_1.ImageUnavailableError('WeChat image media is unavailable.');
+            }
+            throw error;
         }
     }
-    async loadAudio(chatId, localId, account, signal) {
-        this.requireAccount(account);
-        let result;
+    /** Requests voice bytes lazily and converts the daemon's WAV copy for STT. */
+    async loadAudio(messageId, account, username, signal) {
+        this.requireAccount(account, username);
+        const origin = { account: account, path: this.pathFor(account) };
         try {
-            result = await this.request(`/api/messages/${encodeURIComponent(chatId)}/media/${localId}`, undefined, signal, limit_1.MAX_ENCODED_AUDIO_BYTES + limit_1.MEDIA_RESPONSE_OVERHEAD_BYTES);
+            const selection = await this.selectMedia(origin, messageId, 'voice', signal);
+            if (selection.status !== 'ready') {
+                return selection;
+            }
+            this.requireAccount(account, username);
+            const content = await this.mediaContent(origin.path, selection.asset.id, limit_1.MAX_AUDIO_BYTES, signal);
+            this.requireAccount(account, username);
+            const mimeType = (content.contentType ?? selection.asset.contentType ?? '').toLowerCase();
+            const format = (0, audio_1.audioExtension)(mimeType);
+            return { status: 'ready', audio: (0, audio_1.audioFile)(content.bytes.toString('base64'), format, messageId) };
         }
         catch (error) {
-            if (error instanceof media_1.MediaUnavailableError || error instanceof WechatRequestError &&
-                error.status >= 400 && error.status < 500 && error.status !== 408 && error.status !== 429) {
+            if (error instanceof media_1.MediaUnavailableError) {
+                return { status: 'unavailable', reason: error.message };
+            }
+            if (error instanceof WechatRequestError && isTerminalMediaStatus(error.status)) {
                 return { status: 'unavailable', reason: error.message };
             }
             throw error;
         }
-        this.requireAccount(account);
-        if (!isRecord(result) || typeof result.type !== 'string') {
-            throw new Error('Unexpected WeChat voice media response.');
+    }
+    /** Lists attachment copies, fetching the best cached one or starting one download. */
+    async selectMedia(origin, messageId, kind, signal) {
+        let assets;
+        try {
+            const page = await this.request(`${origin.path}/messages/${encodeURIComponent(messageId)}/media`, undefined, signal);
+            if (!(0, type_guards_1.isRecord)(page) || !Array.isArray(page.items)) {
+                throw new Error('Unexpected WeChat message media response.');
+            }
+            // Ownership is checked against the captured account and this exact message.
+            assets = page.items.map((item) => parseMediaAsset(item, origin.account, messageId))
+                .filter((asset) => asset !== undefined);
         }
-        if (result.type !== 'voice' || result.data === undefined || result.data === null) {
-            if (result.retryable === true || result.type === 'pending' && result.retryable !== false) {
-                return { status: 'pending' };
+        catch (error) {
+            if (error instanceof WechatRequestError && isTerminalMediaStatus(error.status)) {
+                return { status: 'unavailable' };
             }
-            return { status: 'unavailable' };
+            throw error;
         }
-        if (typeof result.data !== 'string' || typeof result.format !== 'string') {
-            return { status: 'unavailable', reason: 'invalid voice media fields' };
+        // Voice exposes `normal` (decoded WAV) and `encoded` (raw SILK) copies. Only the decoded
+        // copy can feed STT here, so a raw copy is never selected even when it is already cached.
+        const matching = assets.filter((asset) => asset.kind === kind &&
+            (kind !== 'voice' || (asset.actualVariant ?? asset.variant) !== 'encoded'));
+        const available = matching.filter((asset) => asset.state === 'available')
+            .sort((left, right) => variantRank(kind, left) - variantRank(kind, right));
+        if (available.length > 0) {
+            return { status: 'ready', asset: available[0] };
+        }
+        const pending = matching.filter((asset) => asset.state === 'pending' && asset.retryable)
+            .sort((left, right) => variantRank(kind, left) - variantRank(kind, right));
+        if (pending.length === 0) {
+            return { status: 'unavailable' };
         }
+        // MediaTransferRequest accepts only messageId, assetId, and quality; use the exact copy.
         try {
-            return { status: 'ready', audio: (0, audio_1.audioFile)(result.data, result.format, localId) };
+            await this.request(`${origin.path}/messages/${encodeURIComponent(messageId)}/media-transfers`, { messageId, assetId: pending[0].id }, signal);
         }
         catch (error) {
-            return { status: 'unavailable', reason: error instanceof Error ? error.message : 'invalid voice data' };
+            if (error instanceof WechatRequestError && isTerminalMediaStatus(error.status)) {
+                return { status: 'unavailable' };
+            }
+            throw error;
         }
+        return { status: 'pending' };
     }
-    getStatus() {
-        return {
-            active: this.handler !== undefined,
-            lastSuccessfulPollAt: this.lastSuccessfulPollAt,
-            consecutivePollFailures: this.failures,
-            failedChats: this.chatFailures.size,
-            lastPollError: this.lastPollError,
-            lastPollErrorAt: this.lastPollErrorAt
-        };
+    /** Streams cached bytes from the account-scoped route, never an advertised URL. */
+    async mediaContent(accountPath, assetId, maxBytes, signal) {
+        return this.requestBytes(`${accountPath}/media/${encodeURIComponent(assetId)}/content`, signal, maxBytes);
     }
-    schedule(delay) {
-        if (this.handler === undefined) {
-            return;
+    validateImage(image) {
+        const data = Buffer.from(image.data);
+        if (data.byteLength === 0) {
+            throw new Error('WeChat image attachments must not be empty.');
         }
-        this.timer = setTimeout(() => {
-            this.polling = this.poll().then(() => {
-                this.failures = 0;
-                this.lastSuccessfulPollAt = new Date().toISOString();
-            }).catch((error) => {
-                if (this.handler !== undefined) {
-                    this.failures += 1;
-                    this.recordPollError(error);
-                    console.error('[wechat] polling failed:', error instanceof Error ? error.message : error);
+        const dataUrl = (0, images_1.imageDataUrl)(data.toString('base64'));
+        const mimeType = dataUrl.slice(5, dataUrl.indexOf(';'));
+        if (mimeType !== image.mimeType) {
+            throw new Error('WeChat image MIME type does not match its bytes.');
+        }
+        return { data, filename: image.filename.trim() || 'image.png', mimeType };
+    }
+    validateVoice(audio) {
+        if (audio === undefined) {
+            throw new Error('Voice reply requires synthesized audio.');
+        }
+        if (!audio.data.byteLength || audio.data.byteLength > limit_1.MAX_AUDIO_BYTES) {
+            throw new Error('Voice reply audio is empty or exceeds the audio size limit.');
+        }
+        (0, audio_1.audioExtension)(audio.mimeType);
+        return audio;
+    }
+    /** Stages one file and waits for the daemon to accept the media message. */
+    async sendMedia(message, account, accountPath, destination, kind, media, signal) {
+        await this.runSend(message, `${kind} job`, 'job', destination, async (operationSignal) => {
+            const sourceId = await this.upload(accountPath, media, operationSignal);
+            this.requireActiveAccount(message);
+            operationSignal.throwIfAborted();
+            const result = await this.request(`${accountPath}/sends`, { kind, threadId: destination, sourceId }, operationSignal, { 'Idempotency-Key': (0, node_crypto_1.randomUUID)() });
+            const job = this.parseMediaJob(result, account, destination);
+            return {
+                id: job.id,
+                state: job.state,
+                ...(job.reason === undefined ? {} : { detail: job.reason }),
+                read: async (readSignal) => {
+                    this.requireActiveAccount(message);
+                    const next = this.parseMediaJob(await this.request(`${accountPath}/jobs/${encodeURIComponent(job.id)}`, undefined, readSignal), account, destination);
+                    this.requireActiveAccount(message);
+                    return { id: next.id, state: next.state, ...(next.reason === undefined ? {} : { detail: next.reason }) };
+                },
+                cancel: async () => {
+                    await this.request(`${accountPath}/jobs/${encodeURIComponent(job.id)}/cancel`, {}, AbortSignal.timeout(limit_1.WECHAT_SEND_CANCEL_TIMEOUT_MS));
                 }
-            }).finally(() => {
-                this.schedule(Math.min(limit_1.MAX_TIMER_MS, this.interval * 2 ** Math.min(this.failures, limit_1.WECHAT_MAX_BACKOFF_EXPONENT)));
-            });
-        }, delay);
+            };
+        }, signal);
     }
-    async readAccount() {
-        const status = await this.request('/api/status/auth');
-        if (!isRecord(status) || status.status !== 'logged_in' ||
-            typeof status.loggedInUser !== 'string' || !status.loggedInUser) {
-            throw new Error('WeChat is not logged in. Log in using agent-wechat first.');
+    /** Sends text and waits for the daemon to accept it; uncertain sends are never repeated. */
+    async sendText(message, account, accountPath, destination, text, signal) {
+        await this.runSend(message, 'send', 'send', destination, async (operationSignal) => {
+            const result = await this.request(`${accountPath}/sends`, { threadId: destination, text }, operationSignal, { 'Idempotency-Key': (0, node_crypto_1.randomUUID)() });
+            const intent = this.parseSendIntent(result, account, destination);
+            return {
+                id: intent.id,
+                state: intent.state,
+                ...(intent.errorCode === undefined ? {} : { detail: intent.errorCode }),
+                read: async (readSignal) => {
+                    this.requireActiveAccount(message);
+                    const next = this.parseSendIntent(await this.request(`${accountPath}/sends/${encodeURIComponent(intent.id)}`, undefined, readSignal), account, destination);
+                    this.requireActiveAccount(message);
+                    return { id: next.id, state: next.state, ...(next.errorCode === undefined ? {} : { detail: next.errorCode }) };
+                },
+                cancel: async () => {
+                    await this.request(`${accountPath}/sends/${encodeURIComponent(intent.id)}/cancel`, {}, AbortSignal.timeout(limit_1.WECHAT_SEND_CANCEL_TIMEOUT_MS));
+                }
+            };
+        }, signal);
+    }
+    /** Uploads bytes with the multipart field name `file` and returns the source ID. */
+    async upload(accountPath, media, signal) {
+        const form = new FormData();
+        form.set('file', new Blob([new Uint8Array(media.data)], { type: media.mimeType }), media.filename);
+        const result = await this.request(`${accountPath}/uploads`, form, signal);
+        if (!(0, type_guards_1.isRecord)(result) || !(0, type_guards_1.isString)(result.id) || !result.id ||
+            !(0, type_guards_1.isString)(result.mediaType) || !(0, type_guards_1.isString)(result.name)) {
+            throw new Error('Unexpected WeChat upload response.');
+        }
+        return result.id;
+    }
+    /** Validates a response against the account that originated the send, not the current one. */
+    parseSendIntent(value, account, destination) {
+        if (!(0, type_guards_1.isRecord)(value) || !(0, type_guards_1.isString)(value.id) || !value.id ||
+            value.accountId !== account || value.destination !== destination ||
+            !(0, type_guards_1.isString)(value.state) || !SEND_STATES.has(value.state) ||
+            !(value.errorCode === null || value.errorCode === undefined || (0, type_guards_1.isString)(value.errorCode))) {
+            throw new Error('Unexpected WeChat send response.');
         }
-        return status.loggedInUser;
+        return {
+            id: value.id,
+            state: value.state,
+            ...((0, type_guards_1.isString)(value.errorCode) ? { errorCode: value.errorCode } : {})
+        };
     }
-    async poll() {
-        const account = await this.readAccount();
-        if (account !== this.account) {
-            // Never replay another account's history or reuse its cursors.
-            this.account = account;
-            this.startedAt = Date.now();
-            this.cursors.clear();
-            this.chatFailures.clear();
-        }
-        const chats = [];
-        const pageSize = limit_1.WECHAT_CHAT_PAGE_SIZE;
-        for (let offset = 0;; offset += pageSize) {
-            const page = await this.request(`/api/chats?limit=${pageSize}&offset=${offset}`);
-            if (!Array.isArray(page) || !page.every((chat) => isRecord(chat) && typeof chat.id === 'string')) {
-                throw new Error('Unexpected WeChat chats response.');
-            }
-            chats.push(...page);
-            if (page.length < pageSize) {
-                break;
-            }
+    parseMediaJob(value, account, destination) {
+        if (!(0, type_guards_1.isRecord)(value) || !(0, type_guards_1.isString)(value.id) || !value.id ||
+            value.accountId !== account || value.kind !== 'send' || value.threadId !== destination ||
+            !(0, type_guards_1.isString)(value.state) || !JOB_STATES.has(value.state) ||
+            !(value.reason === null || value.reason === undefined || (0, type_guards_1.isString)(value.reason))) {
+            throw new Error('Unexpected WeChat media job response.');
         }
-        const activeIds = new Set(chats.map((chat) => chat.id));
-        for (const chatId of this.chatFailures.keys()) {
-            if (!activeIds.has(chatId)) {
-                this.chatFailures.delete(chatId);
-            }
+        return {
+            id: value.id,
+            state: value.state,
+            ...((0, type_guards_1.isString)(value.reason) ? { reason: value.reason } : {})
+        };
+    }
+    /**
+     * Submits one outbound operation and waits for its terminal event-stream update. One
+     * status read after registration reconciles an update that raced the POST response;
+     * there is no interval polling. Failure or uncertainty cancels once and never resends.
+     */
+    async runSend(message, label, family, threadId, submit, signal) {
+        const controller = new AbortController();
+        const cancel = () => controller.abort();
+        signal?.addEventListener('abort', cancel, { once: true });
+        if (signal?.aborted) {
+            controller.abort();
         }
-        for (const chat of chats) {
-            if (this.handler === undefined) {
+        this.operations.add(controller);
+        const timer = setTimeout(cancel, limit_1.WECHAT_SEND_TIMEOUT_MS);
+        let handle;
+        let pending;
+        let terminal = false;
+        try {
+            controller.signal.throwIfAborted();
+            handle = await submit(controller.signal);
+            // A submission response may already be terminal; fence it like any stream update.
+            this.requireActiveAccount(message);
+            controller.signal.throwIfAborted();
+            if (handle.state === 'accepted') {
                 return;
             }
-            const chatId = chat.id;
-            if (this.options.chatIds !== undefined && !this.options.chatIds.includes(chatId)) {
-                continue;
-            }
-            if ((this.chatFailures.get(chatId)?.retryAt ?? 0) > Date.now()) {
-                continue;
-            }
-            const cursor = this.cursors.get(chatId) ?? { timestamp: this.startedAt, ids: new Set() };
-            const signature = JSON.stringify([chat.lastMsgLocalId, chat.lastActivityAt, chat.unreadCount]);
-            if (cursor.signature === signature) {
-                continue;
+            if (TERMINAL_STATES.has(handle.state)) {
+                terminal = true;
+                throw this.sendFailure(label, handle.id, handle.state, handle.detail);
             }
-            try {
-                const hadMessages = await this.pollChat(chatId, cursor);
-                // An empty result can mean database keys/data aren't ready yet. Retry with
-                // backoff rather than caching it as an unchanged, successfully read chat.
-                if (!hadMessages && Date.parse(String(chat.lastActivityAt)) >= cursor.timestamp) {
-                    throw new Error('WeChat returned no messages for an active chat; database data may not be ready.');
-                }
-                cursor.signature = hadMessages ? signature : undefined;
-                this.cursors.set(chatId, cursor);
-                this.chatFailures.delete(chatId);
+            pending = this.registerPending(message, label, family, threadId, handle);
+            const outcome = this.waitForOutcome(pending, controller.signal);
+            // Reconcile the submission race once; the event stream remains the primary path.
+            if (!controller.signal.aborted) {
+                this.reconcileOne(pending);
             }
-            catch (error) {
-                console.error(`[wechat] failed to read chat ${chatId}:`, error instanceof Error ? error.message : error);
-                this.recordPollError(error);
-                const count = (this.chatFailures.get(chatId)?.count ?? 0) + 1;
-                this.chatFailures.set(chatId, {
-                    count, retryAt: Date.now() + Math.min(limit_1.MAX_TIMER_MS, this.interval * 2 ** Math.min(count, limit_1.WECHAT_MAX_BACKOFF_EXPONENT))
-                });
+            const result = await outcome;
+            // A switch or deadline during the wait must not turn a stale result into confirmation.
+            this.requireActiveAccount(message);
+            controller.signal.throwIfAborted();
+            if (result.state === 'accepted') {
+                return;
             }
+            terminal = true;
+            throw this.sendFailure(label, pending.id, result.state, result.detail);
         }
-    }
-    recordPollError(error) {
-        this.lastPollError = error instanceof Error ? error.message : 'Unknown polling error';
-        this.lastPollErrorAt = new Date().toISOString();
-    }
-    async pollChat(chatId, cursor) {
-        const messages = new Map();
-        const pageSize = limit_1.WECHAT_MESSAGE_PAGE_SIZE;
-        let hadMessages = false;
-        // The upstream API sorts newest first. Page back to the previous timestamp,
-        // including its entire second so messages with equal timestamps aren't lost.
-        for (let offset = 0;; offset += pageSize) {
-            const page = await this.request(`/api/messages/${encodeURIComponent(chatId)}?limit=${pageSize}&offset=${offset}`);
-            if (!Array.isArray(page)) {
-                throw new Error('Unexpected WeChat messages response.');
-            }
-            hadMessages ||= page.length > 0;
-            let reachedHistory = false;
-            for (const item of page) {
-                if (!isRecord(item) || !Number.isSafeInteger(item.localId) ||
-                    typeof item.timestamp !== 'string' || !Number.isFinite(Date.parse(item.timestamp)) ||
-                    typeof item.content !== 'string' || typeof item.type !== 'number' ||
-                    (item.isSelf !== undefined && typeof item.isSelf !== 'boolean') ||
-                    (item.sender !== undefined && typeof item.sender !== 'string')) {
-                    throw new Error('Unexpected WeChat message fields.');
-                }
-                const message = item;
-                const timestamp = Date.parse(message.timestamp);
-                if (timestamp < cursor.timestamp) {
-                    reachedHistory = true;
+        catch (error) {
+            if (handle !== undefined && !terminal) {
+                try {
+                    await handle.cancel();
                 }
-                else {
-                    // Keep already-seen rows at the cursor timestamp as boundaries too:
-                    // newly discovered messages must not merge across a self/other sender.
-                    messages.set(message.localId, message);
+                catch (cancelError) {
+                    console.warn(`[wechat] unable to cancel ${label} ${handle.id}:`, cancelError instanceof Error ? cancelError.message : cancelError);
                 }
             }
-            if (page.length < pageSize || reachedHistory) {
-                break;
+            if (controller.signal.aborted) {
+                throw new Error(`WeChat ${label} ${handle?.id ?? ''} cancelled or exceeded ` +
+                    `${limit_1.WECHAT_SEND_TIMEOUT_MS} ms; delivery may be unconfirmed and will not be retried.`);
             }
+            throw error;
         }
-        let bundle = [];
-        const flush = () => {
-            if (bundle.length === 0) {
-                return;
-            }
-            this.dispatchBundle(chatId, bundle);
-            for (const message of bundle) {
-                this.advanceCursor(cursor, message);
+        finally {
+            clearTimeout(timer);
+            signal?.removeEventListener('abort', cancel);
+            if (pending !== undefined) {
+                this.removePending(pending);
             }
-            bundle = [];
+            this.operations.delete(controller);
+        }
+    }
+    /** One terminal delivery failure; uncertainty is never retried or resent. */
+    sendFailure(label, id, state, detail) {
+        return new Error(`WeChat ${label} ${id} ${state}` +
+            `${detail === undefined ? '' : `: ${detail}`}. Delivery will not be retried.`);
+    }
+    /** Registers one nonterminal submission for SSE confirmation under its origin fence. */
+    registerPending(message, label, family, threadId, handle) {
+        this.requireActiveAccount(message);
+        const pending = {
+            key: `${family}\u0000${handle.id}`,
+            id: handle.id,
+            family,
+            label,
+            account: this.accountId,
+            username: this.selfUsername,
+            threadId,
+            state: handle.state,
+            ...(handle.detail === undefined ? {} : { detail: handle.detail }),
+            settled: false,
+            read: handle.read,
+            resolve: () => { },
+            reject: () => { }
         };
-        for (const message of [...messages.values()].sort((a, b) => Date.parse(a.timestamp) - Date.parse(b.timestamp) || a.localId - b.localId)) {
-            if (this.handler === undefined) {
-                return hadMessages;
-            }
-            const timestamp = Date.parse(message.timestamp);
-            const alreadySeen = timestamp < cursor.timestamp ||
-                (timestamp === cursor.timestamp && cursor.ids.has(message.localId));
-            if (!alreadySeen && message.isSelf === true &&
-                ((message.type === 1 && message.content) || message.type === 3 || message.type === 34)) {
-                flush();
-                this.dispatchBundle(chatId, [message]);
-                this.advanceCursor(cursor, message);
-                continue;
-            }
-            const eligible = message.isSelf === false && message.sender &&
-                ((message.type === 1 && message.content) || message.type === 3 || message.type === 34);
-            if (alreadySeen || !eligible) {
-                // Even messages we don't deliver interrupt conversational adjacency.
-                flush();
-                if (!alreadySeen) {
-                    this.advanceCursor(cursor, message);
-                }
-                continue;
-            }
-            const previous = bundle.at(-1);
-            if (previous !== undefined && (this.bundleGap === 0 ||
-                message.sender !== previous.sender ||
-                timestamp - Date.parse(previous.timestamp) > this.bundleGap)) {
-                flush();
+        this.pending.set(pending.key, pending);
+        return pending;
+    }
+    /** Resolves when the waiter's terminal outcome arrives or its deadline/caller aborts. */
+    waitForOutcome(pending, signal) {
+        return new Promise((resolve, reject) => {
+            pending.resolve = resolve;
+            pending.reject = reject;
+            const onAbort = () => {
+                reject(new Error(`WeChat ${pending.label} ${pending.id} cancelled.`));
+            };
+            if (signal.aborted) {
+                onAbort();
+                return;
             }
-            bundle.push(message);
+            signal.addEventListener('abort', onAbort, { once: true });
+            pending.cleanup = () => signal.removeEventListener('abort', onAbort);
+        });
+    }
+    /**
+     * Applies one status read or event. Accepted and terminal states latch, so a stale
+     * status read that finishes after a newer SSE update can never override it.
+     */
+    applyOutcome(pending, state, detail) {
+        if (pending.settled) {
+            return;
+        }
+        if (state === 'accepted' || TERMINAL_STATES.has(state)) {
+            this.settlePending(pending, { state, ...(detail === undefined ? {} : { detail }) });
+            return;
+        }
+        pending.state = state;
+        if (detail !== undefined) {
+            pending.detail = detail;
         }
-        flush();
-        return hadMessages;
     }
-    /** Delivers one conversational turn, preserving the source messages for metadata consumers. */
-    dispatchBundle(chatId, messages) {
-        const first = messages[0];
-        const last = messages[messages.length - 1];
-        const sender = first.isSelf ? this.account : first.sender;
-        if (sender === undefined) {
+    settlePending(pending, outcome) {
+        if (pending.settled) {
             return;
         }
-        const account = this.account;
-        const text = messages.map(messageText).join('\n');
-        this.handler?.({
-            text,
-            senderId: sender,
-            senderName: displayName(last),
-            isSelf: first.isSelf === true,
-            timestamp: last.timestamp,
-            channel: chatId,
-            messages: messages.map((message) => ({
-                id: `message:${message.localId}`,
-                text: messageText(message),
-                senderId: message.isSelf ? account : message.sender,
-                senderName: displayName(message),
-                isSelf: message.isSelf === true,
-                timestamp: message.timestamp,
-                images: message.type === 3 ? [{
-                        id: `image:${message.localId}`,
-                        load: (signal) => this.loadImage(chatId, message.localId, account, signal)
-                    }] : undefined,
-                audio: message.type === 34 ? {
-                    id: `voice:${message.localId}`,
-                    load: (signal) => this.loadAudio(chatId, message.localId, account, signal)
-                } : undefined
-            })),
-            metadata: {
-                ...last,
-                content: text,
-                wechatAccount: this.account,
-                localIds: messages.map((message) => message.localId),
-                firstTimestamp: first.timestamp,
-                lastTimestamp: last.timestamp,
-                messages: [...messages]
+        pending.settled = true;
+        this.pending.delete(pending.key);
+        pending.reconcile?.abort();
+        pending.cleanup?.();
+        pending.cleanup = undefined;
+        pending.resolve(outcome);
+    }
+    /** Rejects every outstanding waiter, e.g. on stop or an identity change. */
+    rejectPending(reason) {
+        for (const pending of [...this.pending.values()]) {
+            if (pending.settled) {
+                continue;
             }
-        });
+            pending.settled = true;
+            this.pending.delete(pending.key);
+            pending.reconcile?.abort();
+            pending.cleanup?.();
+            pending.cleanup = undefined;
+            pending.reject(new Error(`${reason} (${pending.label} ${pending.id})`));
+        }
     }
-    advanceCursor(cursor, message) {
-        const timestamp = Date.parse(message.timestamp);
-        if (timestamp > cursor.timestamp) {
-            cursor.timestamp = timestamp;
-            cursor.ids.clear();
+    /** Releases one waiter after its send settles, aborting any status read still in flight. */
+    removePending(pending) {
+        if (this.pending.get(pending.key) === pending) {
+            this.pending.delete(pending.key);
         }
-        cursor.ids.add(message.localId);
+        pending.reconcile?.abort();
+        pending.cleanup?.();
+        pending.cleanup = undefined;
     }
-    async request(endpoint, body, signal, maxBytes, headers = {}) {
-        if (this.handler === undefined) {
-            throw new Error('WeChat adapter is stopped.');
+    /** Starts one status read per pending operation after a (re)connect. */
+    reconcilePending() {
+        for (const pending of [...this.pending.values()]) {
+            this.reconcileOne(pending);
         }
-        const controller = new AbortController();
-        const cancel = () => controller.abort();
-        signal?.addEventListener('abort', cancel, { once: true });
-        if (signal?.aborted) {
-            controller.abort();
+    }
+    /**
+     * Reads one pending operation's status once. The read never blocks the event stream,
+     * never resends, and stops when the waiter settles or a terminal update latches. A
+     * transient failure leaves the waiter to the stream and its existing deadline.
+     *
+     * A reconnect supersedes rather than queues behind a read still in flight from before
+     * the disconnect: that read may predate a confirmation lost with the old connection,
+     * and waiting for it could strand the send until its full deadline.
+     */
+    reconcileOne(pending) {
+        if (pending.settled) {
+            return;
         }
-        this.operations.add(controller);
-        const timer = setTimeout(() => controller.abort(), this.timeout);
-        try {
-            const response = await fetch(`${this.baseUrl}${endpoint}`, {
-                method: body === undefined ? 'GET' : 'POST',
-                headers: { Authorization: `Bearer ${this.token}`,
-                    ...(body instanceof FormData ? {} : { 'Content-Type': 'application/json' }), ...headers },
-                body: body instanceof FormData ? body : body === undefined ? undefined : JSON.stringify(body),
-                signal: controller.signal
-            });
-            if (!response.ok) {
-                throw new WechatRequestError(response.status, endpoint);
+        pending.reconcile?.abort();
+        const controller = new AbortController();
+        pending.reconcile = controller;
+        void (async () => {
+            try {
+                const next = await pending.read(controller.signal);
+                if (pending.settled || pending.reconcile !== controller ||
+                    controller.signal.aborted || next.id !== pending.id) {
+                    return;
+                }
+                this.applyOutcome(pending, next.state, next.detail);
+            }
+            catch (error) {
+                if (!pending.settled && pending.reconcile === controller &&
+                    !controller.signal.aborted) {
+                    console.warn(`[wechat] unable to reconcile ${pending.label} ${pending.id}:`, error instanceof Error ? error.message : error);
+                }
             }
-            if (maxBytes === undefined) {
-                return await response.json();
+            finally {
+                if (pending.reconcile === controller) {
+                    pending.reconcile = undefined;
+                }
             }
+        })();
+    }
+    async request(endpoint, body, signal, headers = {}) {
+        return this.perform(endpoint, body, signal, headers, async (response) => await response.json());
+    }
+    /** Reads bounded raw bytes for media content routes. */
+    async requestBytes(endpoint, signal, maxBytes) {
+        return this.perform(endpoint, undefined, signal, {}, async (response, abort) => {
+            const contentType = response.headers.get('content-type') ?? undefined;
             if (Number(response.headers.get('content-length')) > maxBytes) {
-                controller.abort();
+                abort();
                 throw new media_1.MediaUnavailableError('WeChat media response exceeds the size limit.');
             }
             if (response.body === null) {
@@ -5817,7 +6825,7 @@ class WechatMessagerAdapter {
                     }
                     size += chunk.value.byteLength;
                     if (size > maxBytes) {
-                        controller.abort();
+                        abort();
                         throw new media_1.MediaUnavailableError('WeChat media response exceeds the size limit.');
                     }
                     chunks.push(chunk.value);
@@ -5826,7 +6834,34 @@ class WechatMessagerAdapter {
             finally {
                 reader.releaseLock();
             }
-            return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+            return { bytes: Buffer.concat(chunks), ...(contentType === undefined ? {} : { contentType }) };
+        });
+    }
+    /** Issues one authenticated request with caller, deadline, and shutdown cancellation. */
+    async perform(endpoint, body, signal, headers, consume) {
+        if (this.handler === undefined) {
+            throw new Error('WeChat adapter is stopped.');
+        }
+        const controller = new AbortController();
+        const cancel = () => controller.abort();
+        signal?.addEventListener('abort', cancel, { once: true });
+        if (signal?.aborted) {
+            controller.abort();
+        }
+        this.operations.add(controller);
+        const timer = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            const response = await fetch(`${this.baseUrl}${endpoint}`, {
+                method: body === undefined ? 'GET' : 'POST',
+                headers: { Authorization: `Bearer ${this.token}`,
+                    ...(body instanceof FormData ? {} : { 'Content-Type': 'application/json' }), ...headers },
+                body: body instanceof FormData ? body : body === undefined ? undefined : JSON.stringify(body),
+                signal: controller.signal
+            });
+            if (!response.ok) {
+                throw new WechatRequestError(response.status, endpoint);
+            }
+            return await consume(response, cancel);
         }
         finally {
             clearTimeout(timer);
@@ -5979,6 +7014,7 @@ const images_1 = __webpack_require__(454);
 const input_budget_1 = __webpack_require__(6280);
 const tokens_1 = __webpack_require__(4956);
 const pending_media_1 = __webpack_require__(4078);
+const type_guards_1 = __webpack_require__(3012);
 /** Defers this snapshot before any model request or delivery. */
 class PendingImagesError extends pending_media_1.PendingMediaError {
     constructor() {
@@ -6074,7 +7110,7 @@ async function loadImage(image, signal) {
     attempts.set(image, attempt);
     try {
         const result = await image.load(signal);
-        if (typeof result === 'string') {
+        if ((0, type_guards_1.isString)(result)) {
             attempts.delete(image);
             return result;
         }
@@ -6511,16 +7547,17 @@ exports.generatedImages = generatedImages;
 const limit_1 = __webpack_require__(9258);
 const images_1 = __webpack_require__(454);
 const api_1 = __webpack_require__(2981);
+const type_guards_1 = __webpack_require__(3012);
 /** Validates a numeric width or height limit in pixels. */
 function parseImageDimension(value) {
-    if (typeof value !== 'number' || !Number.isInteger(value) || value < 1 || value > 16384) {
+    if (!(0, type_guards_1.isNumber)(value) || !Number.isInteger(value) || value < 1 || value > 16384) {
         throw new Error('Image dimension must be an integer between 1 and 16384.');
     }
     return value;
 }
 /** Validates a concrete dimension limit; provider-specific supported sizes are checked remotely. */
 function parseImageSize(value) {
-    if (typeof value !== 'string' || !/^[1-9]\d{0,4}x[1-9]\d{0,4}$/.test(value)) {
+    if (!(0, type_guards_1.isString)(value) || !/^[1-9]\d{0,4}x[1-9]\d{0,4}$/.test(value)) {
         throw new Error('Expected WIDTHxHEIGHT.');
     }
     const [width, height] = value.split('x').map(Number);
@@ -6604,7 +7641,7 @@ exports.ImageGenerationPolicy = ImageGenerationPolicy;
 function generatedImages(output, size = `${limit_1.DEFAULT_IMAGE_WIDTH_LIMIT}x${limit_1.DEFAULT_IMAGE_HEIGHT_LIMIT}`) {
     const limit = parseImageSize(size);
     return output.filter((item) => item.type === 'image_generation_call').map((item) => {
-        if (item.status !== 'completed' || typeof item.result !== 'string') {
+        if (item.status !== 'completed' || !(0, type_guards_1.isString)(item.result)) {
             throw new Error('Provider returned an incomplete image generation result.');
         }
         const url = (0, images_1.imageDataUrl)(item.result);
@@ -6636,6 +7673,7 @@ exports.modelInputTokens = modelInputTokens;
 exports.assertInputBudget = assertInputBudget;
 const limit_1 = __webpack_require__(9258);
 const tokens_1 = __webpack_require__(4956);
+const type_guards_1 = __webpack_require__(3012);
 /** Truncates text without breaking Unicode and explicitly marks lost context. */
 function boundedText(text, tokens) {
     return (0, tokens_1.countTokens)(text) <= tokens ? text : `${(0, tokens_1.limitTextTokens)(text, Math.max(1, tokens - limit_1.TRUNCATION_MARKER_TOKENS))}\n[truncated]`;
@@ -6644,8 +7682,8 @@ function boundedText(text, tokens) {
 function modelInputTokens(input, instructions, tools = []) {
     let images = 0;
     const json = JSON.stringify({ input, instructions, tools }, (key, value) => {
-        if (typeof value === 'object' && value !== null && 'type' in value &&
-            value.type === 'image_generation_call' && 'result' in value && typeof value.result === 'string') {
+        if ((0, type_guards_1.isObject)(value) && 'type' in value &&
+            value.type === 'image_generation_call' && 'result' in value && (0, type_guards_1.isString)(value.result)) {
             images += 1;
             return { ...value, result: '[generated image]' };
         }
@@ -6690,6 +7728,7 @@ const limit_1 = __webpack_require__(9258);
 const node_fs_1 = __webpack_require__(3024);
 const node_path_1 = __importDefault(__webpack_require__(6760));
 const responses_client_1 = __webpack_require__(102);
+const type_guards_1 = __webpack_require__(3012);
 /**
  * Name of the file that holds model configurations inside the config folder.
  */
@@ -6710,28 +7749,22 @@ exports.ModelStoreError = ModelStoreError;
 function getModelsPath(configDir) {
     return node_path_1.default.join(configDir, exports.MODELS_FILE_NAME);
 }
-/**
- * Returns true for plain JSON objects (not null, arrays, or primitives).
- */
-function isPlainObject(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
 /**
  * Validates one model entry.
  */
 function parseModelEntry(value, where, seen) {
-    if (!isPlainObject(value)) {
+    if (!(0, type_guards_1.isRecord)(value)) {
         throw new ModelStoreError(`${where} must be an object.`);
     }
-    if (typeof value.id !== 'string' || value.id.trim() === '') {
+    if (!(0, type_guards_1.isString)(value.id) || value.id.trim() === '') {
         throw new ModelStoreError(`${where}: "id" must be a non-empty string.`);
     }
     const id = value.id.trim();
     const name = value.name ?? id;
-    if (typeof name !== 'string' || name.trim() === '') {
+    if (!(0, type_guards_1.isString)(name) || name.trim() === '') {
         throw new ModelStoreError(`${where}: "name" must be a non-empty string.`);
     }
-    if (value.supportsImageToolResults !== undefined && typeof value.supportsImageToolResults !== 'boolean') {
+    if (value.supportsImageToolResults !== undefined && !(0, type_guards_1.isBoolean)(value.supportsImageToolResults)) {
         throw new ModelStoreError(`${where}: "supportsImageToolResults" must be a boolean.`);
     }
     const entry = {
@@ -6749,14 +7782,14 @@ function parseModelEntry(value, where, seen) {
  */
 function parseProvider(value, index, modelsPath) {
     const where = `${modelsPath}: providers[${index}]`;
-    if (!isPlainObject(value)) {
+    if (!(0, type_guards_1.isRecord)(value)) {
         throw new ModelStoreError(`${where} must be an object.`);
     }
-    if (typeof value.provider !== 'string' || value.provider.trim() === '') {
+    if (!(0, type_guards_1.isString)(value.provider) || value.provider.trim() === '') {
         throw new ModelStoreError(`${where}: "provider" must be a non-empty string.`);
     }
     const baseUrl = value.baseUrl;
-    if (typeof baseUrl !== 'string' || baseUrl.trim() === '') {
+    if (!(0, type_guards_1.isString)(baseUrl) || baseUrl.trim() === '') {
         throw new ModelStoreError(`${where}: "baseUrl" must be a non-empty string.`);
     }
     if (!Array.isArray(value.models)) {
@@ -6799,10 +7832,10 @@ async function loadModels(configDir) {
     catch (error) {
         throw new ModelStoreError(`Invalid JSON in ${modelsPath}: ${error.message}`);
     }
-    if (!isPlainObject(parsed) || !Array.isArray(parsed.providers)) {
+    if (!(0, type_guards_1.isRecord)(parsed) || !Array.isArray(parsed.providers)) {
         throw new ModelStoreError(`${modelsPath} must contain an object with a "providers" array.`);
     }
-    if (parsed.$schema !== undefined && typeof parsed.$schema !== 'string') {
+    if (parsed.$schema !== undefined && !(0, type_guards_1.isString)(parsed.$schema)) {
         throw new ModelStoreError(`${modelsPath}: "$schema" must be a string.`);
     }
     const seen = new Set();
@@ -6953,9 +7986,10 @@ __webpack_unused_export__ = extractOutputText;
 __webpack_unused_export__ = extractCitations;
 exports.createResponse = createResponse;
 const limit_1 = __webpack_require__(9258);
+const type_guards_1 = __webpack_require__(3012);
 /** Validates durations against Node's timer range, including programmatic callers. */
 function resolveModelTimeoutMs(value = limit_1.DEFAULT_MODEL_TIMEOUT_MS) {
-    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 1 || value > limit_1.MAX_TIMER_MS) {
+    if (!(0, type_guards_1.isNumber)(value) || !Number.isSafeInteger(value) || value < 1 || value > limit_1.MAX_TIMER_MS) {
         throw new Error(`Model timeout must be an integer from 1 to ${limit_1.MAX_TIMER_MS} milliseconds.`);
     }
     return value;
@@ -6974,12 +8008,6 @@ class ResponsesApiError extends Error {
     }
 }
 exports.ResponsesApiError = ResponsesApiError;
-/**
- * Returns true for plain JSON objects (not null, arrays, or primitives).
- */
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
 /**
  * Builds the endpoint used for Responses API calls.
  */
@@ -6993,10 +8021,10 @@ function responsesEndpoint(baseUrl) {
  * back to a top-level `output_text` string for compatible servers that use it.
  */
 function extractOutputText(payload) {
-    if (!isRecord(payload)) {
+    if (!(0, type_guards_1.isRecord)(payload)) {
         return '';
     }
-    if (typeof payload.output_text === 'string') {
+    if ((0, type_guards_1.isString)(payload.output_text)) {
         return payload.output_text.trim();
     }
     if (!Array.isArray(payload.output)) {
@@ -7004,11 +8032,11 @@ function extractOutputText(payload) {
     }
     const parts = [];
     for (const item of payload.output) {
-        if (!isRecord(item) || !Array.isArray(item.content)) {
+        if (!(0, type_guards_1.isRecord)(item) || !Array.isArray(item.content)) {
             continue;
         }
         for (const content of item.content) {
-            if (isRecord(content) && content.type === 'output_text' && typeof content.text === 'string') {
+            if ((0, type_guards_1.isRecord)(content) && content.type === 'output_text' && (0, type_guards_1.isString)(content.text)) {
                 parts.push(content.text);
             }
         }
@@ -7017,20 +8045,20 @@ function extractOutputText(payload) {
 }
 /** Retains URL citations even when generated text uses provider-specific markers. */
 function extractCitations(payload) {
-    if (!isRecord(payload) || !Array.isArray(payload.output)) {
+    if (!(0, type_guards_1.isRecord)(payload) || !Array.isArray(payload.output)) {
         return [];
     }
     const urls = new Set();
     for (const item of payload.output) {
-        if (!isRecord(item) || item.type !== 'message' || !Array.isArray(item.content)) {
+        if (!(0, type_guards_1.isRecord)(item) || item.type !== 'message' || !Array.isArray(item.content)) {
             continue;
         }
         for (const content of item.content) {
-            if (!isRecord(content) || content.type !== 'output_text' || !Array.isArray(content.annotations)) {
+            if (!(0, type_guards_1.isRecord)(content) || content.type !== 'output_text' || !Array.isArray(content.annotations)) {
                 continue;
             }
             for (const annotation of content.annotations) {
-                if (!isRecord(annotation) || annotation.type !== 'url_citation' || typeof annotation.url !== 'string') {
+                if (!(0, type_guards_1.isRecord)(annotation) || annotation.type !== 'url_citation' || !(0, type_guards_1.isString)(annotation.url)) {
                     continue;
                 }
                 try {
@@ -7105,11 +8133,11 @@ async function createResponse(request) {
         catch (error) {
             throw new ResponsesApiError(`Response from ${url} was not valid JSON: ${error.message}`, response.status, text);
         }
-        if (isRecord(parsed) && ((parsed.error !== undefined && parsed.error !== null) || parsed.status === 'failed' || parsed.status === 'incomplete')) {
+        if ((0, type_guards_1.isRecord)(parsed) && ((parsed.error !== undefined && parsed.error !== null) || parsed.status === 'failed' || parsed.status === 'incomplete')) {
             throw new ResponsesApiError(`Response from ${url} did not complete successfully.`, response.status);
         }
         const result = { outputText: extractOutputText(parsed), citations: extractCitations(parsed), raw: parsed };
-        if (isRecord(parsed) && typeof parsed.id === 'string') {
+        if ((0, type_guards_1.isRecord)(parsed) && (0, type_guards_1.isString)(parsed.id)) {
             result.id = parsed.id;
         }
         return result;
@@ -7188,6 +8216,7 @@ const retry_1 = __webpack_require__(7718);
 const transcriptions_client_1 = __webpack_require__(6763);
 const speech_client_1 = __webpack_require__(5314);
 const image_generation_1 = __webpack_require__(3376);
+const type_guards_1 = __webpack_require__(3012);
 /** A model bound to its provider endpoint and credential. */
 class ProviderModel {
     baseUrl;
@@ -7267,7 +8296,7 @@ class ProviderModel {
     async generateWithTools(input, instructions, localTools, apiTools, signal, reasoningEffort, imageGeneration, generated, onGeneratedImages) {
         const runner = new runner_1.ToolRunner(localTools);
         const initial = [
-            ...(typeof input === 'string' ? [{ role: 'user', content: input }] : input),
+            ...((0, type_guards_1.isString)(input) ? [{ role: 'user', content: input }] : input),
             ...generated.output
         ];
         if (generated.images.length > 0) {
@@ -7335,8 +8364,8 @@ class ProviderModel {
                 throw error;
             }
             const raw = result.raw;
-            if (typeof raw !== 'object' || raw === null || !('output' in raw) || !Array.isArray(raw.output) ||
-                !raw.output.every((item) => typeof item === 'object' && item !== null && !Array.isArray(item))) {
+            if (!(0, type_guards_1.isObject)(raw) || !('output' in raw) || !Array.isArray(raw.output) ||
+                !raw.output.every((item) => (0, type_guards_1.isRecord)(item))) {
                 throw new Error('Tool-capable models must return a Responses API output array.');
             }
             const output = raw.output;
@@ -7345,7 +8374,7 @@ class ProviderModel {
             if (imageCalls.length > 0 && reservation === undefined) {
                 throw new Error('Provider generated images without an available image generation quota.');
             }
-            if (reservation !== undefined && output.filter((item) => typeof item.type === 'string' &&
+            if (reservation !== undefined && output.filter((item) => (0, type_guards_1.isString)(item.type) &&
                 item.type.endsWith('_call') && item.type !== 'function_call').length > 1) {
                 throw new Error('Provider exceeded the reserved image generation tool call budget.');
             }
@@ -7365,7 +8394,7 @@ class ProviderModel {
                 throw new Error(`Provider tool output "${String(needsClient.type)}" requires unsupported client execution or approval.`);
             }
             // Hosted calls execute at the provider; retain their items but never run them locally.
-            usedApiCalls += output.filter((item) => typeof item.type === 'string' &&
+            usedApiCalls += output.filter((item) => (0, type_guards_1.isString)(item.type) &&
                 item.type.endsWith('_call') && item.type !== 'function_call').length;
             if (usedApiCalls > limit_1.MAX_MODEL_TOOL_CALLS) {
                 throw new Error('Model exceeded the provider-hosted tool call budget.');
@@ -7383,8 +8412,8 @@ class ProviderModel {
             const turn = [...output];
             const imageParts = [];
             for (const call of calls) {
-                if (typeof call.call_id !== 'string' || !call.call_id || typeof call.name !== 'string' ||
-                    typeof call.arguments !== 'string' || callIds.has(call.call_id)) {
+                if (!(0, type_guards_1.isString)(call.call_id) || !call.call_id || !(0, type_guards_1.isString)(call.name) ||
+                    !(0, type_guards_1.isString)(call.arguments) || callIds.has(call.call_id)) {
                     throw new Error('Model returned a malformed or duplicate function call.');
                 }
                 callIds.add(call.call_id);
@@ -7611,6 +8640,7 @@ __webpack_unused_export__ = ({ value: true });
 exports.createTranscription = createTranscription;
 const limit_1 = __webpack_require__(9258);
 const responses_client_1 = __webpack_require__(102);
+const type_guards_1 = __webpack_require__(3012);
 /** Calls an OpenAI-compatible audio/transcriptions endpoint using native multipart upload. */
 async function createTranscription(request) {
     request.signal?.throwIfAborted();
@@ -7648,8 +8678,8 @@ async function createTranscription(request) {
             }
             throw new responses_client_1.ResponsesApiError('Transcription model returned invalid JSON.', response.status);
         }
-        if (typeof result !== 'object' || result === null || Array.isArray(result) ||
-            !('text' in result) || typeof result.text !== 'string' || result.text.length > limit_1.MAX_TRANSCRIPT_CHARS) {
+        if (!(0, type_guards_1.isRecord)(result) ||
+            !('text' in result) || !(0, type_guards_1.isString)(result.text) || result.text.length > limit_1.MAX_TRANSCRIPT_CHARS) {
             throw new responses_client_1.ResponsesApiError(`Transcription model must return a text string of at most ${limit_1.MAX_TRANSCRIPT_CHARS} characters.`, response.status);
         }
         return result.text.trim();
@@ -7958,6 +8988,7 @@ const limits_1 = __webpack_require__(6276);
 const conversation_input_1 = __webpack_require__(9644);
 const read_image_1 = __webpack_require__(1069);
 const image_generation_1 = __webpack_require__(3376);
+const type_guards_1 = __webpack_require__(3012);
 /** Shared output contract for generation and formatting-only repair. */
 const REPLY_FORMAT_INSTRUCTIONS = [
     'Return only JSON, without fences: {"reply":true,"text":"Hello!","memoryUpdates":{"notes":[],"forget":[]}}. reply must be boolean; text must be the nonempty outgoing message when true, or "" when false.',
@@ -8098,13 +9129,13 @@ class ModelReplier {
         catch {
             throw new Error('Reply model returned invalid JSON.');
         }
-        if (typeof result !== 'object' || result === null || Array.isArray(result) ||
-            !('reply' in result) || typeof result.reply !== 'boolean' ||
-            !('text' in result) || typeof result.text !== 'string') {
+        if (!(0, type_guards_1.isRecord)(result) ||
+            !('reply' in result) || !(0, type_guards_1.isBoolean)(result.reply) ||
+            !('text' in result) || !(0, type_guards_1.isString)(result.text)) {
             throw new Error('Reply model must return reply and text.');
         }
         const memoryUpdates = (0, interface_2.parseMemoryUpdates)('memoryUpdates' in result ? result.memoryUpdates : undefined);
-        if ('voice' in result && typeof result.voice !== 'boolean') {
+        if ('voice' in result && !(0, type_guards_1.isBoolean)(result.voice)) {
             throw new Error('Reply model voice must be a boolean.');
         }
         if (!result.reply) {
@@ -8162,6 +9193,7 @@ const voice_transcriber_1 = __webpack_require__(5276);
 const context_file_1 = __webpack_require__(3384);
 const voice_synthesizer_1 = __webpack_require__(7393);
 const image_generation_1 = __webpack_require__(3376);
+const type_guards_1 = __webpack_require__(3012);
 __exportStar(__webpack_require__(2590), exports);
 __exportStar(__webpack_require__(5230), exports);
 __exportStar(__webpack_require__(2977), exports);
@@ -8178,6 +9210,26 @@ __exportStar(__webpack_require__(6549), exports);
 /** A manual/self reply arrived after the snapshot was taken. */
 class SupersededTurnError extends Error {
 }
+/** Keeps one opaque identity field verbatim; absent, blank, and non-string values mean none. */
+function identityField(value) {
+    // The adapter compares both identity fields by exact string equality; trimming or case
+    // folding here could merge two distinct accounts into one scheduling and storage scope.
+    const exact = (0, type_guards_1.isString)(value) ? value : '';
+    return exact === '' ? null : exact;
+}
+/**
+ * Reads the signed-in identity that scopes one message's scheduling and stored context.
+ *
+ * A daemon account is a profile, not a user: the same account ID can sign in as a new
+ * username, so context must be scoped by both fields, used exactly as reported. Messages
+ * from transports without WeChat identity return undefined and keep their transport-neutral
+ * keys, while a message without a username never shares a namespace with a named login.
+ */
+function wechatIdentity(message) {
+    const account = identityField(message.metadata?.wechatAccount);
+    const username = identityField(message.metadata?.wechatUsername);
+    return account === null && username === null ? undefined : { account, username };
+}
 /** Owns chat pipelines, message handling, and adapter startup/shutdown. */
 class ChatServer {
     options;
@@ -8382,18 +9434,18 @@ class ChatServer {
         if (statusRequest === undefined && regularMessages.length === 0) {
             return;
         }
-        const key = JSON.stringify([
-            chat.name,
-            message.metadata?.wechatAccount ?? null,
-            message.channel ?? message.senderId
-        ]);
+        const identity = wechatIdentity(message);
+        const thread = message.channel ?? message.senderId;
+        // The signed-in username scopes scheduling, so a re-login never inherits old context.
+        const key = JSON.stringify(identity === undefined
+            ? [chat.name, null, thread]
+            : [chat.name, identity.account, identity.username, thread]);
         let conversation = this.conversations.get(key);
         if (conversation === undefined) {
-            const memoryKey = JSON.stringify([
-                chat.messager.name,
-                message.metadata?.wechatAccount ?? chat.name,
-                message.channel ?? message.senderId
-            ]);
+            // Stored memory and images use the same scope, so a re-login never loads them.
+            const memoryKey = JSON.stringify(identity === undefined
+                ? [chat.messager.name, chat.name, thread]
+                : [chat.messager.name, identity.account, identity.username, thread]);
             conversation = {
                 chat, memoryKey, latest: message, messages: [], revision: 0,
                 processing: false, hasPendingMessages: false, selfRevision: 0, retryAttempts: 0
@@ -8725,8 +9777,8 @@ class ChatServer {
             `Processing errors: ${this.processingFailures} (filters ${this.filterFailures})`,
             `Last processing error: ${this.lastProcessingError ?? 'none'} (${age(this.lastProcessingErrorAt)})`,
             `Deliveries: ${this.deliveries}; failures ${this.deliveryFailures}; last ${age(this.lastDeliveryAt)}`,
-            `Adapter: ${chat.messager.name}${health === undefined ? '' : health.active ? ' active' : ' stopped'}; poll failures ${health?.consecutivePollFailures ?? 0}; failed chats ${health?.failedChats ?? 0}`,
-            `Last poll: ${age(health?.lastSuccessfulPollAt)}; last poll error: ${age(health?.lastPollErrorAt)}`,
+            `Adapter: ${chat.messager.name}${health === undefined ? '' : health.active ? ' active' : ' stopped'}; stream failures ${health?.consecutiveFailures ?? 0}`,
+            `Last event: ${age(health?.lastEventAt)}; stream activity: ${age(health?.lastStreamActivityAt)}; last error: ${health?.lastError ?? 'none'} (${age(health?.lastErrorAt)})`,
             `Delay: ${limit_1.MIN_REPLY_DELAY_MS / 60_000}–${limit_1.MAX_REPLY_DELAY_MS / 60_000}m; memory: ${limit_1.MEMORY_RETENTION_MS / (24 * 60 * 60 * 1000)} days/${chat.memoryTokenLimit} tokens`
         ].join('\n');
         await this.deliverReply(chat, message, { text: (0, limits_1.limitReplyText)(text), direct: true });
@@ -8758,22 +9810,23 @@ exports.ChatServer = ChatServer;
 /***/ },
 
 /***/ 2981
-(__unused_webpack_module, exports) {
+(__unused_webpack_module, exports, __webpack_require__) {
 
 "use strict";
 var __webpack_unused_export__;
 
 __webpack_unused_export__ = ({ value: true });
 exports.parseApiTools = parseApiTools;
+const type_guards_1 = __webpack_require__(3012);
 /** Validates the shared shape; the selected provider validates tool-specific options. */
 function parseApiTools(value) {
     if (!Array.isArray(value)) {
         throw new Error('apiTools must be an array of tool type strings or provider-hosted tool objects.');
     }
     return value.map((entry, index) => {
-        const tool = typeof entry === 'string' ? { type: entry } : entry;
-        if (typeof tool !== 'object' || tool === null || Array.isArray(tool) ||
-            !('type' in tool) || typeof tool.type !== 'string' || !/^\S+$/.test(tool.type)) {
+        const tool = (0, type_guards_1.isString)(entry) ? { type: entry } : entry;
+        if (!(0, type_guards_1.isRecord)(tool) ||
+            !('type' in tool) || !(0, type_guards_1.isString)(tool.type) || !/^\S+$/.test(tool.type)) {
             throw new Error(`apiTools[${index}] must be a nonempty tool type string or an object with a type, without whitespace in the type.`);
         }
         if (tool.type === 'function' || tool.type === 'custom') {
@@ -8974,6 +10027,7 @@ __webpack_unused_export__ = ({ value: true });
 exports.CurrentTimeTool = void 0;
 const limit_1 = __webpack_require__(9258);
 const interface_1 = __webpack_require__(6598);
+const type_guards_1 = __webpack_require__(3012);
 class CurrentTimeTool {
     definition = {
         type: 'function',
@@ -8990,7 +10044,7 @@ class CurrentTimeTool {
     execute(args) {
         const values = (0, interface_1.toolArguments)(args, ['timezone']);
         const timezone = values.timezone ?? 'UTC';
-        if (typeof timezone !== 'string' || !timezone.trim() || timezone.length > limit_1.MAX_TIMEZONE_CHARS) {
+        if (!(0, type_guards_1.isString)(timezone) || !timezone.trim() || timezone.length > limit_1.MAX_TIMEZONE_CHARS) {
             throw new Error('timezone must be an IANA timezone string or null.');
         }
         const formatter = new Intl.DateTimeFormat('en-US', {
@@ -9282,7 +10336,7 @@ async function readPublicPage(value, signal) {
 /***/ },
 
 /***/ 6598
-(__unused_webpack_module, exports) {
+(__unused_webpack_module, exports, __webpack_require__) {
 
 "use strict";
 
@@ -9290,6 +10344,7 @@ Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.ToolImageResult = void 0;
 exports.toolArguments = toolArguments;
 exports.stringArgument = stringArgument;
+const type_guards_1 = __webpack_require__(3012);
 /** Native image attachments are kept separate from JSON tool output. */
 class ToolImageResult {
     images;
@@ -9300,7 +10355,7 @@ class ToolImageResult {
 exports.ToolImageResult = ToolImageResult;
 /** Validates an argument object before a tool accesses any fields. */
 function toolArguments(args, keys) {
-    if (typeof args !== 'object' || args === null || Array.isArray(args)) {
+    if (!(0, type_guards_1.isRecord)(args)) {
         throw new Error('Tool arguments must be a JSON object.');
     }
     const record = args;
@@ -9312,7 +10367,7 @@ function toolArguments(args, keys) {
 /** Reads a bounded, nonempty string argument. */
 function stringArgument(args, name, maxLength) {
     const value = args[name];
-    if (typeof value !== 'string' || !value.trim() || value.length > maxLength) {
+    if (!(0, type_guards_1.isString)(value) || !value.trim() || value.length > maxLength) {
         throw new Error(`${name} must be a nonempty string of at most ${maxLength} characters.`);
     }
     return value.trim();
@@ -9428,6 +10483,7 @@ const current_time_1 = __webpack_require__(4212);
 const read_url_1 = __webpack_require__(8289);
 const web_search_1 = __webpack_require__(9728);
 const read_image_1 = __webpack_require__(1069);
+const type_guards_1 = __webpack_require__(3012);
 exports.DEFAULT_TOOL_NAMES = ['web_search', 'read_url', 'calculate', 'current_time', 'read_image'];
 const factories = new Map([
     ['web_search', () => new web_search_1.WebSearchTool()],
@@ -9453,13 +10509,13 @@ function parseLocalTools(value) {
     }
     const names = value.map((entry, index) => {
         let name = entry;
-        if (typeof entry === 'object' && entry !== null && !Array.isArray(entry)) {
+        if ((0, type_guards_1.isRecord)(entry)) {
             if (Object.keys(entry).some((key) => key !== 'type')) {
                 throw new Error(`localTools[${index}] supports only the type field.`);
             }
             name = 'type' in entry ? entry.type : undefined;
         }
-        if (typeof name !== 'string' || !hasTool(name)) {
+        if (!(0, type_guards_1.isString)(name) || !hasTool(name)) {
             throw new Error(`localTools[${index}] must name a registered tool. Available: ${listTools().join(', ')}.`);
         }
         return name;
@@ -9630,6 +10686,51 @@ class WebSearchTool {
 exports.WebSearchTool = WebSearchTool;
 
 
+/***/ },
+
+/***/ 3012
+(__unused_webpack_module, exports) {
+
+"use strict";
+var __webpack_unused_export__;
+
+/**
+ * Shared runtime type guards for values that arrive as untrusted data, such as
+ * parsed JSON, provider responses, and configuration files.
+ */
+__webpack_unused_export__ = ({ value: true });
+exports.isString = isString;
+exports.isNumber = isNumber;
+exports.isBoolean = isBoolean;
+exports.isObject = isObject;
+exports.isRecord = isRecord;
+exports.isFunction = isFunction;
+/** Returns true when `value` is a string. */
+function isString(value) {
+    return typeof value === 'string';
+}
+/** Returns true when `value` is a number, including `NaN` and infinities. */
+function isNumber(value) {
+    return typeof value === 'number';
+}
+/** Returns true when `value` is a boolean. */
+function isBoolean(value) {
+    return typeof value === 'boolean';
+}
+/** Returns true for any non-null object, including arrays, dates, and maps. */
+function isObject(value) {
+    return typeof value === 'object' && value !== null;
+}
+/** Returns true for non-null objects that are not arrays; functions are rejected. */
+function isRecord(value) {
+    return isObject(value) && !Array.isArray(value);
+}
+/** Returns true for functions, typed as callable so callers need no assertions. */
+function isFunction(value) {
+    return typeof value === 'function';
+}
+
+
 /***/ },
 
 /***/ 1421