@blade-hq/agent-kit 0.0.0-placeholder.0 → 0.4.1

package/dist/internal/core/api/socket.js

@@ -0,0 +1,824 @@
+import { io } from "socket.io-client";
+import { contentPreview, getTextContent } from "../lib/chat";
+import { trackEvent } from "../lib/analytics";
+import { postToParent } from "../lib/parent-bridge";
+import { buildToolPreviewKey } from "../lib/tool-preview";
+import { isUiMeta } from "../lib/ui-meta";
+import { useAuthStore } from "../stores/auth-store";
+import { useBackgroundStore } from "../stores/background-store";
+import { useCardStateStore } from "../stores/card-state-store";
+import { useChatStore } from "../stores/chat-store";
+import { useConnectionStore } from "../stores/connection-store";
+import { useRuntimeStore } from "../stores/runtime-store";
+import { invalidateHomeSidebarSessions, setOnSessionChange, useSessionStore, } from "../stores/session-store";
+import { useGisStore } from "../stores/gis-store";
+import { useTaskStore } from "../stores/task-store";
+import { useUiBridgeStore } from "../stores/ui-bridge-store";
+import { useUiStore } from "../stores/ui-store";
+import { getAuthedUrl } from "./client";
+import { hasClientAuthOverride, resolveSocketToken } from "./auth-resolve";
+function extractSkillIdForAnalytics(message) {
+    const text = getTextContent(message);
+    const tagMatch = text.match(/<skill>([^<]+)<\/skill>/);
+    if (tagMatch?.[1]?.trim()) {
+        return tagMatch[1].trim();
+    }
+    const slashCommandMatch = text.match(/^请使用\s+(.+?)\s+skill\s+完成任务(?:\n|$)/);
+    if (slashCommandMatch?.[1]?.trim()) {
+        return slashCommandMatch[1].trim();
+    }
+    return undefined;
+}
+function invalidateSessionCheckpoints(sessionId) {
+    const queryClient = globalThis.__agentQueryClient;
+    if (!queryClient)
+        return;
+    void queryClient.invalidateQueries({ queryKey: ["checkpoints", sessionId] });
+}
+function invalidateFileTree(sessionId) {
+    const queryClient = globalThis.__agentQueryClient;
+    if (!queryClient)
+        return;
+    void queryClient.invalidateQueries({ queryKey: ["file-tree", sessionId] });
+}
+function shouldSuppressOptimisticUserMessage(sessionId, askuserAnswer) {
+    if (askuserAnswer && typeof askuserAnswer.tool_call_id === "string") {
+        return true;
+    }
+    const session = useSessionStore.getState().sessions.find((item) => item.id === sessionId);
+    if (session?.status !== "waiting_for_input") {
+        return false;
+    }
+    const messages = useChatStore.getState().messages[sessionId] ?? [];
+    return messages.some((message) => (message.tool_calls ?? []).some((toolCall) => toolCall.status === "awaiting_answer"));
+}
+function invalidateSkillStats(sessionId) {
+    const queryClient = globalThis.__agentQueryClient;
+    if (!queryClient)
+        return;
+    void queryClient.invalidateQueries({ queryKey: ["skill-stats", sessionId] });
+}
+function invalidateSessionSkills(sessionId) {
+    const queryClient = globalThis.__agentQueryClient;
+    if (!queryClient)
+        return;
+    void queryClient.invalidateQueries({ queryKey: ["session-skills", sessionId] });
+}
+/**
+ * ship-attack v2：首次 skill 绑定后，`GET /api/sessions/:id` 返回的
+ * `primary_skill_snapshot` 从 null 变为 skill 配置快照。useSessionSkillMeta
+ * 依赖这份 detail 驱动 StageStepBar / useStepManifestView / 并行控件等；
+ * 仅 patch sessions 列表（名字）而不失效 detail 缓存，前端会看到改名但
+ * 阶段栏/骨架直到下一次 refetch 才出现。此 helper 触发 detail 重新获取。
+ */
+function invalidateSessionDetail(sessionId) {
+    const queryClient = globalThis.__agentQueryClient;
+    if (!queryClient)
+        return;
+    void queryClient.invalidateQueries({ queryKey: ["session-detail", sessionId] });
+}
+function invalidateContextStats(sessionId) {
+    const queryClient = globalThis.__agentQueryClient;
+    if (!queryClient)
+        return;
+    void queryClient.invalidateQueries({ queryKey: ["context-stats", sessionId] });
+}
+let onWorkspaceFilesChanged = null;
+export function setOnWorkspaceFilesChanged(fn) {
+    onWorkspaceFilesChanged = fn;
+}
+function invalidateSessionFiles(sessionId, filePath) {
+    const queryClient = globalThis.__agentQueryClient;
+    if (!queryClient)
+        return;
+    // 单个文件已知就精确 invalidate；否则 predicate 匹配该 session 下所有 session-file
+    // 查询，覆盖 ExplanationContent / FilePreviewDialog / QuoteButton 等共享同一 cache 的场景。
+    if (filePath) {
+        void queryClient.invalidateQueries({ queryKey: ["session-file", sessionId, filePath] });
+        void queryClient.invalidateQueries({ queryKey: ["session-image", sessionId, filePath] });
+        return;
+    }
+    void queryClient.invalidateQueries({
+        predicate: (query) => {
+            const [root, sid] = query.queryKey;
+            return ((root === "session-file" || root === "session-image") &&
+                sid === sessionId);
+        },
+    });
+}
+function notifyWorkspaceFilesChanged(sessionId, filePath) {
+    invalidateFileTree(sessionId);
+    invalidateSessionFiles(sessionId, filePath);
+    onWorkspaceFilesChanged?.({ sessionId, filePath });
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function extractModeFromBlocks(blocks) {
+    const modeBlock = blocks.find((block) => block.type === "mode_change");
+    if (modeBlock && isRecord(modeBlock.content) && typeof modeBlock.content.to === "string") {
+        return modeBlock.content.to;
+    }
+    if (blocks.some((block) => block.type === "planning_enter"))
+        return "planning";
+    if (blocks.some((block) => block.type === "planning_exit"))
+        return "executing";
+    return null;
+}
+function normalizeSocketUrl(backendUrl) {
+    const normalizedUrl = backendUrl.trim().replace(/\/$/, "");
+    if (normalizedUrl) {
+        return normalizedUrl;
+    }
+    if (typeof window !== "undefined") {
+        return window.location.origin;
+    }
+    return "";
+}
+function hasAuthenticatedSession() {
+    if (hasClientAuthOverride()) {
+        return Boolean(resolveSocketToken());
+    }
+    const { token, socketAuthToken, user } = useAuthStore.getState();
+    return Boolean(token || socketAuthToken || user);
+}
+function resolveArtifactType(contentType) {
+    const normalized = contentType.trim().toLowerCase();
+    if (normalized === "markdown" ||
+        normalized === "md" ||
+        normalized === "text/markdown" ||
+        normalized === "text/x-markdown") {
+        return "markdown";
+    }
+    if (normalized === "html" || normalized === "text/html") {
+        return "html";
+    }
+    if (normalized === "url" || normalized === "text/uri-list") {
+        return "url";
+    }
+    if (normalized === "pdf" || normalized === "application/pdf") {
+        return "pdf";
+    }
+    if (normalized === "docx" ||
+        normalized === "application/vnd.openxmlformats-officedocument.wordprocessingml.document") {
+        return "docx";
+    }
+    if (normalized === "excel" ||
+        normalized === "xlsx" ||
+        normalized === "xls" ||
+        normalized === "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" ||
+        normalized === "application/vnd.ms-excel") {
+        return "excel";
+    }
+    if (normalized === "pptx" ||
+        normalized === "ppt" ||
+        normalized === "application/vnd.openxmlformats-officedocument.presentationml.presentation" ||
+        normalized === "application/vnd.ms-powerpoint" ||
+        normalized === "application/vnd.ms-powerpoint.presentation.macroenabled.12") {
+        return "ppt";
+    }
+    if (normalized === "csv" || normalized === "text/csv") {
+        return "csv";
+    }
+    if (normalized === "image" || normalized.startsWith("image/")) {
+        return "image";
+    }
+    return "file";
+}
+function buildToolPreviewSignature(content, type) {
+    return `${type}:${content}`;
+}
+function isToolBridgeContent(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        !Array.isArray(value) &&
+        typeof value.action === "string");
+}
+function isGisGoalListPayload(value) {
+    return isRecord(value) && Array.isArray(value.goals);
+}
+function isGisResourceListPayload(value) {
+    return isRecord(value) && Array.isArray(value.resources);
+}
+function isGisTargetListPayload(value) {
+    return isRecord(value) && Array.isArray(value.targets);
+}
+class AgentSocket {
+    socket;
+    subscribedSession = null;
+    previewArtifactsByToolCall = new Map();
+    pendingReplayMessages = new Map();
+    pendingReplayModes = new Map();
+    constructor(backendUrl) {
+        this.socket = io(normalizeSocketUrl(backendUrl), {
+            transports: ["websocket"],
+            autoConnect: false,
+            withCredentials: true,
+            auth: (cb) => {
+                const authToken = resolveSocketToken();
+                cb(authToken ? { token: authToken } : {});
+            },
+        });
+        this._bindStoreHandlers();
+        this._bindConnectionHandlers();
+        // Wire session changes to socket subscriptions
+        setOnSessionChange((sessionId) => {
+            if (sessionId) {
+                this.subscribe(sessionId);
+                return;
+            }
+            this.unsubscribe();
+        });
+        // Cookie-authenticated sessions have `user` without a persisted bearer token.
+        if (hasAuthenticatedSession()) {
+            useConnectionStore.getState().markConnecting();
+            this.socket.connect();
+        }
+        else {
+            useConnectionStore.getState().markDisconnected();
+        }
+    }
+    _ensureConnected() {
+        if (this.socket.connected || this.socket.active) {
+            return;
+        }
+        if (!hasAuthenticatedSession()) {
+            return;
+        }
+        useConnectionStore.getState().markConnecting();
+        this.socket.connect();
+    }
+    _resolveSessionId(data) {
+        return data?.session_id ?? this.subscribedSession;
+    }
+    _bindStoreHandlers() {
+        const s = this.socket;
+        const applyTurn = (sessionId, turn) => {
+            useChatStore.getState().upsertTurn(sessionId, turn);
+            invalidateContextStats(sessionId);
+            const mode = extractModeFromBlocks(turn.blocks);
+            if (mode === "planning" || mode === "executing") {
+                useSessionStore.getState().setMode(sessionId, mode);
+            }
+            this._applyProjectionSideEffects(sessionId, turn);
+        };
+        s.on("turn:start", (data) => {
+            const sessionId = this._resolveSessionId(data);
+            if (!sessionId)
+                return;
+            applyTurn(sessionId, data);
+        });
+        s.on("turn:patch", (data) => {
+            const sessionId = this._resolveSessionId(data);
+            if (!sessionId)
+                return;
+            useChatStore.getState().applyTurnPatch(sessionId, data);
+            if (data.data.workspace_changed) {
+                notifyWorkspaceFilesChanged(sessionId);
+            }
+            const turn = data.data.turn;
+            if (!turn)
+                return;
+            const mode = extractModeFromBlocks(turn.blocks);
+            if (mode === "planning" || mode === "executing") {
+                useSessionStore.getState().setMode(sessionId, mode);
+            }
+            this._applyProjectionSideEffects(sessionId, turn);
+        });
+        s.on("turn:end", (data) => {
+            const sessionId = this._resolveSessionId(data);
+            if (!sessionId)
+                return;
+            applyTurn(sessionId, data);
+        });
+        s.on("chat:start", (data) => {
+            const sessionId = this._resolveSessionId(data);
+            if (!sessionId)
+                return;
+            useSessionStore.getState().updateSessionStatus(sessionId, "running");
+            useChatStore.getState().setStreaming(sessionId, true);
+        });
+        s.on("chat:end", (data) => {
+            const sessionId = this._resolveSessionId(data);
+            if (sessionId) {
+                const status = data?.status ?? "completed";
+                useSessionStore.getState().updateSessionStatus(sessionId, status === "paused"
+                    ? "waiting_for_input"
+                    : status === "interrupted"
+                        ? "interrupted"
+                        : status === "failed"
+                            ? "failed"
+                            : "completed");
+                if (status === "interrupted") {
+                    useChatStore.getState().markInterrupted(sessionId);
+                }
+                else if (status === "failed") {
+                    useChatStore.getState().markFailed(sessionId);
+                }
+                useChatStore.getState().setStreaming(sessionId, false);
+                invalidateContextStats(sessionId);
+                useRuntimeStore.getState().addEvent(sessionId, {
+                    type: "chat:end",
+                    title: status === "paused"
+                        ? "Waiting for input"
+                        : status === "interrupted"
+                            ? "运行已中断"
+                            : status === "failed"
+                                ? "Run failed"
+                                : "Run completed",
+                    status: status === "paused"
+                        ? "info"
+                        : status === "interrupted" || status === "failed"
+                            ? "error"
+                            : "done",
+                    detail: status === "paused"
+                        ? "Paused for user input"
+                        : status === "interrupted"
+                            ? "用户已中断"
+                            : status === "failed"
+                                ? "Streaming failed"
+                                : "Streaming finished",
+                });
+            }
+        });
+        s.on("task:updated", (data) => {
+            const sessionId = this._resolveSessionId(data);
+            if (sessionId) {
+                useTaskStore.getState().setTasks(sessionId, data.tasks);
+            }
+        });
+        s.on("system:error", (data) => {
+            const sessionId = this._resolveSessionId(data);
+            if (sessionId) {
+                useSessionStore.getState().updateSessionStatus(sessionId, "failed");
+                useChatStore.getState().markFailed(sessionId);
+                useChatStore.getState().addErrorMessage(sessionId, data.message);
+                useChatStore.getState().setStreaming(sessionId, false);
+                useRuntimeStore.getState().addEvent(sessionId, {
+                    type: "system:error",
+                    title: "Runtime error",
+                    status: "error",
+                    detail: data.message,
+                });
+            }
+        });
+        s.on("replay:input_mismatch", (data) => {
+            const sessionId = this._resolveSessionId(data);
+            if (!sessionId)
+                return;
+            const keepReplay = !window.confirm("即将转入自主模式，是否继续？");
+            const message = this.pendingReplayMessages.get(sessionId) ?? data.actual_message ?? "";
+            const mode = this.pendingReplayModes.get(sessionId);
+            this.pendingReplayMessages.delete(sessionId);
+            this.pendingReplayModes.delete(sessionId);
+            this.socket.emit("chat:send", {
+                session_id: sessionId,
+                message,
+                mode,
+                replay_decision: keepReplay ? "keep_replay" : "continue_replay",
+            });
+        });
+        s.on("system:notification", (data) => {
+            const sessionId = this._resolveSessionId(data);
+            if (!sessionId)
+                return;
+            this._applySystemNotification(sessionId, "root", data);
+        });
+        s.on("task:synced", (data) => {
+            const sessionId = this._resolveSessionId(data);
+            if (sessionId) {
+                useTaskStore.getState().setTasks(sessionId, data.tasks);
+            }
+        });
+        // 后端编排层直接变更 workspace 文件（例如 whatif rerun rename step 目录）
+        // 时发出，不依赖 agent tool 的 turn:patch.workspace_changed 通道。
+        s.on("workspace:files_changed", (data) => {
+            const sessionId = this._resolveSessionId(data);
+            if (sessionId) {
+                notifyWorkspaceFilesChanged(sessionId, data.file_path);
+            }
+        });
+        // ship-attack v2：首次触发 skill 自动绑定后后端广播；前端原地 patch
+        // sessions 缓存里的 intent / bound_skill_id，避免成果表改名需要刷新才能看到。
+        s.on("session:updated", (data) => {
+            const sessionId = this._resolveSessionId(data);
+            if (!sessionId)
+                return;
+            const patch = {};
+            if (typeof data.intent === "string")
+                patch.intent = data.intent;
+            if ("model" in data)
+                patch.model = data.model;
+            if ("bound_skill_id" in data)
+                patch.bound_skill_id = data.bound_skill_id;
+            if ("replay_state" in data)
+                patch.replay_state = data.replay_state;
+            if (Object.keys(patch).length > 0) {
+                useSessionStore.getState().patchSession(sessionId, patch);
+            }
+            if (typeof data.intent === "string") {
+                invalidateHomeSidebarSessions();
+            }
+            // 同步失效 session detail 缓存：绑定后 primary_skill_snapshot 从 null
+            // 变为 skill 快照，useSessionSkillMeta 需重新拉取才能让中间栏阶段徽章
+            // 和并行控件出现（见 PR #564 codex review P1）。
+            invalidateSessionDetail(sessionId);
+        });
+        s.on("session:rewind", (data) => {
+            if (!this.subscribedSession)
+                return;
+            const sessionId = this.subscribedSession;
+            // Clear mode so history reload can re-infer it
+            const { modes, ...rest } = useSessionStore.getState();
+            const { [sessionId]: _, ...restModes } = modes;
+            useSessionStore.setState({ ...rest, modes: restModes });
+            // Re-load session state
+            useSessionStore.getState().setActiveSession(sessionId);
+            useRuntimeStore.getState().addEvent(sessionId, {
+                type: "session:rewind",
+                title: "Conversation rewound",
+                status: "info",
+                detail: data.checkpoint_id,
+            });
+            invalidateSessionCheckpoints(sessionId);
+        });
+        const handleArtifact = (sessionId, data) => {
+            const type = resolveArtifactType(data.content_type);
+            const filePath = `/api/sessions/${sessionId}/files/${encodeURIComponent(data.file_path)}`;
+            const fileUrl = getAuthedUrl(filePath);
+            const content = type === "ppt"
+                ? filePath
+                : type === "image" || type === "pdf" || type === "docx" || type === "excel"
+                    ? fileUrl
+                    : data.content;
+            if (data.session_id != null && data.session_id === this.subscribedSession) {
+                useUiStore.getState().setActiveRightTab("preview");
+            }
+            useUiStore.getState().pushArtifact({
+                type,
+                content,
+                sourceUrl: type === "ppt" ? fileUrl : undefined,
+                title: data.title,
+                key: data.file_path,
+                revision: Date.now(),
+            });
+        };
+        s.on("artifact:created", (data) => {
+            const sessionId = this._resolveSessionId(data);
+            if (!sessionId)
+                return;
+            notifyWorkspaceFilesChanged(sessionId, data.file_path);
+            handleArtifact(sessionId, data);
+        });
+        s.on("bg:started", (data) => {
+            const sessionId = this._resolveSessionId(data);
+            if (!sessionId)
+                return;
+            const taskId = typeof data.task_id === "string" ? data.task_id : typeof data.id === "string" ? data.id : "";
+            if (!taskId)
+                return;
+            useBackgroundStore.getState().upsertTask(sessionId, {
+                id: taskId,
+                command: typeof data.command === "string" ? data.command : "",
+                description: typeof data.description === "string" ? data.description : undefined,
+                status: "running",
+                elapsed_seconds: typeof data.elapsed_seconds === "number" ? data.elapsed_seconds : 0,
+            });
+        });
+        s.on("bg:tasks_completed", (data) => {
+            const sessionId = this._resolveSessionId(data);
+            if (!sessionId)
+                return;
+            for (const task of data.tasks ?? []) {
+                const taskId = typeof task.id === "string" ? task.id : typeof task.task_id === "string" ? task.task_id : "";
+                if (!taskId)
+                    continue;
+                useBackgroundStore.getState().upsertTask(sessionId, {
+                    id: taskId,
+                    command: typeof task.command === "string" ? task.command : "",
+                    description: typeof task.description === "string" ? task.description : undefined,
+                    status: task.status === "running" || task.status === "failed" ? task.status : "done",
+                    exit_code: typeof task.exit_code === "number" || task.exit_code === null ? task.exit_code : undefined,
+                    elapsed_seconds: typeof task.elapsed_seconds === "number" ? task.elapsed_seconds : 0,
+                    output_lines_count: typeof task.output_lines_count === "number" ? task.output_lines_count : undefined,
+                    output: Array.isArray(task.output_preview) && task.output_preview.length > 0
+                        ? task.output_preview.join("\n")
+                        : undefined,
+                });
+            }
+        });
+        s.on("skills:changed", (data) => {
+            const sessionId = this._resolveSessionId(data);
+            if (!sessionId)
+                return;
+            invalidateSkillStats(sessionId);
+            invalidateSessionSkills(sessionId);
+        });
+        s.on("artifact:updated", (data) => {
+            const sessionId = this._resolveSessionId(data);
+            if (!sessionId)
+                return;
+            notifyWorkspaceFilesChanged(sessionId, data.file_path);
+            if (data.old_string != null && data.new_string != null) {
+                useUiStore.getState().pushArtifact({
+                    type: "diff",
+                    content: data.new_string,
+                    oldContent: data.old_string,
+                    title: data.title,
+                    key: data.file_path,
+                });
+                return;
+            }
+            handleArtifact(sessionId, data);
+        });
+    }
+    _bindConnectionHandlers() {
+        this.socket.on("connect", () => {
+            useConnectionStore.getState().markConnected();
+            console.log("[agent-socket] connected, id:", this.socket.id);
+            const sessionId = this.subscribedSession;
+            if (sessionId) {
+                useSessionStore.getState().setActiveSession(sessionId);
+                // 重连后 socket.io 会分配新 sid，旧 sid 在后端 room 里的订阅关系不
+                // 会迁移过来 —— 必须重新 emit session:subscribe，否则后端 room
+                // 广播的 turn:patch / chat:end 我们收不到，UI 会卡在 "运行中 + 停
+                // 止按钮"（因为没机会把 isStreaming 翻回 false）。
+                this.socket.emit("session:subscribe", { session_id: sessionId });
+            }
+        });
+        this.socket.on("connect_error", (err) => {
+            useConnectionStore.getState().markDisconnected();
+            console.error("[agent-socket] connect_error:", err.message);
+        });
+        this.socket.on("disconnect", (reason) => {
+            useConnectionStore.getState().markDisconnected();
+            console.log("[agent-socket] disconnected:", reason);
+        });
+        this.socket.io.on("reconnect_attempt", (attempt) => {
+            useConnectionStore
+                .getState()
+                .markConnecting(typeof attempt === "number" ? attempt : 0);
+        });
+    }
+    _applyProjectionSideEffects(sessionId, turn) {
+        for (const block of turn.blocks) {
+            if (block.type === "tool_bridge" && isToolBridgeContent(block.content)) {
+                if (block.content.action === "gis.goals.updated" && isGisGoalListPayload(block.content.payload)) {
+                    useGisStore.getState().setGoals(sessionId, block.content.payload.goals);
+                    continue;
+                }
+                if (block.content.action === "gis.resources.updated" &&
+                    isGisResourceListPayload(block.content.payload)) {
+                    useGisStore
+                        .getState()
+                        .setResources(sessionId, block.content.payload.resources);
+                    continue;
+                }
+                if (block.content.action === "gis.targets.updated" &&
+                    isGisTargetListPayload(block.content.payload)) {
+                    useGisStore.getState().setTargets(sessionId, block.content.payload.targets);
+                    continue;
+                }
+                if (block.content.action.startsWith("map.")) {
+                    useGisStore.getState().pushMapCommand(sessionId, {
+                        action: block.content.action,
+                        payload: block.content.payload,
+                        toolCallId: block.tool_call_id,
+                    });
+                    continue;
+                }
+                postToParent({
+                    __bladeBridge: true,
+                    direction: "agent-to-host",
+                    action: block.content.action,
+                    payload: block.content.payload,
+                    meta: {
+                        sessionId,
+                        ...(block.tool_call_id ? { toolCallId: block.tool_call_id } : {}),
+                        timestamp: Date.now(),
+                    },
+                });
+                continue;
+            }
+            if (block.type !== "tool_ui" || !block.tool_call_id || !isUiMeta(block.content)) {
+                continue;
+            }
+            const ui = block.content;
+            if (ui.target !== "preview") {
+                continue;
+            }
+            const previewType = ui.resourceHTML ? "resource-html" : "resource-uri";
+            const previewContent = ui.resourceHTML ?? ui.resourceUri ?? ui.resourceURI;
+            if (!previewContent) {
+                continue;
+            }
+            const previewKey = buildToolPreviewKey(previewContent, previewType, block.tool_call_id);
+            const signature = buildToolPreviewSignature(previewContent, previewType);
+            if (this.previewArtifactsByToolCall.get(previewKey) === signature) {
+                continue;
+            }
+            this.previewArtifactsByToolCall.set(previewKey, signature);
+            useUiStore.getState().pushArtifact({
+                type: previewType,
+                content: previewContent,
+                title: ui.title ?? "工具预览",
+                key: previewKey,
+                bridgeSessionId: sessionId,
+            });
+        }
+        for (const block of turn.blocks) {
+            if (block.type !== "system_notification" || !isRecord(block.content)) {
+                continue;
+            }
+            this._applySystemNotification(sessionId, turn.loop_id, block.content);
+        }
+    }
+    _applySystemNotification(sessionId, loopId, notification) {
+        const notificationType = notification.notification_type ?? "system_notification";
+        const title = notification.title ?? notificationType;
+        const detail = typeof notification.detail === "string"
+            ? notification.detail
+            : notification.detail == null
+                ? undefined
+                : JSON.stringify(notification.detail);
+        const status = notification.status === "running" ||
+            notification.status === "done" ||
+            notification.status === "error"
+            ? notification.status
+            : "info";
+        useRuntimeStore.getState().addEvent(sessionId, {
+            type: notificationType,
+            title,
+            status,
+            detail,
+            loopName: loopId,
+        });
+        if (notificationType !== "bg:started" || !isRecord(notification.metadata)) {
+            return;
+        }
+        const taskId = typeof notification.metadata.task_id === "string" ? notification.metadata.task_id : "";
+        const command = typeof notification.metadata.command === "string" ? notification.metadata.command : "";
+        const description = typeof notification.metadata.description === "string"
+            ? notification.metadata.description
+            : undefined;
+        if (!taskId)
+            return;
+        useBackgroundStore.getState().upsertTask(sessionId, {
+            id: taskId,
+            command,
+            description,
+            status: "running",
+            elapsed_seconds: 0,
+        });
+    }
+    subscribe(sessionId) {
+        const previousSessionId = this.subscribedSession;
+        const isSameSession = previousSessionId === sessionId;
+        if (previousSessionId && !isSameSession) {
+            this.socket.emit("session:unsubscribe", { session_id: previousSessionId });
+            useUiBridgeStore.getState().clearSession(previousSessionId);
+        }
+        this.subscribedSession = sessionId;
+        if (!isSameSession) {
+            // Clear artifacts and card states from previous session
+            this.previewArtifactsByToolCall.clear();
+            useUiStore.getState().clearArtifacts();
+            useCardStateStore.getState().clearAllStates();
+        }
+        this.socket.emit("session:subscribe", { session_id: sessionId });
+    }
+    unsubscribe() {
+        const previousSessionId = this.subscribedSession;
+        if (previousSessionId) {
+            this.socket.emit("session:unsubscribe", { session_id: previousSessionId });
+            useUiBridgeStore.getState().clearSession(previousSessionId);
+            this.subscribedSession = null;
+        }
+        this.previewArtifactsByToolCall.clear();
+    }
+    /**
+     * 附加订阅：仅把当前 sid 加进 sessionId 的 room，不切 subscribedSession，
+     * 也不清空当前会话的 artifact/card state。用于"并行拟制"这类场景 ——
+     * 创建 N 个后台 session 后需要收到它们的 chat:end / task:updated 才能让
+     * 成果表里那几条卡片状态流转到"已完成"；缺失订阅时广播事件永远到不了
+     * 前端，卡片就会停留在乐观写入的"运行中"态。
+     *
+     * 幂等：后端 session:subscribe handler 只做 enter_room，重复 emit 无副作用。
+     */
+    attachSession(sessionId) {
+        this.socket.emit("session:subscribe", { session_id: sessionId });
+    }
+    send(sessionId, message, mode, askuserAnswer, extras) {
+        this._ensureConnected();
+        const suppressOptimisticUserMessage = shouldSuppressOptimisticUserMessage(sessionId, askuserAnswer);
+        if (!suppressOptimisticUserMessage) {
+            useChatStore.getState().addUserMessage(sessionId, message);
+        }
+        useChatStore.getState().setStreaming(sessionId, true);
+        // Optimistically update askAnswers so live multi-turn AskUserQuestion
+        // sessions keep previously answered cards in answered state.
+        if (askuserAnswer && typeof askuserAnswer.tool_call_id === "string") {
+            const { tool_call_id, ...rest } = askuserAnswer;
+            const current = useChatStore.getState().askAnswers[sessionId] ?? {};
+            useChatStore.getState().setAskAnswers(sessionId, {
+                ...current,
+                [tool_call_id]: rest,
+            });
+        }
+        if (!suppressOptimisticUserMessage) {
+            useRuntimeStore.getState().addEvent(sessionId, {
+                type: "chat:start",
+                title: "User prompt sent",
+                status: "running",
+                detail: contentPreview(message),
+            });
+        }
+        if (!extras?.replay_decision) {
+            this.pendingReplayMessages.set(sessionId, message);
+            this.pendingReplayModes.set(sessionId, mode);
+        }
+        this.socket.emit("chat:send", {
+            session_id: sessionId,
+            message,
+            mode,
+            askuser_answer: askuserAnswer,
+            model: extras?.model,
+            whatif: extras?.whatif,
+            replay_decision: extras?.replay_decision,
+        });
+        const skillId = extractSkillIdForAnalytics(message);
+        trackEvent("message_sent", {
+            session_id: sessionId,
+            ...(skillId ? { skill_id: skillId } : {}),
+        });
+        if (skillId) {
+            trackEvent("skill_invoked", {
+                session_id: sessionId,
+                skill_id: skillId,
+            });
+        }
+    }
+    stop(sessionId) {
+        this.socket.emit("chat:stop", { session_id: sessionId });
+    }
+    compact(sessionId) {
+        return new Promise((resolve, reject) => {
+            this.socket.timeout(30_000).emit("chat:compact", { session_id: sessionId }, (err, response) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                resolve(response ?? {});
+            });
+        });
+    }
+    reconnect() {
+        this.socket.disconnect();
+        useConnectionStore.getState().markConnecting();
+        this.socket.connect();
+    }
+    disconnect() {
+        this.socket.disconnect();
+        useConnectionStore.getState().markDisconnected();
+    }
+    destroy() {
+        this.socket.removeAllListeners();
+        this.socket.disconnect();
+        useConnectionStore.getState().markDisconnected();
+    }
+    // biome-ignore lint/suspicious/noExplicitAny: socket.io listeners are event-specific and forwarded transparently.
+    on(event, listener) {
+        this.socket.on(event, listener);
+        return this;
+    }
+    // biome-ignore lint/suspicious/noExplicitAny: socket.io listeners are event-specific and forwarded transparently.
+    off(event, listener) {
+        this.socket.off(event, listener);
+        return this;
+    }
+    // biome-ignore lint/suspicious/noExplicitAny: generic emit for custom events.
+    emit(event, data) {
+        this.socket.emit(event, data);
+        return this;
+    }
+    getSubscribedSession() {
+        return this.subscribedSession;
+    }
+}
+export let agentSocket = null;
+export function initSocket(backendUrl) {
+    agentSocket?.destroy();
+    agentSocket = new AgentSocket(backendUrl);
+    return agentSocket;
+}
+export function setSocketBaseUrl(backendUrl) {
+    // Don't re-subscribe the old session — it likely doesn't exist on the new backend.
+    // The UI layer will re-subscribe after fetching sessions from the new backend.
+    return initSocket(backendUrl);
+}
+export function getSocket() {
+    if (!agentSocket)
+        throw new Error("Socket not initialized. Call initSocket() first.");
+    return agentSocket;
+}
+//# sourceMappingURL=socket.js.map