@blade-hq/agent-client 1.1.1

package/dist/index.js

@@ -0,0 +1,4182 @@
+// src/auth-login.ts
+function isAuthCallbackMessage(value) {
+  return typeof value === "object" && value !== null && value.type === "blade-agent:sdk-auth";
+}
+function randomState() {
+  const bytes = new Uint8Array(24);
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+var storageKeyFor = (baseUrl) => `blade-sdk-token:${baseUrl}`;
+function readStoredToken(baseUrl) {
+  if (typeof localStorage === "undefined") return null;
+  try {
+    return localStorage.getItem(storageKeyFor(baseUrl));
+  } catch {
+    return null;
+  }
+}
+function writeStoredToken(baseUrl, token, mode) {
+  if (mode !== "local" || typeof localStorage === "undefined") return;
+  try {
+    if (token) {
+      localStorage.setItem(storageKeyFor(baseUrl), token);
+    } else {
+      localStorage.removeItem(storageKeyFor(baseUrl));
+    }
+  } catch {
+  }
+}
+async function loginWithPopup(client, options = {}) {
+  if (typeof window === "undefined") {
+    throw new Error("client.auth.login() \u53EA\u80FD\u5728\u6D4F\u89C8\u5668\u4E2D\u8C03\u7528\uFF1BNode.js \u573A\u666F\u8BF7\u76F4\u63A5\u4F20\u5165 token\u3002");
+  }
+  const rawOrigin = window.location.origin;
+  const clientOrigin = /^https?:\/\//.test(rawOrigin) ? rawOrigin : "null";
+  const width = options.width ?? 480;
+  const height = options.height ?? 640;
+  const left = Math.max(0, (window.screen.width - width) / 2);
+  const top = Math.max(0, (window.screen.height - height) / 2);
+  const state = randomState();
+  const authorizeUrl = new URL(
+    "/api/auth/sdk/authorize",
+    client.options.baseUrl || window.location.origin
+  );
+  authorizeUrl.searchParams.set("client_origin", clientOrigin);
+  authorizeUrl.searchParams.set("state", state);
+  const popup = window.open(
+    authorizeUrl.toString(),
+    "blade-sdk-login",
+    `popup=yes,width=${width},height=${height},left=${left},top=${top}`
+  );
+  if (!popup) {
+    throw new Error("\u767B\u5F55\u5F39\u7A97\u88AB\u6D4F\u89C8\u5668\u62E6\u622A\u4E86\u3002\u8BF7\u5141\u8BB8\u672C\u7AD9\u6253\u5F00\u5F39\u7A97\u540E\u91CD\u8BD5\u3002");
+  }
+  const expectedOrigin = new URL(client.options.baseUrl || window.location.origin).origin;
+  return new Promise((resolve, reject) => {
+    const timeoutMs = options.timeoutMs ?? 5 * 60 * 1e3;
+    let settled = false;
+    const cleanup = () => {
+      window.removeEventListener("message", onMessage);
+      globalThis.clearInterval(closeWatcher);
+      globalThis.clearTimeout(timeoutHandle);
+    };
+    const settle = (fn) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      fn();
+    };
+    const onMessage = (event) => {
+      if (event.origin !== expectedOrigin) return;
+      if (!isAuthCallbackMessage(event.data)) return;
+      if (event.data.state !== state) return;
+      const message = event.data;
+      try {
+        popup.close();
+      } catch {
+      }
+      if (message.status === "denied") {
+        settle(() => reject(new Error("\u4F60\u53D6\u6D88\u4E86\u6388\u6743\uFF0C\u672A\u5B8C\u6210\u767B\u5F55\u3002")));
+        return;
+      }
+      if (message.status !== "success" || !message.code) {
+        settle(() => reject(new Error(message.error || "\u767B\u5F55\u5931\u8D25\uFF0C\u672A\u53D6\u5F97\u6388\u6743\u7801\u3002")));
+        return;
+      }
+      client.json("POST", "/api/auth/sdk/token", {
+        code: message.code,
+        state,
+        client_origin: clientOrigin
+      }).then((response) => {
+        settle(() => resolve({ token: response.access_token, user: response.user }));
+      }).catch((error) => {
+        settle(
+          () => reject(error instanceof Error ? error : new Error("\u6388\u6743\u7801\u6362\u53D6\u4EE4\u724C\u5931\u8D25\uFF0C\u8BF7\u91CD\u8BD5\u3002"))
+        );
+      });
+    };
+    const closeWatcher = globalThis.setInterval(() => {
+      if (popup.closed && !settled) {
+        globalThis.setTimeout(() => {
+          settle(() => reject(new Error("\u767B\u5F55\u7A97\u53E3\u5DF2\u5173\u95ED\uFF0C\u672A\u5B8C\u6210\u6388\u6743\u3002")));
+        }, 400);
+      }
+    }, 500);
+    const timeoutHandle = globalThis.setTimeout(() => {
+      settle(() => reject(new Error("\u767B\u5F55\u8D85\u65F6\uFF0C\u8BF7\u91CD\u8BD5\u3002")));
+    }, timeoutMs);
+    window.addEventListener("message", onMessage);
+  });
+}
+
+// src/rest.ts
+var DOCS_URL = "https://blade-hq.github.io/public-skills/";
+var BladeApiError = class extends Error {
+  response;
+  status;
+  statusText;
+  constructor(response, message) {
+    super(message ?? `\u8BF7\u6C42\u5931\u8D25\uFF08${response.status} ${response.statusText}\uFF09`);
+    this.name = "BladeApiError";
+    this.response = response;
+    this.status = response.status;
+    this.statusText = response.statusText;
+  }
+};
+async function extractErrorDetail(response) {
+  try {
+    const cloned = response.clone();
+    const contentType = cloned.headers.get("content-type") ?? "";
+    if (contentType.includes("application/json")) {
+      const data = await cloned.json();
+      const detail = data?.detail;
+      if (typeof detail === "string" && detail.trim()) return detail;
+      if (Array.isArray(detail) && detail.length > 0) {
+        const first = detail[0];
+        if (first && typeof first.msg === "string") return first.msg;
+      }
+    } else {
+      const text = (await cloned.text()).trim();
+      if (text) return text;
+    }
+  } catch {
+  }
+  return void 0;
+}
+function decorateAuthError(error) {
+  if (!(error instanceof BladeApiError)) return error;
+  if (error.status === 401) {
+    error.message = `${error.message}\uFF08\u672A\u767B\u5F55\u6216\u51ED\u8BC1\u5DF2\u5931\u6548\u3002\u6D4F\u89C8\u5668\u573A\u666F\u8C03\u7528 client.auth.login() \u5F39\u7A97\u767B\u5F55\uFF0C\u81EA\u52A8\u5316\u573A\u666F\u5728 new BladeClient({ token }) \u4F20\u5165 PAT\u3002\u63A5\u5165\u6307\u5357\uFF1A${DOCS_URL}\uFF09`;
+  } else if (error.status === 403) {
+    error.message = `${error.message}\uFF08\u5F53\u524D\u8D26\u53F7\u65E0\u6743\u8BBF\u95EE\u8BE5\u8D44\u6E90\u3002\u63A5\u5165\u6307\u5357\uFF1A${DOCS_URL}\uFF09`;
+  }
+  return error;
+}
+
+// src/resources/auth.ts
+var AuthResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * 弹窗授权登录（浏览器专用）：弹出后端授权页，用户点击"许可授权"后
+   * 自动取得 PAT 并热挂载到当前 client。等价于 client.login()。
+   */
+  login(options) {
+    return this.client.login(options);
+  }
+  /** 清除 login() 存储的令牌。 */
+  logoutToken() {
+    this.client.logoutToken();
+  }
+  getProviders() {
+    return this.client.json("GET", "/api/auth/providers");
+  }
+  getMe() {
+    return this.client.json("GET", "/api/auth/me");
+  }
+  logout() {
+    return this.client.json("POST", "/api/auth/logout");
+  }
+};
+
+// src/resources/headless.ts
+var HeadlessError = class extends Error {
+  constructor(message, detail) {
+    super(message);
+    this.detail = detail;
+    this.name = "HeadlessError";
+  }
+  detail;
+};
+var SYSTEM_ERROR_CHAT_END_GRACE_MS = 1e3;
+var HeadlessResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  async run(prompt, options = {}) {
+    const { session_id } = await this.client.sessions.createSessionWithRequest({
+      intent: prompt,
+      model: options.model ?? null
+    });
+    return this.runTracked(session_id, prompt, options, false);
+  }
+  async runInSession(sessionId, prompt, options = {}) {
+    return this.runTracked(sessionId, prompt, options, false);
+  }
+  async runWithSession(prompt, options = {}) {
+    const { session_id } = await this.client.sessions.createSessionWithRequest({
+      intent: prompt,
+      model: options.model ?? null
+    });
+    return this.runTracked(session_id, prompt, options, true);
+  }
+  async runTracked(sessionId, prompt, options, returnEnvelope) {
+    const timeoutMs = options.timeoutMs ?? 3e5;
+    const session_id = sessionId;
+    const socket = this.client.socket();
+    await ensureSocketConnected(socket, timeoutMs, { session_id });
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      let stopSent = false;
+      let started = false;
+      let chatRunId = null;
+      let systemErrorTimeout = null;
+      const timeout = setTimeout(() => {
+        fail(new HeadlessError(`headless run timed out after ${timeoutMs}ms`, { session_id, chat_run_id: chatRunId }));
+      }, timeoutMs);
+      const cleanup = (sendStop) => {
+        clearTimeout(timeout);
+        if (systemErrorTimeout) {
+          clearTimeout(systemErrorTimeout);
+          systemErrorTimeout = null;
+        }
+        socket.off("chat:start", onChatStart);
+        socket.off("chat:end", onChatEnd);
+        socket.off("system:error", onSystemError);
+        if (sendStop && !stopSent) {
+          stopSent = true;
+          socket.emit("chat:stop", { session_id }, () => void 0);
+        }
+        socket.emit("session:unsubscribe", { session_id });
+      };
+      const finish = (value) => {
+        if (settled) return;
+        settled = true;
+        cleanup(false);
+        if (returnEnvelope) {
+          resolve({ session_id, chat_run_id: chatRunId, result: value });
+          return;
+        }
+        resolve(value);
+      };
+      const fail = (error) => {
+        if (settled) return;
+        settled = true;
+        cleanup(true);
+        reject(error);
+      };
+      const failWithoutStop = (error) => {
+        if (settled) return;
+        settled = true;
+        cleanup(false);
+        reject(error);
+      };
+      const rejectAfterChatEnd = (error) => {
+        if (settled) return;
+        settled = true;
+        cleanup(false);
+        reject(error);
+      };
+      function onChatStart(payload) {
+        if (payload.session_id && payload.session_id !== session_id) return;
+        started = true;
+      }
+      function onSystemError(payload) {
+        if (payload.session_id !== session_id) return;
+        if (!started) {
+          failWithoutStop(new HeadlessError(payload.message || "headless run failed", {
+            session_id,
+            chat_run_id: chatRunId,
+            event: payload
+          }));
+          return;
+        }
+        if (systemErrorTimeout) {
+          clearTimeout(systemErrorTimeout);
+        }
+        systemErrorTimeout = setTimeout(() => {
+          systemErrorTimeout = null;
+          fail(new HeadlessError(payload.message || "headless run failed", {
+            session_id,
+            chat_run_id: chatRunId,
+            event: payload
+          }));
+        }, SYSTEM_ERROR_CHAT_END_GRACE_MS);
+      }
+      function onChatEnd(payload) {
+        if (payload.session_id && payload.session_id !== session_id) return;
+        chatRunId = typeof payload.chat_run_id === "string" ? payload.chat_run_id : chatRunId;
+        const result = payload.result;
+        if (payload.status === "failed") {
+          rejectAfterChatEnd(new HeadlessError(errorMessageFromResult(result) ?? "headless run failed", {
+            session_id,
+            chat_run_id: chatRunId,
+            event: payload
+          }));
+          return;
+        }
+        try {
+          finish(normalizeResult(result, Boolean(options.schema)));
+        } catch (error) {
+          rejectAfterChatEnd(error);
+        }
+      }
+      socket.on("chat:start", onChatStart);
+      socket.on("chat:end", onChatEnd);
+      socket.on("system:error", onSystemError);
+      socket.emit("session:subscribe", { session_id, event_format: "raw" });
+      socket.emit("chat:send", {
+        session_id,
+        message: prompt,
+        headless: true,
+        output_schema: options.schema ?? null,
+        model: options.model ?? null
+      });
+    });
+  }
+};
+function normalizeResult(result, hasSchema) {
+  if (!isRecord(result)) {
+    throw new HeadlessError("headless run finished without a result", result);
+  }
+  const errMsg = typeof result.err_msg === "string" ? result.err_msg : "";
+  if (errMsg) {
+    throw new HeadlessError(errMsg, result);
+  }
+  if (!hasSchema) {
+    const text = result.result;
+    return typeof text === "string" ? text : String(text ?? "");
+  }
+  const { err_msg: _errMsg, ...businessResult } = result;
+  return businessResult;
+}
+function errorMessageFromResult(result) {
+  if (isRecord(result) && typeof result.err_msg === "string" && result.err_msg) {
+    return result.err_msg;
+  }
+  return null;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function ensureSocketConnected(socket, timeoutMs, detail) {
+  if (socket.connected) {
+    return Promise.resolve();
+  }
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const timeout = setTimeout(() => {
+      finish(() => reject(new HeadlessError(`socket connection timed out after ${timeoutMs}ms`, detail)));
+    }, timeoutMs);
+    const onConnect = () => finish(resolve);
+    const onConnectError = (error) => {
+      finish(() => reject(new HeadlessError("socket connection failed", { ...detail, event: error })));
+    };
+    const finish = (callback) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      socket.off("connect", onConnect);
+      socket.off("connect_error", onConnectError);
+      callback();
+    };
+    socket.on("connect", onConnect);
+    socket.on("connect_error", onConnectError);
+    socket.connect();
+  });
+}
+
+// src/shared/projection/helpers.ts
+function upsertToolCall(state, toolCallId, toolName, displayName, args) {
+  if (!toolCallId) return;
+  let found = false;
+  for (let i = 0; i < state.toolCalls.length; i++) {
+    if (state.toolCalls[i].id !== toolCallId) continue;
+    const tc = state.toolCalls[i];
+    state.toolCalls[i] = {
+      ...tc,
+      tool_name: toolName || tc.tool_name,
+      display_name: displayName || tc.display_name,
+      arguments: args || tc.arguments
+    };
+    found = true;
+    break;
+  }
+  if (!found) {
+    state.toolCalls.push({
+      id: toolCallId,
+      tool_name: toolName,
+      display_name: displayName,
+      arguments: args,
+      status: "pending"
+    });
+  }
+  let blockFound = false;
+  for (let i = 0; i < state.blocks.length; i++) {
+    const b = state.blocks[i];
+    if (b.type !== "tool_use" || b.tool_call_id !== toolCallId) continue;
+    state.blocks[i] = {
+      ...b,
+      content: args || b.content,
+      tool_name: toolName || b.tool_name,
+      display_name: displayName || b.display_name
+    };
+    blockFound = true;
+    break;
+  }
+  if (!blockFound) {
+    state.blocks.push({
+      type: "tool_use",
+      content: args,
+      tool_call_id: toolCallId,
+      tool_name: toolName || null,
+      display_name: displayName || null
+    });
+  }
+}
+function applyToolResult(state, toolCallId, result, status, durationMs, sourceLoop) {
+  let toolName = "";
+  let displayName = "";
+  let finalResult = result;
+  for (let i = 0; i < state.toolCalls.length; i++) {
+    const tc = state.toolCalls[i];
+    if (tc.id !== toolCallId) continue;
+    if (typeof result === "string") {
+      finalResult = maybeEnrichAskUserResult(tc.tool_name, result, sourceLoop);
+    }
+    const update = { status, result: finalResult };
+    if (durationMs != null) update.duration_ms = durationMs;
+    state.toolCalls[i] = { ...tc, ...update };
+    toolName = tc.tool_name;
+    displayName = tc.display_name;
+    break;
+  }
+  upsertToolResultBlock(state, toolCallId, finalResult, toolName, displayName);
+}
+function appendToolResultDelta(state, toolCallId, delta) {
+  if (!toolCallId || !delta) return;
+  let toolName = "";
+  let displayName = "";
+  let currentResult = "";
+  for (let i = 0; i < state.toolCalls.length; i++) {
+    const tc = state.toolCalls[i];
+    if (tc.id !== toolCallId) continue;
+    toolName = tc.tool_name;
+    displayName = tc.display_name;
+    if (typeof tc.result === "string") currentResult = tc.result;
+    state.toolCalls[i] = { ...tc, result: currentResult + delta };
+    break;
+  }
+  for (const block of state.blocks) {
+    if (block.type !== "tool_result" || block.tool_call_id !== toolCallId) continue;
+    if (typeof block.content === "string") currentResult = block.content;
+    break;
+  }
+  upsertToolResultBlock(state, toolCallId, currentResult + delta, toolName, displayName);
+}
+function upsertToolResultBlock(state, toolCallId, content, toolName, displayName) {
+  for (let i = 0; i < state.blocks.length; i++) {
+    const block = state.blocks[i];
+    if (block.type !== "tool_result" || block.tool_call_id !== toolCallId) continue;
+    state.blocks[i] = {
+      ...block,
+      content,
+      tool_name: toolName || block.tool_name,
+      display_name: displayName || block.display_name
+    };
+    return;
+  }
+  state.blocks.push({
+    type: "tool_result",
+    content,
+    tool_call_id: toolCallId,
+    tool_name: toolName || null,
+    display_name: displayName || null
+  });
+}
+function appendTextBlock(state, blockType, content) {
+  if (content == null || content === "") return;
+  const text = String(content);
+  const lastBlock = state.blocks[state.blocks.length - 1];
+  if (lastBlock && lastBlock.type === blockType && typeof lastBlock.content === "string") {
+    state.blocks[state.blocks.length - 1] = {
+      ...lastBlock,
+      content: lastBlock.content + text
+    };
+    return;
+  }
+  state.blocks.push({ type: blockType, content: text });
+}
+function appendToolCallArguments(state, toolCallId, delta) {
+  let newArgs = "";
+  for (let i = 0; i < state.toolCalls.length; i++) {
+    const tc = state.toolCalls[i];
+    if (tc.id === toolCallId) {
+      newArgs = tc.arguments + delta;
+      state.toolCalls[i] = { ...tc, arguments: newArgs };
+      break;
+    }
+  }
+  if (!newArgs) return;
+  for (let i = 0; i < state.blocks.length; i++) {
+    const b = state.blocks[i];
+    if (b.type === "tool_use" && b.tool_call_id === toolCallId) {
+      state.blocks[i] = { ...b, content: newArgs };
+      break;
+    }
+  }
+}
+function maybeEnrichAskUserResult(toolName, result, sourceLoop) {
+  if (!sourceLoop) return result;
+  const normalized = toolName.includes(":") ? toolName.split(":").pop() : toolName;
+  if (normalized !== "AskUserQuestion") return result;
+  try {
+    const payload = JSON.parse(result);
+    if (typeof payload !== "object" || payload === null) return result;
+    payload.source_loop = sourceLoop;
+    return JSON.stringify(payload);
+  } catch {
+    return result;
+  }
+}
+function buildSystemNotificationTurn(sequence, turnId, loopId, notificationType, status, title, detail, metadata) {
+  return {
+    id: turnId,
+    sequence,
+    turn_id: turnId,
+    loop_id: loopId,
+    kind: "message",
+    role: "system",
+    status: "completed",
+    blocks: [
+      {
+        type: "system_notification",
+        content: {
+          notification_type: notificationType,
+          status,
+          title,
+          detail,
+          metadata
+        }
+      }
+    ],
+    tool_calls: [],
+    model: null,
+    usage: null,
+    duration_ms: 0
+  };
+}
+function buildSystemNotificationBlock(notificationType, status, title, detail, metadata) {
+  return {
+    type: "system_notification",
+    content: {
+      notification_type: notificationType,
+      status,
+      title,
+      detail,
+      metadata
+    }
+  };
+}
+function buildMarkerTurn(sequence, turnId, loopId, blockType, content) {
+  return {
+    id: turnId,
+    sequence,
+    turn_id: turnId,
+    loop_id: loopId,
+    kind: "message",
+    role: "assistant",
+    status: "completed",
+    blocks: [{ type: blockType, content }],
+    tool_calls: [],
+    model: null,
+    usage: null,
+    duration_ms: 0
+  };
+}
+function buildCompactionTurn(sequence, compactionId, loopId, status, data) {
+  const tokensBefore = asInt(data.tokens_before);
+  const tokensAfter = asInt(data.tokens_after);
+  let savedRatio = null;
+  if (tokensBefore && tokensBefore > 0 && tokensAfter != null) {
+    savedRatio = 1 - tokensAfter / tokensBefore;
+  } else {
+    savedRatio = asFloat(data.saved_ratio);
+  }
+  let archivedCount = asInt(data.archived_count);
+  if (archivedCount == null && Array.isArray(data.archived_files)) {
+    archivedCount = data.archived_files.length;
+  }
+  const content = data.content;
+  const summaryFull = compactionSummaryFull(content);
+  const summaryPreview = summaryFull ? summaryFull.split("\n").map((l) => l.trim()).filter(Boolean).join(" ").slice(0, 200) : null;
+  return {
+    id: `compaction:${compactionId}`,
+    sequence,
+    turn_id: `compaction:${compactionId}`,
+    loop_id: loopId,
+    kind: "compaction",
+    role: "system",
+    status,
+    blocks: [],
+    tool_calls: [],
+    model: null,
+    usage: null,
+    duration_ms: 0,
+    compaction_id: compactionId,
+    summary_preview: summaryPreview,
+    summary_full: summaryFull,
+    archived_count: archivedCount,
+    tokens_before: tokensBefore,
+    tokens_after: tokensAfter,
+    saved_ratio: savedRatio,
+    trigger: asTrigger(data.trigger),
+    failure_reason: typeof data.reason === "string" && data.reason ? data.reason : null,
+    fallback_applied: typeof data.fallback_applied === "boolean" ? data.fallback_applied : null
+  };
+}
+function compactionSummaryFull(content) {
+  const text = String(content ?? "");
+  if (!text) return null;
+  const cleaned = text.replace("<compaction-summary>", "").replace("</compaction-summary>", "").replace(/\r\n/g, "\n").replace(/\r/g, "\n").trim();
+  return cleaned || null;
+}
+function asInt(value) {
+  if (typeof value === "boolean") return null;
+  if (typeof value === "number") return Math.trunc(value);
+  return null;
+}
+function asFloat(value) {
+  if (typeof value === "boolean") return null;
+  if (typeof value === "number") return value;
+  return null;
+}
+function asTrigger(value) {
+  if (value === "auto" || value === "manual" || value === "forced_retry") return value;
+  return null;
+}
+function setToolCallStatus(turn, toolCallId, status, result, pendingQuestionRef) {
+  if (!turn || !toolCallId) return;
+  const toolCalls = "toolCalls" in turn ? turn.toolCalls : turn.tool_calls;
+  for (let i = 0; i < toolCalls.length; i++) {
+    if (toolCalls[i].id !== toolCallId) continue;
+    toolCalls[i] = {
+      ...toolCalls[i],
+      status,
+      result,
+      pending_question_ref: pendingQuestionRef
+    };
+    return;
+  }
+}
+function applyAskUserPauseToTurn(turn, pauseToolData, toolCallId, childLoopName, description, displayNameResolver) {
+  if (!turn || !toolCallId) return;
+  const sourceLoop = childLoopName ? { loop_name: childLoopName, description } : null;
+  const toolName = String(pauseToolData.name ?? "AskUserQuestion");
+  const args = JSON.stringify(pauseToolData.arguments ?? {});
+  const result = askUserResultFromPausePayload(pauseToolData, sourceLoop);
+  const isTurnState = "toolCalls" in turn;
+  const toolCalls = isTurnState ? turn.toolCalls : turn.tool_calls;
+  const blocks = turn.blocks;
+  const displayName = displayNameResolver(toolName);
+  let found = false;
+  for (let i = 0; i < toolCalls.length; i++) {
+    if (toolCalls[i].id !== toolCallId) continue;
+    toolCalls[i] = {
+      ...toolCalls[i],
+      tool_name: toolName || toolCalls[i].tool_name,
+      display_name: displayName || toolCalls[i].display_name,
+      arguments: args || toolCalls[i].arguments
+    };
+    found = true;
+    break;
+  }
+  if (!found) {
+    toolCalls.push({
+      id: toolCallId,
+      tool_name: toolName,
+      display_name: displayName,
+      arguments: args,
+      status: "pending"
+    });
+  }
+  let blockFound = false;
+  for (let i = 0; i < blocks.length; i++) {
+    if (blocks[i].type !== "tool_use" || blocks[i].tool_call_id !== toolCallId) continue;
+    blocks[i] = { ...blocks[i], content: args, tool_name: toolName, display_name: displayName };
+    blockFound = true;
+    break;
+  }
+  if (!blockFound) {
+    blocks.push({
+      type: "tool_use",
+      content: args,
+      tool_call_id: toolCallId,
+      tool_name: toolName,
+      display_name: displayName
+    });
+  }
+  setToolCallStatus(turn, toolCallId, "awaiting_answer", result, null);
+  let resultBlockFound = false;
+  for (let i = 0; i < blocks.length; i++) {
+    if (blocks[i].type !== "tool_result" || blocks[i].tool_call_id !== toolCallId) continue;
+    blocks[i] = { ...blocks[i], content: result };
+    resultBlockFound = true;
+    break;
+  }
+  if (!resultBlockFound) {
+    blocks.push({
+      type: "tool_result",
+      content: result,
+      tool_call_id: toolCallId,
+      tool_name: toolName,
+      display_name: displayName
+    });
+  }
+}
+function applyChildPauseToParent(parentTurn, parentToolCallId, childLoopName, childToolCallId, description, displayNameResolver) {
+  if (!parentTurn || !parentToolCallId) return;
+  const toolCalls = "toolCalls" in parentTurn ? parentTurn.toolCalls : parentTurn.tool_calls;
+  const blocks = parentTurn.blocks;
+  const displayName = displayNameResolver("Agent");
+  let found = false;
+  for (let i = 0; i < toolCalls.length; i++) {
+    if (toolCalls[i].id !== parentToolCallId) continue;
+    toolCalls[i] = {
+      ...toolCalls[i],
+      tool_name: "Agent",
+      display_name: displayName || toolCalls[i].display_name
+    };
+    found = true;
+    break;
+  }
+  if (!found) {
+    toolCalls.push({
+      id: parentToolCallId,
+      tool_name: "Agent",
+      display_name: displayName,
+      arguments: "",
+      status: "pending"
+    });
+  }
+  let blockFound = false;
+  for (let i = 0; i < blocks.length; i++) {
+    if (blocks[i].type !== "tool_use" || blocks[i].tool_call_id !== parentToolCallId) continue;
+    blockFound = true;
+    break;
+  }
+  if (!blockFound) {
+    blocks.push({
+      type: "tool_use",
+      content: "",
+      tool_call_id: parentToolCallId,
+      tool_name: "Agent",
+      display_name: displayName
+    });
+  }
+  setToolCallStatus(parentTurn, parentToolCallId, "awaiting_answer", null, {
+    child_loop_name: childLoopName,
+    child_tool_call_id: childToolCallId,
+    description: description || null
+  });
+}
+function askUserResultFromPausePayload(pauseToolData, sourceLoop) {
+  const args = typeof pauseToolData.arguments === "object" && pauseToolData.arguments !== null ? pauseToolData.arguments : {};
+  const payload = { questions: args.questions ?? [] };
+  if (sourceLoop) payload.source_loop = sourceLoop;
+  return JSON.stringify(payload);
+}
+function sourceLoopFor(loopId, loopDescriptions) {
+  if (loopId === "root") return null;
+  const description = loopDescriptions.get(loopId);
+  if (!description) return null;
+  return { loop_name: loopId, description };
+}
+function normalizeChildPause(pausePayload) {
+  const rawPtd = pausePayload.pause_tool_data;
+  const pauseToolData = typeof rawPtd === "object" && rawPtd !== null ? { ...rawPtd } : { ...pausePayload };
+  let sourceLoop = pauseToolData.source_loop;
+  if (typeof sourceLoop !== "object" || sourceLoop === null) {
+    sourceLoop = pausePayload.source_loop;
+  }
+  const childLoopName = String(pausePayload.child_loop_name ?? "") || (typeof sourceLoop === "object" && sourceLoop ? String(sourceLoop.name ?? "") : "");
+  const childToolCallId = String(
+    pausePayload.child_pause_tool_call_id ?? pauseToolData.tool_call_id ?? ""
+  );
+  const description = typeof sourceLoop === "object" && sourceLoop ? String(sourceLoop.description ?? "") : "";
+  if (childLoopName && description) {
+    pauseToolData.source_loop = { name: childLoopName, description };
+  }
+  return { pauseToolData, childLoopName, childToolCallId, description };
+}
+
+// src/schemas/message.ts
+function inferToolStatus(resultStr) {
+  if (resultStr.includes('"Cancelled by user"')) return "cancelled";
+  try {
+    const parsed = JSON.parse(resultStr);
+    if (typeof parsed === "object" && parsed !== null) {
+      if ("error" in parsed && parsed.error) return "error";
+      const nested = parsed.result;
+      if (typeof nested === "object" && nested !== null && "error" in nested && nested.error) {
+        return "error";
+      }
+    }
+  } catch {
+  }
+  return "done";
+}
+
+// src/shared/projection/state.ts
+function createTurnState(turnId, loopId, opts = {}) {
+  return {
+    turnId,
+    loopId,
+    role: "assistant",
+    model: opts.model ?? null,
+    startedAt: Date.now(),
+    contextWindow: opts.contextWindow ?? 0,
+    blocks: [],
+    toolCalls: [],
+    usage: null,
+    memoryRefs: opts.memoryRefs ?? null,
+    parentForkToolCallId: null
+  };
+}
+function snapshot(state, sequence, status) {
+  return {
+    id: state.turnId,
+    sequence,
+    turn_id: state.turnId,
+    loop_id: state.loopId,
+    kind: "message",
+    role: state.role,
+    status,
+    blocks: [...state.blocks],
+    tool_calls: [...state.toolCalls],
+    model: state.model,
+    usage: state.usage ? { ...state.usage } : null,
+    duration_ms: Math.max(0, Date.now() - state.startedAt),
+    started_at: new Date(state.startedAt).toISOString(),
+    context_window: state.contextWindow,
+    memory_refs: state.memoryRefs,
+    parent_fork_tool_call_id: state.parentForkToolCallId
+  };
+}
+var PAUSE_TOOL_NAMES = /* @__PURE__ */ new Set(["AskUserQuestion", "ExitPlanMode"]);
+function toolStatusFromResult(result) {
+  const text = typeof result === "string" ? result : Array.isArray(result) ? result.filter(
+    (p) => typeof p === "object" && p !== null && p.type === "text"
+  ).map((p) => p.text ?? "").join("\n") : String(result ?? "");
+  return inferToolStatus(text);
+}
+
+// src/shared/projection/builder.ts
+var ClientProjectionBuilder = class {
+  activeTurns = /* @__PURE__ */ new Map();
+  lastTurnIds = /* @__PURE__ */ new Map();
+  latestTurns = /* @__PURE__ */ new Map();
+  loopDescriptions = /* @__PURE__ */ new Map();
+  pendingChildPauses = /* @__PURE__ */ new Map();
+  pendingMemoryRefs = /* @__PURE__ */ new Map();
+  activeCompactions = /* @__PURE__ */ new Map();
+  seq = 0;
+  syntheticCounter = 0;
+  displayNameResolver;
+  constructor(displayNameResolver) {
+    this.displayNameResolver = displayNameResolver ?? ((n) => n);
+  }
+  processBatch(events) {
+    const lastUpsertByTurn = /* @__PURE__ */ new Map();
+    const nonUpserts = [];
+    for (const event of events) {
+      const updates = this.processEvent(event);
+      if (!updates) continue;
+      for (const u of updates) {
+        if (u.kind === "upsert") {
+          lastUpsertByTurn.set(u.turn.turn_id, u);
+        } else {
+          nonUpserts.push(u);
+        }
+      }
+    }
+    return [...nonUpserts, ...lastUpsertByTurn.values()];
+  }
+  processEvent(event) {
+    const payload = event.payload;
+    const loopId = String(payload.loop_name ?? "root");
+    switch (event.type) {
+      case "memory:inject:done":
+        return this.onMemoryInject(loopId, payload);
+      case "memory:inject:none":
+        return null;
+      case "loop:turn":
+        return this.onLoopTurn(loopId, payload);
+      case "mode:change":
+        return this.onModeChange(loopId, payload);
+      case "plan:status:update":
+        return this.onPlanStatusUpdate(loopId, payload);
+      case "workspace:changed":
+        return this.onWorkspaceChanged(loopId, payload);
+      case "agent:start":
+        return this.onAgentStart(loopId, payload);
+      case "bg:started":
+        return this.onBgStarted(loopId, payload);
+      case "bg:tasks_completed":
+        return this.onBgTasksCompleted(loopId, payload);
+      case "loop:ask_user_answer":
+        return this.onAskUserAnswer(loopId, payload);
+      case "user:message":
+        return this.onUserMessage(loopId, payload);
+    }
+    if (event.type.startsWith("compaction:"))
+      return this.onCompaction(event.type, loopId, payload);
+    const state = this.activeTurns.get(loopId);
+    if (!state) {
+      if (event.type === "chat:end") {
+        this.pendingMemoryRefs.delete(loopId);
+        return null;
+      }
+      if (event.type === "agent:end") return this.onAgentEnd(null, loopId, payload);
+      return null;
+    }
+    switch (event.type) {
+      case "llm:thinking:delta":
+        return this.onDelta(state, "thinking", "", String(payload.content ?? ""));
+      case "llm:content:delta":
+        return this.onDelta(state, "text", "", String(payload.content ?? ""));
+      case "llm:tool_call:created":
+        return this.onToolCallCreated(state, payload);
+      case "llm:response:done":
+        return this.onResponseDone(state, loopId, payload);
+      case "tool:result:delta":
+        return this.onToolResultDelta(state, payload);
+      case "tool:result:done":
+        return this.onToolResultDone(state, loopId, payload);
+      case "loop:tool_ui":
+        return this.onToolUi(state, payload);
+      case "loop:tool_bridge":
+        return this.onToolBridge(state, payload);
+      case "tool:approval:required":
+        return this.onToolApprovalRequired(state, payload);
+      case "loop:child_pause":
+        return this.onChildPause(state, loopId, payload);
+      case "chat:end":
+        return this.onChatEnd(state, loopId, payload);
+      case "agent:end":
+        return this.onAgentEnd(state, loopId, payload);
+      default:
+        return null;
+    }
+  }
+  reset() {
+    this.activeTurns.clear();
+    this.lastTurnIds.clear();
+    this.latestTurns.clear();
+    this.loopDescriptions.clear();
+    this.pendingChildPauses.clear();
+    this.pendingMemoryRefs.clear();
+    this.activeCompactions.clear();
+    this.seq = 0;
+    this.syntheticCounter = 0;
+  }
+  seedSequence(maxSeq) {
+    if (maxSeq > this.seq) {
+      this.seq = maxSeq;
+    }
+  }
+  // --- Event handlers ---
+  onMemoryInject(loopId, payload) {
+    const refs = payload.memory_refs;
+    const turnId = String(payload.turn_id ?? "");
+    if (Array.isArray(refs) && refs.length > 0) {
+      this.pendingMemoryRefs.set(loopId, {
+        turnId,
+        refs: refs.map((r) => ({
+          id: Number(r.id),
+          content_preview: String(r.content_preview ?? ""),
+          skill_name: r.skill_name != null ? String(r.skill_name) : null
+        }))
+      });
+    }
+    return null;
+  }
+  onLoopTurn(loopId, payload) {
+    let turnId = String(payload.turn_id ?? this.nextTurnId(`turn:${loopId}`));
+    let memoryRefs = null;
+    const pending = this.pendingMemoryRefs.get(loopId);
+    if (pending) {
+      this.pendingMemoryRefs.delete(loopId);
+      if (pending.turnId) turnId = pending.turnId;
+      memoryRefs = pending.refs;
+    }
+    const rawCw = payload.context_window;
+    const contextWindow = typeof rawCw === "number" && rawCw > 0 ? Math.trunc(rawCw) : 0;
+    const state = createTurnState(turnId, loopId, {
+      model: optStr(payload.model),
+      contextWindow,
+      memoryRefs
+    });
+    this.activeTurns.set(loopId, state);
+    this.lastTurnIds.set(loopId, turnId);
+    const turn = snapshot(state, this.nextSeq(), "streaming");
+    this.latestTurns.set(loopId, turn);
+    return [{ kind: "upsert", turn }];
+  }
+  onModeChange(loopId, payload) {
+    const content = {};
+    if (payload.from != null && payload.from !== "") content.from = String(payload.from);
+    if (payload.to != null && payload.to !== "") content.to = String(payload.to);
+    const turn = buildMarkerTurn(
+      this.nextSeq(),
+      this.nextTurnId("mode_change"),
+      loopId,
+      "mode_change",
+      content
+    );
+    return [{ kind: "upsert", turn }];
+  }
+  onPlanStatusUpdate(loopId, payload) {
+    let statuses = payload.statuses;
+    if (typeof statuses !== "object" || statuses === null) {
+      statuses = payload._statuses ?? {};
+    }
+    const turn = buildMarkerTurn(
+      this.nextSeq(),
+      this.nextTurnId("plan_status"),
+      loopId,
+      "plan_status",
+      { plan_yaml: payload.plan_yaml ?? "", statuses }
+    );
+    return [{ kind: "upsert", turn }];
+  }
+  onWorkspaceChanged(loopId, payload) {
+    const updates = [
+      {
+        kind: "workspace_changed",
+        loopId,
+        toolCallId: optStr(payload.tool_call_id) ?? void 0,
+        toolName: toolNameFromPayload(payload) ?? void 0
+      }
+    ];
+    const state = this.activeTurns.get(loopId);
+    if (state) {
+      const turn = snapshot(state, this.nextSeq(), "streaming");
+      this.latestTurns.set(loopId, turn);
+      this.lastTurnIds.set(loopId, turn.turn_id);
+      updates.push({ kind: "upsert", turn });
+    }
+    return updates;
+  }
+  onAgentStart(loopId, payload) {
+    const description = optStr(payload.description);
+    if (description) this.loopDescriptions.set(loopId, description);
+    const turn = buildSystemNotificationTurn(
+      this.nextSeq(),
+      this.nextTurnId("agent:start"),
+      loopId,
+      "agent:start",
+      "running",
+      `Agent: ${payload.description ?? payload.skill_id ?? "agent"}`,
+      optStr(payload.prompt),
+      {
+        skill_id: optStr(payload.skill_id),
+        description: optStr(payload.description),
+        parent_fork_tool_call_id: optStr(payload.parent_fork_tool_call_id)
+      }
+    );
+    return [{ kind: "upsert", turn }];
+  }
+  onBgStarted(loopId, payload) {
+    const taskId = optStr(payload.task_id) ?? "";
+    const command = optStr(payload.command);
+    const description = optStr(payload.description);
+    const turn = buildSystemNotificationTurn(
+      this.nextSeq(),
+      this.nextTurnId("bg:started"),
+      loopId,
+      "bg:started",
+      "running",
+      description ?? `Background: ${taskId || "task"}`,
+      command,
+      { task_id: taskId, command, description }
+    );
+    return [{ kind: "upsert", turn }];
+  }
+  onBgTasksCompleted(loopId, payload) {
+    const taskIds = Array.isArray(payload.task_ids) ? payload.task_ids : [];
+    const count = typeof payload.count === "number" ? payload.count : taskIds.length;
+    const detail = taskIds.map(String).join(", ");
+    const turn = buildSystemNotificationTurn(
+      this.nextSeq(),
+      this.nextTurnId("bg:tasks_completed"),
+      loopId,
+      "bg:tasks_completed",
+      "done",
+      `Background tasks completed (${count})`,
+      detail || null,
+      { task_ids: taskIds, count }
+    );
+    return [{ kind: "upsert", turn }];
+  }
+  onAskUserAnswer(loopId, payload) {
+    const toolCallId = String(payload.tool_call_id ?? "");
+    const pending = this.pendingChildPauses.get(toolCallId);
+    const parentLoopId = pending?.parentLoopName;
+    if (pending) {
+      this.pendingChildPauses.delete(toolCallId);
+      const childTurn = this.activeTurns.get(pending.childLoopName) ?? this.latestTurns.get(pending.childLoopName);
+      setToolCallStatus(childTurn, pending.childToolCallId, "done", null, null);
+      const parentTurn = this.activeTurns.get(pending.parentLoopName) ?? this.latestTurns.get(pending.parentLoopName);
+      setToolCallStatus(parentTurn, pending.parentToolCallId, "done", null, null);
+    }
+    const directTurn = this.activeTurns.get(loopId) ?? this.latestTurns.get(loopId);
+    setToolCallStatus(directTurn, toolCallId, "done", null, null);
+    return this.collectLoopUpdates(loopId, parentLoopId);
+  }
+  onUserMessage(_loopId, payload) {
+    const entryId = String(payload.entry_id ?? this.nextTurnId("user"));
+    const displayContent = payload.display_content ?? payload.content ?? "";
+    const turn = {
+      id: entryId,
+      sequence: this.nextSeq(),
+      turn_id: entryId,
+      loop_id: "root",
+      kind: "message",
+      role: "user",
+      status: "completed",
+      blocks: [{ type: "text", content: displayContent }],
+      tool_calls: [],
+      model: null,
+      usage: null,
+      duration_ms: 0
+    };
+    return [{ kind: "upsert", turn }];
+  }
+  // --- Delta / streaming events ---
+  onDelta(state, blockType, _toolCallId, content) {
+    if (!content) return null;
+    appendTextBlock(state, blockType, content);
+    return this.syncPatch(state);
+  }
+  onToolCallCreated(state, payload) {
+    if ("arguments_delta" in payload) {
+      const delta = String(payload.arguments_delta ?? "");
+      const toolCallId2 = String(payload.id ?? "");
+      if (delta && toolCallId2) {
+        appendToolCallArguments(state, toolCallId2, delta);
+        return this.syncPatch(state);
+      }
+      return null;
+    }
+    const toolCallId = String(payload.id ?? "");
+    const toolName = toolNameFromPayload(payload);
+    const displayName = String(payload.display_name ?? "") || this.displayNameResolver(toolName);
+    const args = toolArgsFromPayload(payload);
+    upsertToolCall(state, toolCallId, toolName, displayName, args);
+    return this.syncPatch(state);
+  }
+  onResponseDone(state, loopId, payload) {
+    const model = optStr(payload.model);
+    if (model) state.model = model;
+    if (typeof payload.usage === "object" && payload.usage !== null) {
+      state.usage = { ...payload.usage };
+    }
+    const toolCalls = payload.tool_calls;
+    if (Array.isArray(toolCalls)) {
+      for (const raw of toolCalls) {
+        if (typeof raw !== "object" || raw === null) continue;
+        const tc = raw;
+        const fn = tc.function ?? {};
+        const toolName = String(fn.name ?? "");
+        const displayName = String(tc.display_name ?? "") || this.displayNameResolver(toolName);
+        upsertToolCall(
+          state,
+          String(tc.id ?? ""),
+          toolName,
+          displayName,
+          String(fn.arguments ?? "")
+        );
+      }
+    }
+    if (state.toolCalls.length === 0) {
+      return this.finalize(loopId, "completed");
+    }
+    return this.syncPatch(state);
+  }
+  onToolResultDone(state, loopId, payload) {
+    const toolCallId = String(payload.tool_call_id ?? "");
+    const content = payload.content ?? "";
+    const status = toolStatusFromResult(content);
+    const rawDuration = payload.duration_ms;
+    const durationMs = typeof rawDuration === "number" && rawDuration >= 0 ? Math.round(rawDuration) : null;
+    const sl = sourceLoopFor(state.loopId, this.loopDescriptions);
+    applyToolResult(state, toolCallId, content, status, durationMs, sl);
+    if (this.shouldFinalizeAfterToolResults(state)) {
+      return this.finalize(loopId, "completed");
+    }
+    return this.syncPatch(state);
+  }
+  onToolResultDelta(state, payload) {
+    appendToolResultDelta(
+      state,
+      String(payload.tool_call_id ?? ""),
+      String(payload.content ?? "")
+    );
+    return this.syncPatch(state);
+  }
+  onToolUi(state, payload) {
+    const toolCallId = String(payload.tool_call_id ?? "");
+    const ui = payload.ui;
+    if (toolCallId && typeof ui === "object" && ui !== null) {
+      state.blocks.push({
+        type: "tool_ui",
+        content: ui,
+        tool_call_id: toolCallId
+      });
+    }
+    return this.syncPatch(state);
+  }
+  onToolBridge(state, payload) {
+    const bridge = payload.bridge;
+    if (typeof bridge !== "object" || bridge === null) return null;
+    state.blocks.push({
+      type: "tool_bridge",
+      content: bridge,
+      tool_call_id: String(payload.tool_call_id ?? "") || null
+    });
+    return this.syncPatch(state);
+  }
+  onToolApprovalRequired(state, payload) {
+    const toolCallId = String(payload.tool_call_id ?? "");
+    const toolName = String(payload.tool_name ?? "");
+    const displayName = this.displayNameResolver(toolName);
+    upsertToolCall(state, toolCallId, toolName, displayName, "");
+    return this.syncPatch(state);
+  }
+  onChildPause(state, loopId, payload) {
+    const pauseToolData = payload.pause_tool_data;
+    if (typeof pauseToolData !== "object" || pauseToolData === null)
+      return this.syncPatch(state);
+    const ptd = pauseToolData;
+    const sourceLoop = ptd.source_loop;
+    if (typeof sourceLoop === "object" && sourceLoop) {
+      const slName = String(sourceLoop.name ?? "");
+      const slDesc = optStr(sourceLoop.description);
+      if (slName && slDesc) this.loopDescriptions.set(slName, slDesc);
+    }
+    const { childLoopName, childToolCallId, description } = normalizeChildPause(payload);
+    if (!childToolCallId) return this.syncPatch(state);
+    const existing = this.pendingChildPauses.get(childToolCallId);
+    const parentLoopName = String(
+      payload.parent_loop_name ?? existing?.parentLoopName ?? "root"
+    );
+    const parentToolCallId = String(
+      payload.parent_fork_tool_call_id ?? existing?.parentToolCallId ?? ""
+    );
+    const resolvedChildLoopName = String(payload.child_loop_name ?? "") || existing?.childLoopName || childLoopName || loopId;
+    this.pendingChildPauses.set(childToolCallId, {
+      parentLoopName,
+      parentToolCallId,
+      childLoopName: resolvedChildLoopName,
+      childToolCallId,
+      description: description || existing?.description || ""
+    });
+    applyAskUserPauseToTurn(
+      state,
+      ptd,
+      childToolCallId,
+      resolvedChildLoopName,
+      this.pendingChildPauses.get(childToolCallId).description,
+      this.displayNameResolver
+    );
+    const parentTurn = this.activeTurns.get(parentLoopName) ?? this.latestTurns.get(parentLoopName);
+    if (parentTurn) {
+      applyChildPauseToParent(
+        parentTurn,
+        parentToolCallId,
+        resolvedChildLoopName,
+        childToolCallId,
+        this.pendingChildPauses.get(childToolCallId).description,
+        this.displayNameResolver
+      );
+    }
+    return this.collectLoopUpdates(loopId, parentLoopName);
+  }
+  onChatEnd(state, loopId, payload) {
+    const status = String(payload.status ?? "completed");
+    const pauseToolData = payload.pause_tool_data;
+    if (typeof pauseToolData === "object" && pauseToolData !== null) {
+      const ptd = pauseToolData;
+      const pauseToolName = String(ptd.name ?? "");
+      const normalized = pauseToolName.includes(":") ? pauseToolName.split(":").pop() : pauseToolName;
+      const sourceLoop = ptd.source_loop;
+      if (typeof sourceLoop === "object" && sourceLoop) {
+        const slName = String(sourceLoop.name ?? "");
+        const slDesc = optStr(sourceLoop.description);
+        if (slName && slDesc) this.loopDescriptions.set(slName, slDesc);
+        if (status === "paused" && slName) {
+          applyChildPauseToParent(
+            state,
+            String(ptd.parent_fork_tool_call_id ?? ""),
+            slName,
+            String(ptd.tool_call_id ?? ""),
+            slDesc ?? "",
+            this.displayNameResolver
+          );
+          const childTurn = this.activeTurns.get(slName);
+          if (childTurn) {
+            applyAskUserPauseToTurn(
+              childTurn,
+              ptd,
+              String(ptd.tool_call_id ?? ""),
+              slName,
+              slDesc ?? "",
+              this.displayNameResolver
+            );
+          }
+        }
+      } else if (status === "paused" && normalized === "AskUserQuestion") {
+        applyAskUserPauseToTurn(
+          state,
+          ptd,
+          String(ptd.tool_call_id ?? ""),
+          "",
+          "",
+          this.displayNameResolver
+        );
+      }
+    }
+    const finalStatus = { completed: "completed", paused: "paused", failed: "failed", interrupted: "interrupted" }[status];
+    if (!finalStatus) return null;
+    if (!this.activeTurns.has(loopId)) {
+      this.pendingMemoryRefs.delete(loopId);
+    }
+    return this.finalize(loopId, finalStatus);
+  }
+  onAgentEnd(state, loopId, payload) {
+    const ok = payload.ok !== false;
+    const status = ok ? "done" : "error";
+    const title = `Agent: ${payload.description ?? payload.skill_id ?? "agent"}`;
+    const detail = optStr(payload.error);
+    const metadata = {
+      skill_id: optStr(payload.skill_id),
+      description: optStr(payload.description),
+      parent_fork_tool_call_id: optStr(payload.parent_fork_tool_call_id),
+      ok
+    };
+    if (state) {
+      state.blocks.push(buildSystemNotificationBlock("agent:end", status, title, detail, metadata));
+      return this.finalize(loopId, ok ? "completed" : "failed");
+    }
+    const turn = buildSystemNotificationTurn(
+      this.nextSeq(),
+      this.nextTurnId("agent:end"),
+      loopId,
+      "agent:end",
+      status,
+      title,
+      detail,
+      metadata
+    );
+    return [{ kind: "upsert", turn }];
+  }
+  onCompaction(eventType, loopId, payload) {
+    const compactionId = String(payload.compaction_id ?? "");
+    if (!compactionId) return null;
+    const current = {
+      ...this.activeCompactions.get(compactionId) ?? {},
+      ...payload,
+      loop_id: loopId
+    };
+    let status;
+    switch (eventType) {
+      case "compaction:start":
+        status = "streaming";
+        this.activeCompactions.set(compactionId, current);
+        break;
+      case "compaction:end":
+        status = "completed";
+        this.activeCompactions.delete(compactionId);
+        break;
+      case "compaction:abort":
+        status = "interrupted";
+        this.activeCompactions.delete(compactionId);
+        break;
+      case "compaction:error":
+        status = "failed";
+        this.activeCompactions.delete(compactionId);
+        break;
+      default:
+        status = "streaming";
+        this.activeCompactions.set(compactionId, current);
+    }
+    const turn = buildCompactionTurn(this.nextSeq(), compactionId, loopId, status, current);
+    return [{ kind: "upsert", turn }];
+  }
+  // --- Internal helpers ---
+  syncPatch(state) {
+    const turn = snapshot(state, this.nextSeq(), "streaming");
+    this.latestTurns.set(state.loopId, turn);
+    this.lastTurnIds.set(state.loopId, turn.turn_id);
+    return [{ kind: "upsert", turn }];
+  }
+  finalize(loopId, status) {
+    const state = this.activeTurns.get(loopId);
+    if (!state) return null;
+    this.activeTurns.delete(loopId);
+    const turn = snapshot(state, this.nextSeq(), status);
+    this.lastTurnIds.set(loopId, turn.turn_id);
+    this.latestTurns.set(loopId, turn);
+    return [{ kind: "upsert", turn }];
+  }
+  shouldFinalizeAfterToolResults(state) {
+    if (state.toolCalls.length === 0) return true;
+    if (state.toolCalls.some((tc) => tc.status === "pending")) return false;
+    return !state.toolCalls.some((tc) => {
+      const normalized = tc.tool_name.includes(":") ? tc.tool_name.split(":").pop() : tc.tool_name;
+      return PAUSE_TOOL_NAMES.has(normalized);
+    });
+  }
+  collectLoopUpdates(...loopIds) {
+    const updates = [];
+    for (const loopId of loopIds) {
+      if (!loopId) continue;
+      const state = this.activeTurns.get(loopId);
+      if (state) {
+        updates.push(...this.syncPatch(state));
+        continue;
+      }
+      const proj = this.latestTurns.get(loopId);
+      if (proj) {
+        const updated = { ...proj, sequence: this.nextSeq() };
+        this.latestTurns.set(loopId, updated);
+        updates.push({ kind: "upsert", turn: updated });
+      }
+    }
+    return updates;
+  }
+  nextSeq() {
+    return ++this.seq;
+  }
+  nextTurnId(prefix) {
+    this.syntheticCounter++;
+    const hex = Math.random().toString(16).slice(2, 10);
+    return `${prefix}:${this.syntheticCounter}:${hex}`;
+  }
+};
+function optStr(value) {
+  if (value == null || value === "") return null;
+  return String(value);
+}
+function toolNameFromPayload(payload) {
+  const fn = payload.function;
+  if (typeof fn === "object" && fn !== null) {
+    return String(fn.name ?? "");
+  }
+  return String(payload.tool_name ?? "");
+}
+function toolArgsFromPayload(payload) {
+  const fn = payload.function;
+  if (typeof fn === "object" && fn !== null) {
+    return String(fn.arguments ?? "");
+  }
+  return "";
+}
+
+// src/shared/projection/history.ts
+function projectHistory(entries) {
+  const turns = [];
+  const toolOwners = /* @__PURE__ */ new Map();
+  const latestAssistantByLoop = /* @__PURE__ */ new Map();
+  const pendingChildPauses = /* @__PURE__ */ new Map();
+  let sequence = 0;
+  for (const entry of entries) {
+    const kind = String(entry.kind ?? "");
+    const loopId = String(entry.loop_name ?? "root");
+    const id = String(entry.id ?? `history-${sequence + 1}`);
+    if (kind === "message" && isRecord2(entry.message)) {
+      const message = entry.message;
+      const role = String(message.role ?? "");
+      if (role === "tool") {
+        const toolCallId = String(message.tool_call_id ?? "");
+        const owner = toolOwners.get(toolCallId);
+        const toolCall = owner?.tool_calls.find((item) => item.id === toolCallId);
+        if (owner && toolCall) {
+          toolCall.status = message._error ? "error" : inferToolStatus(String(message.content ?? ""));
+          toolCall.result = message.content ?? "";
+          owner.blocks.push({
+            type: "tool_result",
+            content: message.content ?? "",
+            tool_call_id: toolCallId
+          });
+        }
+        continue;
+      }
+      if (role !== "user" && role !== "assistant" && role !== "system") continue;
+      const toolCalls = role === "assistant" ? buildToolCalls(message.tool_calls) : [];
+      const blocks = buildBlocks(message, toolCalls);
+      const turn = {
+        id,
+        sequence: ++sequence,
+        turn_id: id,
+        loop_id: loopId,
+        kind: "message",
+        role,
+        status: message._error ? "failed" : "completed",
+        blocks,
+        tool_calls: toolCalls,
+        model: stringOrNull(message.model),
+        usage: isRecord2(message._usage) ? { ...message._usage } : null,
+        duration_ms: numberOrZero(message._duration_ms),
+        started_at: typeof entry.timestamp === "string" ? entry.timestamp : void 0
+      };
+      turns.push(turn);
+      if (role === "assistant") latestAssistantByLoop.set(loopId, turn);
+      for (const toolCall of toolCalls) toolOwners.set(toolCall.id, turn);
+      continue;
+    }
+    if (kind === "mode_change") {
+      turns.push(markerTurn(id, ++sequence, loopId, "mode_change", entry.data ?? {}));
+    } else if (kind === "plan_status") {
+      const data = entry.data ?? {};
+      turns.push(
+        markerTurn(id, ++sequence, loopId, "plan_status", {
+          plan_yaml: data.plan_yaml ?? "",
+          statuses: data.statuses ?? data._statuses ?? {}
+        })
+      );
+    } else if (kind === "tool_ui" || kind === "tool_bridge") {
+      const data = entry.data ?? {};
+      const toolCallId = String(data.tool_call_id ?? "");
+      const owner = toolOwners.get(toolCallId) ?? findLatestAssistant(turns, loopId);
+      const content = kind === "tool_ui" ? data.ui : data.bridge;
+      if (owner && content !== void 0) {
+        owner.blocks.push({
+          type: kind,
+          content,
+          tool_call_id: toolCallId || null
+        });
+      }
+    } else if (kind === "compaction" || kind === "tool_result_archive") {
+      const data = entry.data ?? {};
+      const compactionId = String(data.compaction_id ?? entry.id ?? `history-${sequence + 1}`);
+      let content = isRecord2(entry.message) ? entry.message.content : void 0;
+      if (kind === "tool_result_archive") {
+        const archivedCount = Array.isArray(data.archived_files) ? data.archived_files.length : 0;
+        content = `<compaction-summary>
+\u5DF2\u5F52\u6863 ${archivedCount} \u4E2A\u5927\u578B\u5DE5\u5177\u7ED3\u679C\u3002
+</compaction-summary>`;
+      }
+      turns.push(
+        buildCompactionTurn(++sequence, compactionId, loopId, "completed", {
+          ...data,
+          content
+        })
+      );
+    } else if (kind === "child_pause") {
+      const data = entry.data ?? {};
+      const sourceLoop = isRecord2(data.source_loop) ? data.source_loop : {};
+      const childLoopId = String(data.child_loop_name ?? sourceLoop.name ?? "");
+      const childToolCallId = String(data.child_pause_tool_call_id ?? "");
+      const parentToolCallId = String(data.parent_fork_tool_call_id ?? "");
+      const pauseToolData = isRecord2(data.pause_tool_data) ? data.pause_tool_data : {};
+      const description = String(sourceLoop.description ?? "");
+      applyAskUserPauseToTurn(
+        latestAssistantByLoop.get(childLoopId),
+        pauseToolData,
+        childToolCallId,
+        childLoopId,
+        description,
+        (name) => name
+      );
+      applyChildPauseToParent(
+        latestAssistantByLoop.get(loopId),
+        parentToolCallId,
+        childLoopId,
+        childToolCallId,
+        description,
+        (name) => name
+      );
+      if (childToolCallId) {
+        pendingChildPauses.set(childToolCallId, {
+          childLoopId,
+          parentLoopId: loopId,
+          parentToolCallId
+        });
+      }
+    } else if (kind === "ask_user_answer") {
+      const data = entry.data ?? {};
+      const toolCallId = String(data.tool_call_id ?? "");
+      const pending = pendingChildPauses.get(toolCallId);
+      if (pending) {
+        setToolCallStatus(latestAssistantByLoop.get(pending.childLoopId), toolCallId, "done", null, null);
+        setToolCallStatus(
+          latestAssistantByLoop.get(pending.parentLoopId),
+          pending.parentToolCallId,
+          "done",
+          null,
+          null
+        );
+        pendingChildPauses.delete(toolCallId);
+      } else {
+        setToolCallStatus(latestAssistantByLoop.get(loopId), toolCallId, "done", null, null);
+      }
+      turns.push(
+        markerTurn(
+          id,
+          ++sequence,
+          loopId,
+          "ask_user_answer",
+          data,
+          toolCallId || null
+        )
+      );
+    }
+  }
+  return turns;
+}
+function buildToolCalls(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter(isRecord2).map((raw) => {
+    const fn = isRecord2(raw.function) ? raw.function : {};
+    const name = String(fn.name ?? "");
+    return {
+      id: String(raw.id ?? ""),
+      tool_name: name,
+      display_name: String(raw.display_name ?? name),
+      arguments: typeof fn.arguments === "string" ? fn.arguments : JSON.stringify(fn.arguments ?? {}),
+      status: "running",
+      result: null
+    };
+  });
+}
+function buildBlocks(message, toolCalls) {
+  const displayContent = message.role === "user" ? message._display_content : void 0;
+  const stored = message._blocks;
+  const blocks = [];
+  if (displayContent !== void 0) {
+    blocks.push({ type: "text", content: displayContent });
+  } else if (Array.isArray(stored)) {
+    for (const raw of stored) {
+      if (!isRecord2(raw)) continue;
+      const type3 = String(raw.type ?? "");
+      if (type3 === "thinking") blocks.push({ type: type3, content: raw.thinking ?? raw.content ?? "" });
+      if (type3 === "text") blocks.push({ type: type3, content: raw.text ?? raw.content ?? "" });
+    }
+  } else if (message.content !== void 0 && message.content !== "") {
+    blocks.push({ type: "text", content: message.content });
+  }
+  for (const toolCall of toolCalls) {
+    blocks.push({
+      type: "tool_use",
+      content: { name: toolCall.tool_name, arguments: toolCall.arguments },
+      tool_call_id: toolCall.id
+    });
+  }
+  return blocks;
+}
+function markerTurn(id, sequence, loopId, type3, content, toolCallId = null) {
+  return {
+    id,
+    sequence,
+    turn_id: id,
+    loop_id: loopId,
+    kind: type3,
+    role: "system",
+    status: "completed",
+    blocks: [{ type: type3, content, tool_call_id: toolCallId }],
+    tool_calls: [],
+    model: null,
+    usage: null,
+    duration_ms: 0
+  };
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringOrNull(value) {
+  return typeof value === "string" ? value : null;
+}
+function numberOrZero(value) {
+  return typeof value === "number" ? value : 0;
+}
+function findLatestAssistant(turns, loopId) {
+  for (let index = turns.length - 1; index >= 0; index -= 1) {
+    const turn = turns[index];
+    if (turn?.role === "assistant" && turn.loop_id === loopId) return turn;
+  }
+  return void 0;
+}
+
+// src/resources/sessions.ts
+function toCreateSessionPayload(request) {
+  return {
+    intent: request.intent ?? "",
+    template_id: request.template_id,
+    solution_id: request.solution_id,
+    biz_role_id: request.biz_role_id ?? null,
+    model: request.model ?? null,
+    enable_thinking: request.enable_thinking ?? null,
+    memory_enabled: request.memory_enabled ?? null,
+    primary_skill_id: request.primary_skill_id ?? null,
+    env: request.env,
+    disable_tools: request.disable_tools ?? null,
+    session_solution_asset_id: request.session_solution_asset_id ?? null,
+    compaction_ratio: request.compaction_ratio ?? null,
+    ...request.runtime_type ? { runtime_type: request.runtime_type } : {},
+    ...request.daemon_id ? { daemon_id: request.daemon_id } : {}
+  };
+}
+var SessionsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * 连接一个已存在的会话，返回实时会话对象 AgentSession
+   * （自动完成历史加载、Socket.IO 订阅、断线重连补数）。
+   */
+  connect(sessionId) {
+    return this.client.hub.connect(sessionId);
+  }
+  /** 创建新会话并直接连接，返回可收发消息的 AgentSession。 */
+  async create(request = {}) {
+    await this.client.ensureVersionCompatible();
+    const { session_id } = await this.createSessionWithRequest(request);
+    return this.connect(session_id);
+  }
+  fetchSessionsPage({
+    limit,
+    offset,
+    template_id_prefix,
+    solution_id,
+    q
+  }) {
+    const searchParams = new URLSearchParams();
+    searchParams.set("limit", String(limit));
+    searchParams.set("offset", String(offset));
+    if (template_id_prefix) searchParams.set("template_id_prefix", template_id_prefix);
+    if (solution_id) searchParams.set("solution_id", solution_id);
+    const trimmedQuery = q?.trim();
+    if (trimmedQuery) searchParams.set("q", trimmedQuery);
+    return this.client.json("GET", `/api/sessions?${searchParams.toString()}`);
+  }
+  async listSessions(template_id_prefix, solution_id) {
+    const pageSize = 100;
+    const sessions = [];
+    let offset = 0;
+    while (true) {
+      const page = await this.fetchSessionsPage({ limit: pageSize, offset, template_id_prefix, solution_id });
+      sessions.push(...page.items);
+      if (sessions.length >= page.total || page.items.length === 0) return sessions;
+      offset += page.items.length;
+    }
+  }
+  listSessionsPaginated(params) {
+    return this.fetchSessionsPage(params);
+  }
+  listSessionsWithSkillData() {
+    return this.client.json("GET", "/api/sessions/with-skill-data");
+  }
+  createSession(intent, template_id, primary_skill_id) {
+    return this.createSessionWithRequest({ intent, template_id, primary_skill_id });
+  }
+  createSessionWithRequest(request) {
+    return this.client.json("POST", "/api/sessions", toCreateSessionPayload(request));
+  }
+  createWithProfile(params) {
+    const { intent, profile } = params;
+    return this.createSessionWithRequest({
+      intent,
+      ...profileToCreateSessionRequest(profile)
+    });
+  }
+  getSession(sessionId, init) {
+    return this.client.jsonFromInit(`/api/sessions/${sessionId}`, init);
+  }
+  updateSession(sessionId, payload) {
+    return this.client.json("PATCH", `/api/sessions/${sessionId}`, payload);
+  }
+  setSessionEnv(sessionId, env) {
+    return this.client.json("PUT", `/api/sessions/${sessionId}/env`, { env });
+  }
+  pinSession(sessionId, pinned) {
+    return this.client.json("PATCH", `/api/sessions/${sessionId}/pin`, { pinned });
+  }
+  startReplaySession(sourceSessionId, speed = 5) {
+    return this.client.json("POST", `/api/sessions/${sourceSessionId}/replay`, { speed });
+  }
+  updateReplaySession(sessionId, payload) {
+    return this.client.json("PATCH", `/api/sessions/${sessionId}/replay`, payload);
+  }
+  updateSharing(sessionId, shared) {
+    return this.client.json("PATCH", `/api/sessions/${sessionId}/sharing`, { shared });
+  }
+  updateSessionMemory(sessionId, memoryEnabled) {
+    return this.client.json("PATCH", `/api/sessions/${sessionId}/memory`, {
+      memory_enabled: memoryEnabled
+    });
+  }
+  createShare(sessionId) {
+    return this.client.json("POST", `/api/sessions/${sessionId}/share`, {});
+  }
+  revokeShare(sessionId, token) {
+    return this.client.json("DELETE", `/api/sessions/${sessionId}/share/${encodeURIComponent(token)}`);
+  }
+  async getSharedSession(token) {
+    const entries = await this.client.jsonFromInit(`/api/share/${encodeURIComponent(token)}`, {
+      credentials: "omit",
+      headers: { Accept: "application/json" }
+    });
+    return projectHistory(entries);
+  }
+  getSessionTasks(sessionId) {
+    return this.client.json("GET", `/api/sessions/${sessionId}/tasks`);
+  }
+  async getSessionTurns(sessionId) {
+    const entries = await this.client.json(
+      "GET",
+      `/api/sessions/${sessionId}/messages`
+    );
+    return projectHistory(entries);
+  }
+  getSessionContextStats(sessionId, init) {
+    return this.client.jsonFromInit(`/api/sessions/${sessionId}/context-stats`, init);
+  }
+  getSessionHistory(sessionId, init) {
+    return this.client.jsonFromInit(`/api/sessions/${sessionId}/history`, init);
+  }
+  tokenizePrompt(prompt, model) {
+    return this.client.json("POST", "/api/sessions/tokenize/prompt", { prompt, model });
+  }
+  tokenizeMessages(messages, options) {
+    return this.client.json("POST", "/api/sessions/tokenize/messages", {
+      messages,
+      model: options?.model,
+      add_generation_prompt: options?.add_generation_prompt ?? true,
+      enable_thinking: options?.enable_thinking ?? null,
+      tools: options?.tools ?? null
+    });
+  }
+  getSessionCheckpoints(sessionId, init) {
+    return this.client.jsonFromInit(`/api/sessions/${sessionId}/checkpoints`, init);
+  }
+  checkoutSession(sessionId, checkpointId, position, mode, linear) {
+    return this.client.json("POST", `/api/sessions/${sessionId}/checkout`, {
+      checkpoint_id: checkpointId,
+      position,
+      ...mode ? { mode } : {},
+      ...linear ? { linear } : {}
+    });
+  }
+  async rewindSession(sessionId, checkpointId) {
+    const result = await this.checkoutSession(sessionId, checkpointId, "before");
+    return { id: result.id, content: result.content };
+  }
+  switchBranch(sessionId, checkpointId) {
+    return this.client.json("POST", `/api/sessions/${sessionId}/switch-branch`, {
+      checkpoint_id: checkpointId
+    });
+  }
+  deleteSession(sessionId) {
+    return this.client.json("DELETE", `/api/sessions/${sessionId}`);
+  }
+  listBackgroundTasks(sessionId, init) {
+    return this.client.jsonFromInit(`/api/sessions/${sessionId}/background-tasks`, init);
+  }
+  getBackgroundTask(sessionId, taskId, tail = 100, init) {
+    return this.client.jsonFromInit(`/api/sessions/${sessionId}/background-tasks/${taskId}?tail=${tail}`, init);
+  }
+  stopBackgroundTask(sessionId, taskId) {
+    return this.client.json("POST", `/api/sessions/${sessionId}/background-tasks/${taskId}/stop`);
+  }
+  probeSessionUrl(sessionId, url) {
+    return this.client.json(
+      "GET",
+      `/api/sessions/${sessionId}/probe-url?url=${encodeURIComponent(url)}`
+    );
+  }
+  listDir(sessionId, dirPath) {
+    return this.client.json("GET", `/api/sessions/${sessionId}/ls/${encodeURIComponent(dirPath)}`);
+  }
+  async uploadFiles(sessionId, dirPath, files, options = {}) {
+    const formData = new FormData();
+    const entries = Array.from(files).map(
+      (f) => f instanceof File ? { file: f, name: f.name } : f
+    );
+    for (const entry of entries) {
+      formData.append("files", entry.file, entry.name);
+    }
+    const relativePaths = entries.map((e) => e.file.webkitRelativePath || e.name);
+    if (relativePaths.some((p) => p.includes("/"))) {
+      formData.append("paths", JSON.stringify(relativePaths));
+    }
+    const response = await this.client.formData(
+      "POST",
+      `/api/sessions/${sessionId}/upload/${encodeURIComponent(dirPath)}`,
+      formData,
+      { expectOk: false, onUploadProgress: options.onProgress }
+    );
+    return response.json();
+  }
+  async deleteFile(sessionId, filePath) {
+    await this.client.json("DELETE", `/api/sessions/${sessionId}/files/${encodeURIComponent(filePath)}`);
+  }
+  writeFile(sessionId, filePath, content) {
+    return this.client.json("PUT", `/api/sessions/${sessionId}/files/${encodeURIComponent(filePath)}`, {
+      content
+    });
+  }
+  renameFile(sessionId, filePath, newName) {
+    return this.client.json("POST", `/api/sessions/${sessionId}/files/${encodeURIComponent(filePath)}/rename`, {
+      new_name: newName
+    });
+  }
+  copyFile(sessionId, filePath) {
+    return this.client.json("POST", `/api/sessions/${sessionId}/files/${encodeURIComponent(filePath)}/copy`);
+  }
+  shareFile(sessionId, sourcePath, linkName, shareFolder) {
+    return this.client.json("POST", `/api/sessions/${sessionId}/share-file`, {
+      source_path: sourcePath,
+      link_name: linkName ?? "",
+      share_folder: shareFolder ?? ""
+    });
+  }
+  getDownloadDirUrl(sessionId, dirPath) {
+    return this.client.buildAuthedUrl(`/api/sessions/${sessionId}/download-dir/${encodeURIComponent(dirPath)}`);
+  }
+  async exportSession(sessionId) {
+    await this.getSession(sessionId);
+    const a = document.createElement("a");
+    a.href = this.client.buildAuthedUrl(`/api/sessions/${sessionId}/export`);
+    a.download = `${sessionId}.zip`;
+    document.body.appendChild(a);
+    a.click();
+    a.remove();
+  }
+  async previewImport(file) {
+    const form = new FormData();
+    form.append("file", file);
+    const res = await this.client.formData("POST", "/api/sessions/preview-import", form);
+    return res.json();
+  }
+  async importSession(file, name, solutionId) {
+    const form = new FormData();
+    form.append("file", file);
+    if (name) form.append("name", name);
+    if (solutionId) form.append("solution_id", solutionId);
+    const res = await this.client.formData("POST", "/api/sessions/import", form);
+    return res.json();
+  }
+};
+function profileToCreateSessionRequest(profile) {
+  const solution = profile.solution;
+  return {
+    solution_id: solution?.kind === "existing" ? solution.solutionId : void 0,
+    session_solution_asset_id: solution?.kind === "prepared" ? solution.assetId : void 0,
+    biz_role_id: solution?.bizRoleId ?? null,
+    model: profile.model ?? null,
+    compaction_ratio: profile.compactionRatio ?? null,
+    enable_thinking: profile.enableThinking ?? null,
+    memory_enabled: profile.memoryEnabled ?? null,
+    disable_tools: profile.disableTools ?? null,
+    env: profile.env
+  };
+}
+
+// src/commands/registry.ts
+var BUFFER_LIMIT_PER_ACTION = 20;
+var CommandRegistry = class {
+  handlers = /* @__PURE__ */ new Map();
+  buffered = /* @__PURE__ */ new Map();
+  onCommand(action, handler) {
+    let set = this.handlers.get(action);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.handlers.set(action, set);
+    }
+    set.add(handler);
+    const pending = this.buffered.get(action);
+    if (pending?.length) {
+      this.buffered.delete(action);
+      for (const command of pending) {
+        this.invoke(handler, action, command);
+      }
+    }
+    return () => {
+      this.handlers.get(action)?.delete(handler);
+    };
+  }
+  dispatch(action, payload, meta = {}) {
+    const set = this.handlers.get(action);
+    if (set && set.size > 0) {
+      for (const handler of [...set]) {
+        this.invoke(handler, action, { payload, meta });
+      }
+      return;
+    }
+    let pending = this.buffered.get(action);
+    if (!pending) {
+      pending = [];
+      this.buffered.set(action, pending);
+    }
+    pending.push({ payload, meta });
+    if (pending.length > BUFFER_LIMIT_PER_ACTION) {
+      pending.shift();
+      console.warn(
+        `[agent-client] \u6307\u4EE4 "${action}" \u65E0\u4EBA\u5904\u7406\u4E14\u7F13\u51B2\u5DF2\u6EE1\uFF0C\u6700\u65E7\u7684\u4E00\u6761\u5DF2\u4E22\u5F03\u3002\u8BF7\u8C03\u7528 onCommand("${action}", handler) \u6CE8\u518C\u5904\u7406\u51FD\u6570\u3002`
+      );
+    }
+  }
+  invoke(handler, action, command) {
+    try {
+      handler(command.payload, command.meta);
+    } catch (error) {
+      console.warn(`[agent-client] \u6307\u4EE4 "${action}" \u7684\u5904\u7406\u51FD\u6570\u629B\u51FA\u5F02\u5E38\uFF1A`, error);
+    }
+  }
+  clear() {
+    this.handlers.clear();
+    this.buffered.clear();
+  }
+};
+
+// src/session/events.ts
+var Emitter = class {
+  handlers = /* @__PURE__ */ new Map();
+  on(name, handler) {
+    let set = this.handlers.get(name);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.handlers.set(name, set);
+    }
+    set.add(handler);
+    return () => this.off(name, handler);
+  }
+  off(name, handler) {
+    this.handlers.get(name)?.delete(handler);
+  }
+  emit(name, event) {
+    const set = this.handlers.get(name);
+    if (!set) return;
+    for (const handler of [...set]) {
+      try {
+        ;
+        handler(event);
+      } catch (error) {
+        console.warn(`[agent-client] "${String(name)}" \u4E8B\u4EF6\u5904\u7406\u5668\u629B\u51FA\u5F02\u5E38\uFF1A`, error);
+      }
+    }
+  }
+  /**
+   * 只把事件交给最先注册的处理器。用于必须由单一交互入口作答的事件，
+   * 避免多个 UI 同时弹窗并提交相互冲突的决定。
+   */
+  emitFirst(name, event) {
+    const handler = this.handlers.get(name)?.values().next().value;
+    if (!handler) return false;
+    try {
+      ;
+      handler(event);
+    } catch (error) {
+      console.warn(`[agent-client] "${String(name)}" \u4E8B\u4EF6\u5904\u7406\u5668\u629B\u51FA\u5F02\u5E38\uFF1A`, error);
+      return false;
+    }
+    return true;
+  }
+  listenerCount(name) {
+    return this.handlers.get(name)?.size ?? 0;
+  }
+  clear() {
+    this.handlers.clear();
+  }
+};
+
+// src/schemas/message-utils.ts
+var SYSTEM_REMINDER_PATTERN = /^<system-reminder>\s*[\s\S]*?\s*<\/system-reminder>$/i;
+var LEGACY_FORK_CONTEXT_MARKERS = [
+  "\u7236\u667A\u80FD\u4F53\u5728\u6D3E\u751F\u4F60\u4E4B\u524D\u5DF2\u7ECF\u5B8C\u6210\u4E86\u4E00\u4E9B\u64CD\u4F5C\u3002",
+  "\u53EF\u901A\u8FC7 `read_file` \u8BFB\u53D6\u3002",
+  "# \u4F60\u7684\u4EFB\u52A1"
+];
+function normalizeMessageContent(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) return content;
+  return String(content ?? "");
+}
+function getTextContent(content) {
+  if (typeof content === "string") return content;
+  return content.filter((part) => part.type === "text").map((part) => part.text).join("");
+}
+function isSystemReminderText(text) {
+  return SYSTEM_REMINDER_PATTERN.test(text.trim());
+}
+function isLegacyForkContextText(text) {
+  const normalized = text.trim();
+  return LEGACY_FORK_CONTEXT_MARKERS.every((marker) => normalized.includes(marker));
+}
+function isHiddenInternalMessage(message) {
+  if (message.role !== "user") return false;
+  const text = getTextContent(normalizeMessageContent(message.content));
+  return isSystemReminderText(text) || isLegacyForkContextText(text);
+}
+function buildMessageContent(text, attachments) {
+  if (attachments.length === 0) return text;
+  const textSegments = [];
+  if (text.trim()) {
+    textSegments.push(text);
+  }
+  for (const attachment of attachments) {
+    let fileText;
+    if (attachment.uploadedPath) {
+      const displayName = attachment.uploadedPath.split("/").pop() || attachment.name;
+      fileText = `[\u9644\u4EF6: ${displayName}] \u5DF2\u4E0A\u4F20\u5230\u5DE5\u4F5C\u533A\u8DEF\u5F84: ${attachment.uploadedPath}`;
+    } else if (attachment.textContent) {
+      const MAX_TEXT_CHARS = 1e5;
+      const content = attachment.textContent.length > MAX_TEXT_CHARS ? `${attachment.textContent.slice(0, MAX_TEXT_CHARS)}
+
+[\u5185\u5BB9\u5DF2\u622A\u65AD\uFF0C\u539F\u59CB\u5171 ${attachment.textContent.length} \u5B57\u7B26]` : attachment.textContent;
+      fileText = `[\u9644\u4EF6: ${attachment.name}]
+${content}`;
+    } else {
+      fileText = `[\u9644\u4EF6: ${attachment.name}]`;
+    }
+    textSegments.push(fileText);
+  }
+  return textSegments.join("\n\n");
+}
+function contentPreview(content, maxLen = 80) {
+  const text = getTextContent(content).trim();
+  return text.length > maxLen ? `${text.slice(0, maxLen)}\u2026` : text;
+}
+function transformSlashCommand(skillName, rawInput) {
+  const prompt = rawInput.replace(`<skill>${skillName}</skill>`, "").trim();
+  return prompt ? `\u8BF7\u4F7F\u7528 ${skillName} skill \u5B8C\u6210\u4EFB\u52A1
+${prompt}` : `\u8BF7\u4F7F\u7528 ${skillName} skill \u5B8C\u6210\u4EFB\u52A1`;
+}
+var ATTACHMENT_TAG_RE = /\[附件:\s*([^\]]+)\](?:[ \t]*已上传到工作区路径:[ \t]*([^\r\n]+))?/g;
+var CONTEXT_PART_RE = /^\[上下文:\s*([^\]]+)\]\n([\s\S]*)$/;
+function extractTextAttachments(content) {
+  if (typeof content === "string") {
+    const attachments2 = [];
+    const contexts2 = [];
+    const ctxMatch = CONTEXT_PART_RE.exec(content);
+    let working = content;
+    if (ctxMatch) {
+      contexts2.push({ label: ctxMatch[1].trim(), content: ctxMatch[2].trim() });
+      working = "";
+    }
+    for (const match of working.matchAll(ATTACHMENT_TAG_RE)) {
+      attachments2.push({
+        name: match[1].trim(),
+        uploadedPath: match[2]?.trim() || void 0
+      });
+    }
+    return {
+      cleanText: working.replace(ATTACHMENT_TAG_RE, ""),
+      attachments: attachments2,
+      contexts: contexts2
+    };
+  }
+  const attachments = [];
+  const contexts = [];
+  const cleanParts = [];
+  for (const part of content) {
+    if (part.type !== "text") continue;
+    const ctxMatch = CONTEXT_PART_RE.exec(part.text);
+    if (ctxMatch) {
+      contexts.push({ label: ctxMatch[1].trim(), content: ctxMatch[2].trim() });
+      continue;
+    }
+    let hasAttachment = false;
+    for (const match of part.text.matchAll(ATTACHMENT_TAG_RE)) {
+      attachments.push({
+        name: match[1].trim(),
+        uploadedPath: match[2]?.trim() || void 0
+      });
+      hasAttachment = true;
+    }
+    if (hasAttachment) {
+      const remaining = part.text.replace(ATTACHMENT_TAG_RE, "");
+      if (remaining.trim()) cleanParts.push(remaining);
+    } else {
+      cleanParts.push(part.text);
+    }
+  }
+  return { cleanText: cleanParts.join("\n"), attachments, contexts };
+}
+function getImageParts(content) {
+  if (typeof content === "string") return [];
+  return content.filter((part) => part.type === "image_url");
+}
+function getFileParts(content) {
+  if (typeof content === "string") return [];
+  return content.filter((part) => part.type === "file");
+}
+function groupMessagesByLoop(messages) {
+  const groups = [];
+  let currentGroup = null;
+  for (const msg of messages) {
+    const loop = msg.loop_name ?? "root";
+    if (loop === "root") {
+      currentGroup = { root: msg, childLoops: [] };
+      groups.push(currentGroup);
+    } else {
+      if (!currentGroup) {
+        currentGroup = { root: null, childLoops: [] };
+        groups.push(currentGroup);
+      }
+      const existingLoop = currentGroup.childLoops.find((l) => l.loopName === loop);
+      if (existingLoop) {
+        existingLoop.messages.push(msg);
+      } else {
+        currentGroup.childLoops.push({ loopName: loop, messages: [msg] });
+      }
+    }
+  }
+  return groups;
+}
+
+// src/session/state.ts
+function createInitialSessionState(sessionId) {
+  return {
+    sessionId,
+    turns: [],
+    messages: [],
+    isStreaming: false,
+    status: null,
+    mode: null,
+    connection: "disconnected",
+    errorMessage: null,
+    askAnswers: {},
+    agentLoops: {},
+    activeCompaction: null
+  };
+}
+function parseAgentDescription(argumentsJson) {
+  try {
+    return JSON.parse(argumentsJson)?.description ?? "\u5B50\u667A\u80FD\u4F53";
+  } catch {
+    return "\u5B50\u667A\u80FD\u4F53";
+  }
+}
+function normalizedToolName(name) {
+  const separatorIndex = name.lastIndexOf(":");
+  return separatorIndex >= 0 ? name.slice(separatorIndex + 1) : name;
+}
+function inferLoopStatusFromMessages(messages) {
+  const toolCalls = messages.flatMap((message) => message.tool_calls ?? []);
+  if (messages.some((message) => message.status === "streaming")) return "running";
+  if (toolCalls.some((toolCall) => toolCall.status === "awaiting_answer")) return "awaiting_answer";
+  if (toolCalls.some((toolCall) => toolCall.status === "error")) return "error";
+  if (toolCalls.some((toolCall) => toolCall.status === "cancelled")) return "cancelled";
+  if (toolCalls.some((toolCall) => toolCall.status === "pending")) return "running";
+  return "done";
+}
+function inferLoopStatusFromTurns(turns, messages) {
+  const latestAgentNotification = [...turns].reverse().flatMap((turn) => turn.blocks).find((block) => {
+    if (block.type !== "system_notification" || !isRecord3(block.content)) return false;
+    return block.content.notification_type === "agent:start" || block.content.notification_type === "agent:end";
+  });
+  if (latestAgentNotification?.type === "system_notification" && isRecord3(latestAgentNotification.content)) {
+    const notificationType = latestAgentNotification.content.notification_type;
+    const status = latestAgentNotification.content.status;
+    if (notificationType === "agent:start" || status === "running") return "running";
+    if (status === "error") return "error";
+    if (status === "cancelled") return "cancelled";
+  }
+  return inferLoopStatusFromMessages(messages);
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parentForkToolCallIdFromTurn(turn) {
+  if (typeof turn.parent_fork_tool_call_id === "string" && turn.parent_fork_tool_call_id.length > 0) {
+    return turn.parent_fork_tool_call_id;
+  }
+  for (const block of turn.blocks) {
+    if (block.type !== "system_notification" || !isRecord3(block.content)) continue;
+    const metadata = block.content.metadata;
+    if (!isRecord3(metadata)) continue;
+    const parentId = metadata.parent_fork_tool_call_id;
+    if (typeof parentId === "string" && parentId.length > 0) return parentId;
+  }
+  return null;
+}
+function buildMessageContent2(turn) {
+  const textBlocks = turn.blocks.filter((block) => block.type === "text");
+  if (textBlocks.length === 0) return "";
+  if (textBlocks.length === 1) return normalizeMessageContent(textBlocks[0].content);
+  return textBlocks.map((block) => {
+    if (typeof block.content === "string") return block.content;
+    return JSON.stringify(block.content);
+  }).join("");
+}
+function askUserAnswerContent(turn) {
+  const answerBlock = turn.blocks.find((block) => block.type === "ask_user_answer");
+  if (!answerBlock || !isRecord3(answerBlock.content)) return null;
+  const answer = answerBlock.content.answer;
+  return typeof answer === "string" && answer.trim().length > 0 ? answer : null;
+}
+function buildReasoning(turn) {
+  const thinking = turn.blocks.filter((block) => block.type === "thinking").map((block) => typeof block.content === "string" ? block.content : JSON.stringify(block.content)).filter(Boolean);
+  if (thinking.length === 0) return void 0;
+  return thinking.join("\n\n");
+}
+function isModeChangeContent(value) {
+  return typeof value === "object" && value !== null && typeof value.from === "string" && typeof value.to === "string";
+}
+function extractModeFromBlocks(blocks) {
+  const modeBlock = blocks.find((block) => block.type === "mode_change");
+  if (modeBlock && isModeChangeContent(modeBlock.content)) {
+    return modeBlock.content.to === "planning" || modeBlock.content.to === "executing" ? modeBlock.content.to : null;
+  }
+  return null;
+}
+function projectionToMessage(turn) {
+  if (turn.kind === "compaction" && turn.compaction_id) {
+    return {
+      role: "assistant",
+      content: turn.summary_preview ?? "",
+      kind: "compaction",
+      loop_name: turn.loop_id,
+      entry_id: turn.turn_id,
+      status: turn.status,
+      compaction: {
+        compaction_id: turn.compaction_id,
+        summary_preview: turn.summary_preview,
+        summary_full: turn.summary_full,
+        archived_count: turn.archived_count,
+        archived_files: turn.archived_files,
+        archived_tool_calls: turn.archived_tool_calls,
+        tokens_before: turn.tokens_before,
+        tokens_after: turn.tokens_after,
+        saved_ratio: turn.saved_ratio,
+        trigger: turn.trigger,
+        failure_reason: turn.failure_reason,
+        fallback_applied: turn.fallback_applied
+      }
+    };
+  }
+  const planningBlock = turn.blocks.find(
+    (block) => block.type === "mode_change" || block.type === "plan_status"
+  );
+  if (planningBlock) {
+    if (planningBlock.type === "plan_status") {
+      return {
+        role: "tool",
+        content: typeof planningBlock.content === "string" ? planningBlock.content : JSON.stringify(planningBlock.content ?? {}, null, 2),
+        kind: "plan_status",
+        loop_name: turn.loop_id,
+        entry_id: turn.turn_id,
+        status: turn.status
+      };
+    }
+    return {
+      role: "assistant",
+      content: typeof planningBlock.content === "string" ? planningBlock.content : JSON.stringify(planningBlock.content ?? {}),
+      kind: planningBlock.type,
+      loop_name: turn.loop_id,
+      entry_id: turn.turn_id,
+      status: turn.status
+    };
+  }
+  const askAnswer = askUserAnswerContent(turn);
+  if (askAnswer !== null) {
+    return {
+      role: "user",
+      content: askAnswer,
+      blocks: turn.blocks,
+      loop_name: turn.loop_id,
+      entry_id: turn.turn_id,
+      status: turn.status,
+      ...typeof turn.duration_ms === "number" ? { duration_ms: turn.duration_ms } : {},
+      ...turn.started_at ? { timestamp: turn.started_at } : {}
+    };
+  }
+  const content = buildMessageContent2(turn);
+  const reasoning = buildReasoning(turn);
+  const toolCalls = turn.tool_calls.length > 0 ? turn.tool_calls.map((toolCall) => ({
+    id: toolCall.id,
+    name: toolCall.tool_name,
+    display_name: toolCall.display_name,
+    arguments: toolCall.arguments,
+    result: toolCall.result ?? void 0,
+    pending_question_ref: toolCall.pending_question_ref ?? void 0,
+    status: toolCall.status === "pending" || toolCall.status === "awaiting_answer" || toolCall.status === "done" || toolCall.status === "error" || toolCall.status === "cancelled" ? toolCall.status : "pending",
+    ...typeof toolCall.duration_ms === "number" ? { duration_ms: toolCall.duration_ms } : {}
+  })) : void 0;
+  if (turn.role === "system" && !content && !toolCalls?.length) {
+    return null;
+  }
+  return {
+    role: turn.role === "system" ? "assistant" : turn.role,
+    content,
+    blocks: turn.blocks,
+    ...reasoning ? { reasoning } : {},
+    ...toolCalls ? { tool_calls: toolCalls } : {},
+    loop_name: turn.loop_id,
+    entry_id: turn.turn_id,
+    status: turn.status,
+    ...typeof turn.duration_ms === "number" ? { duration_ms: turn.duration_ms } : {},
+    ...turn.started_at ? { timestamp: turn.started_at } : {},
+    ...turn.memory_refs?.length ? { memory_refs: turn.memory_refs } : {}
+  };
+}
+var messageProjectionCache = /* @__PURE__ */ new WeakMap();
+function cachedProjectionToMessage(turn) {
+  if (messageProjectionCache.has(turn)) {
+    return messageProjectionCache.get(turn) ?? null;
+  }
+  const message = projectionToMessage(turn);
+  messageProjectionCache.set(turn, message);
+  return message;
+}
+function rebuildAgentLoops(turns, messages) {
+  const childLoopNames = [
+    ...new Set(turns.map((turn) => turn.loop_id).filter((name) => name !== "root"))
+  ];
+  if (childLoopNames.length === 0) return {};
+  const agentToolCalls = messages.filter((message) => message.role === "assistant" && (message.loop_name ?? "root") === "root").flatMap((message) => message.tool_calls ?? []).filter((toolCall) => normalizedToolName(toolCall.name) === "Agent");
+  const loops = {};
+  const agentToolCallsById = new Map(agentToolCalls.map((toolCall) => [toolCall.id, toolCall]));
+  const explicitParentToolCallIds = new Set(
+    turns.map(parentForkToolCallIdFromTurn).filter((id) => id !== null)
+  );
+  const usedToolCallIds = /* @__PURE__ */ new Set();
+  for (const loopName of childLoopNames) {
+    const loopMessages = messages.filter((message) => (message.loop_name ?? "root") === loopName);
+    const loopTurns = turns.filter((turn) => turn.loop_id === loopName);
+    const parentToolCallId = loopTurns.map(parentForkToolCallIdFromTurn).find(Boolean);
+    const explicitToolCall = parentToolCallId && !usedToolCallIds.has(parentToolCallId) ? agentToolCallsById.get(parentToolCallId) ?? null : null;
+    const fallbackToolCall = explicitToolCall === null ? agentToolCalls.find(
+      (toolCall2) => !usedToolCallIds.has(toolCall2.id) && !explicitParentToolCallIds.has(toolCall2.id)
+    ) : null;
+    const toolCall = explicitToolCall ?? fallbackToolCall;
+    if (!toolCall) continue;
+    usedToolCallIds.add(toolCall.id);
+    loops[loopName] = {
+      toolCallId: toolCall.id,
+      description: parseAgentDescription(toolCall.arguments),
+      status: inferLoopStatusFromTurns(loopTurns, loopMessages)
+    };
+  }
+  return loops;
+}
+function materialize(turns) {
+  const projectedMessages = turns.map(cachedProjectionToMessage).filter((message) => message !== null);
+  const messages = projectedMessages.filter((message, index, allMessages) => {
+    if (!message.blocks?.some((block) => block.type === "ask_user_answer")) return true;
+    const next = allMessages[index + 1];
+    return !(next?.role === "user" && next.content === message.content);
+  });
+  const activeCompaction = [...turns].reverse().find(
+    (turn) => turn.kind === "compaction" && turn.status === "streaming" && typeof turn.compaction_id === "string"
+  );
+  return {
+    messages,
+    agentLoops: rebuildAgentLoops(turns, projectedMessages),
+    activeCompaction: activeCompaction ? {
+      turn_id: activeCompaction.turn_id,
+      status: activeCompaction.status,
+      compaction_id: activeCompaction.compaction_id,
+      summary_preview: activeCompaction.summary_preview,
+      summary_full: activeCompaction.summary_full,
+      archived_count: activeCompaction.archived_count,
+      archived_files: activeCompaction.archived_files,
+      archived_tool_calls: activeCompaction.archived_tool_calls,
+      tokens_before: activeCompaction.tokens_before,
+      tokens_after: activeCompaction.tokens_after,
+      saved_ratio: activeCompaction.saved_ratio,
+      trigger: activeCompaction.trigger,
+      failure_reason: activeCompaction.failure_reason,
+      fallback_applied: activeCompaction.fallback_applied
+    } : null
+  };
+}
+var ERROR_ANCHOR_PREFIX = "error-anchor:";
+function orderTurns(turns) {
+  for (let index = 1; index < turns.length; index += 1) {
+    if (turns[index - 1].sequence > turns[index].sequence) {
+      return [...turns].sort((left, right) => left.sequence - right.sequence);
+    }
+  }
+  return turns;
+}
+function areAgentLoopsEqual(left, right) {
+  if (!left) return Object.keys(right).length === 0;
+  const leftEntries = Object.entries(left);
+  const rightKeys = Object.keys(right);
+  if (leftEntries.length !== rightKeys.length) return false;
+  return leftEntries.every(([key, value]) => {
+    const next = right[key];
+    return next !== void 0 && value.toolCallId === next.toolCallId && value.description === next.description && value.status === next.status;
+  });
+}
+function withTurns(state, turns) {
+  const orderedTurns = orderTurns(turns);
+  const { messages, agentLoops, activeCompaction } = materialize(orderedTurns);
+  const isWaitingForInput = orderedTurns.some(
+    (turn) => turn.tool_calls.some((toolCall) => toolCall.status === "awaiting_answer")
+  );
+  const stableAgentLoops = areAgentLoopsEqual(state.agentLoops, agentLoops) ? state.agentLoops : agentLoops;
+  const lastTurnId = orderedTurns[orderedTurns.length - 1]?.turn_id ?? null;
+  const preservedErrors = lastTurnId ? state.messages.filter(
+    (m) => m.role === "error" && typeof m.entry_id === "string" && m.entry_id.startsWith(`${ERROR_ANCHOR_PREFIX}${lastTurnId}:`)
+  ) : [];
+  const mergedMessages = preservedErrors.length > 0 ? [...messages, ...preservedErrors] : messages;
+  const latestMode = [...orderedTurns].reverse().map((turn) => extractModeFromBlocks(turn.blocks)).find((mode) => mode !== null);
+  return {
+    ...state,
+    turns: orderedTurns,
+    messages: mergedMessages,
+    agentLoops: stableAgentLoops,
+    activeCompaction,
+    mode: latestMode ?? state.mode,
+    // 历史恢复时 chat:end(paused) 可能已不在 socket replay 缓存中；
+    // awaiting_answer 是投影里的持久权威状态，必须据此恢复问答交互。
+    status: isWaitingForInput ? "waiting_for_input" : state.status
+  };
+}
+var localTurnCounter = 0;
+function addUserMessage(state, content) {
+  localTurnCounter += 1;
+  const turnId = `local-user-${Date.now()}-${localTurnCounter}`;
+  const optimisticTurn = {
+    id: turnId,
+    sequence: Math.max(0, ...state.turns.map((turn) => turn.sequence)) + 1,
+    turn_id: turnId,
+    loop_id: "root",
+    role: "user",
+    status: "streaming",
+    blocks: [{ type: "text", content }],
+    tool_calls: [],
+    model: null,
+    usage: null,
+    duration_ms: 0
+  };
+  return withTurns(state, [...state.turns, optimisticTurn]);
+}
+function upsertTurn(state, turn) {
+  let existing = [...state.turns];
+  if (turn.role === "user" && !turn.turn_id.startsWith("local-user-")) {
+    existing = existing.filter((t) => !t.turn_id.startsWith("local-user-"));
+  }
+  const index = existing.findIndex((item) => item.turn_id === turn.turn_id);
+  if (index >= 0) {
+    existing[index] = turn;
+  } else {
+    existing.push(turn);
+  }
+  return withTurns(state, existing);
+}
+function applyTurnPatch(state, patch) {
+  const turn = patch.data.turn;
+  if (!turn) return state;
+  const existing = [...state.turns];
+  const index = existing.findIndex((item) => item.turn_id === turn.turn_id);
+  const lastSequence = index >= 0 ? existing[index].sequence : null;
+  if (lastSequence !== null && patch.sequence <= lastSequence) {
+    return state;
+  }
+  const nextTurn = { ...turn, sequence: patch.sequence };
+  if (index >= 0) {
+    existing[index] = nextTurn;
+  } else {
+    existing.push(nextTurn);
+  }
+  return withTurns(state, existing);
+}
+function addErrorMessage(state, content) {
+  const anchorTurnId = state.turns[state.turns.length - 1]?.turn_id ?? null;
+  const entry_id = anchorTurnId ? `${ERROR_ANCHOR_PREFIX}${anchorTurnId}:${Date.now()}` : void 0;
+  return {
+    ...state,
+    messages: [...state.messages, { role: "error", content, loop_name: "root", entry_id }]
+  };
+}
+function markInterrupted(state) {
+  return markStreamingTurns(state, "interrupted", "cancelled");
+}
+function markFailed(state) {
+  return markStreamingTurns(state, "failed", "error");
+}
+function markStreamingTurns(state, turnStatus, toolCallStatus) {
+  const turns = state.turns.map((turn) => {
+    if (turn.status !== "streaming") return turn;
+    return {
+      ...turn,
+      status: turnStatus,
+      tool_calls: turn.tool_calls.map(
+        (toolCall) => toolCall.status === "pending" || toolCall.status === "awaiting_answer" ? { ...toolCall, status: toolCallStatus } : toolCall
+      )
+    };
+  });
+  return withTurns(state, turns);
+}
+
+// src/session/agent-session.ts
+var OOM_MESSAGE = "\u6C99\u76D2\u5185\u5B58\u4F7F\u7528\u8D85\u51FA\u9650\u5236\uFF0C\u5DF2\u81EA\u52A8\u91CD\u542F\u3002\u5982\u679C\u7ECF\u5E38\u89E6\u53D1\uFF0C\u53EF\u4EE5\u8054\u7CFB\u7BA1\u7406\u5458\u8C03\u6574\u989D\u5EA6\u3002";
+var OOM_KEYWORDS_RE = /(?:\b(?:exit_code|ExitedWith|exited with)|退出码)\D*(?<!\d)137(?!\d)/i;
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isOomText(value) {
+  return typeof value === "string" && OOM_KEYWORDS_RE.test(value);
+}
+function parseJsonRecord(value) {
+  if (isRecord4(value)) return value;
+  if (typeof value !== "string") return null;
+  try {
+    const parsed = JSON.parse(value);
+    return isRecord4(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function isOomResult(value) {
+  if (Array.isArray(value)) {
+    return value.some((part) => isOomResult(part));
+  }
+  if (typeof value === "object" && value !== null) {
+    const record = value;
+    if (record.exit_code === 137) return true;
+    if (typeof record.text === "string" && isOomText(record.text)) return true;
+    if (typeof record.content === "string" && isOomText(record.content)) return true;
+    return false;
+  }
+  if (typeof value === "string") {
+    const parsed = parseJsonRecord(value);
+    if (parsed?.exit_code === 137) return true;
+    return isOomText(value);
+  }
+  return false;
+}
+function isToolBridgeContent(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && typeof value.action === "string";
+}
+function sessionStatusFromChatEnd(status) {
+  if (status === "paused") return "waiting_for_input";
+  if (status === "interrupted") return "interrupted";
+  if (status === "failed") return "failed";
+  return "completed";
+}
+function extractTerminalChatEndStatus(events) {
+  for (let i = events.length - 1; i >= 0; i--) {
+    const event = events[i];
+    if (event?.type !== "chat:end") continue;
+    const status = event.payload?.status;
+    return typeof status === "string" ? status : "completed";
+  }
+  return null;
+}
+function isUiMetaLike(value) {
+  return isRecord4(value) && ("resourceHTML" in value || "resourceUri" in value || "resourceURI" in value);
+}
+var AgentSession = class _AgentSession {
+  sessionId;
+  state;
+  listeners = /* @__PURE__ */ new Set();
+  emitter = new Emitter();
+  commands = new CommandRegistry();
+  runtime;
+  projectionBuilder = new ClientProjectionBuilder();
+  pendingTurnPatches = /* @__PURE__ */ new Map();
+  patchFlushHandle = null;
+  patchFlushCancel = null;
+  joined = false;
+  joinPending = null;
+  pendingReplayMessage = null;
+  pendingReplayMode;
+  recentChatEndAt = 0;
+  disposed = false;
+  deliveredCommandKeys = /* @__PURE__ */ new Set();
+  deliveredToolPreviews = /* @__PURE__ */ new Map();
+  oomNotifiedKeys = /* @__PURE__ */ new Set();
+  seenToolCallIds = /* @__PURE__ */ new Set();
+  finishedToolCallIds = /* @__PURE__ */ new Set();
+  emittedMessageTurnIds = /* @__PURE__ */ new Set();
+  constructor(sessionId, runtime, connection) {
+    this.sessionId = sessionId;
+    this.runtime = runtime;
+    this.state = { ...createInitialSessionState(sessionId), connection };
+  }
+  /** 从一份静态 turn 快照构造只展示历史的会话（例如公开分享页）。 */
+  static fromTurns(sessionId, turns) {
+    const readonlyError = () => {
+      throw new Error("\u9759\u6001\u4F1A\u8BDD\u53EA\u7528\u4E8E\u5C55\u793A\u5386\u53F2\uFF0C\u4E0D\u80FD\u6267\u884C\u4F1A\u8BDD\u64CD\u4F5C");
+    };
+    const session = new _AgentSession(
+      sessionId,
+      {
+        emitEvent: readonlyError,
+        emitWithAck: async () => readonlyError(),
+        ensureConnected: readonlyError,
+        fetchTurns: async () => turns,
+        onDispose: () => void 0
+      },
+      "connected"
+    );
+    session.state = {
+      ...withTurns(session.state, turns),
+      status: "completed"
+    };
+    return session;
+  }
+  // ---------------------------------------------------------------- 状态订阅
+  /** 返回当前会话快照。引用稳定：状态未变化时返回同一对象。 */
+  getState() {
+    return this.state;
+  }
+  /** 订阅状态变化。返回取消订阅函数。 */
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  setState(next) {
+    if (next === this.state) return;
+    this.state = next;
+    for (const listener of [...this.listeners]) {
+      try {
+        listener();
+      } catch (error) {
+        console.warn("[agent-client] \u72B6\u6001\u8BA2\u9605\u56DE\u8C03\u629B\u51FA\u5F02\u5E38\uFF1A", error);
+      }
+    }
+  }
+  update(fn) {
+    this.setState(fn(this.state));
+  }
+  // ---------------------------------------------------------------- 语义事件
+  /** 监听语义事件（底层逃生舱，见 events.ts）。返回取消函数。 */
+  on(name, handler) {
+    return this.emitter.on(name, handler);
+  }
+  off(name, handler) {
+    this.emitter.off(name, handler);
+  }
+  /**
+   * 监听智能体下发给宿主页面的指令。
+   *
+   * action 是技能作者在工具返回值 `_meta.bridge` 里写的契约字符串（如
+   * "map.highlight"），由你和技能作者约定；注册前到达的指令会被缓冲补投。
+   */
+  onCommand(action, handler) {
+    return this.commands.onCommand(action, handler);
+  }
+  // ---------------------------------------------------------------- 动作
+  /** 发送一条消息。字符串或多模态内容均可。 */
+  async send(content, options = {}) {
+    this.runtime.ensureConnected();
+    if (this.state.isStreaming) {
+      this.update((s) => addErrorMessage(s, "\u5F53\u524D\u56DE\u590D\u5C1A\u672A\u7ED3\u675F\uFF0C\u8BF7\u7A0D\u540E\u518D\u53D1\u9001\u3002"));
+      return;
+    }
+    await this.ensureIdleBeforeSend();
+    if (this.state.isStreaming) {
+      this.update((s) => addErrorMessage(s, "\u5F53\u524D\u56DE\u590D\u5C1A\u672A\u7ED3\u675F\uFF0C\u8BF7\u7A0D\u540E\u518D\u53D1\u9001\u3002"));
+      return;
+    }
+    const askUserAnswer = options.askUserAnswer;
+    if (!(askUserAnswer && typeof askUserAnswer.tool_call_id === "string")) {
+      this.update((s) => addUserMessage(s, content));
+    }
+    this.update((s) => ({ ...s, isStreaming: true }));
+    if (askUserAnswer && typeof askUserAnswer.tool_call_id === "string") {
+      const { tool_call_id, ...rest } = askUserAnswer;
+      this.update((s) => ({
+        ...s,
+        askAnswers: { ...s.askAnswers, [tool_call_id]: rest }
+      }));
+    }
+    if (!options.replayDecision) {
+      this.pendingReplayMessage = content;
+      this.pendingReplayMode = options.mode;
+    }
+    const payload = {
+      session_id: this.sessionId,
+      message: content,
+      mode: options.mode,
+      askuser_answer: askUserAnswer,
+      model: options.model,
+      thinking_override: options.thinkingOverride,
+      whatif: options.whatif,
+      replay_decision: options.replayDecision
+    };
+    try {
+      await this.ensureJoined();
+    } catch (error) {
+      this.update(
+        (s) => addErrorMessage(
+          { ...s, isStreaming: false, status: "failed" },
+          error instanceof Error && error.message ? error.message : "\u4F1A\u8BDD\u8BA2\u9605\u5931\u8D25\uFF0C\u6D88\u606F\u672A\u53D1\u9001"
+        )
+      );
+      return;
+    }
+    this.runtime.emitEvent("chat:send", payload);
+  }
+  /** 智能体运行期间追加补充说明（不打断当前回复）。 */
+  append(text) {
+    this.runtime.ensureConnected();
+    this.runtime.emitEvent("chat:append", { session_id: this.sessionId, message: text });
+    this.update((s) => addUserMessage(s, text));
+  }
+  /** 停止当前回复。 */
+  stop() {
+    return this.runtime.emitWithAck("chat:stop", { session_id: this.sessionId }, 35e3).then((response) => response ?? {});
+  }
+  /** 手动触发上下文压缩。 */
+  compact() {
+    return this.runtime.emitWithAck("chat:compact", { session_id: this.sessionId }, 3e4).then((response) => response ?? {});
+  }
+  /**
+   * 把一段业务数据作为附件放进聊天输入框（比如地图上选中的点位）。
+   * 附件随下一条消息一起发给智能体。需要 ChatView / useChat 渲染层配合展示；
+   * 无 UI 场景可直接用 send()。
+   */
+  attach(label, data) {
+    const content = typeof data === "string" ? data : JSON.stringify(data, null, 2);
+    this.emitter.emit("attachRequested", { label, content });
+  }
+  /** 往聊天输入框追加一段文字（不发送）。 */
+  insertText(text) {
+    this.emitter.emit("insertTextRequested", { text });
+  }
+  /** 释放订阅与监听器。之后该实例不再接收任何事件。 */
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.cancelPatchFlush();
+    this.listeners.clear();
+    this.emitter.clear();
+    this.commands.clear();
+    this.runtime.onDispose(this);
+  }
+  get isDisposed() {
+    return this.disposed;
+  }
+  // ------------------------------------------------------- Hub 回调（内部）
+  /** @internal 连接状态变化（同 client 下所有会话共享一条连接）。 */
+  _setConnection(connection) {
+    if (this.state.connection === connection) return;
+    this.update((s) => ({ ...s, connection }));
+  }
+  /** @internal socket 重连后由 Hub 调用：重新加入房间并补数。 */
+  async _rejoinAfterReconnect() {
+    const turnsBeforeRejoin = this.state.turns;
+    this.joined = false;
+    this.joinPending = null;
+    try {
+      await this.ensureJoined();
+      await this.syncTurnsFromHistory({
+        clearOnEmpty: true,
+        preserveChangesSince: turnsBeforeRejoin
+      });
+    } catch {
+    }
+  }
+  /** @internal 首次连接：加载历史 + 加入房间。 */
+  async _bootstrap() {
+    await this.syncTurnsFromHistory({ suppressErrors: false });
+    await this.ensureJoined();
+  }
+  /** @internal */
+  _handleTurnStart(turn) {
+    this.markRunningIfIdle();
+    this.applyTurn(turn);
+  }
+  /** @internal */
+  _handleTurnPatch(patch) {
+    this.markRunningIfIdle();
+    if (patch.data.workspace_changed) {
+      this.emitter.emit("workspaceChanged", {});
+    }
+    const current = this.pendingTurnPatches.get(patch.turn_id);
+    if (!current || patch.sequence >= current.sequence) {
+      this.pendingTurnPatches.set(patch.turn_id, patch);
+    }
+    this.schedulePatchFlush();
+  }
+  /** @internal */
+  _handleTurnEnd(turn) {
+    this.applyTurn(turn);
+  }
+  /** @internal 历史回放通道（event_format: raw）。 */
+  _handleTurnEvents(events) {
+    if (!events.length) return;
+    const terminalChatEndStatus = extractTerminalChatEndStatus(events);
+    if (!terminalChatEndStatus) {
+      this.markRunningIfIdle();
+    }
+    if (this.state.turns.length) {
+      this.projectionBuilder.seedSequence(Math.max(...this.state.turns.map((t) => t.sequence)));
+    }
+    const updates = this.projectionBuilder.processBatch(events);
+    for (const update of updates) {
+      if (update.kind === "upsert") {
+        this.applyTurn(update.turn);
+      } else if (update.kind === "workspace_changed") {
+        this.emitter.emit("workspaceChanged", {});
+      }
+    }
+    if (terminalChatEndStatus) {
+      this.finishStreaming(terminalChatEndStatus);
+    }
+  }
+  /** @internal */
+  _handleChatStart() {
+    this.update((s) => ({ ...s, status: "running", errorMessage: null, isStreaming: true }));
+  }
+  /** @internal */
+  _handleChatEnd(status) {
+    this.flushPatches();
+    this.finishStreaming(status);
+    this.recentChatEndAt = Date.now();
+    void this.syncTurnsFromHistory();
+    this.emitter.emit("chatEnd", { status });
+  }
+  /** @internal */
+  _handleSystemError(message) {
+    this.flushPatches();
+    const finalMessage = isOomText(message) ? OOM_MESSAGE : message;
+    this.update(
+      (s) => addErrorMessage(markFailed({ ...s, status: "failed", errorMessage: finalMessage, isStreaming: false }), finalMessage)
+    );
+    this.recentChatEndAt = Date.now();
+    this.emitter.emit("error", { message: finalMessage });
+  }
+  /** @internal */
+  _handleTaskUpdated(tasks) {
+    this.emitter.emit("taskListUpdated", { tasks });
+  }
+  /** @internal */
+  _handleWorkspaceFilesChanged(filePath) {
+    this.emitter.emit("workspaceChanged", { filePath });
+  }
+  /** @internal */
+  _handleSessionUpdated(data) {
+    if (data.status) {
+      this.update((s) => ({ ...s, status: data.status ?? s.status }));
+    }
+    this.emitter.emit("sessionUpdated", {
+      intent: data.intent,
+      status: data.status,
+      model: data.model,
+      boundSkillId: data.bound_skill_id,
+      replayState: data.replay_state
+    });
+  }
+  /** @internal */
+  _handleRewind(checkpointId) {
+    this.update((s) => ({ ...s, mode: null, errorMessage: null }));
+    void this.syncTurnsFromHistory({ clearOnEmpty: true });
+    this.emitter.emit("rewind", { checkpointId });
+  }
+  /** @internal */
+  _handleReplayMismatch(data) {
+    const message = this.pendingReplayMessage ?? data.actual_message ?? "";
+    const mode = this.pendingReplayMode;
+    this.pendingReplayMessage = null;
+    this.pendingReplayMode = void 0;
+    const respond = (decision) => {
+      this.runtime.emitEvent("chat:send", {
+        session_id: this.sessionId,
+        message,
+        mode,
+        replay_decision: decision
+      });
+    };
+    const handled = this.emitter.emitFirst("replayMismatch", {
+      actualMessage: data.actual_message,
+      expectedMessage: data.expected_message,
+      respond
+    });
+    if (!handled) {
+      respond("continue_replay");
+    }
+  }
+  /** @internal */
+  _handleSystemNotification(loopId, notification) {
+    const notificationType = typeof notification.notification_type === "string" ? notification.notification_type : "system_notification";
+    const title = typeof notification.title === "string" ? notification.title : notificationType;
+    const detail = typeof notification.detail === "string" ? notification.detail : notification.detail == null ? void 0 : JSON.stringify(notification.detail);
+    const status = notification.status === "running" || notification.status === "done" || notification.status === "error" ? notification.status : "info";
+    this.emitter.emit("notification", {
+      type: notificationType,
+      title,
+      detail,
+      status,
+      loopId,
+      metadata: isRecord4(notification.metadata) ? notification.metadata : void 0
+    });
+    if (notificationType === "bg:started" && isRecord4(notification.metadata)) {
+      const taskId = typeof notification.metadata.task_id === "string" ? notification.metadata.task_id : "";
+      if (taskId) {
+        this.emitter.emit("backgroundTask", {
+          id: taskId,
+          command: typeof notification.metadata.command === "string" ? notification.metadata.command : "",
+          description: typeof notification.metadata.description === "string" ? notification.metadata.description : void 0,
+          status: "running",
+          elapsedSeconds: 0
+        });
+      }
+    }
+  }
+  /** @internal */
+  _handleBackgroundTask(task) {
+    this.emitter.emit("backgroundTask", task);
+  }
+  /** @internal */
+  _handleArtifact(event) {
+    this.emitter.emit("artifact", event);
+  }
+  /** @internal 加入房间的应答里带 is_running，据此校准流式状态。 */
+  _applyRunningState(isRunning) {
+    if (isRunning) {
+      this.update((s) => ({ ...s, status: "running", isStreaming: true }));
+    } else if (this.state.isStreaming) {
+      this.update((s) => ({ ...s, isStreaming: false }));
+      void this.syncTurnsFromHistory();
+    }
+  }
+  // ---------------------------------------------------------------- 内部实现
+  markRunningIfIdle() {
+    if (!this.state.isStreaming) {
+      this.update((s) => ({ ...s, status: "running", isStreaming: true }));
+    }
+  }
+  finishStreaming(status) {
+    const sessionStatus = sessionStatusFromChatEnd(status);
+    this.update((s) => {
+      let next = { ...s, status: sessionStatus, isStreaming: false };
+      if (status === "interrupted") next = markInterrupted(next);
+      else if (status === "failed") next = markFailed(next);
+      return next;
+    });
+  }
+  applyTurn(turn) {
+    this.flushPatches();
+    const previous = this.state;
+    this.update((s) => upsertTurn(s, turn));
+    this.emitTurnDerivedEvents(previous, turn);
+  }
+  schedulePatchFlush() {
+    if (this.patchFlushHandle != null) return;
+    const flush = () => {
+      this.patchFlushHandle = null;
+      this.patchFlushCancel = null;
+      this.flushPatches();
+    };
+    if (typeof window !== "undefined" && typeof window.requestAnimationFrame === "function") {
+      const handle2 = window.requestAnimationFrame(flush);
+      this.patchFlushHandle = handle2;
+      this.patchFlushCancel = () => window.cancelAnimationFrame(handle2);
+      return;
+    }
+    const handle = globalThis.setTimeout(flush, 33);
+    this.patchFlushHandle = handle;
+    this.patchFlushCancel = () => globalThis.clearTimeout(handle);
+  }
+  cancelPatchFlush() {
+    this.patchFlushCancel?.();
+    this.patchFlushHandle = null;
+    this.patchFlushCancel = null;
+    this.pendingTurnPatches.clear();
+  }
+  flushPatches() {
+    if (this.pendingTurnPatches.size === 0) return;
+    const patches = [...this.pendingTurnPatches.values()].sort(
+      (left, right) => left.sequence - right.sequence
+    );
+    this.pendingTurnPatches.clear();
+    for (const patch of patches) {
+      const previous = this.state;
+      this.update((s) => applyTurnPatch(s, patch));
+      const turn = patch.data.turn;
+      if (turn) {
+        this.emitTurnDerivedEvents(previous, turn);
+      }
+    }
+    if (this.patchFlushCancel) {
+      this.patchFlushCancel();
+      this.patchFlushHandle = null;
+      this.patchFlushCancel = null;
+    }
+  }
+  /** turn 数据落地后统一派生语义事件（指令 / 工具调用 / 消息 / 模式 / 预览 / OOM）。 */
+  emitTurnDerivedEvents(previous, turn) {
+    const mode = extractModeFromBlocks(turn.blocks);
+    if (mode && previous.mode !== mode) {
+      this.emitter.emit("modeChange", { mode });
+    }
+    for (const block of turn.blocks) {
+      if (block.type === "tool_result" && isOomResult(block.content)) {
+        this.notifySandboxOom(block.tool_call_id ?? turn.id);
+      }
+      if (block.type === "tool_bridge" && isToolBridgeContent(block.content)) {
+        this.dispatchCommand(turn, block);
+        continue;
+      }
+      if (block.type === "tool_ui" && block.tool_call_id && isUiMetaLike(block.content)) {
+        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 key = `${block.tool_call_id}:${previewType}`;
+        if (this.deliveredToolPreviews.get(key) === previewContent) continue;
+        this.deliveredToolPreviews.set(key, previewContent);
+        this.emitter.emit("toolPreview", {
+          toolCallId: block.tool_call_id,
+          type: previewType,
+          content: previewContent,
+          title: ui.title ?? "\u5DE5\u5177\u9884\u89C8"
+        });
+      }
+      if (block.type === "system_notification" && isRecord4(block.content)) {
+        this._handleSystemNotification(turn.loop_id, block.content);
+      }
+    }
+    for (const toolCall of turn.tool_calls) {
+      const info = {
+        id: toolCall.id,
+        name: toolCall.tool_name,
+        display_name: toolCall.display_name,
+        arguments: toolCall.arguments,
+        result: toolCall.result ?? void 0,
+        status: toolCall.status === "pending" || toolCall.status === "awaiting_answer" || toolCall.status === "done" || toolCall.status === "error" || toolCall.status === "cancelled" ? toolCall.status : "pending"
+      };
+      if (!this.seenToolCallIds.has(toolCall.id)) {
+        this.seenToolCallIds.add(toolCall.id);
+        this.emitter.emit("toolCall", { toolCall: info, turn });
+      }
+      const finished = toolCall.status === "done" || toolCall.status === "error" || toolCall.status === "cancelled";
+      if (finished && !this.finishedToolCallIds.has(toolCall.id)) {
+        this.finishedToolCallIds.add(toolCall.id);
+        this.emitter.emit("toolResult", { toolCall: info, turn });
+        if (isOomResult(toolCall.result)) {
+          this.notifySandboxOom(toolCall.id);
+        }
+      }
+    }
+    if (turn.status !== "streaming" && !this.emittedMessageTurnIds.has(turn.turn_id)) {
+      const message = this.state.messages.find((m) => m.entry_id === turn.turn_id);
+      if (message) {
+        this.emittedMessageTurnIds.add(turn.turn_id);
+        this.emitter.emit("message", { message, turn });
+      }
+    }
+  }
+  dispatchCommand(turn, block) {
+    if (!isToolBridgeContent(block.content)) return;
+    const { action, payload } = block.content;
+    let payloadKey = "";
+    try {
+      payloadKey = JSON.stringify(payload ?? null);
+    } catch {
+      payloadKey = String(payload ?? "");
+    }
+    const deliveryKey = [block.tool_call_id ?? turn.id, action, payloadKey].join("\0");
+    if (this.deliveredCommandKeys.has(deliveryKey)) return;
+    this.deliveredCommandKeys.add(deliveryKey);
+    const meta = { toolCallId: block.tool_call_id ?? void 0 };
+    this.emitter.emit("command", { action, payload, toolCallId: meta.toolCallId });
+    this.commands.dispatch(action, payload, meta);
+  }
+  notifySandboxOom(key) {
+    if (this.oomNotifiedKeys.has(key)) return;
+    this.oomNotifiedKeys.add(key);
+    this.update((s) => addErrorMessage(s, OOM_MESSAGE));
+    this.emitter.emit("sandboxOom", { toolCallId: key });
+  }
+  async syncTurnsFromHistory(options = {}) {
+    const { clearOnEmpty = false, suppressErrors = true, preserveChangesSince } = options;
+    const turnsAtRequestStart = this.state.turns;
+    try {
+      const turns = await this.runtime.fetchTurns(this.sessionId);
+      if (turns.length === 0 && !clearOnEmpty) return;
+      this.update((state) => {
+        const mergeBaseline = preserveChangesSince ?? turnsAtRequestStart;
+        if (state.turns === mergeBaseline) return withTurns(state, turns);
+        const historyById = new Map(turns.map((turn) => [turn.turn_id, turn]));
+        let merged = withTurns(state, turns);
+        for (const current of state.turns) {
+          const fromHistory = historyById.get(current.turn_id);
+          if (!fromHistory || current.sequence > fromHistory.sequence) {
+            merged = upsertTurn(merged, current);
+          }
+        }
+        return merged;
+      });
+      this.replayCommandsFromTurns(turns);
+    } catch (error) {
+      if (!suppressErrors) throw error;
+    }
+  }
+  /**
+   * 把历史里的指令补投给宿主页面。
+   *
+   * 重开会话、断线补数时，地图高亮这类"页面当前状态"必须能恢复——
+   * 否则刷新一次页面，之前智能体让页面做的事就全丢了。
+   * 只回放指令：toolCall / message 这些事件如果按历史全量重放，
+   * 监听器会在挂载瞬间收到几百条陈年事件。
+   * dispatch 内部按 deliveredCommandKeys 去重，重复调用安全。
+   */
+  replayCommandsFromTurns(turns) {
+    for (const turn of turns) {
+      for (const block of turn.blocks) {
+        if (block.type === "tool_bridge" && isToolBridgeContent(block.content)) {
+          this.dispatchCommand(turn, block);
+        }
+      }
+    }
+  }
+  ensureJoined() {
+    if (this.joined) return Promise.resolve();
+    if (this.joinPending) return this.joinPending;
+    const join = this.runtime.emitWithAck(
+      "session:subscribe",
+      { session_id: this.sessionId, event_format: "raw", resume: true },
+      5e3
+    ).then((response) => {
+      if (response && response.ok === false) {
+        throw new Error(
+          typeof response.message === "string" && response.message ? response.message : "Session subscription failed"
+        );
+      }
+      this.joined = true;
+      this._applyRunningState(Boolean(response?.is_running));
+    }).finally(() => {
+      this.joinPending = null;
+    });
+    this.joinPending = join;
+    return join;
+  }
+  async ensureIdleBeforeSend() {
+    if (Date.now() - this.recentChatEndAt > 3e3) return;
+    const deadline = Date.now() + 3e3;
+    while (Date.now() < deadline) {
+      const response = await this.stop();
+      const status = String(response.status ?? "");
+      if (status !== "stopping") return;
+      await new Promise((resolve) => globalThis.setTimeout(resolve, 150));
+    }
+  }
+};
+
+// src/session/hub.ts
+var SessionHub = class {
+  client;
+  sessions = /* @__PURE__ */ new Map();
+  bootstrapPending = /* @__PURE__ */ new Map();
+  connection = "disconnected";
+  connectionListeners = /* @__PURE__ */ new Set();
+  bound = false;
+  hasConnected = false;
+  constructor(client) {
+    this.client = client;
+  }
+  /** 当前 Socket.IO 连接状态。 */
+  getConnection() {
+    return this.connection;
+  }
+  /** 订阅连接状态变化。 */
+  onConnectionChange(listener) {
+    this.connectionListeners.add(listener);
+    return () => {
+      this.connectionListeners.delete(listener);
+    };
+  }
+  /** 取得（或复用）一个会话的 AgentSession，并完成历史加载 + 房间订阅。 */
+  async connect(sessionId) {
+    await this.client.ensureVersionCompatible();
+    const existing = this.sessions.get(sessionId);
+    if (existing && !existing.isDisposed) {
+      return this.bootstrapPending.get(sessionId) ?? existing;
+    }
+    this.ensureBound();
+    const session = new AgentSession(sessionId, this.runtimeFor(), this.connection);
+    this.sessions.set(sessionId, session);
+    this.ensureConnected();
+    const bootstrap = session._bootstrap().then(() => session);
+    this.bootstrapPending.set(sessionId, bootstrap);
+    try {
+      return await bootstrap;
+    } catch (error) {
+      session.dispose();
+      throw error;
+    } finally {
+      if (this.bootstrapPending.get(sessionId) === bootstrap) {
+        this.bootstrapPending.delete(sessionId);
+      }
+    }
+  }
+  /** 已有实例则返回，不触发网络请求。 */
+  peek(sessionId) {
+    if (this.bootstrapPending.has(sessionId)) return void 0;
+    const session = this.sessions.get(sessionId);
+    return session && !session.isDisposed ? session : void 0;
+  }
+  /** 手动重连（例如登录态变化后）。 */
+  reconnect() {
+    this.ensureBound();
+    const socket = this.client.socket();
+    socket.disconnect();
+    this.setConnection("connecting");
+    socket.connect();
+  }
+  /** 断开连接（不清理 session 实例）。 */
+  disconnect() {
+    this.client.socket().disconnect();
+    this.setConnection("disconnected");
+  }
+  /** 清理当前身份下缓存的全部会话，避免切换登录身份后复用旧快照。 */
+  disposeAll() {
+    this.bootstrapPending.clear();
+    for (const session of [...this.sessions.values()]) {
+      session.dispose();
+    }
+  }
+  /**
+   * @internal 底层 socket 被换掉时由 BladeClient 调用（如 setBaseUrl）。
+   * 事件监听器绑在旧 socket 实例上，换新实例后必须重绑，否则所有
+   * turn:* / chat:* 事件都会静默丢弃。
+   */
+  _handleSocketReplaced() {
+    this.bound = false;
+    this.setConnection("disconnected");
+    if (this.sessions.size === 0) return;
+    this.ensureBound();
+    this.ensureConnected();
+  }
+  runtimeFor() {
+    return {
+      emitEvent: (event, data) => {
+        ;
+        this.client.socket().emit(event, data);
+      },
+      emitWithAck: (event, data, timeoutMs) => new Promise((resolve, reject) => {
+        ;
+        this.client.socket().timeout(timeoutMs).emit(event, data, (err, response) => {
+          if (err) {
+            reject(err);
+            return;
+          }
+          resolve(response);
+        });
+      }),
+      ensureConnected: () => this.ensureConnected(),
+      fetchTurns: (sessionId) => this.client.sessions.getSessionTurns(sessionId),
+      onDispose: (session) => {
+        if (this.sessions.get(session.sessionId) === session) {
+          this.sessions.delete(session.sessionId);
+        }
+        ;
+        this.client.socket().emit("session:unsubscribe", { session_id: session.sessionId });
+      }
+    };
+  }
+  ensureConnected() {
+    const socket = this.client.socket();
+    if (socket.connected || socket.active) return;
+    this.setConnection("connecting");
+    socket.connect();
+  }
+  setConnection(status) {
+    if (this.connection === status) return;
+    this.connection = status;
+    for (const session of this.sessions.values()) {
+      session._setConnection(status);
+    }
+    for (const listener of [...this.connectionListeners]) {
+      try {
+        listener(status);
+      } catch (error) {
+        console.warn("[agent-client] \u8FDE\u63A5\u72B6\u6001\u56DE\u8C03\u629B\u51FA\u5F02\u5E38\uFF1A", error);
+      }
+    }
+  }
+  /** 事件带 session_id 时精确路由；缺省时按当前唯一活跃会话兜底。 */
+  route(sessionId) {
+    if (sessionId) {
+      const session = this.sessions.get(sessionId);
+      return session && !session.isDisposed ? [session] : [];
+    }
+    const active = [...this.sessions.values()].filter((session) => !session.isDisposed);
+    return active.length === 1 ? active : [];
+  }
+  ensureBound() {
+    if (this.bound) return;
+    this.bound = true;
+    const socket = this.client.socket();
+    socket.on("connect", () => {
+      const isReconnect = this.hasConnected;
+      this.hasConnected = true;
+      this.setConnection("connected");
+      if (isReconnect) {
+        for (const session of this.sessions.values()) {
+          void session._rejoinAfterReconnect();
+        }
+      }
+    });
+    socket.on("connect_error", () => this.setConnection("disconnected"));
+    socket.on("disconnect", () => this.setConnection("disconnected"));
+    socket.io.on("reconnect_attempt", () => this.setConnection("reconnecting"));
+    socket.on("turn:start", (data) => {
+      for (const session of this.route(data.session_id)) session._handleTurnStart(data);
+    });
+    socket.on("turn:patch", (data) => {
+      for (const session of this.route(data.session_id)) session._handleTurnPatch(data);
+    });
+    socket.on("turn:end", (data) => {
+      for (const session of this.route(data.session_id)) session._handleTurnEnd(data);
+    });
+    socket.on("turn:events", (data) => {
+      for (const session of this.route(data.session_id)) session._handleTurnEvents(data.events ?? []);
+    });
+    socket.on("chat:start", (data) => {
+      for (const session of this.route(data?.session_id)) session._handleChatStart();
+    });
+    socket.on("chat:end", (data) => {
+      for (const session of this.route(data?.session_id)) {
+        session._handleChatEnd(data?.status ?? "completed");
+      }
+    });
+    socket.on("system:error", (data) => {
+      for (const session of this.route(data.session_id)) session._handleSystemError(data.message);
+    });
+    socket.on(
+      "system:notification",
+      (data) => {
+        for (const session of this.route(data.session_id)) {
+          session._handleSystemNotification("root", data);
+        }
+      }
+    );
+    socket.on("task:updated", (data) => {
+      for (const session of this.route(data.session_id)) session._handleTaskUpdated(data.tasks);
+    });
+    socket.on("task:synced", (data) => {
+      for (const session of this.route(data.session_id)) session._handleTaskUpdated(data.tasks);
+    });
+    socket.on(
+      "workspace:files_changed",
+      (data) => {
+        for (const session of this.route(data.session_id)) {
+          session._handleWorkspaceFilesChanged(data.file_path);
+        }
+      }
+    );
+    socket.on(
+      "session:updated",
+      (data) => {
+        for (const session of this.route(data.session_id)) {
+          session._handleSessionUpdated(data);
+        }
+      }
+    );
+    socket.on("session:rewind", (data) => {
+      for (const session of this.route(data.session_id)) {
+        session._handleRewind(data.checkpoint_id);
+      }
+    });
+    socket.on(
+      "replay:input_mismatch",
+      (data) => {
+        for (const session of this.route(data.session_id)) session._handleReplayMismatch(data);
+      }
+    );
+    socket.on("artifact:created", (data) => {
+      this.routeArtifact(data, "created");
+    });
+    socket.on("artifact:updated", (data) => {
+      this.routeArtifact(data, "updated");
+    });
+    socket.on("bg:started", (data) => {
+      const taskId = typeof data.task_id === "string" ? data.task_id : typeof data.id === "string" ? data.id : "";
+      if (!taskId) return;
+      for (const session of this.route(data.session_id)) {
+        session._handleBackgroundTask({
+          id: taskId,
+          command: typeof data.command === "string" ? data.command : "",
+          description: typeof data.description === "string" ? data.description : void 0,
+          status: "running",
+          elapsedSeconds: typeof data.elapsed_seconds === "number" ? data.elapsed_seconds : 0
+        });
+      }
+    });
+    socket.on(
+      "bg:tasks_completed",
+      (data) => {
+        for (const session of this.route(data.session_id)) {
+          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;
+            session._handleBackgroundTask({
+              id: taskId,
+              command: typeof task.command === "string" ? task.command : "",
+              description: typeof task.description === "string" ? task.description : void 0,
+              status: task.status === "running" || task.status === "failed" ? task.status : "done",
+              exitCode: typeof task.exit_code === "number" || task.exit_code === null ? task.exit_code : void 0,
+              elapsedSeconds: typeof task.elapsed_seconds === "number" ? task.elapsed_seconds : 0,
+              output: Array.isArray(task.output_preview) && task.output_preview.length > 0 ? task.output_preview.join("\n") : void 0
+            });
+          }
+        }
+      }
+    );
+  }
+  routeArtifact(data, kind) {
+    const filePath = typeof data.file_path === "string" ? data.file_path : "";
+    if (!filePath) return;
+    for (const session of this.route(data.session_id)) {
+      session._handleWorkspaceFilesChanged(filePath);
+      session._handleArtifact({
+        filePath,
+        contentType: typeof data.content_type === "string" ? data.content_type : "",
+        title: typeof data.title === "string" ? data.title : filePath,
+        content: typeof data.content === "string" ? data.content : "",
+        oldString: typeof data.old_string === "string" ? data.old_string : void 0,
+        newString: typeof data.new_string === "string" ? data.new_string : void 0,
+        kind
+      });
+    }
+  }
+};
+
+// src/socket.ts
+import { io } from "socket.io-client";
+
+// src/auth.ts
+function buildSocketAuth(options) {
+  const token = resolveAuthToken(options);
+  return token ? { token } : void 0;
+}
+function resolveAuthToken(options) {
+  const token = typeof options.token === "function" ? options.token() : options.token;
+  return token ? token : null;
+}
+
+// src/version.ts
+var SDK_NAME = "agent-client";
+var SDK_VERSION = "2.0.0";
+var MIN_SERVER_VERSION = "1.1.1";
+var LEGACY_SDK = "@blade-hq/agent-kit@1.1.0";
+var VersionMismatchError = class extends Error {
+  serverVersion;
+  sdkVersion;
+  hint;
+  constructor(options) {
+    super(
+      `SDK \u4E0E Server \u7248\u672C\u4E0D\u5339\u914D\uFF08SDK ${SDK_NAME}@${SDK_VERSION}\uFF0CServer ${options.serverVersion ?? "\u7248\u672C\u672A\u77E5\uFF08\u4E0D\u652F\u6301 /api/version\uFF09"}\uFF09\uFF1A${options.hint}`
+    );
+    this.name = "VersionMismatchError";
+    this.serverVersion = options.serverVersion;
+    this.sdkVersion = SDK_VERSION;
+    this.hint = options.hint;
+  }
+};
+function parseCoreVersion(version) {
+  const match = /^(\d+)\.(\d+)\.(\d+)/.exec(version.trim());
+  if (!match) return null;
+  return [Number(match[1]), Number(match[2]), Number(match[3])];
+}
+function isPrerelease(version) {
+  const trimmed = version.trim();
+  if (!parseCoreVersion(trimmed)) return true;
+  return /[-+]/.test(trimmed);
+}
+function compareVersions(a, b) {
+  const left = parseCoreVersion(a);
+  const right = parseCoreVersion(b);
+  if (!left || !right) return 0;
+  for (let i = 0; i < 3; i++) {
+    if (left[i] !== right[i]) return left[i] - right[i];
+  }
+  return 0;
+}
+function assertVersionCompatible(info) {
+  if (info === null) {
+    throw new VersionMismatchError({
+      serverVersion: null,
+      hint: `\u8BE5 Server \u4E0D\u63D0\u4F9B /api/version\uFF0C\u8BF4\u660E\u7248\u672C\u4F4E\u4E8E ${MIN_SERVER_VERSION}\u3002\u8BF7\u6539\u7528 ${LEGACY_SDK} \u63A5\u5165\uFF0C\u6216\u628A Server \u5347\u7EA7\u5230 ${MIN_SERVER_VERSION} \u53CA\u4EE5\u4E0A\u3002`
+    });
+  }
+  if (!isPrerelease(info.version) && compareVersions(info.version, MIN_SERVER_VERSION) < 0) {
+    throw new VersionMismatchError({
+      serverVersion: info.version,
+      hint: `\u672C SDK \u9700\u8981 Server ${MIN_SERVER_VERSION} \u53CA\u4EE5\u4E0A\u3002\u8BF7\u6539\u7528 ${LEGACY_SDK} \u63A5\u5165\u8BE5 Server\uFF0C\u6216\u628A Server \u5347\u7EA7\u5230 ${MIN_SERVER_VERSION} \u53CA\u4EE5\u4E0A\u3002`
+    });
+  }
+  const minSdk = info.min_sdk;
+  if (minSdk && !isPrerelease(SDK_VERSION) && compareVersions(SDK_VERSION, minSdk) < 0) {
+    throw new VersionMismatchError({
+      serverVersion: info.version,
+      hint: `\u8BE5 Server \u8981\u6C42 SDK ${minSdk} \u53CA\u4EE5\u4E0A\uFF0C\u8BF7\u628A ${SDK_NAME} \u5347\u7EA7\u5230 ${minSdk} \u53CA\u4EE5\u4E0A\u3002`
+    });
+  }
+}
+
+// src/socket.ts
+function withSdkIdentity(auth) {
+  return { ...auth ?? {}, sdk: SDK_NAME, sdk_version: SDK_VERSION };
+}
+function createSocket(options) {
+  const token = resolveAuthToken(options);
+  return io(options.baseUrl, {
+    path: options.path ?? "/socket.io",
+    withCredentials: true,
+    query: token ? { token } : void 0,
+    auth: typeof options.token === "function" ? (cb) => cb(withSdkIdentity(buildSocketAuth(options))) : withSdkIdentity(buildSocketAuth(options)),
+    autoConnect: false
+  });
+}
+
+// src/blade-client.ts
+var REFRESH_PATH = "/api/auth/refresh";
+var BladeClient = class {
+  refreshPromise = null;
+  socketInstance = null;
+  socketReplacementListeners = /* @__PURE__ */ new Set();
+  /** login() / setToken() 热挂载的令牌，优先级高于构造参数。 */
+  runtimeToken = null;
+  options;
+  auth;
+  headless;
+  sessions;
+  /** 实时会话中枢：client.sessions.connect() 内部使用，一般不直接访问。 */
+  hub;
+  /** 版本握手结果缓存：每个 client 实例只探测一次，不逐请求重复。 */
+  versionCheck = null;
+  constructor(options) {
+    this.options = {
+      ...options,
+      baseUrl: normalizeBaseUrl(options.baseUrl)
+    };
+    this.auth = new AuthResource(this);
+    this.headless = new HeadlessResource(this);
+    this.sessions = new SessionsResource(this);
+    this.hub = new SessionHub(this);
+    if (this.options.token === void 0) {
+      this.runtimeToken = readStoredToken(this.options.baseUrl);
+    }
+  }
+  /**
+   * 弹窗授权登录：用户在弹出的授权页点击"许可授权"后自动取得 PAT，
+   * REST 与 Socket.IO 立即生效。只在浏览器可用。
+   */
+  async login(options) {
+    const result = await loginWithPopup(this, options);
+    this.setToken(result.token);
+    return result;
+  }
+  /** 退出登录：清除 login() 存储的令牌并断开实时连接。 */
+  logoutToken() {
+    this.setToken(null);
+    this.hub.disconnect();
+  }
+  /** 热挂载访问令牌（null 表示清除）。会重建 Socket.IO 连接以携带新凭证。 */
+  setToken(token) {
+    const previousToken = this.resolveToken();
+    this.runtimeToken = token;
+    const nextToken = this.resolveToken();
+    if (previousToken !== nextToken) {
+      this.hub.disposeAll();
+    }
+    writeStoredToken(this.options.baseUrl, token, this.options.tokenStorage ?? "local");
+    if (this.socketInstance) {
+      const wasConnected = this.socketInstance.connected || this.socketInstance.active;
+      this.socketInstance.disconnect();
+      if (wasConnected || token) {
+        this.socketInstance.connect();
+      }
+    }
+  }
+  /** 当前是否持有访问令牌（不代表令牌一定有效）。 */
+  hasToken() {
+    return Boolean(this.resolveRestToken());
+  }
+  /**
+   * 当前访问令牌（PAT），未登录时为 null。
+   *
+   * SDK 只封装会话相关接口；其余长尾接口对照后端 Swagger（`<baseUrl>/docs`）
+   * 用原生 fetch 自行调用，把本令牌填入 Authorization 头即可：
+   *
+   * ```ts
+   * fetch(`${baseUrl}/api/memories/search?q=xxx`, {
+   *   headers: { Authorization: `Bearer ${client.token}` },
+   * })
+   * ```
+   *
+   * 安全约束：该令牌只应发往 baseUrl 同源接口，不要附加到第三方域名的请求上。
+   */
+  get token() {
+    return this.resolveRestToken();
+  }
+  /**
+   * 版本握手：首次连接前查询 Server 版本，不匹配则抛 VersionMismatchError。
+   * 结果缓存在实例上，失败的探测不缓存以便重试。
+   */
+  async ensureVersionCompatible() {
+    if (!this.versionCheck) {
+      this.versionCheck = this.fetchServerVersion().then(assertVersionCompatible).catch((error) => {
+        this.versionCheck = null;
+        throw error;
+      });
+    }
+    return this.versionCheck;
+  }
+  /**
+   * 读取 /api/version。接口存在但 404/响应不合法 → null（按旧 Server 处理）；
+   * 网络层不可达（后端没启动、端口不通、代理配错）→ 抛连接错误。
+   * 两者必须区分：把「后端没起」误报成「版本不匹配，请改用 agent-kit」
+   * 会把开发者引向完全错误的排查方向。
+   */
+  async fetchServerVersion() {
+    let response;
+    try {
+      response = await this.fetch("GET", "/api/version", { expectOk: false });
+    } catch (error) {
+      throw new Error(
+        `\u65E0\u6CD5\u8FDE\u63A5\u5230 Server\uFF08${this.options.baseUrl || "\u5F53\u524D\u57DF\u540D"}\uFF09\u3002\u8BF7\u786E\u8BA4\u540E\u7AEF\u5DF2\u542F\u52A8\u3001\u5730\u5740\u4E0E\u7AEF\u53E3\u6B63\u786E\u3002`,
+        { cause: error }
+      );
+    }
+    if (!response.ok) return null;
+    try {
+      const info = await response.json();
+      return typeof info?.version === "string" ? info : null;
+    } catch {
+      return null;
+    }
+  }
+  setBaseUrl(baseUrl) {
+    const nextBaseUrl = normalizeBaseUrl(baseUrl);
+    if (nextBaseUrl === this.options.baseUrl) {
+      return;
+    }
+    this.hub.disposeAll();
+    this.options.baseUrl = nextBaseUrl;
+    this.versionCheck = null;
+    if (this.socketInstance) {
+      this.socketInstance.removeAllListeners();
+      this.socketInstance.disconnect();
+      this.socketInstance = null;
+      this.hub._handleSocketReplaced();
+      for (const listener of [...this.socketReplacementListeners]) {
+        try {
+          listener();
+        } catch (error) {
+          console.warn("[agent-client] socket \u66FF\u6362\u56DE\u8C03\u629B\u51FA\u5F02\u5E38\uFF1A", error);
+        }
+      }
+    }
+  }
+  /** 底层 Socket.IO 实例因后端地址变化而被替换时通知高级集成层。 */
+  onSocketReplaced(listener) {
+    this.socketReplacementListeners.add(listener);
+    return () => {
+      this.socketReplacementListeners.delete(listener);
+    };
+  }
+  socket() {
+    if (!this.socketInstance) {
+      this.socketInstance = createSocket({
+        baseUrl: this.options.baseUrl,
+        token: () => this.resolveSocketToken()
+      });
+    }
+    return this.socketInstance;
+  }
+  async json(method, path, body) {
+    const response = await this.fetch(method, path, {
+      body: body === void 0 ? void 0 : JSON.stringify(body),
+      headers: body === void 0 ? void 0 : { "content-type": "application/json" }
+    });
+    return readJsonResponse(response);
+  }
+  async jsonFromInit(path, init = {}) {
+    const method = (init.method ?? "GET").toUpperCase();
+    const headers = new Headers(init.headers);
+    if (init.body != null && !isFormData(init.body) && !headers.has("content-type")) {
+      headers.set("content-type", "application/json");
+    }
+    const response = await this.fetch(method, path, {
+      body: init.body,
+      credentials: init.credentials,
+      headers,
+      signal: init.signal
+    });
+    return readJsonResponse(response);
+  }
+  async text(method, path) {
+    const response = await this.fetch(method, path);
+    return response.text();
+  }
+  async textFromInit(path, init = {}) {
+    const method = (init.method ?? "GET").toUpperCase();
+    const response = await this.fetch(method, path, {
+      body: init.body,
+      credentials: init.credentials,
+      headers: init.headers,
+      signal: init.signal
+    });
+    return response.text();
+  }
+  async responseFromInit(path, init = {}) {
+    const method = (init.method ?? "GET").toUpperCase();
+    return this.fetch(method, path, {
+      body: init.body,
+      credentials: init.credentials,
+      headers: init.headers,
+      signal: init.signal
+    });
+  }
+  async blob(method, path) {
+    const response = await this.fetch(method, path);
+    return response.blob();
+  }
+  async formData(method, path, form, options = {}) {
+    if (options.onUploadProgress && !this.options.fetchImpl && typeof XMLHttpRequest !== "undefined") {
+      return this.formDataWithUploadProgress(method, path, form, options);
+    }
+    return this.fetch(method, path, { body: form, expectOk: options.expectOk });
+  }
+  async fetch(method, path, init = {}, isRetry = false) {
+    const url = this.buildUrl(path);
+    const response = await (this.options.fetchImpl ?? fetch)(url.toString(), {
+      method,
+      body: init.body,
+      credentials: init.credentials ?? "include",
+      headers: this.buildHeaders(url, init.headers),
+      signal: init.signal
+    });
+    if (response.status === 401 && !isRetry && this.shouldRefreshFor401(url)) {
+      const refreshed = await this.tryRefresh();
+      if (refreshed) {
+        return this.fetch(method, path, init, true);
+      }
+    }
+    if (init.expectOk !== false && !response.ok) {
+      const detail = await extractErrorDetail(response);
+      throw decorateAuthError(new BladeApiError(response, detail));
+    }
+    return response;
+  }
+  buildAuthedUrl(path) {
+    const url = new URL(this.toBaseRelativePath(path), this.baseUrlWithTrailingSlash());
+    const token = this.resolveTokenForUrl(url);
+    if (token) {
+      url.searchParams.set("token", token);
+    }
+    return url.toString();
+  }
+  buildHeaders(url, headers) {
+    const result = new Headers(headers);
+    if (!this.isSameBackendUrl(url)) {
+      return result;
+    }
+    const token = this.resolveRestToken();
+    if (token) {
+      result.set("Authorization", `Bearer ${token}`);
+    }
+    return result;
+  }
+  buildUrl(path) {
+    return new URL(this.toBaseRelativePath(path), this.baseUrlWithTrailingSlash());
+  }
+  baseUrlWithTrailingSlash() {
+    return this.options.baseUrl.endsWith("/") ? this.options.baseUrl : `${this.options.baseUrl}/`;
+  }
+  toBaseRelativePath(path) {
+    return path.startsWith("/") ? path.slice(1) : path;
+  }
+  isSameBackendUrl(url) {
+    const base = new URL(this.baseUrlWithTrailingSlash());
+    if (url.origin !== base.origin) {
+      return false;
+    }
+    const basePath = base.pathname.replace(/\/+$/, "");
+    if (basePath === "") {
+      return true;
+    }
+    return url.pathname === basePath || url.pathname.startsWith(`${basePath}/`);
+  }
+  shouldRefreshFor401(url) {
+    const refreshUrl = this.buildUrl(REFRESH_PATH);
+    return this.isSameBackendUrl(url) && url.pathname !== refreshUrl.pathname && !this.hasExplicitBearerToken();
+  }
+  hasExplicitBearerToken() {
+    return Boolean(this.resolveRestToken());
+  }
+  async tryRefresh() {
+    if (this.refreshPromise) {
+      return this.refreshPromise;
+    }
+    this.refreshPromise = (async () => {
+      try {
+        const response = await (this.options.fetchImpl ?? fetch)(
+          this.buildUrl(REFRESH_PATH).toString(),
+          {
+            method: "POST",
+            credentials: "include"
+          }
+        );
+        if (!response.ok) {
+          return false;
+        }
+        await this.options.onRefreshSuccess?.();
+        return true;
+      } catch {
+        return false;
+      } finally {
+        this.refreshPromise = null;
+      }
+    })();
+    return this.refreshPromise;
+  }
+  resolveTokenForUrl(url) {
+    if (!this.isSameBackendUrl(url)) {
+      return null;
+    }
+    return this.resolveRestToken();
+  }
+  resolveRestToken() {
+    return this.resolveToken();
+  }
+  resolveSocketToken() {
+    if (this.runtimeToken) return this.runtimeToken;
+    return resolveTokenOption(this.options.socketToken ?? this.options.token);
+  }
+  resolveToken() {
+    if (this.runtimeToken) return this.runtimeToken;
+    return resolveTokenOption(this.options.token);
+  }
+  formDataWithUploadProgress(method, path, form, options, isRetry = false) {
+    const url = this.buildUrl(path);
+    const headers = this.buildHeaders(url);
+    return new Promise((resolve, reject) => {
+      const xhr = new XMLHttpRequest();
+      xhr.open(method, url.toString(), true);
+      xhr.withCredentials = true;
+      headers.forEach((value, key) => {
+        xhr.setRequestHeader(key, value);
+      });
+      xhr.upload.onprogress = (event) => {
+        options.onUploadProgress?.({
+          loaded: event.loaded,
+          total: event.lengthComputable ? event.total : void 0,
+          percent: event.lengthComputable && event.total > 0 ? event.loaded / event.total : void 0
+        });
+      };
+      xhr.onerror = () => reject(new TypeError("Network request failed"));
+      xhr.ontimeout = () => reject(new TypeError("Network request timed out"));
+      xhr.onabort = () => reject(new DOMException("Request aborted", "AbortError"));
+      xhr.onload = async () => {
+        if (xhr.status === 401 && !isRetry && this.shouldRefreshFor401(url)) {
+          const refreshed = await this.tryRefresh();
+          if (refreshed) {
+            resolve(this.formDataWithUploadProgress(method, path, form, options, true));
+            return;
+          }
+        }
+        const response = new Response(xhr.responseText, {
+          status: xhr.status,
+          statusText: xhr.statusText,
+          headers: parseXhrHeaders(xhr.getAllResponseHeaders())
+        });
+        if (options.expectOk !== false && !response.ok) {
+          const detail = await extractErrorDetail(response.clone());
+          reject(new BladeApiError(response, detail));
+          return;
+        }
+        options.onUploadProgress?.({ loaded: 1, total: 1, percent: 1 });
+        resolve(response);
+      };
+      xhr.send(form);
+    });
+  }
+};
+function resolveTokenOption(tokenOption) {
+  const token = typeof tokenOption === "function" ? tokenOption() : tokenOption;
+  return token ? token : null;
+}
+function normalizeBaseUrl(baseUrl) {
+  const normalized = baseUrl.trim().replace(/\/+$/, "");
+  if (normalized || typeof window === "undefined") {
+    return normalized;
+  }
+  return window.location.origin;
+}
+function isFormData(value) {
+  return typeof FormData !== "undefined" && value instanceof FormData;
+}
+function readJsonResponse(response) {
+  if (response.status === 204 || response.headers.get("content-length") === "0") {
+    return Promise.resolve(void 0);
+  }
+  return response.json();
+}
+function parseXhrHeaders(rawHeaders) {
+  const headers = new Headers();
+  for (const line of rawHeaders.trim().split(/[\r\n]+/)) {
+    const separatorIndex = line.indexOf(":");
+    if (separatorIndex <= 0) continue;
+    headers.append(line.slice(0, separatorIndex).trim(), line.slice(separatorIndex + 1).trim());
+  }
+  return headers;
+}
+
+// src/commands/protocol.ts
+function isCommandEnvelope(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const record = value;
+  return record.__bladeBridge === true && record.direction === "agent-to-host" && typeof record.action === "string";
+}
+function isInboundEnvelope(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const record = value;
+  return record.__bladeBridge === true && record.direction === "host-to-agent" && (record.action === "addContext" || record.action === "appendInput" || record.action === "sendMessage");
+}
+
+// src/commands/embedded.ts
+function connectEmbedded(options) {
+  if (typeof window === "undefined") {
+    throw new Error("connectEmbedded() \u53EA\u80FD\u5728\u6D4F\u89C8\u5668\u4E2D\u4F7F\u7528\u3002");
+  }
+  if (!options.allowedOrigins?.length) {
+    throw new Error(
+      "connectEmbedded() \u9700\u8981 allowedOrigins\uFF08Blade \u9875\u9762\u7684 origin\uFF09\uFF0C\u5426\u5219\u65E0\u6CD5\u5B89\u5168\u63A5\u6536\u6D88\u606F\u3002"
+    );
+  }
+  const registry = new CommandRegistry();
+  const allowed = new Set(options.allowedOrigins);
+  const onMessage = (event) => {
+    if (!allowed.has(event.origin)) return;
+    if (options.iframe && event.source !== options.iframe.contentWindow) return;
+    if (!isCommandEnvelope(event.data)) return;
+    registry.dispatch(event.data.action, event.data.payload, {
+      toolCallId: event.data.meta?.toolCallId
+    });
+  };
+  window.addEventListener("message", onMessage);
+  const post = (action, payload) => {
+    const target = options.iframe?.contentWindow;
+    if (!target) {
+      console.warn("[agent-client] connectEmbedded \u672A\u7ED1\u5B9A iframe\uFF0C\u65E0\u6CD5\u5411\u667A\u80FD\u4F53\u53D1\u9001\u6D88\u606F\u3002");
+      return;
+    }
+    target.postMessage(
+      { __bladeBridge: true, direction: "host-to-agent", action, payload },
+      options.allowedOrigins[0]
+    );
+  };
+  return {
+    onCommand: (action, handler) => registry.onCommand(action, handler),
+    attach: (label, data) => {
+      const content = typeof data === "string" ? data : JSON.stringify(data, null, 2);
+      post("addContext", { label, content });
+    },
+    insertText: (text) => post("appendInput", { text }),
+    send: (text) => post("sendMessage", { text }),
+    dispose: () => {
+      window.removeEventListener("message", onMessage);
+      registry.clear();
+    }
+  };
+}
+
+// src/schemas/session.ts
+import { type } from "arktype";
+var SessionStatus = type(
+  "'created' | 'running' | 'completed' | 'failed' | 'interrupted' | 'waiting_for_input'"
+);
+var SessionInfo = type({
+  id: "string",
+  intent: "string",
+  status: SessionStatus,
+  created_at: "string",
+  updated_at: "string",
+  "shared?": "boolean",
+  "memory_enabled?": "boolean",
+  "is_persistent?": "boolean",
+  "is_headless?": "boolean",
+  "viewer_role?": "'owner' | 'viewer'",
+  "template_id?": "string | null",
+  "model?": "string | null",
+  "enable_thinking?": "boolean | null",
+  "solution_id?": "string | null",
+  "biz_role_id?": "string | null",
+  "solution?": "unknown",
+  "plan_summary?": "string | null",
+  "primary_skill_id?": "string | null",
+  // ship-attack v2：后端 engine.set_bound_skill 写入的"绑定 skill id"。
+  // 未绑定 / 非 ship-attack session 为 null。
+  "bound_skill_id?": "string | null",
+  "replay_state?": "unknown",
+  "is_pinned?": "boolean",
+  "pinned_at?": "string | null",
+  "is_example?": "boolean",
+  "ports?": "unknown",
+  "disable_tools?": "string[]",
+  "runtime_type?": "string | null",
+  "daemon_id?": "string | null",
+  "match?": "unknown"
+});
+
+// src/schemas/solution.ts
+var LayoutType = /* @__PURE__ */ ((LayoutType2) => {
+  LayoutType2["Default"] = "default";
+  LayoutType2["SkillEditor"] = "skill-editor";
+  LayoutType2["BladeCoa"] = "blade-coa";
+  LayoutType2["SolutionEditor"] = "solution-editor";
+  LayoutType2["SolutionEditor2"] = "solution-editor2";
+  LayoutType2["ChatPreview"] = "chat-preview";
+  LayoutType2["ChatOnly"] = "chat-only";
+  LayoutType2["SolutionApp"] = "solution-app";
+  LayoutType2["Custom"] = "custom";
+  return LayoutType2;
+})(LayoutType || {});
+
+// src/schemas/task.ts
+import { type as type2 } from "arktype";
+var TaskStatus = type2("'pending' | 'in_progress' | 'done' | 'failed' | 'skipped'");
+var Task = type2({
+  id: "string",
+  goal: "string",
+  skills: "string[]",
+  depends_on: "string[]",
+  status: TaskStatus,
+  result_summary: "string",
+  number: "string"
+});
+export {
+  AgentSession,
+  BladeApiError,
+  BladeClient,
+  ClientProjectionBuilder,
+  LayoutType,
+  MIN_SERVER_VERSION,
+  SDK_NAME,
+  SDK_VERSION,
+  SessionHub,
+  SessionInfo,
+  SessionStatus,
+  Task,
+  TaskStatus,
+  VersionMismatchError,
+  buildMessageContent,
+  connectEmbedded,
+  contentPreview,
+  createInitialSessionState,
+  createSocket,
+  extractTextAttachments,
+  getFileParts,
+  getImageParts,
+  getTextContent,
+  groupMessagesByLoop,
+  isCommandEnvelope,
+  isHiddenInternalMessage,
+  isInboundEnvelope,
+  normalizeMessageContent,
+  transformSlashCommand
+};
+//# sourceMappingURL=index.js.map