weacpx 0.3.1 → 0.4.0-beta.0

package/dist/weixin/api/types.d.ts

@@ -0,0 +1,201 @@
+/**
+ * Weixin protocol types (mirrors proto: GetUpdatesReq/Resp, WeixinMessage, SendMessageReq).
+ * API uses JSON over HTTP; bytes fields are base64 strings in JSON.
+ */
+/** Common request metadata attached to every CGI request. */
+export interface BaseInfo {
+    channel_version?: string;
+}
+/** proto: UploadMediaType */
+export declare const UploadMediaType: {
+    readonly IMAGE: 1;
+    readonly VIDEO: 2;
+    readonly FILE: 3;
+    readonly VOICE: 4;
+};
+export interface GetUploadUrlReq {
+    filekey?: string;
+    /** proto field 2: media_type, see UploadMediaType */
+    media_type?: number;
+    to_user_id?: string;
+    /** 原文件明文大小 */
+    rawsize?: number;
+    /** 原文件明文 MD5 */
+    rawfilemd5?: string;
+    /** 原文件密文大小（AES-128-ECB 加密后） */
+    filesize?: number;
+    /** 缩略图明文大小（IMAGE/VIDEO 时必填） */
+    thumb_rawsize?: number;
+    /** 缩略图明文 MD5（IMAGE/VIDEO 时必填） */
+    thumb_rawfilemd5?: string;
+    /** 缩略图密文大小（IMAGE/VIDEO 时必填） */
+    thumb_filesize?: number;
+    /** 不需要缩略图上传 URL，默认 false */
+    no_need_thumb?: boolean;
+    /** 加密 key */
+    aeskey?: string;
+}
+export interface GetUploadUrlResp {
+    /** 原图上传加密参数 */
+    upload_param?: string;
+    /** 缩略图上传加密参数，无缩略图时为空 */
+    thumb_upload_param?: string;
+    /** 完整上传 URL（服务端直接返回，无需客户端拼接） */
+    upload_full_url?: string;
+}
+export declare const MessageType: {
+    readonly NONE: 0;
+    readonly USER: 1;
+    readonly BOT: 2;
+};
+export declare const MessageItemType: {
+    readonly NONE: 0;
+    readonly TEXT: 1;
+    readonly IMAGE: 2;
+    readonly VOICE: 3;
+    readonly FILE: 4;
+    readonly VIDEO: 5;
+};
+export declare const MessageState: {
+    readonly NEW: 0;
+    readonly GENERATING: 1;
+    readonly FINISH: 2;
+};
+export interface TextItem {
+    text?: string;
+}
+/** CDN media reference; aes_key is base64-encoded bytes in JSON. */
+export interface CDNMedia {
+    encrypt_query_param?: string;
+    aes_key?: string;
+    /** 加密类型: 0=只加密fileid, 1=打包缩略图/中图等信息 */
+    encrypt_type?: number;
+    /** 完整下载 URL（服务端直接返回，无需客户端拼接） */
+    full_url?: string;
+}
+export interface ImageItem {
+    /** 原图 CDN 引用 */
+    media?: CDNMedia;
+    /** 缩略图 CDN 引用 */
+    thumb_media?: CDNMedia;
+    /** Raw AES-128 key as hex string (16 bytes); preferred over media.aes_key for inbound decryption. */
+    aeskey?: string;
+    url?: string;
+    mid_size?: number;
+    thumb_size?: number;
+    thumb_height?: number;
+    thumb_width?: number;
+    hd_size?: number;
+}
+export interface VoiceItem {
+    media?: CDNMedia;
+    /** 语音编码类型：1=pcm 2=adpcm 3=feature 4=speex 5=amr 6=silk 7=mp3 8=ogg-speex */
+    encode_type?: number;
+    bits_per_sample?: number;
+    /** 采样率 (Hz) */
+    sample_rate?: number;
+    /** 语音长度 (毫秒) */
+    playtime?: number;
+    /** 语音转文字内容 */
+    text?: string;
+}
+export interface FileItem {
+    media?: CDNMedia;
+    file_name?: string;
+    md5?: string;
+    len?: string;
+}
+export interface VideoItem {
+    media?: CDNMedia;
+    video_size?: number;
+    play_length?: number;
+    video_md5?: string;
+    thumb_media?: CDNMedia;
+    thumb_size?: number;
+    thumb_height?: number;
+    thumb_width?: number;
+}
+export interface RefMessage {
+    message_item?: MessageItem;
+    title?: string;
+}
+export interface MessageItem {
+    type?: number;
+    create_time_ms?: number;
+    update_time_ms?: number;
+    is_completed?: boolean;
+    msg_id?: string;
+    ref_msg?: RefMessage;
+    text_item?: TextItem;
+    image_item?: ImageItem;
+    voice_item?: VoiceItem;
+    file_item?: FileItem;
+    video_item?: VideoItem;
+}
+/** Unified message (proto: WeixinMessage). Replaces the old split Message + MessageContent + FullMessage. */
+export interface WeixinMessage {
+    seq?: number;
+    message_id?: number;
+    from_user_id?: string;
+    to_user_id?: string;
+    client_id?: string;
+    create_time_ms?: number;
+    update_time_ms?: number;
+    delete_time_ms?: number;
+    session_id?: string;
+    group_id?: string;
+    message_type?: number;
+    message_state?: number;
+    item_list?: MessageItem[];
+    context_token?: string;
+}
+/** GetUpdates request: bytes fields are base64 strings in JSON. */
+export interface GetUpdatesReq {
+    /** @deprecated compat only, will be removed */
+    sync_buf?: string;
+    /** Full context buf cached locally; send "" when none (first request or after reset). */
+    get_updates_buf?: string;
+}
+/** GetUpdates response: bytes fields are base64 strings in JSON. */
+export interface GetUpdatesResp {
+    ret?: number;
+    /** Error code returned by the server (e.g. -14 = session timeout). Present when request fails. */
+    errcode?: number;
+    errmsg?: string;
+    msgs?: WeixinMessage[];
+    /** @deprecated compat only */
+    sync_buf?: string;
+    /** Full context buf to cache locally and send on next request. */
+    get_updates_buf?: string;
+    /** Server-suggested timeout (ms) for the next getUpdates long-poll. */
+    longpolling_timeout_ms?: number;
+}
+/** SendMessage request: wraps a single WeixinMessage. */
+export interface SendMessageReq {
+    msg?: WeixinMessage;
+}
+export interface SendMessageResp {
+}
+/** Typing status: 1 = typing (default), 2 = cancel typing. */
+export declare const TypingStatus: {
+    readonly TYPING: 1;
+    readonly CANCEL: 2;
+};
+/** SendTyping request: send a typing indicator to a user. */
+export interface SendTypingReq {
+    ilink_user_id?: string;
+    typing_ticket?: string;
+    /** 1=typing (default), 2=cancel typing */
+    status?: number;
+}
+export interface SendTypingResp {
+    ret?: number;
+    errmsg?: string;
+}
+/** GetConfig response: bot config including typing_ticket. */
+export interface GetConfigResp {
+    ret?: number;
+    errmsg?: string;
+    /** Base64-encoded typing ticket for sendTyping. */
+    typing_ticket?: string;
+}

package/dist/weixin/auth/accounts.d.ts

@@ -0,0 +1,63 @@
+export declare const DEFAULT_BASE_URL = "https://ilinkai.weixin.qq.com";
+export declare const CDN_BASE_URL = "https://novac2c.cdn.weixin.qq.com/c2c";
+/** Normalize an account ID to a filesystem-safe string. */
+export declare function normalizeAccountId(raw: string): string;
+/**
+ * Pattern-based reverse of normalizeWeixinAccountId for known weixin ID suffixes.
+ * Used only as a compatibility fallback when loading accounts / sync bufs stored
+ * under the old raw ID.
+ * e.g. "b0f5860fdecb-im-bot" → "b0f5860fdecb@im.bot"
+ */
+export declare function deriveRawAccountId(normalizedId: string): string | undefined;
+/** Returns all accountIds registered via QR login. */
+export declare function listIndexedWeixinAccountIds(): string[];
+/** Register accountId as the sole account in the persistent index. */
+export declare function registerWeixinAccountId(accountId: string): void;
+/** Unified per-account data: token + baseUrl in one file. */
+export type WeixinAccountData = {
+    token?: string;
+    savedAt?: string;
+    baseUrl?: string;
+    /** Last linked Weixin user id from QR login (optional). */
+    userId?: string;
+};
+/** Load account data by ID, with compatibility fallbacks. */
+export declare function loadWeixinAccount(accountId: string): WeixinAccountData | null;
+/**
+ * Persist account data after QR login (merges into existing file).
+ * - token: overwritten when provided.
+ * - baseUrl: stored when non-empty; resolveWeixinAccount falls back to DEFAULT_BASE_URL.
+ * - userId: set when `update.userId` is provided; omitted from file when cleared to empty.
+ */
+export declare function saveWeixinAccount(accountId: string, update: {
+    token?: string;
+    baseUrl?: string;
+    userId?: string;
+}): void;
+/** Remove account data file. */
+export declare function clearWeixinAccount(accountId: string): void;
+/** Remove all account data files and clear the account index. */
+export declare function clearAllWeixinAccounts(): void;
+/**
+ * Read `routeTag` from openclaw.json (for callers without an `OpenClawConfig` object).
+ * Checks per-account `channels.<id>.accounts[accountId].routeTag` first, then section-level
+ * `channels.<id>.routeTag`. Matches `feat_weixin_extension` behavior; channel key is `"openclaw-weixin"`.
+ */
+export declare function loadConfigRouteTag(accountId?: string): string | undefined;
+/**
+ * No-op stub — config reload is now handled externally via `openclaw gateway restart`.
+ */
+export declare function triggerWeixinChannelReload(): Promise<void>;
+export type ResolvedWeixinAccount = {
+    accountId: string;
+    baseUrl: string;
+    cdnBaseUrl: string;
+    token?: string;
+    enabled: boolean;
+    /** true when a token has been obtained via QR login. */
+    configured: boolean;
+};
+/** List accountIds from the index file (written at QR login). */
+export declare function listWeixinAccountIds(): string[];
+/** Resolve a weixin account by ID, reading stored credentials. */
+export declare function resolveWeixinAccount(accountId?: string | null): ResolvedWeixinAccount;

package/dist/weixin/auth/login-qr.d.ts

@@ -0,0 +1,31 @@
+/** Default `bot_type` for ilink get_bot_qrcode / get_qrcode_status (this channel build). */
+export declare const DEFAULT_ILINK_BOT_TYPE = "3";
+export type WeixinQrStartResult = {
+    qrcodeUrl?: string;
+    message: string;
+    sessionKey: string;
+};
+export type WeixinQrWaitResult = {
+    connected: boolean;
+    botToken?: string;
+    accountId?: string;
+    baseUrl?: string;
+    /** The user ID of the person who scanned the QR code; add to allowFrom. */
+    userId?: string;
+    message: string;
+};
+export declare function startWeixinLoginWithQr(opts: {
+    verbose?: boolean;
+    timeoutMs?: number;
+    force?: boolean;
+    accountId?: string;
+    apiBaseUrl: string;
+    botType?: string;
+}): Promise<WeixinQrStartResult>;
+export declare function waitForWeixinLogin(opts: {
+    timeoutMs?: number;
+    verbose?: boolean;
+    sessionKey: string;
+    apiBaseUrl: string;
+    botType?: string;
+}): Promise<WeixinQrWaitResult>;

package/dist/weixin/bot.d.ts

@@ -0,0 +1,54 @@
+import type { Agent } from "./agent/interface.js";
+import type { PendingFinalChunk } from "./messaging/quota-manager.js";
+import type { RuntimeMediaStore } from "../channels/media-store.js";
+export type LoginOptions = {
+    /** Override the API base URL. */
+    baseUrl?: string;
+    /** Log callback (defaults to console.log). */
+    log?: (msg: string) => void;
+};
+export type StartOptions = {
+    /** Account ID to use. Auto-selects the first registered account if omitted. */
+    accountId?: string;
+    /** Additional allowed root directories for outbound media paths. */
+    allowedMediaRoots?: string[];
+    /** AbortSignal to stop the bot. */
+    abortSignal?: AbortSignal;
+    /** Log callback (defaults to console.log). */
+    log?: (msg: string) => void;
+    /** Reset outbound quota when an inbound message arrives. */
+    onInbound?: (chatKey: string) => void;
+    /** Reserve the per-chat final-tier slot before sending the final reply.
+     * Returns false when the final tier (FINAL_BUDGET) is exhausted; callers
+     * must drop the send and log when this happens. */
+    reserveFinal?: (chatKey: string) => boolean;
+    finalRemaining?: (chatKey: string) => number;
+    hasPendingFinal?: (chatKey: string) => boolean;
+    drainPendingFinal?: (chatKey: string, available: number) => PendingFinalChunk[];
+    prependPendingFinal?: (chatKey: string, chunks: PendingFinalChunk[]) => void;
+    enqueuePendingFinal?: (chatKey: string, chunks: PendingFinalChunk[]) => void;
+    dropPendingFinal?: (chatKey: string) => void;
+    mediaStore?: RuntimeMediaStore;
+};
+/**
+ * Interactive QR-code login. Prints the QR code to the terminal and waits
+ * for the user to scan it with WeChat.
+ *
+ * Returns the normalized account ID on success.
+ */
+export declare function login(opts?: LoginOptions): Promise<string>;
+/**
+ * Remove all stored WeChat account credentials.
+ */
+export declare function logout(opts?: {
+    log?: (msg: string) => void;
+}): void;
+/**
+ * Check whether at least one WeChat account is logged in and configured.
+ */
+export declare function isLoggedIn(): boolean;
+/**
+ * Start the bot — long-polls for new messages and dispatches them to the agent.
+ * Blocks until the abort signal fires or an unrecoverable error occurs.
+ */
+export declare function start(agent: Agent, opts?: StartOptions): Promise<void>;

package/dist/weixin/cdn/aes-ecb.d.ts

@@ -0,0 +1,6 @@
+/** Encrypt buffer with AES-128-ECB (PKCS7 padding is default). */
+export declare function encryptAesEcb(plaintext: Buffer, key: Buffer): Buffer;
+/** Decrypt buffer with AES-128-ECB (PKCS7 padding). */
+export declare function decryptAesEcb(ciphertext: Buffer, key: Buffer): Buffer;
+/** Compute AES-128-ECB ciphertext size (PKCS7 padding to 16-byte boundary). */
+export declare function aesEcbPaddedSize(plaintextSize: number): number;

package/dist/weixin/cdn/cdn-upload.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Upload one buffer to the Weixin CDN with AES-128-ECB encryption.
+ * Returns the download encrypted_query_param from the CDN response.
+ * Retries up to UPLOAD_MAX_RETRIES times on server errors; client errors (4xx) abort immediately.
+ */
+export declare function uploadBufferToCdn(params: {
+    buf: Buffer;
+    /** From getUploadUrl.upload_full_url; POST target when set (takes precedence over uploadParam). */
+    uploadFullUrl?: string;
+    uploadParam?: string;
+    filekey: string;
+    cdnBaseUrl: string;
+    label: string;
+    aeskey: Buffer;
+}): Promise<{
+    downloadParam: string;
+}>;

package/dist/weixin/cdn/cdn-url.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Unified CDN URL construction for Weixin CDN upload/download.
+ */
+/** Build a CDN download URL from encrypt_query_param. */
+export declare function buildCdnDownloadUrl(encryptedQueryParam: string, cdnBaseUrl: string): string;
+/** Build a CDN upload URL from upload_param and filekey. */
+export declare function buildCdnUploadUrl(params: {
+    cdnBaseUrl: string;
+    uploadParam: string;
+    filekey: string;
+}): string;

package/dist/weixin/cdn/pic-decrypt.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Download and AES-128-ECB decrypt a CDN media file. Returns plaintext Buffer.
+ * aesKeyBase64: CDNMedia.aes_key JSON field (see parseAesKey for supported formats).
+ */
+export declare function downloadAndDecryptBuffer(encryptedQueryParam: string, aesKeyBase64: string, cdnBaseUrl: string, label: string, fullUrl?: string, maxBytes?: number): Promise<Buffer>;
+/**
+ * Download plain (unencrypted) bytes from the CDN. Returns the raw Buffer.
+ */
+export declare function downloadPlainCdnBuffer(encryptedQueryParam: string, cdnBaseUrl: string, label: string, fullUrl?: string, maxBytes?: number): Promise<Buffer>;

package/dist/weixin/cdn/upload.d.ts

@@ -0,0 +1,42 @@
+import type { WeixinApiOptions } from "../api/api.js";
+export type UploadedFileInfo = {
+    filekey: string;
+    /** 由 upload_param 上传后 CDN 返回的下载加密参数; fill into ImageItem.media.encrypt_query_param */
+    downloadEncryptedQueryParam: string;
+    /** AES-128-ECB key, hex-encoded; convert to base64 for CDNMedia.aes_key */
+    aeskey: string;
+    /** Plaintext file size in bytes */
+    fileSize: number;
+    /** Ciphertext file size in bytes (AES-128-ECB with PKCS7 padding); use for ImageItem.hd_size / mid_size */
+    fileSizeCiphertext: number;
+};
+/**
+ * Download a remote media URL (image, video, file) to a local temp file in destDir.
+ * Returns the local file path; extension is inferred from Content-Type / URL.
+ */
+export declare function downloadRemoteImageToTemp(url: string, destDir: string): Promise<string>;
+/** Upload a local image file to the Weixin CDN with AES-128-ECB encryption. */
+export declare function uploadFileToWeixin(params: {
+    filePath: string;
+    toUserId: string;
+    opts: WeixinApiOptions;
+    cdnBaseUrl: string;
+}): Promise<UploadedFileInfo>;
+/** Upload a local video file to the Weixin CDN. */
+export declare function uploadVideoToWeixin(params: {
+    filePath: string;
+    toUserId: string;
+    opts: WeixinApiOptions;
+    cdnBaseUrl: string;
+}): Promise<UploadedFileInfo>;
+/**
+ * Upload a local file attachment (non-image, non-video) to the Weixin CDN.
+ * Uses media_type=FILE; no thumbnail required.
+ */
+export declare function uploadFileAttachmentToWeixin(params: {
+    filePath: string;
+    fileName: string;
+    toUserId: string;
+    opts: WeixinApiOptions;
+    cdnBaseUrl: string;
+}): Promise<UploadedFileInfo>;

package/dist/weixin/index.d.ts

@@ -0,0 +1,6 @@
+export type { Agent, ChatRequest, ChatResponse } from "./agent/interface.js";
+export { login, start, logout, isLoggedIn } from "./bot.js";
+export type { LoginOptions, StartOptions } from "./bot.js";
+export { sendMessageWeixin, markdownToPlainText } from "./messaging/send.js";
+export { getContextToken } from "./messaging/inbound.js";
+export { resolveWeixinAccount, listWeixinAccountIds, clearAllWeixinAccounts } from "./auth/accounts.js";

package/dist/weixin/media/media-download.d.ts

@@ -0,0 +1,18 @@
+import type { WeixinInboundMediaOpts } from "../messaging/inbound.js";
+import type { WeixinMessage } from "../api/types.js";
+/** Persist a buffer via the framework's unified media store. */
+type SaveMediaFn = (buffer: Buffer, contentType?: string, subdir?: string, maxBytes?: number, originalFilename?: string) => Promise<{
+    path: string;
+}>;
+/**
+ * Download and decrypt media from a single MessageItem.
+ * Returns the populated WeixinInboundMediaOpts fields; empty object on unsupported type or failure.
+ */
+export declare function downloadMediaFromItem(item: WeixinMessage["item_list"] extends (infer T)[] | undefined ? T : never, deps: {
+    cdnBaseUrl: string;
+    saveMedia: SaveMediaFn;
+    log: (msg: string) => void;
+    errLog: (msg: string) => void;
+    label: string;
+}): Promise<WeixinInboundMediaOpts>;
+export {};

package/dist/weixin/media/mime.d.ts

@@ -0,0 +1,6 @@
+/** Get MIME type from filename extension. Returns "application/octet-stream" for unknown extensions. */
+export declare function getMimeFromFilename(filename: string): string;
+/** Get file extension from MIME type. Returns ".bin" for unknown types. */
+export declare function getExtensionFromMime(mimeType: string): string;
+/** Get file extension from Content-Type header or URL path. Returns ".bin" for unknown. */
+export declare function getExtensionFromContentTypeOrUrl(contentType: string | null, url: string): string;

package/dist/weixin/media/silk-transcode.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Try to transcode a SILK audio buffer to WAV using silk-wasm.
+ * silk-wasm's decode() returns { data: Uint8Array (pcm_s16le), duration: number }.
+ *
+ * Returns a WAV Buffer on success, or null if silk-wasm is unavailable or decoding fails.
+ * Callers should fall back to passing the raw SILK file when null is returned.
+ */
+export declare function silkToWav(silkBuf: Buffer): Promise<Buffer | null>;

package/dist/weixin/messaging/conversation-executor.d.ts

@@ -0,0 +1,7 @@
+export type ConversationExecutorLane = "normal" | "control";
+type ConversationTask<T> = () => Promise<T>;
+export type ConversationExecutor = {
+    run<T>(conversationId: string, lane: ConversationExecutorLane, task: ConversationTask<T>): Promise<T>;
+};
+export declare function createConversationExecutor(): ConversationExecutor;
+export {};

package/dist/weixin/messaging/debug-mode.d.ts

@@ -0,0 +1,9 @@
+/** Toggle debug mode for a bot account. Returns the new state. */
+export declare function toggleDebugMode(accountId: string): boolean;
+/** Check whether debug mode is active for a bot account. */
+export declare function isDebugMode(accountId: string): boolean;
+/**
+ * Reset internal state — only for tests.
+ * @internal
+ */
+export declare function _resetForTest(): void;

package/dist/weixin/messaging/deliver-coordinator-message.d.ts

@@ -0,0 +1,22 @@
+import type { AppLogger } from "../../logging/app-logger";
+import { sendMessageWeixin } from "./send.js";
+export interface DeliverCoordinatorMessageInput {
+    coordinatorSession: string;
+    chatKey: string;
+    accountId?: string;
+    replyContextToken?: string;
+    text: string;
+}
+export interface DeliverCoordinatorMessageDeps {
+    listAccountIds: () => string[];
+    resolveAccount: (accountId: string) => {
+        accountId: string;
+        baseUrl: string;
+        token?: string;
+    };
+    getContextToken: (accountId: string, userId: string) => string | undefined;
+    sendMessage?: typeof sendMessageWeixin;
+    reserveMidSegment?: (chatKey: string) => boolean;
+    logger: AppLogger;
+}
+export declare function deliverCoordinatorMessage(input: DeliverCoordinatorMessageInput, deps: DeliverCoordinatorMessageDeps): Promise<void>;

package/dist/weixin/messaging/deliver-orchestration-task-notice.d.ts

@@ -0,0 +1,18 @@
+import type { AppLogger } from "../../logging/app-logger";
+import type { OrchestrationTaskRecord } from "../../orchestration/orchestration-types";
+import { sendOrchestrationTaskNotice } from "./send-orchestration-notice.js";
+export interface DeliverOrchestrationTaskNoticeDeps {
+    listAccountIds: () => string[];
+    resolveAccount: (accountId: string) => {
+        accountId: string;
+        baseUrl: string;
+        token?: string;
+    };
+    getContextToken: (accountId: string, userId: string) => string | undefined;
+    markDelivered: (taskId: string, accountId: string) => Promise<void>;
+    markFailed: (taskId: string, errorMessage: string) => Promise<void>;
+    sendNotice?: typeof sendOrchestrationTaskNotice;
+    reserveFinal?: (chatKey: string) => boolean;
+    logger: AppLogger;
+}
+export declare function deliverOrchestrationTaskNotice(task: OrchestrationTaskRecord, deps: DeliverOrchestrationTaskNoticeDeps): Promise<void>;

package/dist/weixin/messaging/deliver-orchestration-task-progress.d.ts

@@ -0,0 +1,16 @@
+import type { AppLogger } from "../../logging/app-logger";
+import type { OrchestrationTaskRecord } from "../../orchestration/orchestration-types";
+import { sendMessageWeixin } from "./send.js";
+export interface DeliverOrchestrationTaskProgressDeps {
+    listAccountIds: () => string[];
+    resolveAccount: (accountId: string) => {
+        accountId: string;
+        baseUrl: string;
+        token?: string;
+    };
+    getContextToken: (accountId: string, userId: string) => string | undefined;
+    sendMessage?: typeof sendMessageWeixin;
+    reserveMidSegment?: (chatKey: string) => boolean;
+    logger: AppLogger;
+}
+export declare function deliverOrchestrationTaskProgress(task: OrchestrationTaskRecord, text: string, deps: DeliverOrchestrationTaskProgressDeps): Promise<void>;

package/dist/weixin/messaging/error-notice.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Send a plain-text error notice back to the user.
+ * Fire-and-forget: errors are logged but never thrown, so callers stay unaffected.
+ * No-op when contextToken is absent (we have no conversation reference to reply into).
+ */
+export declare function sendWeixinErrorNotice(params: {
+    to: string;
+    contextToken: string | undefined;
+    message: string;
+    baseUrl: string;
+    token?: string;
+    errLog: (m: string) => void;
+}): Promise<void>;

package/dist/weixin/messaging/execute-chat-turn.d.ts

@@ -0,0 +1,12 @@
+import type { Agent, ChatRequest, ChatResponse } from "../agent/interface.js";
+export interface ExecuteChatTurnParams {
+    agent: Agent;
+    request: Omit<ChatRequest, "reply">;
+    onReplySegment?: (text: string) => Promise<boolean | void>;
+}
+export interface ExecutedChatTurn {
+    text?: string;
+    media?: ChatResponse["media"];
+    usedReply: boolean;
+}
+export declare function executeChatTurn(params: ExecuteChatTurnParams): Promise<ExecutedChatTurn>;

package/dist/weixin/messaging/final-heads-up.d.ts

@@ -0,0 +1,5 @@
+export interface FinalHeadsUpInput {
+    total: number;
+    sentSoFar: number;
+}
+export declare function buildFinalHeadsUp(input: FinalHeadsUpInput): string;

package/dist/weixin/messaging/handle-weixin-message-turn.d.ts

@@ -0,0 +1,30 @@
+import type { Agent } from "../agent/interface.js";
+import type { WeixinMessage } from "../api/types.js";
+import { RuntimeMediaStore } from "../../channels/media-store.js";
+import { downloadMediaFromItem } from "../media/media-download.js";
+import type { PendingFinalChunk } from "./quota-manager.js";
+export declare function chunkFinalText(text: string, maxBytes: number): string[];
+export declare function resolveMediaTempDir(customRoot?: string): string;
+export type HandleWeixinMessageTurnDeps = {
+    accountId: string;
+    agent: Agent;
+    baseUrl: string;
+    cdnBaseUrl: string;
+    token?: string;
+    typingTicket?: string;
+    log: (msg: string) => void;
+    errLog: (msg: string) => void;
+    mediaTempDir?: string;
+    onInbound?: (chatKey: string) => void;
+    reserveFinal?: (chatKey: string) => boolean;
+    finalRemaining?: (chatKey: string) => number;
+    enqueuePendingFinal?: (chatKey: string, chunks: PendingFinalChunk[]) => void;
+    hasPendingFinal?: (chatKey: string) => boolean;
+    drainPendingFinal?: (chatKey: string, available: number) => PendingFinalChunk[];
+    prependPendingFinal?: (chatKey: string, chunks: PendingFinalChunk[]) => void;
+    mediaStore?: RuntimeMediaStore;
+    downloadMediaFromItemFn?: typeof downloadMediaFromItem;
+    allowedMediaRoots?: string[];
+};
+export declare function getWeixinMessageTurnLane(full: WeixinMessage): "normal" | "control";
+export declare function handleWeixinMessageTurn(full: WeixinMessage, deps: HandleWeixinMessageTurnDeps): Promise<void>;