shennian 0.2.88 → 0.2.89

package/dist/assets/wechat-channel/macos/manifest.json

@@ -0,0 +1,13 @@
+{
+  "schemaVersion": 1,
+  "helperVersion": "0.1.0",
+  "protocolVersion": 1,
+  "platforms": {
+    "darwin": {
+      "executable": "shennian-wechat-channel-helper",
+      "sha256": "02b8569879cf116d9838474a7f2300f12e3bd252d41369647df2d450936e851d",
+      "signed": false,
+      "notarized": false
+    }
+  }
+}

package/dist/src/agents/adapter.d.ts

@@ -36,6 +36,12 @@ export declare abstract class AgentAdapter extends EventEmitter<AgentAdapterEven
         externalChannel?: ExternalChannelSessionStatus | null;
         env?: NodeJS.ProcessEnv;
     }): void;
+    getStatus?(): Promise<{
+        active: boolean;
+        runId?: string | null;
+        runPhase?: SessionRunPhase | null;
+        canStop?: boolean;
+    }>;
     setTitle?(agentSessionId: string, title: string, workDir?: string): Promise<void>;
     abstract start(sessionId: string, workDir: string, agentSessionId?: string | null): Promise<void>;
     abstract send(text: string, modelId?: string, reasoningEffort?: string, attachments?: ChatAttachmentMeta[]): Promise<void>;

package/dist/src/agents/codex-control.d.ts

@@ -0,0 +1,35 @@
+import type { SessionRunPhase } from '@shennian/wire';
+export type CodexThreadActivity = {
+    active: boolean;
+    turnId: string | null;
+    runPhase: SessionRunPhase | null;
+    canStop: boolean;
+};
+export declare class CodexAppServerProxyClient {
+    private readonly opts;
+    private process;
+    private rpcSeq;
+    private pendingRequests;
+    private stderr;
+    private initialized;
+    constructor(opts?: {
+        workDir?: string;
+        timeoutMs?: number;
+    });
+    start(): Promise<void>;
+    initialize(): Promise<void>;
+    readThreadActivity(threadId: string): Promise<CodexThreadActivity>;
+    interruptThread(threadId: string): Promise<CodexThreadActivity>;
+    close(): Promise<void>;
+    private sendRpc;
+    private handleMessage;
+    private rejectAllPending;
+}
+export declare function probeCodexThreadActivity(params: {
+    threadId: string;
+    workDir?: string;
+}): Promise<CodexThreadActivity | null>;
+export declare function interruptCodexThread(params: {
+    threadId: string;
+    workDir?: string;
+}): Promise<CodexThreadActivity | null>;

package/dist/src/agents/codex-control.js

@@ -0,0 +1,188 @@
+// @arch docs/architecture/cli/agent-adapters.md
+// @test src/__tests__/codex-control.test.ts
+import { createInterface } from 'node:readline';
+import { resolveBuiltinCommand, spawnAgentCommand } from './command-spec.js';
+import { buildAgentProcessEnv } from '../agent-env.js';
+import { CODEX_APP_SERVER_CLIENT_INFO } from './codex-utils.js';
+function mapThreadStatusToRunPhase(status) {
+    const flags = status?.type === 'active' && Array.isArray(status.activeFlags) ? status.activeFlags : [];
+    if (flags.includes('waitingOnApproval'))
+        return 'waiting_approval';
+    if (flags.includes('waitingOnUserInput'))
+        return 'waiting_user_input';
+    return 'thinking';
+}
+function latestActiveTurnId(turns) {
+    if (!Array.isArray(turns))
+        return null;
+    for (let index = turns.length - 1; index >= 0; index--) {
+        const turn = turns[index];
+        if (!turn || typeof turn !== 'object')
+            continue;
+        const record = turn;
+        if (record.status !== 'inProgress')
+            continue;
+        return typeof record.id === 'string' ? record.id : null;
+    }
+    return null;
+}
+export class CodexAppServerProxyClient {
+    opts;
+    process = null;
+    rpcSeq = 1;
+    pendingRequests = new Map();
+    stderr = '';
+    initialized = false;
+    constructor(opts = {}) {
+        this.opts = opts;
+    }
+    async start() {
+        if (this.process)
+            return;
+        const spec = resolveBuiltinCommand('codex');
+        if (!spec)
+            throw new Error('Command "codex" not found. Is OpenAI Codex CLI installed?');
+        const proc = spawnAgentCommand(spec, ['app-server', 'proxy'], {
+            cwd: this.opts.workDir || undefined,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: buildAgentProcessEnv({ NO_COLOR: '1' }),
+        });
+        this.process = proc;
+        this.stderr = '';
+        const rl = createInterface({ input: proc.stdout });
+        rl.on('line', (line) => {
+            if (!line.trim())
+                return;
+            let msg;
+            try {
+                msg = JSON.parse(line);
+            }
+            catch {
+                return;
+            }
+            this.handleMessage(msg);
+        });
+        proc.stderr?.on('data', (chunk) => {
+            this.stderr += chunk.toString();
+        });
+        proc.on('close', (code) => {
+            if (this.process !== proc)
+                return;
+            this.process = null;
+            this.rejectAllPending(new Error(this.stderr.trim() || `codex app-server proxy exited with code ${code}`));
+        });
+        proc.on('error', (error) => {
+            if (this.process !== proc)
+                return;
+            this.process = null;
+            this.rejectAllPending(error);
+        });
+    }
+    async initialize() {
+        if (this.initialized)
+            return;
+        await this.start();
+        await this.sendRpc('initialize', {
+            clientInfo: CODEX_APP_SERVER_CLIENT_INFO,
+            capabilities: { experimentalApi: true },
+        });
+        this.initialized = true;
+    }
+    async readThreadActivity(threadId) {
+        await this.initialize();
+        const response = await this.sendRpc('thread/read', { threadId, includeTurns: true });
+        const status = response.thread?.status ?? null;
+        const active = status?.type === 'active';
+        const turnId = latestActiveTurnId(response.thread?.turns);
+        return {
+            active,
+            turnId,
+            runPhase: active ? mapThreadStatusToRunPhase(status) : null,
+            canStop: Boolean(active && turnId),
+        };
+    }
+    async interruptThread(threadId) {
+        const activity = await this.readThreadActivity(threadId);
+        if (!activity.turnId)
+            return activity;
+        await this.sendRpc('turn/interrupt', { threadId, turnId: activity.turnId }, 5_000);
+        return { active: false, turnId: activity.turnId, runPhase: null, canStop: false };
+    }
+    async close() {
+        const proc = this.process;
+        this.process = null;
+        if (!proc)
+            return;
+        proc.kill('SIGTERM');
+        await new Promise((resolve) => {
+            proc.on('close', resolve);
+            setTimeout(() => {
+                proc.kill('SIGKILL');
+                resolve();
+            }, 1000).unref?.();
+        });
+        this.rejectAllPending(new Error('codex app-server proxy stopped'));
+    }
+    sendRpc(method, params, timeoutMs = this.opts.timeoutMs ?? 8_000) {
+        const proc = this.process;
+        if (!proc?.stdin)
+            return Promise.reject(new Error('codex app-server proxy is not running'));
+        const id = this.rpcSeq++;
+        const payload = JSON.stringify({ id, method, params });
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pendingRequests.delete(id);
+                reject(new Error(`codex app-server proxy request timed out: ${method}`));
+            }, timeoutMs);
+            this.pendingRequests.set(id, { resolve, reject, timer });
+            proc.stdin.write(`${payload}\n`, (error) => {
+                if (!error)
+                    return;
+                clearTimeout(timer);
+                this.pendingRequests.delete(id);
+                reject(error);
+            });
+        });
+    }
+    handleMessage(msg) {
+        if (msg.id == null)
+            return;
+        const pending = this.pendingRequests.get(msg.id);
+        if (!pending)
+            return;
+        clearTimeout(pending.timer);
+        this.pendingRequests.delete(msg.id);
+        if (msg.error)
+            pending.reject(new Error(msg.error.message || `codex app-server proxy error ${msg.error.code ?? ''}`.trim()));
+        else
+            pending.resolve(msg.result);
+    }
+    rejectAllPending(error) {
+        for (const [id, pending] of this.pendingRequests.entries()) {
+            clearTimeout(pending.timer);
+            pending.reject(error);
+            this.pendingRequests.delete(id);
+        }
+    }
+}
+export async function probeCodexThreadActivity(params) {
+    const client = new CodexAppServerProxyClient({ workDir: params.workDir, timeoutMs: 5_000 });
+    try {
+        return await client.readThreadActivity(params.threadId);
+    }
+    catch {
+        return null;
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+export async function interruptCodexThread(params) {
+    const client = new CodexAppServerProxyClient({ workDir: params.workDir, timeoutMs: 8_000 });
+    try {
+        return await client.interruptThread(params.threadId);
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}

package/dist/src/agents/codex.d.ts

@@ -1,5 +1,6 @@
 import { AgentAdapter } from './adapter.js';
 import type { ChatAttachmentMeta, ExternalChannelSessionStatus } from '@shennian/wire';
+import type { SessionRunPhase } from '@shennian/wire';
 export { isCodexUnsupportedEffortError, isMissingCodexRolloutError, normalizeCodexModelId, normalizeCodexReasoningEffort, } from './codex-utils.js';
 export declare class CodexAdapter extends AgentAdapter {
     private readonly options;
@@ -40,6 +41,12 @@ export declare class CodexAdapter extends AgentAdapter {
     resume(agentSessionId: string): Promise<void>;
     setTitle(agentSessionId: string, title: string, workDir?: string): Promise<void>;
     stop(): Promise<void>;
+    getStatus(): Promise<{
+        active: boolean;
+        runId?: string | null;
+        runPhase?: SessionRunPhase | null;
+        canStop?: boolean;
+    }>;
     private spawnCodex;
     private spawnAppServer;
     private ensureAppServer;
@@ -49,6 +56,7 @@ export declare class CodexAdapter extends AgentAdapter {
     private interruptActiveTurn;
     private sendRpc;
     private handleAppServerMessage;
+    private mapThreadStatusToRunPhase;
     private handleAppServerNonJsonStdout;
     private failAppServerStartup;
     private handleAppServerCompletedItem;

package/dist/src/agents/codex.js

@@ -117,6 +117,30 @@ export class CodexAdapter extends AgentAdapter {
         await this.interruptActiveTurn().catch(() => { });
         await this.killProcess();
     }
+    async getStatus() {
+        const threadId = this.agentSessionId;
+        const activeTurnId = this.activeTurnId;
+        if (!threadId || !this.process) {
+            return { active: false, runId: activeTurnId, runPhase: null, canStop: false };
+        }
+        let status = null;
+        try {
+            const response = await this.sendRpc('thread/read', { threadId, includeTurns: false }, 5_000);
+            status = response.thread?.status ?? null;
+        }
+        catch {
+            // If the local control channel is still alive but the status read fails,
+            // fall back to activeTurnId. This keeps the stop button available for
+            // the running turn while avoiding false positives for idle sessions.
+        }
+        const active = status?.type === 'active' || Boolean(activeTurnId);
+        return {
+            active,
+            runId: activeTurnId,
+            runPhase: active ? this.mapThreadStatusToRunPhase(status) : null,
+            canStop: Boolean(active && activeTurnId && this.process),
+        };
+    }
     spawnCodex(args) {
         const spec = resolveBuiltinCommand('codex');
         if (!spec) {
@@ -351,6 +375,27 @@ export class CodexAdapter extends AgentAdapter {
             return;
         const params = msg.params ?? {};
         switch (msg.method) {
+            case 'turn/started': {
+                const turn = typeof params.turn === 'object' && params.turn !== null
+                    ? params.turn
+                    : null;
+                const turnId = typeof turn?.id === 'string' ? turn.id : null;
+                if (turnId)
+                    this.activeTurnId = turnId;
+                break;
+            }
+            case 'thread/status/changed': {
+                const threadId = typeof params.threadId === 'string' ? params.threadId : '';
+                if (threadId && this.agentSessionId && threadId !== this.agentSessionId)
+                    break;
+                const status = typeof params.status === 'object' && params.status !== null
+                    ? params.status
+                    : null;
+                if (status?.type === 'active') {
+                    this.emitEvent({ state: 'heartbeat', runPhase: this.mapThreadStatusToRunPhase(status) });
+                }
+                break;
+            }
             case 'item/agentMessage/delta': {
                 const itemId = typeof params.itemId === 'string' ? params.itemId : '';
                 if (itemId)
@@ -387,6 +432,14 @@ export class CodexAdapter extends AgentAdapter {
             }
         }
     }
+    mapThreadStatusToRunPhase(status) {
+        const flags = status?.type === 'active' && Array.isArray(status.activeFlags) ? status.activeFlags : [];
+        if (flags.includes('waitingOnApproval'))
+            return 'waiting_approval';
+        if (flags.includes('waitingOnUserInput'))
+            return 'waiting_user_input';
+        return 'thinking';
+    }
     handleAppServerNonJsonStdout(line) {
         const normalized = normalizeTerminalText(line);
         if (!looksLikeCodexInteractiveAuthPrompt(normalized))

package/dist/src/channels/base.d.ts

@@ -1,5 +1,5 @@
 import type { ExternalChannelSessionStatus } from '@shennian/wire';
-export type ExternalChannelRuntimeStatus = Pick<ExternalChannelSessionStatus, 'wechatRpaRuntimeState' | 'wechatRpaLastRunAt' | 'wechatRpaLastMessageAt' | 'wechatRpaLastInterruptedAt' | 'wechatRpaPendingReplyCount' | 'wechatRpaLastError' | 'wechatRpaLastRunId' | 'wechatRpaLastTracePath' | 'wechatRpaLastTraceSummary' | 'wechatRpaRecentTaskSummaries'>;
+export type ExternalChannelRuntimeStatus = Pick<ExternalChannelSessionStatus, 'wechatRpaRuntimeState' | 'wechatRpaLastRunAt' | 'wechatRpaLastMessageAt' | 'wechatRpaLastInterruptedAt' | 'wechatRpaPendingReplyCount' | 'wechatRpaLastError' | 'wechatRpaLastRunId' | 'wechatRpaLastTracePath' | 'wechatRpaLastTraceSummary' | 'wechatRpaRecentTaskSummaries' | 'wechatRpaPreflightChecks' | 'wechatRpaServerDecisionAvailable' | 'wechatRpaPrivacyConsentAccepted'>;
 export type ExternalChannelType = 'wecom' | 'websocket' | 'wechat-rpa';
 export type ExternalChannelConfig = {
     id: string;
@@ -51,6 +51,9 @@ export type ExternalChannelView = {
     wechatRpaLastTracePath?: string | null;
     wechatRpaLastTraceSummary?: string | null;
     wechatRpaRecentTaskSummaries?: ExternalChannelSessionStatus['wechatRpaRecentTaskSummaries'];
+    wechatRpaPreflightChecks?: ExternalChannelSessionStatus['wechatRpaPreflightChecks'];
+    wechatRpaServerDecisionAvailable?: boolean | null;
+    wechatRpaPrivacyConsentAccepted?: boolean | null;
 };
 export type ExternalMessageEvent = {
     type: 'external.message';

package/dist/src/channels/runtime.d.ts

@@ -100,6 +100,7 @@ export declare class ChannelRuntime {
         downloadAttachments?: boolean;
         downloadAttachmentsDir?: string;
         selfNickname?: string;
+        privacyConsentAccepted?: boolean;
         flowScriptPath?: string;
     }): Promise<ExternalChannelView>;
 }

package/dist/src/channels/runtime.js

@@ -350,6 +350,8 @@ export class ChannelRuntime {
         };
         const priorSecret = this.secrets.get(nextConfig.secretRef);
         const source = input.source || (priorSecret?.source === 'macos-probe' || priorSecret?.source === 'fixture-jsonl' || priorSecret?.source === 'macos-flow' || priorSecret?.source === 'windows-visual-flow' || priorSecret?.source === 'wechat-rpa-lab' ? priorSecret.source : defaultWeChatRpaSource());
+        if (input.enabled && source === 'windows-visual-flow')
+            throw new Error('个人微信通道当前仅支持 macOS');
         const configs = allConfigs
             .filter((channel) => channel.id !== nextConfig.id)
             .map((channel) => (channel.sessionId ?? channel.managerSessionId) === boundSessionId && channel.type === 'wechat-rpa'
@@ -369,6 +371,7 @@ export class ChannelRuntime {
             downloadAttachments: input.downloadAttachments ?? (priorSecret?.downloadAttachments === undefined ? true : Boolean(priorSecret.downloadAttachments)),
             downloadAttachmentsDir: input.downloadAttachmentsDir?.trim() || stringOrUndefined(priorSecret?.downloadAttachmentsDir),
             selfNickname: input.selfNickname?.trim() || stringOrUndefined(priorSecret?.selfNickname),
+            privacyConsentAccepted: input.privacyConsentAccepted ?? Boolean(priorSecret?.privacyConsentAccepted),
             flowScriptPath: input.flowScriptPath?.trim() || stringOrUndefined(priorSecret?.flowScriptPath),
             canReply: input.canReply ?? priorSecret?.canReply ?? false,
             systemPrompt: input.systemPrompt ?? (typeof priorSecret?.systemPrompt === 'string' ? priorSecret.systemPrompt : ''),
@@ -410,6 +413,9 @@ function wechatRpaViewFields(secret) {
         downloadAttachments: secret.downloadAttachments === undefined ? true : Boolean(secret.downloadAttachments),
         downloadAttachmentsDir: typeof secret.downloadAttachmentsDir === 'string' ? secret.downloadAttachmentsDir : '',
         selfNickname: typeof secret.selfNickname === 'string' ? secret.selfNickname : '',
+        wechatRpaPrivacyConsentAccepted: Boolean(secret.privacyConsentAccepted),
+        wechatRpaServerDecisionAvailable: true,
+        wechatRpaPreflightChecks: buildWeChatRpaPreflightChecks(secret),
     };
 }
 function wechatRpaStatusFields(secret) {
@@ -426,6 +432,9 @@ function wechatRpaStatusFields(secret) {
         downloadAttachments: secret.downloadAttachments === undefined ? true : Boolean(secret.downloadAttachments),
         downloadAttachmentsDir: typeof secret.downloadAttachmentsDir === 'string' ? secret.downloadAttachmentsDir : null,
         selfNickname: typeof secret.selfNickname === 'string' ? secret.selfNickname : null,
+        wechatRpaPrivacyConsentAccepted: Boolean(secret.privacyConsentAccepted),
+        wechatRpaServerDecisionAvailable: true,
+        wechatRpaPreflightChecks: buildWeChatRpaPreflightChecks(secret),
     };
 }
 function normalizeWeChatRpaGroups(groups) {
@@ -441,7 +450,29 @@ function normalizeWeChatRpaGroups(groups) {
     return result;
 }
 function defaultWeChatRpaSource() {
-    return 'wechat-rpa-lab';
+    return 'macos-flow';
+}
+function buildWeChatRpaPreflightChecks(secret) {
+    const checks = [];
+    checks.push({
+        code: 'mac_only',
+        ok: secret.source !== 'windows-visual-flow',
+        severity: 'blocking',
+        message: secret.source === 'windows-visual-flow' ? '个人微信通道当前仅支持 macOS。' : '当前配置使用 macOS 微信通道。',
+    });
+    checks.push({
+        code: 'privacy_consent_required',
+        ok: Boolean(secret.privacyConsentAccepted),
+        severity: 'blocking',
+        message: Boolean(secret.privacyConsentAccepted) ? '已确认微信通道数据与隐私授权。' : '启用前需要确认微信通道数据与隐私授权。',
+    });
+    checks.push({
+        code: 'server_decision_unavailable',
+        ok: true,
+        severity: 'blocking',
+        message: '服务端判断能力可用。',
+    });
+    return checks;
 }
 export function planExternalReplySends(channelType, input) {
     const parts = splitExternalReplyText(input.text);

package/dist/src/channels/secret-registry.d.ts

@@ -17,6 +17,7 @@ type ChannelSecretRecord = {
     downloadAttachments?: boolean;
     downloadAttachmentsDir?: string;
     selfNickname?: string;
+    privacyConsentAccepted?: boolean;
     idleSeconds?: number;
     recentLimit?: number;
     flowScriptPath?: string;

package/dist/src/channels/wechat-channel/anchor.d.ts

@@ -0,0 +1,10 @@
+import type { WeChatChannelObservedMessage } from './client.js';
+export declare function normalizeWeChatAnchorText(value: unknown): string;
+export declare function weChatAnchorText(message: WeChatChannelObservedMessage): string;
+export declare function weChatTextSimilarity(left: unknown, right: unknown): number;
+export declare function isLikelySameWeChatMessage(previous: WeChatChannelObservedMessage, current: WeChatChannelObservedMessage, threshold?: number): boolean;
+export declare function filterNewWeChatMessagesByAnchor(input: {
+    previous: WeChatChannelObservedMessage[];
+    current: WeChatChannelObservedMessage[];
+    threshold?: number;
+}): WeChatChannelObservedMessage[];

package/dist/src/channels/wechat-channel/anchor.js

@@ -0,0 +1,65 @@
+// @arch docs/features/wechat-rpa-productization-plan.md
+// @test src/__tests__/wechat-channel-anchor.test.ts
+export function normalizeWeChatAnchorText(value) {
+    if (typeof value !== 'string')
+        return '';
+    return value
+        .normalize('NFKC')
+        .replace(/\s+/g, ' ')
+        .trim()
+        .toLowerCase();
+}
+export function weChatAnchorText(message) {
+    return normalizeWeChatAnchorText(message.anchorText || message.normalizedText || message.textExcerpt || '');
+}
+export function weChatTextSimilarity(left, right) {
+    const a = normalizeWeChatAnchorText(left);
+    const b = normalizeWeChatAnchorText(right);
+    if (!a || !b)
+        return 0;
+    if (a === b)
+        return 1;
+    const distance = levenshtein(a, b);
+    return 1 - distance / Math.max(a.length, b.length);
+}
+export function isLikelySameWeChatMessage(previous, current, threshold = 0.86) {
+    if (previous.stableMessageKey && previous.stableMessageKey === current.stableMessageKey)
+        return true;
+    if (previous.senderRole !== current.senderRole)
+        return false;
+    if (previous.kind !== current.kind)
+        return false;
+    const previousAnchor = weChatAnchorText(previous);
+    const currentAnchor = weChatAnchorText(current);
+    if (!previousAnchor || !currentAnchor)
+        return false;
+    return weChatTextSimilarity(previousAnchor, currentAnchor) >= threshold;
+}
+export function filterNewWeChatMessagesByAnchor(input) {
+    const consumed = new Set();
+    const result = [];
+    for (const current of input.current) {
+        const index = input.previous.findIndex((previous, previousIndex) => {
+            return !consumed.has(previousIndex) && isLikelySameWeChatMessage(previous, current, input.threshold);
+        });
+        if (index >= 0) {
+            consumed.add(index);
+            continue;
+        }
+        result.push(current);
+    }
+    return result;
+}
+function levenshtein(a, b) {
+    const prev = Array.from({ length: b.length + 1 }, (_, index) => index);
+    const curr = Array.from({ length: b.length + 1 }, () => 0);
+    for (let i = 1; i <= a.length; i += 1) {
+        curr[0] = i;
+        for (let j = 1; j <= b.length; j += 1) {
+            curr[j] = Math.min(prev[j] + 1, curr[j - 1] + 1, prev[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+        }
+        for (let j = 0; j <= b.length; j += 1)
+            prev[j] = curr[j];
+    }
+    return prev[b.length];
+}

package/dist/src/channels/wechat-channel/client.d.ts

@@ -0,0 +1,74 @@
+import type { WeChatChannelRuntime, WeChatChannelBindingConfig } from './runtime.js';
+export type WeChatChannelApiClientOptions = {
+    serverUrl?: string;
+    machineToken?: string;
+    fetchImpl?: typeof fetch;
+};
+export type WeChatChannelObservedMessage = {
+    stableMessageKey: string;
+    senderRole: 'self' | 'contact' | 'system' | 'unknown';
+    senderName?: string | null;
+    kind: string;
+    normalizedText?: string | null;
+    anchorText?: string | null;
+    anchorMetadata?: unknown;
+    neighborContext?: unknown;
+    textExcerpt?: string | null;
+    bbox?: unknown;
+    mediaMetadata?: unknown;
+    isBaseline?: boolean;
+    deliveryStatus?: string;
+    observedAt?: string;
+    visualBlocks?: Array<{
+        blockId: string;
+        blockKind: string;
+        bbox?: unknown;
+        model: string;
+        dims: number;
+        vectorBase64: string;
+    }>;
+};
+export type WeChatChannelApiClient = ReturnType<typeof createWeChatChannelApiClient>;
+export type WeChatChannelObserveInput = {
+    screenshots: Array<{
+        captureIndex?: number;
+        mimeType: string;
+        dataBase64: string;
+        width: number;
+        height: number;
+    }>;
+    edgeOcrBlocks?: unknown[];
+    visibleConversationFingerprints?: unknown[];
+    localLedgerTailAnchors?: unknown[];
+};
+export type WeChatChannelObserveResponse = {
+    ok: true;
+    observedMessages?: WeChatChannelObservedMessage[];
+    diff?: unknown;
+    reasonCode?: string;
+};
+export type WeChatChannelOutboundStatusInput = {
+    replyId: string;
+    idempotencyKey: string;
+    status: string;
+    replyBaseRevision?: number;
+    sentAt?: string;
+    confirmedAt?: string;
+    failureCode?: string;
+    lastErrorSummary?: string;
+};
+export declare function createWeChatChannelApiClient(options?: WeChatChannelApiClientOptions): {
+    getRuntimePolicy: () => Promise<unknown>;
+    upsertRuntime: (runtime: WeChatChannelRuntime, binding?: WeChatChannelBindingConfig) => Promise<unknown>;
+    observe: (runtime: WeChatChannelRuntime, binding: WeChatChannelBindingConfig, input: WeChatChannelObserveInput) => Promise<WeChatChannelObserveResponse>;
+    ingest: (runtime: WeChatChannelRuntime, binding: WeChatChannelBindingConfig, input: {
+        idempotencyKey: string;
+        messages: WeChatChannelObservedMessage[];
+    }) => Promise<unknown>;
+    reportOutboundStatus: (runtime: WeChatChannelRuntime, binding: WeChatChannelBindingConfig, input: WeChatChannelOutboundStatusInput) => Promise<unknown>;
+    reportRunStatus: (runtime: WeChatChannelRuntime, binding: WeChatChannelBindingConfig, input: {
+        status: string;
+        reasonCode?: string;
+        traceId?: string;
+    }) => Promise<unknown>;
+};