@h-ai/ai 0.1.0-alpha.67 → 0.1.0-alpha.69

package/dist/ai-audio-ws-protocol-S4N8-LBa.d.ts

@@ -1,1739 +0,0 @@
-import * as _h_ai_core from '@h-ai/core';
-import { HaiResult } from '@h-ai/core';
-import { a_ as ChatMessage, az as InteractionScope, Y as MemoryType, bL as RagOptions, bP as ReasoningOptions, cm as ToolRegistryOperations, bx as MemoryEntry, c2 as SessionInfo, bq as LLMOperations, bD as MemoryOperations, bK as RagOperations, bO as ReasoningOperations, d as AIConfigInput, aP as AIStoreProvider, c as AIConfig, co as ToolsOperations, c6 as StreamOperations, bV as RetrievalOperations, bk as KnowledgeOperations, aJ as A2AOperations, s as AudioOperations, k as AudioContent, a3 as PlayableAudio, l as AudioFormat } from './ai-reasoning-types-DZd_6Umd.js';
-import * as zod from 'zod';
-import { z } from 'zod';
-import { Buffer } from 'node:buffer';
-import { PromptMessage } from '@modelcontextprotocol/sdk/types.js';
-import * as zod_v4_core from 'zod/v4/core';
-
-/**
- * @h-ai/ai — Compress 子功能类型
- *
- * 定义上下文压缩操作的类型接口：滑动窗口、摘要、混合三种策略。
- * 在对话超出模型上下文窗口时，自动压缩历史消息以保持对话连续性。
- * @module ai-compress-types
- */
-
-/** 压缩策略枚举 */
-declare const CompressionStrategySchema: z.ZodEnum<{
-    summary: "summary";
-    "sliding-window": "sliding-window";
-    hybrid: "hybrid";
-}>;
-/** 压缩策略类型 */
-type CompressionStrategy = z.infer<typeof CompressionStrategySchema>;
-/**
- * 上下文压缩选项
- */
-interface CompressOptions {
-    /** 压缩策略（默认使用配置的 defaultStrategy） */
-    strategy?: CompressionStrategy;
-    /** 目标 token 数（默认使用配置的 defaultMaxTokens，0 表示取模型 maxTokens 的 80%） */
-    maxTokens?: number;
-    /** 保留 system 消息（默认 true） */
-    preserveSystem?: boolean;
-    /** 保留最近 N 条消息不压缩（默认使用配置的 preserveLastN） */
-    preserveLastN?: number;
-    /** 摘要用的模型 */
-    summaryModel?: string;
-}
-/**
- * 上下文压缩结果
- */
-interface CompressResult {
-    /** 压缩后的消息列表 */
-    messages: ChatMessage[];
-    /** 原始消息的估算 token 数 */
-    originalTokens: number;
-    /** 压缩后的估算 token 数 */
-    compressedTokens: number;
-    /** 被移除/合并的消息数 */
-    removedCount: number;
-    /** 生成的摘要文本（仅 summary/hybrid 策略有值） */
-    summary?: string;
-}
-/**
- * Compress 操作接口
- *
- * 管理对话消息的压缩，支持三种策略：
- * - `sliding-window`：移除最旧的消息，保留最近 N 条
- * - `summary`：使用 LLM 生成摘要替换旧消息
- * - `hybrid`：先滑动窗口，不够则回退到摘要
- *
- * @example
- * ```ts
- * const result = await compressOps.tryCompress(messages, {
- *   strategy: 'hybrid',
- *   maxTokens: 4000,
- * })
- * if (result.success) {
- *   const compressed = result.data.messages
- * }
- * ```
- */
-interface CompressOperations {
-    /**
-     * 尝试压缩消息列表，使其不超过指定 Token 预算
-     *
-     * 如果当前 token 数未超限则直接返回（不压缩），因此命名为 tryCompress。
-     * 如果受保护的 system、最近消息或最新 user 输入自身已超过预算，返回
-     * `HaiAIError.CONTEXT_BUDGET_EXCEEDED`，不会删除受保护内容或返回超预算的成功结果。
-     *
-     * @param messages - 消息列表
-     * @param options - 压缩选项
-     * @returns 满足预算的压缩结果，或无法满足预算时的显式错误
-     */
-    tryCompress: (messages: ChatMessage[], options?: CompressOptions) => Promise<HaiResult<CompressResult>>;
-}
-
-/**
- * @h-ai/ai — Summary 子功能类型
- *
- * 定义摘要生成操作的类型接口：使用 LLM 对对话消息生成摘要，支持增量摘要。
- * @module ai-summary-types
- */
-
-/**
- * 摘要生成选项
- */
-interface SummaryOptions {
-    /** 摘要用的模型 */
-    model?: string;
-    /** 温度覆盖 */
-    temperature?: number;
-    /** 自定义摘要 systemPrompt（覆盖模块配置与内置默认提示词） */
-    systemPrompt?: string;
-    /** 前序摘要文本（用于增量摘要） */
-    previousSummary?: string;
-}
-/**
- * 摘要生成结果
- */
-interface SummaryResult {
-    /** 摘要文本 */
-    summary: string;
-    /** 摘要的估算 Token 数 */
-    tokenCount: number;
-    /** 覆盖的原始消息数 */
-    coveredMessages: number;
-}
-/**
- * Summary 操作接口
- *
- * 使用 LLM 对消息列表生成摘要，支持全量摘要与增量摘要。
- *
- * @example
- * ```ts
- * // 生成摘要（含元数据）
- * const result = await summaryOps.summarize(messages)
- * // result.data: { summary, tokenCount, coveredMessages }
- *
- * // 仅获取摘要文本
- * const text = await summaryOps.generate(messages)
- *
- * // 增量摘要
- * const updated = await summaryOps.summarize(newMessages, {
- *   systemPrompt: 'Focus on product decisions and pending action items.',
- *   previousSummary: oldSummary,
- * })
- * ```
- */
-interface SummaryOperations {
-    /**
-     * 生成摘要文本
-     *
-     * @param messages - 消息列表
-     * @param options - 摘要选项
-     * @returns 摘要文本
-     */
-    generate: (messages: ChatMessage[], options?: SummaryOptions) => Promise<HaiResult<string>>;
-    /**
-     * 生成摘要（含元数据）
-     *
-     * @param messages - 消息列表
-     * @param options - 摘要选项
-     * @returns 摘要结果（含 Token 数、覆盖消息数）
-     */
-    summarize: (messages: ChatMessage[], options?: SummaryOptions) => Promise<HaiResult<SummaryResult>>;
-}
-
-/**
- * @h-ai/ai — Context 子功能类型
- *
- * 定义上下文管理操作的类型接口。
- * Context 是全部子模块的聚合层，提供有状态的 ContextManager：
- * 多轮对话自动压缩 + 可选 LLM / Memory / RAG / Reasoning / Tools 编排。
- * @module ai-context-types
- */
-
-/**
- * Context 子功能可选依赖
- *
- * 传入后 ContextManager 可提供 chat/chatStream 等高层编排能力。
- * 各依赖按需传入，未传入的能力不可用。
- */
-interface ContextDeps {
-    /** LLM 操作（chat/chatStream 必需） */
-    llm?: LLMOperations;
-    /** Memory 操作（记忆注入/提取需要） */
-    memory?: MemoryOperations;
-    /** RAG 操作（检索增强生成需要） */
-    rag?: RagOperations;
-    /** Reasoning 操作（推理引擎需要） */
-    reasoning?: ReasoningOperations;
-    /** Summary 操作（会话固化 consolidate 需要） */
-    summary?: SummaryOperations;
-}
-/**
- * 会话固化选项（`ContextManager.consolidate` 使用）
- *
- * 把「短期会话记忆 + 摘要」固化为「长期记忆」，形成
- * `Session Memory → Summary → Long-term Memory` 的生命周期闭环。
- */
-interface ConsolidateOptions {
-    /**
-     * 长期记忆作用域。
-     *
-     * 默认使用管理器 `memory.scope`。通常应传入**不含 sessionId** 的作用域
-     * （如 `{ userId, personaId }`），使固化后的记忆跨会话持久，而非绑定单次会话。
-     */
-    scope?: Record<string, unknown>;
-    /** 固化提取的记忆类型限制 */
-    types?: MemoryType[];
-    /** 摘要 / 提取使用的模型 */
-    model?: string;
-    /** 固化提取的自定义 systemPrompt */
-    extractionSystemPrompt?: string;
-}
-/**
- * 会话固化结果
- */
-interface ConsolidateResult {
-    /** 本次会话的整合摘要 */
-    summary: string;
-    /** 固化到长期记忆的条目 */
-    memories: MemoryEntry[];
-}
-/**
- * 对话轮次状态
- *
- * 描述一次 assistant 生成从「模型产出」到「真实进入对话」的生命周期：
- * - `generating` — 模型正在/已生成，但尚未确定实际对外表达的内容
- * - `speaking` — 已进入下游表达（如 TTS 合成 / 播放）
- * - `completed` — 已提交，完整生成文本即为真实文本
- * - `interrupted` — 被打断，仅实际表达出去的部分（committed）进入对话
- */
-type ConversationTurnStatus = 'generating' | 'speaking' | 'completed' | 'interrupted';
-/**
- * 对话轮次
- *
- * 区分「模型生成的文本」与「真实进入对话的文本」，解决多智能体 / 语音访谈等场景中
- * 「AI 说到一半被打断，下一轮所有参与者应看到真实发生了什么」的问题。
- */
-interface ConversationTurn {
-    /** 轮次唯一标识 */
-    id: string;
-    /** 发言者 */
-    speaker: 'user' | 'assistant';
-    /** 模型生成的完整文本 */
-    generated: string;
-    /** 实际提交进入上下文的文本（`completed` 时通常等于 generated；`interrupted` 时为真实表达部分） */
-    committed: string;
-    /** 轮次状态 */
-    status: ConversationTurnStatus;
-    /** 创建时间（Unix 毫秒） */
-    createdAt: number;
-    /** 提交时间（Unix 毫秒，未提交时为 undefined） */
-    committedAt?: number;
-}
-/**
- * 提交 / 打断轮次的输入
- */
-interface CommitTurnInput {
-    /**
-     * 实际进入对话的文本。
-     *
-     * - `commitTurn` 不传时默认使用模型生成的完整文本（generated）。
-     * - `interruptTurn` 不传时默认视为「未表达任何内容」（空串，不写入上下文）。
-     */
-    text?: string;
-}
-/**
- * 有状态上下文管理器配置
- *
- * 通过嵌套子对象直接引用各子模块的配置类型，避免字段重复声明。
- */
-interface ContextManagerOptions {
-    /** 交互作用域（objectId + sessionId） */
-    scope?: InteractionScope;
-    /** 系统提示词（创建时作为首条 system 消息追加） */
-    systemPrompt?: string;
-    /** LLM 模型名覆盖 */
-    model?: string;
-    /** 温度覆盖 */
-    temperature?: number;
-    /**
-     * 对话提交模式（默认 `auto`）
-     *
-     * - `auto`：`chat` / `chatStream` 生成结束后，自动把**模型生成的完整文本**写入上下文并触发记忆提取。
-     * - `manual`：生成结束后**不写入**上下文，仅登记一个待提交轮次并返回 `turnId`；由调用方在确定
-     *   「实际发生了什么」后，通过 `commitTurn` / `interruptTurn` 写入**真实文本**。
-     *
-     * 用于「模型生成 → TTS 合成 → 实际播放」链路：AI 说到一半被打断时，只有真正播放出去的
-     * 部分才应进入下一轮所有参与者可见的对话状态，而不是模型本想说完的全文。
-     */
-    turnCommit?: 'auto' | 'manual';
-    /**
-     * 并发生成策略（默认 `reject`）
-     *
-     * ContextManager 默认实行**单活动生成**：同一管理器同一时刻只允许一个未完成的
-     * `chat` / `chatStream` 轮次，避免「上一轮 AI 尚未退出，下一轮 user 消息先写入」
-     * 导致的消息乱序（user1 → user2 → assistant1）。
-     *
-     * - `reject`：已有活动生成时，新的 `chat` / `chatStream` 立即返回 `CONTEXT_BUSY` 错误。
-     * - `queue`：新请求排队，等待前一轮次进入终态（`completed` / `interrupted`）后再开始。
-     *
-     * `manual` 提交模式下，屏障持续到 `commitTurn` / `interruptTurn` 提交真实文本为止，
-     * 因此「打断当前轮次 → 立即发起下一轮」也能保证顺序正确。
-     */
-    concurrency?: 'reject' | 'queue';
-    /**
-     * 压缩配置（覆盖全局 compress 配置）
-     *
-     * 直接引用 CompressOptions，加上 auto 开关。
-     */
-    compress?: CompressOptions & {
-        /** 是否自动触发压缩（默认 true） */
-        auto?: boolean;
-    };
-    /**
-     * 记忆配置
-     *
-     * 控制记忆注入与提取。`scope` / `types` / `minImportance` 会完整透传给 Memory 的
-     * `injectMemories` 与 `extract`，用于表达「用户 + 主题 + 角色」等多维隔离
-     * （如 `{ userId, topicId, personaId }`）。
-     */
-    memory?: {
-        /** 是否启用记忆注入（默认 false） */
-        enable?: boolean;
-        /** 是否启用自动记忆提取（默认 false） */
-        enableExtract?: boolean;
-        /** 业务作用域（透传给 injectMemories / extract，key-value 匹配隔离） */
-        scope?: Record<string, unknown>;
-        /** 注入 / 提取时限定的记忆类型 */
-        types?: MemoryType[];
-        /** 注入时的最低重要性阈值 */
-        minImportance?: number;
-        /** 注入的记忆数量 */
-        topK?: number;
-        /** 注入记忆占用的最大 token 预算 */
-        maxTokens?: number;
-        /** 注入位置：system 追加或最后一条用户消息前插入 */
-        position?: 'system' | 'before-last';
-        /** 记忆提取使用的模型（覆盖默认提取模型） */
-        extractionModel?: string;
-        /** 记忆提取的自定义 systemPrompt */
-        extractionSystemPrompt?: string;
-    };
-    /**
-     * RAG 配置
-     *
-     * 引用 RagOptions 中检索相关的字段。
-     */
-    rag?: Pick<RagOptions, 'sources' | 'topK' | 'minScore' | 'enableRerank' | 'rerankModel'> & {
-        /** 是否启用 RAG 检索增强（默认 false） */
-        enable?: boolean;
-    };
-    /**
-     * 推理配置
-     *
-     * 引用 ReasoningOptions 中策略相关的字段。
-     */
-    reasoning?: Pick<ReasoningOptions, 'strategy' | 'maxRounds'> & {
-        /** 是否启用推理引擎替代普通 LLM（默认 false） */
-        enable?: boolean;
-    };
-    /** 工具注册表（传入后 chat/chatStream 支持 function calling） */
-    tools?: ToolRegistryOperations;
-    /**
-     * 工具调用最大轮次（默认 10）
-     *
-     * 当 LLM 返回 tool_calls 时，自动执行工具并将结果回传 LLM，
-     * 重复此过程直到 LLM 给出文本回复或达到最大轮次。
-     */
-    maxToolRounds?: number;
-}
-/**
- * 重置管理器选项（`ContextManager.reset` 使用）
- */
-interface ContextResetOptions {
-    /**
-     * 是否保留系统提示词（默认 `true`）
-     *
-     * 系统提示词（Persona / System Prompt）只在创建时追加一次；重置若不保留，
-     * 会连同对话历史一起清空。默认重新写入系统提示词，避免 Persona 语义丢失。
-     */
-    preserveSystemPrompt?: boolean;
-    /**
-     * 是否终止活动轮次（默认 `true`）
-     *
-     * 为 `true` 时：中断内部生成信号，使所有非终态轮次进入 `interrupted` 终态，
-     * 释放并发屏障，并阻止这些旧轮次在重置后被再次 `commitTurn` / `interruptTurn`。
-     */
-    cancelActiveTurn?: boolean;
-    /**
-     * 是否等待后台记忆提取任务完成后再清空（默认 `false`）
-     *
-     * 为 `true` 时先 `flush()` 等待正在运行的记忆提取写入完成；否则不等待
-     * （已在途的提取任务仍会自行写入记忆后端，但其结果不再影响本管理器状态）。
-     */
-    waitForMemoryTasks?: boolean;
-}
-/**
- * 单次 chat/chatStream 请求的覆盖选项
- */
-interface ContextChatOptions {
-    /** LLM 模型名覆盖 */
-    model?: string;
-    /** 温度覆盖 */
-    temperature?: number;
-    /** 是否启用本次 LLM 调用的持久化（默认 false，Context 自行管理状态） */
-    enablePersist?: boolean;
-    /**
-     * 请求取消信号
-     *
-     * 透传给底层 LLM 调用；打断、用户切换等场景可 `abortController.abort()`
-     * 立即停止上游生成与计费。
-     */
-    signal?: AbortSignal;
-}
-/**
- * chat() 返回的结果
- */
-interface ContextChatResult {
-    /** LLM 回复内容 */
-    reply: string;
-    /** 使用的模型 */
-    model: string;
-    /**
-     * 本次生成对应的对话轮次 ID
-     *
-     * `turnCommit: 'manual'` 时，用于后续 `commitTurn` / `interruptTurn` 提交真实文本；
-     * `auto` 模式下该轮已自动提交（`completed`）。
-     */
-    turnId: string;
-    /** Token 使用统计 */
-    usage?: {
-        prompt_tokens: number;
-        completion_tokens: number;
-        total_tokens: number;
-    };
-}
-/**
- * chatStream() 产出的事件
- *
- * 事件序列：`turn_started` → `delta`* → `done`；中途取消（AbortSignal）时为
- * `turn_started` → `delta`* → `cancelled`。`cancelled` 保留 turnId 与已生成文本，
- * 调用方可用真实内容调用 `commitTurn` / `interruptTurn` 提交。
- */
-type ContextStreamEvent = {
-    type: 'turn_started';
-    turnId: string;
-} | {
-    type: 'delta';
-    text: string;
-} | {
-    type: 'tool_call';
-    name: string;
-    arguments: string;
-} | {
-    type: 'tool_result';
-    name: string;
-    content: string;
-    success: boolean;
-} | {
-    type: 'done';
-    reply: string;
-    model: string;
-    turnId: string;
-    usage?: {
-        prompt_tokens: number;
-        completion_tokens: number;
-        total_tokens: number;
-    };
-} | {
-    type: 'cancelled';
-    turnId: string;
-    generated: string;
-};
-/**
- * 有状态上下文管理器接口
- *
- * 适用于多轮对话场景。追加消息并在超限时自动压缩；
- * 若传入 deps.llm 则可直接通过 chat/chatStream 进行对话编排。
- *
- * @example
- * ```ts
- * // 创建管理器并直接对话
- * const managerResult = ai.context.createManager({
- *   scope: { objectId: 'user-001', sessionId: 'sess-001' },
- *   systemPrompt: '你是一个友好的助手。',
- *   compress: { maxTokens: 8000, strategy: 'hybrid' },
- *   memory: { enable: true, enableExtract: true },
- * })
- * const manager = managerResult.data
- *
- * const result = await manager.chat('你好')
- * if (result.success) {
- *   const reply = result.data.reply
- *   // 将 reply 渲染到对话界面
- * }
- *
- * for await (const event of manager.chatStream('讲个故事')) {
- *   if (event.type === 'delta') process.stdout.write(event.text)
- * }
- *
- * await manager.save()
- * ```
- */
-interface ContextManager {
-    /** 当前作用域（如已配置） */
-    readonly scope?: InteractionScope;
-    /**
-     * 追加消息
-     *
-     * 自动在超限时触发压缩（如果启用了 compress.auto）。
-     *
-     * @param message - 要追加的消息
-     * @returns 成功返回 ok(undefined)
-     */
-    addMessage: (message: ChatMessage) => Promise<HaiResult<void>>;
-    /**
-     * 获取当前消息列表（压缩后）
-     *
-     * @returns 当前消息列表
-     */
-    getMessages: () => HaiResult<ChatMessage[]>;
-    /**
-     * 获取当前 token 使用量
-     *
-     * @returns 当前 token 数和预算
-     */
-    getTokenUsage: () => HaiResult<{
-        current: number;
-        budget: number;
-    }>;
-    /**
-     * 获取历史摘要列表
-     *
-     * @returns 每次压缩产生的摘要
-     */
-    getSummaries: () => HaiResult<SummaryResult[]>;
-    /**
-     * 持久化当前状态（需要 scope + 存储可用）
-     *
-     * 内部会先 `flush()` 等待所有后台记忆提取完成，确保持久化时记忆已写入。
-     */
-    save: () => Promise<HaiResult<void>>;
-    /**
-     * 等待所有后台记忆提取任务完成
-     *
-     * chat/chatStream 的自动记忆提取是「即发即忘」的后台任务；在开始下一轮召回、
-     * 生成总结或关闭前调用 `flush()`，可避免「上一轮记忆尚未写完」的时序问题（issue #14）。
-     *
-     * @returns 全部任务完成返回 ok(undefined)
-     */
-    flush: () => Promise<HaiResult<void>>;
-    /**
-     * 当前挂起的后台记忆提取任务数量
-     *
-     * 供应用侧观测；为 0 表示无待写入的记忆任务。
-     */
-    readonly pendingMemoryTasks: number;
-    /**
-     * 重置管理器
-     *
-     * 默认行为：终止活动轮次（进入终态并释放并发屏障）、清空消息 / 摘要 / 轮次 /
-     * 待提交轮次，并重新写入系统提示词。可通过选项调整。
-     *
-     * @param options - 重置选项（保留系统提示词 / 终止活动轮次 / 等待记忆任务）
-     * @returns 成功返回 ok(undefined)
-     */
-    reset: (options?: ContextResetOptions) => Promise<HaiResult<void>>;
-    /**
-     * 获取对话轮次列表（Conversation Commit Layer）
-     *
-     * 记录每次 chat/chatStream 生成的轮次及其 `generated` / `committed` / `status`，
-     * 供应用侧观测「模型生成」与「真实进入对话」的差异。
-     *
-     * @returns 轮次列表（按发生顺序）
-     */
-    getTurns: () => HaiResult<ConversationTurn[]>;
-    /**
-     * 标记某轮次进入「表达中」（如 TTS 开始播放）
-     *
-     * 仅更新状态用于观测，不改变上下文内容。
-     *
-     * @param turnId - 轮次 ID
-     * @returns 成功返回 ok(undefined)；轮次不存在返回 CONTEXT_TURN_NOT_FOUND
-     */
-    markTurnSpeaking: (turnId: string) => HaiResult<void>;
-    /**
-     * 提交轮次（`turnCommit: 'manual'` 场景）
-     *
-     * 把真实文本写入上下文并触发记忆提取；`text` 缺省时使用模型生成的完整文本。
-     * 提交后该轮 `status` 变为 `completed`。
-     *
-     * @param turnId - 轮次 ID
-     * @param input - 提交内容（可覆盖为真实表达文本）
-     * @returns 成功返回 ok(undefined)；轮次不存在或已提交返回对应错误
-     */
-    commitTurn: (turnId: string, input?: CommitTurnInput) => Promise<HaiResult<void>>;
-    /**
-     * 打断轮次（`turnCommit: 'manual'` 场景）
-     *
-     * 只把「实际表达出去的部分」写入上下文；`text` 缺省时视为未表达任何内容（不写入）。
-     * 打断后该轮 `status` 变为 `interrupted`。
-     *
-     * @param turnId - 轮次 ID
-     * @param input - 实际表达出去的文本
-     * @returns 成功返回 ok(undefined)；轮次不存在或已提交返回对应错误
-     */
-    interruptTurn: (turnId: string, input?: CommitTurnInput) => Promise<HaiResult<void>>;
-    /**
-     * 将当前会话固化为长期记忆（Memory 生命周期）
-     *
-     * 流程：整合会话摘要（历史摘要 + 当前消息）→ 从摘要中提取长期记忆 → 以持久作用域写入。
-     * 需要 deps.summary + deps.memory 可用。用于会话结束时把「短期会话记忆」沉淀为
-     * 「跨会话长期记忆」，形成 Session → Summary → Long-term Memory 闭环。
-     *
-     * @param options - 固化选项（长期作用域、类型、模型等）
-     * @returns 会话摘要与固化的记忆条目
-     */
-    consolidate: (options?: ConsolidateOptions) => Promise<HaiResult<ConsolidateResult>>;
-    /**
-     * 发送消息并获取回复（需 deps.llm 可用）
-     *
-     * 流程：追加用户消息 → 自动压缩 → 注入记忆(可选) → RAG(可选) → LLM/Reasoning → 追加助手消息 → 提取记忆(可选)
-     *
-     * @param message - 用户消息文本
-     * @param options - 单次请求覆盖选项
-     * @returns 对话结果
-     */
-    chat: (message: string, options?: ContextChatOptions) => Promise<HaiResult<ContextChatResult>>;
-    /**
-     * 流式发送消息并获取回复（需 deps.llm 可用）
-     *
-     * 产出事件序列：turn_started → delta* → done（中途取消时 → cancelled）
-     *
-     * @param message - 用户消息文本
-     * @param options - 单次请求覆盖选项
-     * @returns 异步可迭代的 ContextStreamEvent
-     */
-    chatStream: (message: string, options?: ContextChatOptions) => AsyncIterable<ContextStreamEvent>;
-}
-/**
- * Context 操作接口（通过 `ai.context` 访问）
- *
- * 提供有状态的 ContextManager，管理多轮对话的消息追加、自动压缩与对话编排。
- * 原子操作（token / summary / compress）已独立暴露在 `ai.token`、`ai.summary`、`ai.compress`。
- * 需要先调用 `ai.init()` 初始化后使用。
- *
- * @example
- * ```ts
- * // 创建管理器并对话
- * const managerResult = ai.context.createManager({
- *   scope: { objectId: 'user-001', sessionId: 'sess-001' },
- *   compress: { maxTokens: 8000 },
- *   memory: { enable: true },
- * })
- * const manager = managerResult.data
- * const result = await manager.chat('你好')
- *
- * // 从持久化恢复管理器
- * const restored = await ai.context.restoreManager(
- *   { objectId: 'user-001', sessionId: 'sess-001' },
- *   { memory: { enable: true } },
- * )
- * ```
- */
-interface ContextOperations {
-    /**
-     * 创建有状态上下文管理器
-     *
-     * @param options - 管理器配置
-     * @returns 管理器实例
-     */
-    createManager: (options?: ContextManagerOptions) => HaiResult<ContextManager>;
-    /**
-     * 从持久化恢复上下文管理器
-     *
-     * @param scope - 交互作用域
-     * @param options - 管理器配置覆盖
-     * @returns 恢复的管理器实例
-     */
-    restoreManager: (scope: InteractionScope, options?: Omit<ContextManagerOptions, 'scope'>) => Promise<HaiResult<ContextManager>>;
-    /**
-     * 列出指定主体的所有会话
-     *
-     * @param objectId - 主体 ID
-     * @returns 会话信息列表
-     */
-    listSessions: (objectId: string) => Promise<HaiResult<SessionInfo[]>>;
-    /**
-     * 重命名会话
-     *
-     * @param scope - 交互作用域（objectId + sessionId，用于多租户隔离）
-     * @param title - 新标题
-     * @returns 成功返回 ok(undefined)
-     */
-    renameSession: (scope: InteractionScope, title: string) => Promise<HaiResult<void>>;
-    /**
-     * 删除会话（删除会话元数据和对应的上下文数据）
-     *
-     * @param scope - 交互作用域（objectId + sessionId，用于多租户隔离）
-     * @returns 成功返回 ok(undefined)
-     */
-    removeSession: (scope: InteractionScope) => Promise<HaiResult<void>>;
-}
-
-/**
- * @h-ai/ai — Embedding 子功能类型
- *
- * 定义向量嵌入操作的类型接口。
- * @module ai-embedding-types
- */
-
-/**
- * Embedding 请求参数
- */
-interface EmbeddingRequest {
-    /** 输入文本（单条或批量） */
-    input: string | string[];
-    /** 模型名称（可选，未指定时使用配置中的默认模型） */
-    model?: string;
-    /** 向量维度（可选，部分模型支持） */
-    dimensions?: number;
-}
-/**
- * 单条 Embedding 结果
- */
-interface EmbeddingItem {
-    /** 在输入列表中的索引 */
-    index: number;
-    /** 向量数据 */
-    embedding: number[];
-}
-/**
- * Embedding 响应
- */
-interface EmbeddingResponse {
-    /** 模型名称 */
-    model: string;
-    /** Embedding 结果列表 */
-    data: EmbeddingItem[];
-    /** Token 使用统计 */
-    usage: {
-        prompt_tokens: number;
-        total_tokens: number;
-    };
-}
-/**
- * Embedding Provider 接口
- *
- * 底层嵌入 API 适配层。
- */
-interface EmbeddingProvider {
-    /** 生成向量嵌入 */
-    embed: (request: EmbeddingRequest) => Promise<HaiResult<EmbeddingResponse>>;
-}
-/**
- * Embedding 操作接口（通过 `ai.embedding` 访问）
- *
- * 需要先调用 `ai.init()` 初始化后使用。
- *
- * @example
- * ```ts
- * // 单条文本嵌入
- * const result = await ai.embedding.embed({ input: 'Hello World' })
- *
- * // 批量嵌入
- * const result = await ai.embedding.embed({
- *   input: ['文本1', '文本2', '文本3'],
- * })
- * ```
- */
-interface EmbeddingOperations {
-    /**
-     * 生成向量嵌入
-     *
-     * @param request - Embedding 请求
-     * @returns Embedding 响应
-     */
-    embed: (request: EmbeddingRequest) => Promise<HaiResult<EmbeddingResponse>>;
-    /**
-     * 便捷方法：嵌入单条文本，直接返回向量
-     *
-     * @param text - 输入文本
-     * @returns 向量数组
-     */
-    embedText: (text: string) => Promise<HaiResult<number[]>>;
-    /**
-     * 便捷方法：批量嵌入文本，返回向量列表
-     *
-     * @param texts - 输入文本列表
-     * @returns 向量数组列表（与输入顺序一致）
-     */
-    embedBatch: (texts: string[]) => Promise<HaiResult<number[][]>>;
-}
-
-/**
- * @h-ai/ai — File 子功能类型
- *
- * 定义文件解析操作的类型接口。
- * @module ai-file-types
- */
-
-/**
- * 文件解析方法
- *
- * - `text` — 直接解码为 UTF-8 文本（txt / md / csv / 等文本格式）
- * - `html` — HTML 标签剥除后提取文本
- * - `pdf` — 使用 pdfjs-dist 解析 PDF（需安装可选依赖）
- * - `docx` — 使用 mammoth 解析 Word 文档（需安装可选依赖）
- * - `ocr` — 通过视觉 LLM 进行 OCR 识别（图片及无原生解析器的格式）
- */
-type FileParseMethod = 'text' | 'html' | 'pdf' | 'docx' | 'ocr';
-/**
- * 文件解析输出格式
- * - `text` — 纯文本（默认），适合程序处理
- * - `markdown` — Markdown 格式，保留文档结构（标题、列表、粗斜体等），
- *   适用于 HTML、PDF、DOCX；图片 OCR 会提示模型输出 Markdown
- */
-type OutputFormat = 'text' | 'markdown';
-/**
- * 文件解析选项
- */
-interface FileParseOptions {
-    /** 强制使用指定 MIME 类型（覆盖自动检测） */
-    mimeType?: string;
-    /** 强制使用 OCR（即使有原生解析器支持） */
-    useOcr?: boolean;
-    /**
-     * OCR 使用的视觉模型（请求级覆盖）
-     *
-     * 最高优先级，覆盖 `llm.scenarios.ocr` 场景映射。
-     * 未指定时通过 `llm.scenarios.ocr` 解析。
-     */
-    model?: string;
-    /** OCR 系统提示词（覆盖全局 `file.systemPrompt` 配置） */
-    systemPrompt?: string;
-    /** PDF 最大解析页数（默认解析全部页） */
-    maxPages?: number;
-    /**
-     * 输出格式（默认 `'text'`）
-     */
-    outputFormat?: OutputFormat;
-}
-/**
- * 文件解析请求
- */
-interface FileParseRequest {
-    /**
-     * 文件内容
-     *
-     * - `Buffer` — 二进制文件（图片、PDF、DOCX 等）
-     * - `string` — 文本内容（直接传入文本格式文件）
-     */
-    content: Buffer | string;
-    /** 文件名（用于 MIME 类型自动检测，可选） */
-    filename?: string;
-    /** 解析选项 */
-    options?: FileParseOptions;
-}
-/**
- * 文件解析结果
- */
-interface FileParseResult {
-    /** 提取的文本内容（当 `outputFormat` 为 `'markdown'` 时为 Markdown 格式） */
-    text: string;
-    /** 解析方法 */
-    method: FileParseMethod;
-    /** 页数（PDF 解析时） */
-    pageCount?: number;
-    /** 元数据 */
-    metadata?: {
-        filename?: string;
-        mimeType?: string;
-        charCount?: number;
-    };
-}
-/**
- * File 操作接口（通过 `ai.file` 访问）
- *
- * 需要先调用 `ai.init()` 初始化后使用（OCR 功能需要 LLM 配置）。
- *
- * 支持的格式：
- * - 文本格式（txt、md、csv 等）：直接解码
- * - HTML：剥除标签后提取文本
- * - PDF：使用 pdfjs-dist（需安装），否则回退到 OCR
- * - DOCX：使用 mammoth（需安装），否则回退到 OCR
- * - 图片（JPEG、PNG、GIF、WebP）：通过视觉 LLM OCR 识别
- *
- * @example
- * ```ts
- * import { readFile } from 'node:fs/promises'
- *
- * // 解析 PDF（OCR 模型通过 llm.scenarios.ocr 配置）
- * ai.init({ llm: { apiKey: 'sk-...', scenarios: { ocr: 'gpt-4o' } } })
- *
- * const pdf = await readFile('document.pdf')
- * const result = await ai.file.parse({ content: pdf, filename: 'document.pdf' })
- *
- * // 解析图片（OCR）
- * const image = await readFile('screenshot.png')
- * const result = await ai.file.parse({ content: image, filename: 'screenshot.png' })
- *
- * // 便捷方法：直接获取文本
- * const text = await ai.file.parseText(content, 'document.pdf')
- * ```
- */
-interface FileOperations {
-    /**
-     * 解析文件内容，提取文本
-     *
-     * 自动检测文件格式，选择最优解析方法。
-     *
-     * @param request - 文件解析请求
-     * @returns 解析结果，包含文本内容、解析方法和元数据
-     */
-    parse: (request: FileParseRequest) => Promise<HaiResult<FileParseResult>>;
-    /**
-     * 便捷方法：直接返回提取的文本字符串
-     *
-     * @param content - 文件内容（Buffer 或文本字符串）
-     * @param filename - 文件名（用于格式检测，可选）
-     * @returns 提取的文本内容
-     */
-    parseText: (content: Buffer | string, filename?: string) => Promise<HaiResult<string>>;
-}
-
-/**
- * @h-ai/ai — 文生图公共类型
- *
- * 公共契约只暴露业务需要的提示词、尺寸和标准化图片字节。
- * 厂商请求字段、临时 URL 与响应中间态由 Provider 内部处理。
- * @module image/ai-image-types
- */
-
-/** 图片像素尺寸 */
-interface ImageSize {
-    /** 宽度（像素） */
-    width: number;
-    /** 高度（像素） */
-    height: number;
-}
-/** 可选参考图；Provider 会转换为对应厂商的传输格式 */
-interface ReferenceImage {
-    /** 图片二进制内容 */
-    data: Uint8Array;
-    /** 图片 MIME 类型，例如 `image/png`、`image/jpeg` */
-    mimeType: string;
-}
-/** 文生图请求 */
-interface GenerateImageRequest {
-    /** 图片内容与风格提示词 */
-    prompt: string;
-    /** 模型 ID；不传时使用配置中的默认文生图模型 */
-    model?: string;
-    /** 输出像素尺寸；不传时由模型决定 */
-    size?: ImageSize;
-    /** 用于图生图、编辑或风格参考的一张或多张图片 */
-    referenceImages?: ReferenceImage[];
-    /** 请求取消信号 */
-    signal?: AbortSignal;
-}
-/** 标准化后的单张图片 */
-interface GeneratedImage {
-    /** 图片二进制内容 */
-    data: Uint8Array;
-    /** 图片 MIME 类型 */
-    mimeType: string;
-    /** 实际宽度（厂商返回时提供） */
-    width?: number;
-    /** 实际高度（厂商返回时提供） */
-    height?: number;
-}
-/** 文生图结果 */
-interface GenerateImageResult {
-    /** 厂商实际返回的图片；通常为一张 */
-    images: GeneratedImage[];
-}
-/** 文生图操作接口（通过 `ai.image` 访问） */
-interface ImageOperations {
-    /** 根据文本提示生成图片 */
-    generate: (request: GenerateImageRequest) => Promise<HaiResult<GenerateImageResult>>;
-}
-
-/**
- * @h-ai/ai — MCP 子功能类型
- *
- * 定义 MCP 工具、资源、提示词的注册与调用接口。
- * @module ai-mcp-types
- */
-
-/** MCP 工具定义（注册工具时的元数据） */
-interface MCPToolDefinition {
-    /** 工具名称（需唯一） */
-    name: string;
-    /** 工具功能描述 */
-    description: string;
-    /** 输入参数的 JSON Schema */
-    inputSchema: Record<string, unknown>;
-}
-/** MCP 工具处理器，接收输入参数和执行上下文 */
-type MCPToolHandler<TInput = unknown, TOutput = unknown> = (input: TInput, context: MCPContext) => Promise<TOutput> | TOutput;
-/** MCP 执行上下文，携带请求元数据 */
-interface MCPContext {
-    /** 请求唯一标识（未传入时自动生成 UUID） */
-    requestId?: string;
-    /** 客户端信息（可选） */
-    clientInfo?: {
-        name: string;
-        version: string;
-    };
-    /** 自定义元数据（可选） */
-    metadata?: Record<string, unknown>;
-}
-/** MCP 资源描述（注册资源时的元数据） */
-interface MCPResource {
-    /** 资源 URI（唯一标识） */
-    uri: string;
-    /** 资源名称 */
-    name: string;
-    /** 资源描述（可选） */
-    description?: string;
-    /** MIME 类型（可选，如 `'application/json'`） */
-    mimeType?: string;
-}
-/** MCP 资源内容（readResource 的返回值） */
-interface MCPResourceContent {
-    /** 资源 URI */
-    uri: string;
-    /** MIME 类型（可选） */
-    mimeType?: string;
-    /** 文本内容（与 blob 二选一） */
-    text?: string;
-    /** Base64 编码的二进制内容（与 text 二选一） */
-    blob?: string;
-}
-/** MCP 提示词模板描述 */
-interface MCPPrompt {
-    /** 提示词名称（唯一标识） */
-    name: string;
-    /** 提示词描述（可选） */
-    description?: string;
-    /** 参数定义列表（可选） */
-    arguments?: MCPPromptArgument[];
-}
-/** MCP 提示词参数定义 */
-interface MCPPromptArgument {
-    /** 参数名称 */
-    name: string;
-    /** 参数描述（可选） */
-    description?: string;
-    /** 是否必填（默认 `false`） */
-    required?: boolean;
-}
-/** MCP 提示词消息，直接复用 SDK 的完整判别联合（含图片、音频与嵌入资源） */
-type MCPPromptMessage = PromptMessage;
-/** MCP 提示词内容；按 type 缩窄后访问对应字段 */
-type MCPPromptContent = PromptMessage['content'];
-/** MCP 服务器创建选项 */
-interface McpServerOptions {
-    /** 服务器名称 */
-    name: string;
-    /** 服务器版本（默认 `'1.0.0'`） */
-    version?: string;
-}
-/**
- * MCP 操作接口（通过 `ai.mcp` 访问）
- *
- * 需要先调用 `ai.init()` 初始化，否则所有方法返回 `NOT_INITIALIZED` 错误。
- */
-interface MCPOperations {
-    /** 注册工具并编译 JSON Schema；非法 Schema 返回 MCP_TOOL_ERROR，同名注册覆盖 */
-    registerTool: <TInput, TOutput>(definition: MCPToolDefinition, handler: MCPToolHandler<TInput, TOutput>) => HaiResult<void>;
-    /** 注册资源加载器；读取时校验 text/blob 输出 */
-    registerResource: (resource: MCPResource, handler: () => Promise<MCPResourceContent>) => HaiResult<void>;
-    /** 注册提示词；调用时校验必填参数和 SDK 消息格式 */
-    registerPrompt: (prompt: MCPPrompt, handler: (args: Record<string, string>) => Promise<MCPPromptMessage[]>) => HaiResult<void>;
-    /** 校验输入后执行工具；自动补齐缺失的 requestId */
-    callTool: (name: string, args: unknown, context?: MCPContext) => Promise<HaiResult<unknown>>;
-    /** 读取资源，输出必须恰好含一个有效 text 或 blob */
-    readResource: (uri: string) => Promise<HaiResult<MCPResourceContent>>;
-    /** 渲染提示词；必填参数必须是自身属性，且提供的已声明参数必须是字符串 */
-    getPrompt: (name: string, args: Record<string, string>) => Promise<HaiResult<MCPPromptMessage[]>>;
-}
-
-/**
- * @h-ai/ai — Persona 子功能类型
- *
- * 定义「AI 角色人格」的持久化与组合接口。Persona 解决的是「AI 是谁」的问题：
- * 多智能体场景（如多位专家同台访谈）中，每个 AI 有稳定的系统提示词、性格特征与
- * 长期人格。它与 Memory 正交——Memory 用 `objectId` / `scope` 回答「谁的记忆」，
- * Persona 回答「这个 AI 的身份与人设」，二者通过 `scope: { personaId }` 关联。
- * @module ai-persona-types
- */
-
-/**
- * Persona 档案输入（创建 / 覆盖保存时使用）
- *
- * @example
- * ```ts
- * const input: PersonaProfileInput = {
- *   id: 'xiaop',
- *   name: '小P',
- *   systemPrompt: '你是一位社会学家，善于从群体行为视角分析问题。',
- *   traits: ['谨慎', '喜欢引用真实案例'],
- * }
- * ```
- */
-interface PersonaProfileInput {
-    /** 角色唯一标识（业务侧稳定 ID，如 `xiaop`） */
-    id: string;
-    /**
-     * 所属主体 ID（多租户隔离）
-     *
-     * 不同主体可创建同名角色而互不覆盖；不传时归为平台内置角色 `system`。
-     */
-    objectId?: string;
-    /** 角色显示名（如「小P」） */
-    name?: string;
-    /** 角色系统提示词（定义身份、职责、语气） */
-    systemPrompt: string;
-    /** 性格 / 风格特征（组合进系统提示词，如「谨慎」「喜欢引用案例」） */
-    traits?: string[];
-    /** 附加元数据 */
-    metadata?: Record<string, unknown>;
-}
-/**
- * 完整的 Persona 档案
- */
-interface PersonaProfile {
-    /** 角色唯一标识 */
-    id: string;
-    /** 所属主体 ID（多租户隔离；平台内置角色为 `system`） */
-    objectId: string;
-    /** 角色显示名 */
-    name?: string;
-    /** 角色系统提示词 */
-    systemPrompt: string;
-    /** 性格 / 风格特征 */
-    traits: string[];
-    /** 附加元数据 */
-    metadata?: Record<string, unknown>;
-    /** 创建时间（Unix 毫秒） */
-    createdAt: number;
-    /** 更新时间（Unix 毫秒） */
-    updatedAt: number;
-}
-/**
- * Persona 档案更新输入
- *
- * 所有字段可选，仅更新传入的字段。
- */
-interface PersonaProfileUpdate {
-    /** 更新显示名 */
-    name?: string;
-    /** 更新系统提示词 */
-    systemPrompt?: string;
-    /** 更新特征列表（整体替换） */
-    traits?: string[];
-    /** 更新元数据 */
-    metadata?: Record<string, unknown>;
-}
-/**
- * Persona 操作接口（通过 `ai.persona` 访问）
- *
- * 管理 AI 角色人格的持久化与系统提示词组合。需要先调用 `ai.init()` 初始化后使用。
- *
- * @example
- * ```ts
- * // 定义一个 AI 角色
- * await ai.persona.save({
- *   id: 'xiaoq',
- *   name: '小Q',
- *   systemPrompt: '你是一位经济学家。',
- *   traits: ['数据驱动', '偏好长期视角'],
- * })
- *
- * // 组合出可直接喂给 ContextManager 的系统提示词
- * const composed = await ai.persona.compose('xiaoq')
- * const manager = ai.context.createManager({
- *   systemPrompt: composed.data,
- *   // 该角色的长期记忆用 scope 关联
- *   memory: { enable: true, enableExtract: true, scope: { personaId: 'xiaoq' } },
- * })
- * ```
- */
-interface PersonaOperations {
-    /**
-     * 创建或覆盖保存一个角色档案（upsert 语义）
-     *
-     * @param profile - 角色档案输入
-     * @returns 保存后的完整档案
-     */
-    save: (profile: PersonaProfileInput) => Promise<HaiResult<PersonaProfile>>;
-    /**
-     * 按 ID 获取角色档案
-     *
-     * @param id - 角色 ID
-     * @returns 角色档案，不存在时返回 PERSONA_NOT_FOUND
-     */
-    get: (id: string, options?: PersonaScopeOptions) => Promise<HaiResult<PersonaProfile>>;
-    /**
-     * 更新角色档案（仅更新传入字段）
-     *
-     * @param id - 角色 ID
-     * @param updates - 需要更新的字段
-     * @param options - 主体作用域（默认 `system`）
-     * @returns 更新后的完整档案
-     */
-    update: (id: string, updates: PersonaProfileUpdate, options?: PersonaScopeOptions) => Promise<HaiResult<PersonaProfile>>;
-    /**
-     * 删除角色档案
-     *
-     * @param id - 角色 ID
-     * @param options - 主体作用域（默认 `system`）
-     * @returns 成功返回 ok(undefined)
-     */
-    remove: (id: string, options?: PersonaScopeOptions) => Promise<HaiResult<void>>;
-    /**
-     * 列出指定主体的角色档案
-     *
-     * @param options - 主体作用域（默认 `system`）
-     * @returns 角色档案列表
-     */
-    list: (options?: PersonaScopeOptions) => Promise<HaiResult<PersonaProfile[]>>;
-    /**
-     * 组合角色的完整系统提示词
-     *
-     * 将 `systemPrompt` 与 `traits` 拼装为一段可直接作为 system 消息的文本，
-     * 供 `ai.context.createManager({ systemPrompt })` 使用。
-     *
-     * @param id - 角色 ID
-     * @param options - 主体作用域（默认 `system`）
-     * @returns 组合后的系统提示词，角色不存在时返回 PERSONA_NOT_FOUND
-     */
-    compose: (id: string, options?: PersonaScopeOptions) => Promise<HaiResult<string>>;
-}
-/** Persona 操作的主体作用域选项 */
-interface PersonaScopeOptions {
-    /** 所属主体 ID（不传时归为平台内置角色 `system`） */
-    objectId?: string;
-}
-
-/**
- * @h-ai/ai — Rerank 子功能类型
- *
- * 定义文档重排序操作的类型接口。
- * @module ai-rerank-types
- */
-
-/**
- * 单条待排序文档
- */
-interface RerankDocument {
-    /** 文档唯一标识（可选，便于结果追踪） */
-    id?: string;
-    /** 文档文本内容 */
-    text: string;
-}
-/**
- * Rerank 请求参数
- */
-interface RerankRequest {
-    /** 查询文本 */
-    query: string;
-    /** 待排序文档列表（字符串数组或带 id 的文档对象数组） */
-    documents: string[] | RerankDocument[];
-    /** 模型名称（可选，未指定时使用配置中的默认模型） */
-    model?: string;
-    /** 返回结果数量（可选，默认返回全部文档） */
-    topN?: number;
-    /** 是否在结果中返回文档原文（默认 false） */
-    returnDocuments?: boolean;
-}
-/**
- * 单条 Rerank 结果
- */
-interface RerankItem {
-    /** 文档在原始输入中的索引 */
-    index: number;
-    /** 文档 ID（当输入为带 id 的文档对象时） */
-    id?: string;
-    /** 相关性分数（越高越相关） */
-    relevanceScore: number;
-    /** 文档原文（当 returnDocuments 为 true 时） */
-    document?: string;
-}
-/**
- * Rerank 响应
- */
-interface RerankResponse {
-    /** 使用的模型名称 */
-    model: string;
-    /** 重排序结果列表（按相关性分数降序排列） */
-    results: RerankItem[];
-}
-/**
- * Rerank 操作接口（通过 `ai.rerank` 访问）
- *
- * 需要先调用 `ai.init()` 初始化后使用。
- * 通过专用 Rerank API（兼容 Cohere 格式）对文档进行相关性重排序。
- *
- * @example
- * ```ts
- * // 对检索结果重排序
- * const result = await ai.rerank.rerank({
- *   query: '机器学习入门',
- *   documents: [
- *     '深度学习是机器学习的一个分支',
- *     '今天天气真好',
- *     '神经网络是深度学习的基础',
- *   ],
- *   topN: 2,
- * })
- *
- * // 便捷方法：直接传入文本数组
- * const items = await ai.rerank.rerankTexts('query', ['doc1', 'doc2'])
- * ```
- */
-interface RerankOperations {
-    /**
-     * 对文档列表进行相关性重排序
-     *
-     * @param request - Rerank 请求
-     * @returns 重排序响应，结果按相关性分数降序排列
-     */
-    rerank: (request: RerankRequest) => Promise<HaiResult<RerankResponse>>;
-    /**
-     * 便捷方法：对文本数组重排序，直接返回结果列表
-     *
-     * @param query - 查询文本
-     * @param texts - 待排序文本列表
-     * @param topN - 返回条数（可选）
-     * @returns RerankItem 列表，按相关性分数降序排列
-     */
-    rerankTexts: (query: string, texts: string[], topN?: number) => Promise<HaiResult<RerankItem[]>>;
-}
-
-/**
- * @h-ai/ai — Token 子功能类型
- *
- * 定义 Token 估算操作的类型接口：文本与消息级别的 Token 数估算。
- * 使用 CJK 感知的字符级估算算法，无需外部分词库依赖。
- * @module ai-token-types
- */
-
-/**
- * Token 操作接口
- *
- * 提供 Token 估算能力，使用配置的 `tokenRatio` 做估算。
- *
- * @example
- * ```ts
- * const tokens = tokenOps.estimateText('Hello 世界')
- * const total = tokenOps.estimateMessages(messages)
- * ```
- */
-interface TokenOperations {
-    /**
-     * 估算单条文本的 Token 数
-     *
-     * 使用字符级估算：中文约每字 1.5 token，英文约每 4 字符 1 token。
-     *
-     * @param text - 文本内容
-     * @returns 估算 Token 数
-     */
-    estimateText: (text: string) => number;
-    /**
-     * 估算消息列表的总 Token 数
-     *
-     * 包含消息结构开销（每条消息约 4 token 用于角色标记和分隔）。
-     *
-     * @param messages - 消息列表
-     * @returns 估算 Token 总数
-     */
-    estimateMessages: (messages: ChatMessage[]) => number;
-}
-
-/**
- * AI 模块标准错误定义对象。
- *
- * 通过 `HaiAIError.ERROR_CODE_NAME` 访问具体错误定义，如：
- * ```ts
- * const def = HaiAIError.NOT_INITIALIZED
- * // => { code: 'hai:ai:010', httpStatus: 500, system: 'hai', module: 'ai' }
- * ```
- */
-declare const HaiAIError: {
-    readonly INTERNAL_ERROR: _h_ai_core.HaiErrorDef;
-    readonly NOT_INITIALIZED: _h_ai_core.HaiErrorDef;
-    readonly CONFIGURATION_ERROR: _h_ai_core.HaiErrorDef;
-    readonly INIT_IN_PROGRESS: _h_ai_core.HaiErrorDef;
-    readonly RERANK_API_ERROR: _h_ai_core.HaiErrorDef;
-    readonly RERANK_INVALID_REQUEST: _h_ai_core.HaiErrorDef;
-    readonly API_ERROR: _h_ai_core.HaiErrorDef;
-    readonly INVALID_REQUEST: _h_ai_core.HaiErrorDef;
-    readonly RATE_LIMITED: _h_ai_core.HaiErrorDef;
-    readonly TIMEOUT: _h_ai_core.HaiErrorDef;
-    readonly MODEL_NOT_FOUND: _h_ai_core.HaiErrorDef;
-    readonly CONTEXT_LENGTH_EXCEEDED: _h_ai_core.HaiErrorDef;
-    readonly LLM_RECORD_FAILED: _h_ai_core.HaiErrorDef;
-    readonly LLM_HISTORY_FAILED: _h_ai_core.HaiErrorDef;
-    readonly MCP_CONNECTION_ERROR: _h_ai_core.HaiErrorDef;
-    readonly MCP_PROTOCOL_ERROR: _h_ai_core.HaiErrorDef;
-    readonly MCP_TOOL_ERROR: _h_ai_core.HaiErrorDef;
-    readonly MCP_RESOURCE_ERROR: _h_ai_core.HaiErrorDef;
-    readonly MCP_SERVER_ERROR: _h_ai_core.HaiErrorDef;
-    readonly EMBEDDING_API_ERROR: _h_ai_core.HaiErrorDef;
-    readonly EMBEDDING_MODEL_NOT_FOUND: _h_ai_core.HaiErrorDef;
-    readonly EMBEDDING_INPUT_TOO_LONG: _h_ai_core.HaiErrorDef;
-    readonly TOOL_NOT_FOUND: _h_ai_core.HaiErrorDef;
-    readonly TOOL_VALIDATION_FAILED: _h_ai_core.HaiErrorDef;
-    readonly TOOL_EXECUTION_FAILED: _h_ai_core.HaiErrorDef;
-    readonly TOOL_TIMEOUT: _h_ai_core.HaiErrorDef;
-    readonly TOOL_ALREADY_REGISTERED: _h_ai_core.HaiErrorDef;
-    readonly TOOL_FORBIDDEN: _h_ai_core.HaiErrorDef;
-    readonly REASONING_FAILED: _h_ai_core.HaiErrorDef;
-    readonly REASONING_MAX_ROUNDS: _h_ai_core.HaiErrorDef;
-    readonly REASONING_STRATEGY_NOT_FOUND: _h_ai_core.HaiErrorDef;
-    readonly RETRIEVAL_FAILED: _h_ai_core.HaiErrorDef;
-    readonly RETRIEVAL_SOURCE_NOT_FOUND: _h_ai_core.HaiErrorDef;
-    readonly RAG_FAILED: _h_ai_core.HaiErrorDef;
-    readonly RAG_CONTEXT_BUILD_FAILED: _h_ai_core.HaiErrorDef;
-    readonly KNOWLEDGE_SETUP_FAILED: _h_ai_core.HaiErrorDef;
-    readonly KNOWLEDGE_INGEST_FAILED: _h_ai_core.HaiErrorDef;
-    readonly KNOWLEDGE_RETRIEVE_FAILED: _h_ai_core.HaiErrorDef;
-    readonly KNOWLEDGE_ENTITY_EXTRACT_FAILED: _h_ai_core.HaiErrorDef;
-    readonly KNOWLEDGE_NOT_SETUP: _h_ai_core.HaiErrorDef;
-    readonly KNOWLEDGE_COLLECTION_NOT_FOUND: _h_ai_core.HaiErrorDef;
-    readonly MEMORY_EXTRACT_FAILED: _h_ai_core.HaiErrorDef;
-    readonly MEMORY_STORE_FAILED: _h_ai_core.HaiErrorDef;
-    readonly MEMORY_RECALL_FAILED: _h_ai_core.HaiErrorDef;
-    readonly MEMORY_NOT_FOUND: _h_ai_core.HaiErrorDef;
-    readonly MEMORY_ENRICH_FAILED: _h_ai_core.HaiErrorDef;
-    readonly MEMORY_PROMOTE_FAILED: _h_ai_core.HaiErrorDef;
-    readonly PERSONA_NOT_FOUND: _h_ai_core.HaiErrorDef;
-    readonly PERSONA_SAVE_FAILED: _h_ai_core.HaiErrorDef;
-    readonly FILE_PARSE_FAILED: _h_ai_core.HaiErrorDef;
-    readonly FILE_UNSUPPORTED_FORMAT: _h_ai_core.HaiErrorDef;
-    readonly FILE_OCR_FAILED: _h_ai_core.HaiErrorDef;
-    readonly FILE_INVALID_CONTENT: _h_ai_core.HaiErrorDef;
-    readonly AUDIO_INVALID_REQUEST: _h_ai_core.HaiErrorDef;
-    readonly AUDIO_MODEL_NOT_FOUND: _h_ai_core.HaiErrorDef;
-    readonly AUDIO_PROVIDER_NOT_FOUND: _h_ai_core.HaiErrorDef;
-    readonly AUDIO_UNSUPPORTED_INPUT: _h_ai_core.HaiErrorDef;
-    readonly AUDIO_UPSTREAM_ERROR: _h_ai_core.HaiErrorDef;
-    readonly AUDIO_PROTOCOL_ERROR: _h_ai_core.HaiErrorDef;
-    readonly AUDIO_CONNECTION_FAILED: _h_ai_core.HaiErrorDef;
-    readonly AUDIO_TIMEOUT: _h_ai_core.HaiErrorDef;
-    readonly AUDIO_INPUT_TOO_LARGE: _h_ai_core.HaiErrorDef;
-    readonly AUDIO_CANCELLED: _h_ai_core.HaiErrorDef;
-    readonly IMAGE_INVALID_REQUEST: _h_ai_core.HaiErrorDef;
-    readonly IMAGE_MODEL_NOT_FOUND: _h_ai_core.HaiErrorDef;
-    readonly IMAGE_PROVIDER_NOT_FOUND: _h_ai_core.HaiErrorDef;
-    readonly IMAGE_UPSTREAM_ERROR: _h_ai_core.HaiErrorDef;
-    readonly IMAGE_PROTOCOL_ERROR: _h_ai_core.HaiErrorDef;
-    readonly IMAGE_CANCELLED: _h_ai_core.HaiErrorDef;
-    readonly CONTEXT_COMPRESS_FAILED: _h_ai_core.HaiErrorDef;
-    readonly CONTEXT_SUMMARIZE_FAILED: _h_ai_core.HaiErrorDef;
-    readonly CONTEXT_TOKEN_ESTIMATE_FAILED: _h_ai_core.HaiErrorDef;
-    readonly CONTEXT_BUDGET_EXCEEDED: _h_ai_core.HaiErrorDef;
-    readonly CONTEXT_TURN_NOT_FOUND: _h_ai_core.HaiErrorDef;
-    readonly CONTEXT_TURN_INVALID_STATE: _h_ai_core.HaiErrorDef;
-    readonly CONTEXT_BUSY: _h_ai_core.HaiErrorDef;
-    readonly STORE_FAILED: _h_ai_core.HaiErrorDef;
-    readonly STORE_NOT_AVAILABLE: _h_ai_core.HaiErrorDef;
-    readonly SESSION_NOT_FOUND: _h_ai_core.HaiErrorDef;
-    readonly SESSION_FAILED: _h_ai_core.HaiErrorDef;
-    readonly A2A_NOT_CONFIGURED: _h_ai_core.HaiErrorDef;
-    readonly A2A_HANDLE_FAILED: _h_ai_core.HaiErrorDef;
-    readonly A2A_REMOTE_CALL_FAILED: _h_ai_core.HaiErrorDef;
-    readonly A2A_AUTH_FAILED: _h_ai_core.HaiErrorDef;
-    readonly A2A_LIST_MESSAGES_FAILED: _h_ai_core.HaiErrorDef;
-};
-/**
- * AI 初始化运行时选项
- *
- * 用于传入运行时对象（如自定义 StoreProvider），
- * 这些对象无法通过 Zod 配置 Schema 传递。
- */
-interface AIInitOptions {
-    /**
-     * 自定义存储 Provider
-     *
-     * 提供后 AI 模块将使用此 Provider，而不采用自动选择的存储实现。
-     * 未提供时：reldb + vecdb 已初始化则使用持久化 DB Provider，否则使用进程内临时 Provider。
-     */
-    storeProvider?: AIStoreProvider;
-}
-/**
- * AI 服务接口（通过 `ai` 对象访问）
- *
- * 所有 AI 功能的统一入口，需先调用 `init()` 初始化后才能使用 `llm`、`mcp` 操作。
- * `tools` 和 `stream` 为纯函数，无需初始化即可使用。
- *
- * @example
- * ```ts
- * import { ai } from '@h-ai/ai'
- *
- * await ai.init({ llm: { model: 'gpt-4o-mini' } })
- * const result = await ai.llm.chat({ messages: [{ role: 'user', content: '你好' }] })
- * await ai.close()
- * ```
- */
-interface AIFunctions {
-    /**
-     * 初始化 AI 服务
-     *
-     * 使用 Zod Schema 校验配置，失败返回 `CONFIGURATION_ERROR`。
-     * 重复调用会先关闭旧实例再重新初始化。
-     *
-     * @param config - AI 配置（可选，默认使用空对象并应用 Schema 默认值）
-     * @param options - 运行时选项（可选，用于传入自定义 StoreProvider 等运行时对象）
-     * @returns 成功返回 `ok(undefined)`；配置校验失败返回 `err(HaiAIError.CONFIGURATION_ERROR)`
-     */
-    init: (config?: AIConfigInput, options?: AIInitOptions) => Promise<HaiResult<void>>;
-    /**
-     * 关闭 AI 服务，释放内部状态
-     *
-     * 关闭后 `llm`、`mcp` 操作将返回 `NOT_INITIALIZED` 错误。
-     * 重复关闭不会报错。
-     */
-    close: () => Promise<void>;
-    /** 当前脱敏后的配置快照（未初始化时为 `null`） */
-    readonly config: AIConfig | null;
-    /** 是否已初始化（`init()` 成功后为 `true`，`close()` 后为 `false`） */
-    readonly isInitialized: boolean;
-    /** LLM 操作（聊天、流式、模型列表），需要先调用 `init()` */
-    readonly llm: LLMOperations;
-    /** MCP 操作（工具/资源/提示词注册与调用），需要先调用 `init()` */
-    readonly mcp: MCPOperations;
-    /** 工具操作（定义工具与注册表），纯函数，无需初始化 */
-    readonly tools: ToolsOperations;
-    /** 流处理操作（流处理器、SSE 编解码），纯函数，无需初始化 */
-    readonly stream: StreamOperations;
-    /** Embedding 操作（向量嵌入），需要先调用 `init()` */
-    readonly embedding: EmbeddingOperations;
-    /** 推理操作（ReAct / CoT / Plan-Execute），需要先调用 `init()` */
-    readonly reasoning: ReasoningOperations;
-    /** 检索操作（向量检索），需要先调用 `init()` */
-    readonly retrieval: RetrievalOperations;
-    /** RAG 操作（检索增强生成），需要先调用 `init()` */
-    readonly rag: RagOperations;
-    /** Knowledge 操作（知识库管理与检索），需要先调用 `init()` 和 `knowledge.setup()` */
-    readonly knowledge: KnowledgeOperations;
-    /** Memory 操作（记忆提取、存储、检索、注入），需要先调用 `init()` */
-    readonly memory: MemoryOperations;
-    /** Persona 操作（AI 角色人格档案与系统提示词组合），需要先调用 `init()` */
-    readonly persona: PersonaOperations;
-    /** Token 操作（Token 估算），需要先调用 `init()` */
-    readonly token: TokenOperations;
-    /** Summary 操作（消息摘要生成），需要先调用 `init()` */
-    readonly summary: SummaryOperations;
-    /** Compress 操作（上下文压缩），需要先调用 `init()` */
-    readonly compress: CompressOperations;
-    /** Context 操作（有状态上下文管理器，编排 LLM + Memory + RAG + Reasoning），需要先调用 `init()` */
-    readonly context: ContextOperations;
-    /** Rerank 操作（文档重排序），需要先调用 `init()` */
-    readonly rerank: RerankOperations;
-    /** File 操作（文件内容解析），需要先调用 `init()` */
-    readonly file: FileOperations;
-    /** A2A 操作（Agent-to-Agent 协议），需要先调用 `init()` 并配置 `a2a` */
-    readonly a2a: A2AOperations;
-    /** Audio 操作（语音识别 / 语音合成），需要先调用 `init()` 并配置 `audio` */
-    readonly audio: AudioOperations;
-    /** Image 操作（文生图），需要先调用 `init()` 并配置 `image` */
-    readonly image: ImageOperations;
-}
-
-/** @h-ai/ai — 音频播放负载序列化 */
-
-/**
- * 将标准音频内容转换为浏览器可直接播放的 Base64 负载。
- *
- * `synthesize` 只负责统一供应商输出的字节与格式；裸 PCM 没有容器头，
- * 因此这里负责补齐 WAV 头。MP3/WAV 则只进行 Base64 编码，不重新封装。
- */
-declare function serializePlayableAudio(audio: AudioContent): HaiResult<PlayableAudio>;
-
-/** 统一语音入口的默认路径（相对 API 前缀） */
-declare const AUDIO_WS_PATH = "/ai/audio";
-/**
- * 会话起始消息（客户端首个 JSON 帧）
- *
- * 表达本次语音操作：识别或合成，及可选的模型 / 语言 / 音色 / 格式等参数。
- */
-interface AudioWsStartMessage {
-    type: 'start';
-    /** 操作类型 */
-    operation: 'transcribe' | 'synthesize';
-    /**
-     * 是否流式返回增量结果
-     *
-     * 识别操作：`true` 时服务端桥接为持续音频输入并流式返回临时结果；
-     * `false`（默认）时服务端缓冲完整音频后返回单条最终结果。
-     */
-    stream?: boolean;
-    /** 模型 ID（不传时使用服务端默认模型） */
-    model?: string;
-    /** 识别语言提示 */
-    language?: string;
-    /** 领域提示词 / 热词（识别） */
-    contextHints?: string[];
-    /** 合成音色 */
-    voice?: string;
-    /** 合成自然语言风格指令 */
-    instruction?: string;
-    /** 音频格式（识别时为输入格式，合成时为输出格式） */
-    format?: AudioFormat;
-    /** 采样率 */
-    sampleRate?: number;
-    /** 声道数 */
-    channels?: 1 | 2;
-}
-/** 文本输入帧（合成操作时携带待合成文本） */
-interface AudioWsTextMessage {
-    type: 'text';
-    /** 调用方分配的稳定文本段 ID */
-    segmentId: string;
-    /** 待合成文本片段 */
-    text: string;
-}
-/** 输入结束帧（音频 / 文本输入全部发送完毕） */
-interface AudioWsDoneMessage {
-    type: 'done';
-}
-/** 客户端 JSON 控制消息（音频输入以二进制帧发送，不走 JSON） */
-type AudioWsClientMessage = AudioWsStartMessage | AudioWsTextMessage | AudioWsDoneMessage;
-/** 合法音频格式 */
-declare const AudioFormatSchema: zod.ZodEnum<{
-    pcm16: "pcm16";
-    wav: "wav";
-    mp3: "mp3";
-    opus: "opus";
-}>;
-/** 单个字符串控制字段最大长度（model / language / voice / instruction 等） */
-/** 会话起始帧 Schema */
-declare const AudioWsStartMessageSchema: zod.ZodObject<{
-    type: zod.ZodLiteral<"start">;
-    operation: zod.ZodEnum<{
-        transcribe: "transcribe";
-        synthesize: "synthesize";
-    }>;
-    stream: zod.ZodOptional<zod.ZodBoolean>;
-    model: zod.ZodOptional<zod.ZodString>;
-    language: zod.ZodOptional<zod.ZodString>;
-    contextHints: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
-    voice: zod.ZodOptional<zod.ZodString>;
-    instruction: zod.ZodOptional<zod.ZodString>;
-    format: zod.ZodOptional<zod.ZodEnum<{
-        pcm16: "pcm16";
-        wav: "wav";
-        mp3: "mp3";
-        opus: "opus";
-    }>>;
-    sampleRate: zod.ZodOptional<zod.ZodNumber>;
-    channels: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodLiteral<1>, zod.ZodLiteral<2>]>>;
-}, zod_v4_core.$strip>;
-/** 文本输入帧 Schema（segmentId 非空且长度受限） */
-declare const AudioWsTextMessageSchema: zod.ZodObject<{
-    type: zod.ZodLiteral<"text">;
-    segmentId: zod.ZodString;
-    text: zod.ZodString;
-}, zod_v4_core.$strip>;
-/** 输入结束帧 Schema */
-declare const AudioWsDoneMessageSchema: zod.ZodObject<{
-    type: zod.ZodLiteral<"done">;
-}, zod_v4_core.$strip>;
-/** 客户端 JSON 控制消息 Schema（按 type 判别） */
-declare const AudioWsClientMessageSchema: zod.ZodDiscriminatedUnion<[zod.ZodObject<{
-    type: zod.ZodLiteral<"start">;
-    operation: zod.ZodEnum<{
-        transcribe: "transcribe";
-        synthesize: "synthesize";
-    }>;
-    stream: zod.ZodOptional<zod.ZodBoolean>;
-    model: zod.ZodOptional<zod.ZodString>;
-    language: zod.ZodOptional<zod.ZodString>;
-    contextHints: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
-    voice: zod.ZodOptional<zod.ZodString>;
-    instruction: zod.ZodOptional<zod.ZodString>;
-    format: zod.ZodOptional<zod.ZodEnum<{
-        pcm16: "pcm16";
-        wav: "wav";
-        mp3: "mp3";
-        opus: "opus";
-    }>>;
-    sampleRate: zod.ZodOptional<zod.ZodNumber>;
-    channels: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodLiteral<1>, zod.ZodLiteral<2>]>>;
-}, zod_v4_core.$strip>, zod.ZodObject<{
-    type: zod.ZodLiteral<"text">;
-    segmentId: zod.ZodString;
-    text: zod.ZodString;
-}, zod_v4_core.$strip>, zod.ZodObject<{
-    type: zod.ZodLiteral<"done">;
-}, zod_v4_core.$strip>], "type">;
-/** 语音起止事件（识别操作时服务端 VAD 检测到语音开始 / 结束） */
-interface AudioWsSpeechMessage {
-    type: 'speech_started' | 'speech_stopped';
-}
-/** 识别结果帧（识别操作时返回当前语句的完整文本） */
-interface AudioWsTranscriptMessage {
-    type: 'transcript';
-    /** 当前语句的完整识别文本 */
-    text: string;
-    /** 是否为该语句的最终结果 */
-    final: boolean;
-}
-/**
- * 合成文本段开始；后续二进制帧均属于该段，直到收到对应的 `segment_done`。
- *
- * 携带服务端解析 Provider 后的真实输出音频参数，供浏览器正确标注音频格式。
- */
-interface AudioWsSegmentStartedMessage {
-    type: 'segment_started';
-    segmentId: string;
-    text: string;
-    /** 真实输出音频格式（来自服务端解析后的 Provider 输出，非客户端请求参数） */
-    format: AudioFormat;
-    /** 采样率（Hz）；pcm16 等裸音频必填 */
-    sampleRate?: number;
-    /** 声道数（默认单声道） */
-    channels?: 1 | 2;
-}
-/** 合成文本段的音频已全部发送。 */
-interface AudioWsSegmentDoneMessage {
-    type: 'segment_done';
-    segmentId: string;
-}
-/** 错误帧（领域语义错误码，不暴露厂商协议细节） */
-interface AudioWsErrorMessage {
-    type: 'error';
-    /** 领域错误码（如 `hai:ai:054`） */
-    code: string;
-    /** 错误消息 */
-    message: string;
-}
-/** 结束帧（服务端已发送全部结果，随后关闭连接） */
-interface AudioWsEndMessage {
-    type: 'end';
-}
-/** 服务端 JSON 消息（合成音频以二进制帧返回，不走 JSON） */
-type AudioWsServerMessage = AudioWsSpeechMessage | AudioWsTranscriptMessage | AudioWsSegmentStartedMessage | AudioWsSegmentDoneMessage | AudioWsErrorMessage | AudioWsEndMessage;
-
-export { type FileParseOptions as $, type AIFunctions as A, type CompressResult as B, type CompressionStrategy as C, type ConsolidateOptions as D, type ConsolidateResult as E, type ContextChatOptions as F, type GenerateImageRequest as G, HaiAIError as H, type ImageOperations as I, type ContextChatResult as J, type ContextDeps as K, type ContextManager as L, type McpServerOptions as M, type ContextManagerOptions as N, type ContextOperations as O, type ContextResetOptions as P, type ContextStreamEvent as Q, type ReferenceImage as R, type ConversationTurn as S, type ConversationTurnStatus as T, type EmbeddingItem as U, type EmbeddingOperations as V, type EmbeddingProvider as W, type EmbeddingRequest as X, type EmbeddingResponse as Y, type FileOperations as Z, type FileParseMethod as _, type AIInitOptions as a, type FileParseRequest as a0, type FileParseResult as a1, type MCPContext as a2, type MCPOperations as a3, type MCPPrompt as a4, type MCPPromptArgument as a5, type MCPPromptContent as a6, type MCPPromptMessage as a7, type MCPResource as a8, type MCPResourceContent as a9, type MCPToolDefinition as aa, type MCPToolHandler as ab, type OutputFormat as ac, type PersonaOperations as ad, type PersonaProfile as ae, type PersonaProfileInput as af, type PersonaProfileUpdate as ag, type PersonaScopeOptions as ah, type RerankDocument as ai, type RerankItem as aj, type RerankOperations as ak, type RerankRequest as al, type RerankResponse as am, type SummaryOperations as an, type SummaryOptions as ao, type SummaryResult as ap, type TokenOperations as aq, AUDIO_WS_PATH as b, AudioFormatSchema as c, type AudioWsClientMessage as d, AudioWsClientMessageSchema as e, type AudioWsDoneMessage as f, AudioWsDoneMessageSchema as g, type AudioWsEndMessage as h, type AudioWsErrorMessage as i, type AudioWsSegmentDoneMessage as j, type AudioWsSegmentStartedMessage as k, type AudioWsServerMessage as l, type AudioWsSpeechMessage as m, type AudioWsStartMessage as n, AudioWsStartMessageSchema as o, type AudioWsTextMessage as p, AudioWsTextMessageSchema as q, type AudioWsTranscriptMessage as r, CompressionStrategySchema as s, type GenerateImageResult as t, type GeneratedImage as u, type ImageSize as v, serializePlayableAudio as w, type CommitTurnInput as x, type CompressOperations as y, type CompressOptions as z };