@blade-hq/agent-client 2610.0.1-alpha.1 → 2610.0.2

package/dist/session/queue.d.ts

@@ -0,0 +1,104 @@
+/**
+ * 会话消息队列的共享领域模型：类型、快照合并规则与中文文案。
+ *
+ * 这里是**单一定义处**：AgentSession 的状态机、agent-react 与内置 Web 的队列 UI
+ * 都只用这一份判定，避免"能不能编辑 / 旧快照要不要覆盖"各写一遍后各自演进。
+ * 服务端语义见 issue #2529 与 local://frontend-queue-contract.md。
+ */
+/** 等待消息的服务端生命周期状态。 */
+export type QueuedMessageStatus = "pending" | "delivering" | "claimed" | "consumed" | "cancelled";
+/** 队列里的一条等待消息；权威快照只包含 pending（等待执行）与 delivering（等待接收）。 */
+export interface QueuedMessage {
+    id: string;
+    content: string;
+    position: number;
+    version: number;
+    status: QueuedMessageStatus;
+    created_at: string;
+    updated_at: string;
+    /** 立即补充指向的当前运行 id；普通等待条目没有。 */
+    target_run_id?: string;
+    /** 领取或投递失败的原因。 */
+    error?: string;
+}
+/** 服务端权威队列快照。`revision` 单调递增，客户端据此丢弃过期快照。 */
+export interface SessionQueueSnapshot {
+    session_id: string;
+    revision: number;
+    paused: boolean;
+    pause_reason: string | null;
+    items: QueuedMessage[];
+}
+/**
+ * 还没有拿到服务端快照时的占位。
+ *
+ * `session_id` 为空表示"身份未知"：`shouldApplySnapshot` 会跳过会话身份校验、
+ * 只比较 revision，这样第一份快照（哪怕 revision 为 0 的暂停态）也能装进来。
+ */
+export declare const EMPTY_SESSION_QUEUE: SessionQueueSnapshot;
+/**
+ * 队列命令的 ack 线格式。
+ *
+ * `conflict` 表示乐观并发或状态校验失败，此时快照字段是服务端最新值，客户端必须
+ * 据此刷新本地并保留用户草稿；`error` 时快照字段可能缺失（如鉴权失败），此时只报错、
+ * 不改动本地队列。
+ */
+export interface QueueAck {
+    /** `queued` 只出现在 `chat:send` 的运行中改道：消息已进等待队列，不是失败。 */
+    status: "ok" | "conflict" | "error" | "queued";
+    /**
+     * 只有 `queued` 会带：服务端判定这次改道时该会话是否有运行。
+     * 客户端据此对齐流式标记，不用自己的猜测。
+     */
+    running?: boolean;
+    message?: string | null;
+    session_id?: string;
+    revision?: number;
+    paused?: boolean;
+    pause_reason?: string | null;
+    items?: QueuedMessage[];
+}
+/** 解析后的队列操作结果；UI 只看这一个结构。 */
+export interface QueueOperationResult {
+    ok: boolean;
+    conflict: boolean;
+    /** 服务端快照；缺失时为 null，调用方不得据此清空本地队列。 */
+    snapshot: SessionQueueSnapshot | null;
+    message: string | null;
+    /**
+     * 服务端给的机器可读失败原因（如 `owner_timeout` / `route_broken` / `owner_busy`），
+     * 供调用方决定要不要重试；`message` 是可以直接展示的业务文案。
+     */
+    code?: string;
+}
+/** 判定一份载荷是不是完整的权威队列快照（广播事件用）。 */
+export declare function isSessionQueueSnapshot(value: unknown): value is SessionQueueSnapshot;
+/**
+ * 是否用 `next` 覆盖 `current`。
+ *
+ * 规则只有两条：会话身份必须一致（还没拿到过快照时不校验），且 revision 必须严格
+ * 更新——相等或更旧一律不采纳，乱序到达的旧快照不会把新状态顶回去。
+ */
+export declare function shouldApplySnapshot(current: SessionQueueSnapshot | undefined, next: SessionQueueSnapshot): boolean;
+/**
+ * 解析 `emitWithAck` 的返回值。
+ *
+ * - `ok` / `queued` / `conflict` 且能解析成快照 → `snapshot` 有值；
+ * - `queued` → `ok=true`：`chat:send` 在运行中改道进了等待队列，调用方要撤掉乐观消息；
+ * - `conflict` → `ok=false, conflict=true`（快照可能仍缺失，调用方按 null 处理）；
+ * - `error` 或结构不合法 → `ok=false, conflict=false`，`message` 为服务端文案或兜底。
+ */
+export declare function parseQueueAck(response: unknown, fallbackSessionId: string): QueueOperationResult;
+/** 等待中的条目才能改正文；已经交给运行或开始执行的条目不再可编辑。 */
+export declare function canEditQueuedMessage(item: QueuedMessage): boolean;
+/** 等待中的条目才能删除。 */
+export declare function canCancelQueuedMessage(item: QueuedMessage): boolean;
+/**
+ * 能否立即补充。条目本身必须是等待中的；"会话是否正在运行"由调用方判断——
+ * 服务端会在没有可接收补充的任务时返回冲突。
+ */
+export declare function canDeliverQueuedMessage(item: QueuedMessage): boolean;
+/** 面向前端展示的状态文案；已离开队列视图的状态没有文案。 */
+export declare function queuedMessageStatusLabel(status: QueuedMessageStatus): string;
+/** 暂停原因文案；未知原因原样透出，没有原因返回 null。 */
+export declare function queuePauseReasonLabel(reason: string | null | undefined): string | null;

package/dist/session/state.d.ts

@@ -1,10 +1,13 @@
 import type { ChatMessage, CompactionInfo, MessageContent } from "../schemas/message";
 import type { ContentBlock, PatchEnvelope, TurnProjection } from "../schemas/projection";
 import type { ReplaySpeed, ReplayState, SessionStatus } from "../schemas/session";
-/** 一次 AskUserQuestion 的用户作答（选项选择 + 自定义输入）。 */
+import { type SessionQueueSnapshot } from "./queue";
+/** 一次 AskUserQuestion 的用户作答（选项选择 + 自定义输入 + 可选补充）。 */
 export interface AskUserAnswerData {
     selections: Record<number, number[]>;
     custom: Record<number, string>;
+    /** 选完选项后的自由补充，空着就是没有。 */
+    note?: string;
 }
 export interface AgentLoopInfo {
     toolCallId: string;
@@ -41,8 +44,13 @@ export interface SessionState {
     activeCompaction: ActiveCompactionState | null;
     /** 回放（演示 / 彩排）状态；不是回放会话时为 null。 */
     replay: ReplaySnapshot | null;
+    /** 服务端持久化的等待消息队列快照；只在 revision 更新时替换。 */
+    queue: SessionQueueSnapshot;
     /** 当前身份对这个会话的权限；"viewer" 表示只读（分享链接打开的）。 */
     viewerRole: "owner" | "viewer" | null;
+    /** Stable anchor for the next older projected page. */
+    nextBefore: string | null;
+    loadingOlder: boolean;
 }
 /** 回放会话的快照视图，由服务端的 replay_state 归一化而来。 */
 export interface ReplaySnapshot {
@@ -55,6 +63,10 @@ export interface ReplaySnapshot {
 export declare function toReplaySnapshot(raw: ReplayState | null | undefined): ReplaySnapshot | null;
 export declare function createInitialSessionState(sessionId: string): SessionState;
 export declare function extractModeFromBlocks(blocks: ContentBlock[]): "planning" | "executing" | null;
+export declare function reconcileOptimisticUserTurns(currentTurns: TurnProjection[], incomingTurns: TurnProjection[]): TurnProjection[];
+/** Reconcile a bulk authoritative window only by an echoed request identity.
+ * Positional fallback is reserved for a single live turn from an older server. */
+export declare function reconcileHistoricalUserTurns(currentTurns: TurnProjection[], incomingTurns: TurnProjection[]): TurnProjection[];
 /**
  * 用一份新的 turn 列表重建会话状态。
  * addErrorMessage 注入的 role==="error" 消息不在 turns 里，默认会被物化过程抹掉；
@@ -62,7 +74,12 @@ export declare function extractModeFromBlocks(blocks: ContentBlock[]): "planning
  * turn 推进（新消息 / rewind / 重连）时旧错误自动消失。
  */
 export declare function withTurns(state: SessionState, turns: TurnProjection[]): SessionState;
-export declare function addUserMessage(state: SessionState, content: MessageContent): SessionState;
+/**
+ * 安装一份服务端权威队列快照。旧 revision、别的会话或结构不合法的快照一律不采纳，
+ * 直接返回原 state——引用不变，订阅者不会收到多余通知。
+ */
+export declare function withQueue(state: SessionState, snapshot: SessionQueueSnapshot): SessionState;
+export declare function addUserMessage(state: SessionState, content: MessageContent, clientRequestId?: string): SessionState;
 export declare function upsertTurn(state: SessionState, turn: TurnProjection): SessionState;
 export declare function applyTurnPatch(state: SessionState, patch: PatchEnvelope): SessionState;
 export declare function addErrorMessage(state: SessionState, content: string): SessionState;

package/dist/shared/auth-busy.d.ts

@@ -0,0 +1,9 @@
+/** Return the server-requested delay for a typed temporary auth rejection. */
+export declare function authBusyRetryDelayMs(error: unknown): number | null;
+/** One pending manual reconnect for Socket.IO CONNECT_ERROR auth overloads. */
+export declare class AuthBusyReconnect {
+    private timer;
+    get pending(): boolean;
+    schedule(error: unknown, reconnect: () => void): boolean;
+    cancel(): void;
+}

package/dist/shared/projection/builder.d.ts

@@ -3,6 +3,8 @@ export interface RawEvent {
     type: string;
     payload: Record<string, unknown>;
 }
+/** 在任何事件处理前确认 Socket.IO 批次已到达客户端。 */
+export declare function acknowledgeTurnEvents(acknowledge?: () => void): void;
 export type ProjectionUpdate = {
     kind: "upsert";
     turn: TurnProjection;
@@ -13,11 +15,21 @@ export type ProjectionUpdate = {
     toolName?: string;
     workspacePath?: string;
 };
+/** 是否包含会改变聊天运行生命周期的事件。纯观测/整理事件不启动新一轮。 */
+export declare function hasChatRunEvent(events: RawEvent[]): boolean;
+/**
+ * 缺失 chat:end 时的终态兜底。只有被投影接受到当前 assistant turn 的 followup
+ * 才能结束流式态；陈旧 followup 或其后已有新轮事件时均返回 false。
+ */
+export declare function acceptedPostChatFollowupCompletesLatestRun(events: RawEvent[], updates: ProjectionUpdate[]): boolean;
 export declare class ClientProjectionBuilder {
     private activeTurns;
     private lastTurnIds;
     private latestTurns;
+    private turnsById;
     private loopDescriptions;
+    /** loop_name → 正在运行的子智能体起点，agent:end 结算并挂到父工具调用上。 */
+    private activeSubagentRuns;
     private pendingChildPauses;
     private pendingMemoryRefs;
     private activeCompactions;
@@ -32,6 +44,7 @@ export declare class ClientProjectionBuilder {
     seedSequence(maxSeq: number): void;
     _seedTurns(turns: TurnProjection[]): void;
     private onMemoryInject;
+    private onContextEntry;
     private onLoopTurn;
     private onModeChange;
     private onPlanStatusUpdate;
@@ -44,7 +57,10 @@ export declare class ClientProjectionBuilder {
     private onPostChatFollowup;
     private onDelta;
     private onToolCallCreated;
+    private onToolCallArgumentsDelta;
     private onResponseDone;
+    private applyFirstTokenDelivery;
+    private applyStreamTiming;
     private onToolResultDone;
     private onToolResultDelta;
     private onToolUi;
@@ -53,6 +69,7 @@ export declare class ClientProjectionBuilder {
     private onChildPause;
     private onChatEnd;
     private onAgentEnd;
+    private settleSubagentRun;
     private dropIncompleteToolCalls;
     private onCompaction;
     private syncPatch;

package/dist/shared/projection/context.d.ts

@@ -0,0 +1,3 @@
+import type { TurnProjection } from "../../schemas/projection";
+/** Build one Context turn from the canonical entry used by live and history paths. */
+export declare function buildContextTurn(entry: Record<string, unknown>, sequence: number): TurnProjection | null;

package/dist/shared/projection/helpers.d.ts

@@ -1,10 +1,10 @@
 import type { ContentBlock, PendingQuestionRef, ToolCallProjection, TurnProjection } from "../../schemas/projection";
 import type { TurnState } from "./state";
 export declare function upsertToolCall(state: TurnState, toolCallId: string, toolName: string, displayName: string, args: string): void;
-export declare function applyToolResult(state: TurnState, toolCallId: string, result: unknown, status: ToolCallProjection["status"], durationMs: number | null, sourceLoop: {
+export declare function applyToolResult(state: TurnState, toolCallId: string, result: unknown, status: ToolCallProjection["status"], durationMs: number | null, ranInParallel: boolean | null, sourceLoop: {
     loop_name: string;
     description: string;
-} | null): void;
+} | null, startedAt?: string | null): void;
 export declare function appendToolResultDelta(state: TurnState, toolCallId: string, delta: string, reset?: boolean): void;
 export declare function appendTextBlock(state: TurnState, blockType: ContentBlock["type"], content: unknown): void;
 export declare function appendToolCallArguments(state: TurnState, toolCallId: string, delta: string): void;
@@ -42,6 +42,8 @@ export declare function normalizePostChatFollowup(data: Record<string, unknown>,
     recaption: string;
     suggestions: string[];
     final_artifacts: FinalArtifact[];
+    feedback_eligible: boolean;
+    feedback_scope: "latest_result";
 } | null;
 export declare function normalizeChildPause(pausePayload: Record<string, unknown>): {
     pauseToolData: Record<string, unknown>;

package/dist/shared/projection/history.d.ts

@@ -4,6 +4,7 @@ export interface RawHistoryEntry {
     kind?: string;
     loop_name?: string;
     message?: Record<string, unknown>;
+    source?: Record<string, unknown>;
     data?: Record<string, unknown>;
     timestamp?: string;
     [key: string]: unknown;

package/dist/shared/projection/index.d.ts

@@ -1,3 +1,4 @@
-export { ClientProjectionBuilder, type RawEvent, type ProjectionUpdate } from "./builder";
+export { acceptedPostChatFollowupCompletesLatestRun, acknowledgeTurnEvents, ClientProjectionBuilder, hasChatRunEvent, type RawEvent, type ProjectionUpdate, } from "./builder";
 export { type TurnState, createTurnState, snapshot, PAUSE_TOOL_NAMES } from "./state";
 export { projectHistory, type RawHistoryEntry } from "./history";
+export { buildContextTurn } from "./context";

package/dist/shared/projection/state.d.ts

@@ -10,6 +10,13 @@ export interface TurnState {
     toolCalls: ToolCallProjection[];
     usage: Record<string, unknown> | null;
     responseDone: boolean;
+    firstTokenMs: number | null;
+    streamDurationMs: number | null;
+    firstTokenDeliveryMs: number | null;
+    /** 生产者上报的模型请求时序；缺失时保持 null，不用浏览器时间补（#2581 A1/I1）。 */
+    modelStartedAt: string | null;
+    modelDurationMs: number | null;
+    modelStartedAtReported: boolean;
     memoryRefs: MemoryRef[] | null;
     parentForkToolCallId: string | null;
 }

package/dist/shared/tool-ui-card.d.ts

@@ -0,0 +1,60 @@
+import type { ChatMessage, ToolCallInfo } from "../schemas/message";
+import type { ContentBlock } from "../schemas/projection";
+import { type McpAppData } from "../schemas/mcp-app";
+/**
+ * MCP App 卡片（`_meta.ui` → `tool_ui` block）的共享判定层。
+ *
+ * 判定逻辑不许各写一份（仓库 CLAUDE.md）：agent-react 与 apps/web 都从这里消费卡片的
+ * 实例、可见性、身份和终态规则；样式与状态容器（侧栏页签栈等）两侧各自实现。
+ */
+export interface ToolUiCard {
+    resourceUri?: string;
+    resourceURI?: string;
+    resourceHTML?: string;
+    /** Local HTML source file; hosts can normalize it against the session workspace. */
+    sourcePath?: string;
+    /** 历史投影标记：绝不重新解析 resourceUri（刷新不重放 MCP/资源读取）。 */
+    archived?: boolean;
+    target: "inline" | "preview";
+    height: number;
+    title?: string;
+    /** 留档的 MCP App 来源身份与调用数据（来源 server、ui:// 资源、CSP 元数据）。 */
+    mcpApp?: McpAppData;
+}
+/** 严格守卫：target/height 缺失、archived 无留档 HTML、或 mcpApp 来源身份残缺的
+ * 卡片一律判无效，消息流、侧栏、toolPreview 事件三处一致降级（不渲染、不发事件、
+ * 不推送）。后端 `_tool_ui_meta.py` 总会补齐 target/height 默认值，判无效即数据畸形。 */
+export declare function isToolUiCard(value: unknown): value is ToolUiCard;
+export type ToolUiCardContentType = "resource-html" | "resource-uri" | "resource-file";
+/** 解析卡片实际要渲染的内容。archived 卡片只认留档 HTML，绝不回退到
+ * resourceUri——历史恢复/浏览器刷新不得因此重新发起 MCP 资源读取。 */
+export declare function resolveToolUiCardContent(card: ToolUiCard): {
+    type: ToolUiCardContentType;
+    content: string;
+} | null;
+/** 卡片实例身份/去重键：uri 卡片按内容去重（同一 URI 多次产出只留一份），
+ * 文件 HTML 按来源路径，无来源的 HTML 按 toolCallId 去重。 */
+export declare function buildToolUiCardKey(toolCallId: string, type: ToolUiCardContentType, content: string, sourcePath?: string): string;
+/** 内部「阶段进度」卡片不对用户展示入口。 */
+export declare function isInternalStatusToolUiCard(card: {
+    title?: string | null;
+} | null): boolean;
+/** app-dev 会话里的应用预览卡片：走专门的预览页签，不开普通侧栏 artifact。 */
+export declare function isAppDevToolUiCard(card: ToolUiCard, isAppDev: boolean): boolean;
+export interface InlineToolUiCardEntry {
+    key: string;
+    toolCallId: string;
+    card: ToolUiCard;
+}
+/** 从一轮消息里收集 target=inline 的卡片（渲染进消息流）。 */
+export declare function collectInlineToolUiCards(messages: ChatMessage[]): InlineToolUiCardEntry[];
+export interface PreviewToolUiCardEntry {
+    key: string;
+    toolCall: ToolCallInfo;
+    card: ToolUiCard;
+    /** 所属消息的 blocks；调用方需要还原卡片所在 block 上下文时用。 */
+    blocks: ContentBlock[];
+}
+/** 从一轮消息里收集 target=preview 的卡片（进侧栏/面板，不进消息流），
+ * 并绑定回所属的 toolCall。 */
+export declare function collectPreviewToolUiCards(messages: ChatMessage[]): PreviewToolUiCardEntry[];

package/dist/shared/type-guards.d.ts

@@ -0,0 +1,2 @@
+/** Return true for non-null, non-array objects. */
+export declare function isRecord(value: unknown): value is Record<string, unknown>;

package/dist/socket.d.ts

@@ -4,6 +4,8 @@ import type { ClientToServerEvents, ServerToClientEvents } from "./types/socket-
 export type TypedSocket = Socket<ServerToClientEvents, ClientToServerEvents>;
 export interface CreateSocketOptions extends AuthOptions {
     baseUrl: string;
+    /** MV3 service workers have WebSocket but no XMLHttpRequest. */
+    transports?: ("polling" | "websocket")[];
     path?: string;
 }
 export declare function createSocket(options: CreateSocketOptions): TypedSocket;

package/dist/types/socket-events.d.ts

@@ -32,6 +32,9 @@ export declare namespace ChatSendPayloadSchema {
         [k: string]: unknown;
     } | null);
     type CompactionRatio = (number | null);
+    type NativeApprovalPolicy = (("unlessTrusted" | "never") | null);
+    type KbIds = (number[] | null);
+    type QueueWhenRunning = boolean;
     interface ChatSendPayload {
         session_id: SessionId;
         message: Message;
@@ -48,6 +51,9 @@ export declare namespace ChatSendPayloadSchema {
         runtime_env?: RuntimeEnv;
         app_context?: AppContext;
         compaction_ratio?: CompactionRatio;
+        native_approval_policy?: NativeApprovalPolicy;
+        kb_ids?: KbIds;
+        queue_when_running?: QueueWhenRunning;
         [k: string]: unknown;
     }
     interface Message {
@@ -72,9 +78,11 @@ export type ChatStopPayload = ChatStopPayloadSchema.ChatStopPayload;
 export declare namespace ChatAppendPayloadSchema {
     type SessionId = string;
     type Message = string;
+    type ClientRequestId = (string | null);
     interface ChatAppendPayload {
         session_id: SessionId;
         message: Message;
+        client_request_id?: ClientRequestId;
         [k: string]: unknown;
     }
 }
@@ -87,6 +95,72 @@ export declare namespace ChatCompactPayloadSchema {
     }
 }
 export type ChatCompactPayload = ChatCompactPayloadSchema.ChatCompactPayload;
+export declare namespace ChatQueueListPayloadSchema {
+    type SessionId = string;
+    interface ChatQueueListPayload {
+        session_id: SessionId;
+        [k: string]: unknown;
+    }
+}
+export type ChatQueueListPayload = ChatQueueListPayloadSchema.ChatQueueListPayload;
+export declare namespace ChatQueueUpdatePayloadSchema {
+    type SessionId = string;
+    type ItemId = string;
+    type ExpectedVersion = number;
+    type Message = string;
+    interface ChatQueueUpdatePayload {
+        session_id: SessionId;
+        item_id: ItemId;
+        expected_version: ExpectedVersion;
+        message: Message;
+        [k: string]: unknown;
+    }
+}
+export type ChatQueueUpdatePayload = ChatQueueUpdatePayloadSchema.ChatQueueUpdatePayload;
+export declare namespace ChatQueueReorderPayloadSchema {
+    type SessionId = string;
+    type ExpectedRevision = number;
+    type OrderedIds = string[];
+    interface ChatQueueReorderPayload {
+        session_id: SessionId;
+        expected_revision: ExpectedRevision;
+        ordered_ids: OrderedIds;
+        [k: string]: unknown;
+    }
+}
+export type ChatQueueReorderPayload = ChatQueueReorderPayloadSchema.ChatQueueReorderPayload;
+export declare namespace ChatQueueCancelPayloadSchema {
+    type SessionId = string;
+    type ItemId = string;
+    type ExpectedVersion = (number | null);
+    interface ChatQueueCancelPayload {
+        session_id: SessionId;
+        item_id: ItemId;
+        expected_version?: ExpectedVersion;
+        [k: string]: unknown;
+    }
+}
+export type ChatQueueCancelPayload = ChatQueueCancelPayloadSchema.ChatQueueCancelPayload;
+export declare namespace ChatQueueDeliverPayloadSchema {
+    type SessionId = string;
+    type ItemId = string;
+    type ExpectedVersion = number;
+    interface ChatQueueDeliverPayload {
+        session_id: SessionId;
+        item_id: ItemId;
+        expected_version: ExpectedVersion;
+        [k: string]: unknown;
+    }
+}
+export type ChatQueueDeliverPayload = ChatQueueDeliverPayloadSchema.ChatQueueDeliverPayload;
+export declare namespace ChatQueueResumePayloadSchema {
+    type SessionId = string;
+    interface ChatQueueResumePayload {
+        session_id: SessionId;
+        [k: string]: unknown;
+    }
+}
+export type ChatQueueResumePayload = ChatQueueResumePayloadSchema.ChatQueueResumePayload;
 export declare namespace SessionSubscribePayloadSchema {
     type SessionId = string;
     type Mode = string;
@@ -154,8 +228,10 @@ export declare namespace AgentBoardProjectUnsubscribePayloadSchema {
 export type AgentBoardProjectUnsubscribePayload = AgentBoardProjectUnsubscribePayloadSchema.AgentBoardProjectUnsubscribePayload;
 export declare namespace ChatStartPayloadSchema {
     type SessionId = (string | null);
+    type ChatRunId = (string | null);
     interface ChatStartPayload {
         session_id?: SessionId;
+        chat_run_id?: ChatRunId;
         [k: string]: unknown;
     }
 }
@@ -177,7 +253,54 @@ export declare namespace ChatEndPayloadSchema {
     }
 }
 export type ChatEndPayload = ChatEndPayloadSchema.ChatEndPayload;
+export declare namespace ChatQueueUpdatedPayloadSchema {
+    type SessionId = string;
+    type Revision = number;
+    type Paused = boolean;
+    type PauseReason = (string | null);
+    type Id = string;
+    type Content = string;
+    type Position = number;
+    type Version = number;
+    type Status = string;
+    type CreatedAt = string;
+    type UpdatedAt = string;
+    type TargetRunId = (string | null);
+    type Error = (string | null);
+    type Items = ChatQueueItem[];
+    interface ChatQueueUpdatedPayload {
+        session_id: SessionId;
+        revision: Revision;
+        paused?: Paused;
+        pause_reason?: PauseReason;
+        items?: Items;
+        [k: string]: unknown;
+    }
+    interface ChatQueueItem {
+        id: Id;
+        content: Content;
+        position: Position;
+        version: Version;
+        status: Status;
+        created_at: CreatedAt;
+        updated_at: UpdatedAt;
+        target_run_id?: TargetRunId;
+        error?: Error;
+        [k: string]: unknown;
+    }
+}
+export type ChatQueueUpdatedPayload = ChatQueueUpdatedPayloadSchema.ChatQueueUpdatedPayload;
+export declare namespace SessionCreatedPayloadSchema {
+    type SessionId = string;
+    interface SessionCreatedPayload {
+        session_id: SessionId;
+        [k: string]: unknown;
+    }
+}
+export type SessionCreatedPayload = SessionCreatedPayloadSchema.SessionCreatedPayload;
 export declare namespace SessionUpdatedPayloadSchema {
+    type WorkspacePath = (string | null);
+    type ChatGroupId = (string | null);
     type SessionId = string;
     type Model = (string | null);
     type ReplayState = ({
@@ -187,6 +310,8 @@ export declare namespace SessionUpdatedPayloadSchema {
     type ProjectId = (number | null);
     type ProjectName = (string | null);
     interface SessionUpdatedPayload {
+        workspace_path?: WorkspacePath;
+        chat_group_id?: ChatGroupId;
         session_id: SessionId;
         model?: Model;
         replay_state?: ReplayState;
@@ -207,6 +332,16 @@ export declare namespace WorkspaceFilesChangedPayloadSchema {
     }
 }
 export type WorkspaceFilesChangedPayload = WorkspaceFilesChangedPayloadSchema.WorkspaceFilesChangedPayload;
+export declare namespace MCPAppChangedPayloadSchema {
+    type SessionId = string;
+    type SourceId = string;
+    interface MCPAppChangedPayload {
+        session_id: SessionId;
+        source_id: SourceId;
+        [k: string]: unknown;
+    }
+}
+export type MCPAppChangedPayload = MCPAppChangedPayloadSchema.MCPAppChangedPayload;
 export declare namespace SystemErrorPayloadSchema {
     type Message = string;
     type SessionId = (string | null);
@@ -264,6 +399,20 @@ export declare namespace TurnEventsPayloadSchema {
     }
 }
 export type TurnEventsPayload = TurnEventsPayloadSchema.TurnEventsPayload;
+export declare namespace TurnTimingPayloadSchema {
+    type SessionId = string;
+    type LoopName = string;
+    type TurnId = string;
+    type FirstTokenDeliveryMs = number;
+    interface TurnTimingPayload {
+        session_id: SessionId;
+        loop_name: LoopName;
+        turn_id: TurnId;
+        first_token_delivery_ms: FirstTokenDeliveryMs;
+        [k: string]: unknown;
+    }
+}
+export type TurnTimingPayload = TurnTimingPayloadSchema.TurnTimingPayload;
 export declare namespace AsrReadyPayloadSchema {
     type RequestId = string;
     type Provider = string;
@@ -380,11 +529,58 @@ export declare namespace ChatCompactAckSchema {
     }
 }
 export type ChatCompactAck = ChatCompactAckSchema.ChatCompactAck;
+export declare namespace ChatQueueAckSchema {
+    type SessionId = string;
+    type Revision = number;
+    type Paused = boolean;
+    type PauseReason = (string | null);
+    type Id = string;
+    type Content = string;
+    type Position = number;
+    type Version = number;
+    type Status = string;
+    type CreatedAt = string;
+    type UpdatedAt = string;
+    type TargetRunId = (string | null);
+    type Error = (string | null);
+    type Items = ChatQueueItem[];
+    type Status1 = string;
+    type Message = (string | null);
+    interface ChatQueueAck {
+        session_id: SessionId;
+        revision: Revision;
+        paused?: Paused;
+        pause_reason?: PauseReason;
+        items?: Items;
+        status?: Status1;
+        message?: Message;
+        [k: string]: unknown;
+    }
+    interface ChatQueueItem {
+        id: Id;
+        content: Content;
+        position: Position;
+        version: Version;
+        status: Status;
+        created_at: CreatedAt;
+        updated_at: UpdatedAt;
+        target_run_id?: TargetRunId;
+        error?: Error;
+        [k: string]: unknown;
+    }
+}
+export type ChatQueueAck = ChatQueueAckSchema.ChatQueueAck;
 export interface ClientToServerEvents {
     "chat:send": (payload: ChatSendPayload, ack: (response: ChatSendAck) => void) => void;
     "chat:stop": (payload: ChatStopPayload, ack: (response: ChatStopAck) => void) => void;
-    "chat:append": (payload: ChatAppendPayload) => void;
+    "chat:append": (payload: ChatAppendPayload, ack: (response: ChatQueueAck) => void) => void;
     "chat:compact": (payload: ChatCompactPayload, ack: (response: ChatCompactAck) => void) => void;
+    "chat:queue:list": (payload: ChatQueueListPayload, ack: (response: ChatQueueAck) => void) => void;
+    "chat:queue:update": (payload: ChatQueueUpdatePayload, ack: (response: ChatQueueAck) => void) => void;
+    "chat:queue:reorder": (payload: ChatQueueReorderPayload, ack: (response: ChatQueueAck) => void) => void;
+    "chat:queue:cancel": (payload: ChatQueueCancelPayload, ack: (response: ChatQueueAck) => void) => void;
+    "chat:queue:deliver": (payload: ChatQueueDeliverPayload, ack: (response: ChatQueueAck) => void) => void;
+    "chat:queue:resume": (payload: ChatQueueResumePayload, ack: (response: ChatQueueAck) => void) => void;
     "session:subscribe": (payload: SessionSubscribePayload) => void;
     "session:subscribe_batch": (payload: SessionSubscribeBatchPayload) => void;
     "session:unsubscribe": (payload: SessionUnsubscribePayload) => void;
@@ -398,12 +594,15 @@ export interface ClientToServerEvents {
 export interface ServerToClientEvents {
     "chat:start": (payload: ChatStartPayload) => void;
     "chat:end": (payload: ChatEndPayload) => void;
-    "chat:append:ack": (payload: unknown) => void;
+    "chat:queue:updated": (payload: ChatQueueUpdatedPayload) => void;
+    "session:created": (payload: SessionCreatedPayload) => void;
     "session:updated": (payload: SessionUpdatedPayload) => void;
     "workspace:files_changed": (payload: WorkspaceFilesChangedPayload) => void;
+    "mcp-app:changed": (payload: MCPAppChangedPayload) => void;
     "system:error": (payload: SystemErrorPayload) => void;
     "system:notification": (payload: SystemNotificationPayload) => void;
     "turn:events": (payload: TurnEventsPayload) => void;
+    "turn:timing": (payload: TurnTimingPayload) => void;
     "task:updated": (payload: unknown) => void;
     "task:synced": (payload: unknown) => void;
     "artifact:created": (payload: unknown) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blade-hq/agent-client",
-  "version": "2610.0.1-alpha.1",
+  "version": "2610.0.2",
   "description": "Blade Agent 框架无关客户端：会话实时状态机、REST 通道、弹窗登录、页面协作。浏览器与 Node.js 通用。",
   "repository": {
     "type": "git",
@@ -18,7 +18,9 @@
   "files": [
     "dist",
     "README.md",
-    "public-api.md"
+    "public-api.md",
+    "LICENSE",
+    "THIRD_PARTY_NOTICES.md"
   ],
   "sideEffects": [
     "**/*.css"