@blade-hq/agent-client 2612.0.0-beta.2 → 2612.0.0-beta.20

package/dist/{chunk-PWJJJATA.js → chunk-2VIJBVAC.js}

@@ -1,6 +1,219 @@
+// 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;
+}
+function buildBackendUrl(baseUrl, path) {
+  const base = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+  return new URL(path.startsWith("/") ? path.slice(1) : path, base);
+}
+
+// src/tool-provider.ts
+var ToolProvider = class {
+  constructor(client, options, onDispose) {
+    this.client = client;
+    this.options = options;
+    this.onDispose = onDispose;
+    if (!/^[a-zA-Z0-9_-]{1,128}$/.test(options.providerId) || options.capability.length < 16 || options.capability.length > 4096) throw new Error("Invalid tool provider identity");
+    if (new Set(options.tools.map((t) => t.name)).size !== options.tools.length || options.tools.length > 256) throw new Error("Duplicate or excessive provider tools");
+    this.url = `blade-rpc://${options.providerId}`;
+    this.open();
+  }
+  client;
+  options;
+  onDispose;
+  url;
+  socket;
+  timer;
+  registrationTimer;
+  disposed = false;
+  registered = false;
+  attempts = 0;
+  calls = /* @__PURE__ */ new Map();
+  waiters = /* @__PURE__ */ new Set();
+  /** Resolves only after BA has authenticated and registered this connection. */
+  ready() {
+    if (this.disposed) return Promise.reject(new Error("Tool provider disposed"));
+    if (this.registered) return Promise.resolve();
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.waiters.delete(waiter);
+        reject(new Error("Tool provider registration timed out"));
+      }, 25e3);
+      const waiter = { resolve: () => {
+        clearTimeout(timer);
+        resolve();
+      }, reject: (e) => {
+        clearTimeout(timer);
+        reject(e);
+      } };
+      this.waiters.add(waiter);
+    });
+  }
+  reconnect() {
+    if (this.disposed) return;
+    clearTimeout(this.timer);
+    this.reset();
+    this.open();
+  }
+  reset() {
+    clearTimeout(this.registrationTimer);
+    this.registered = false;
+    const socket = this.socket;
+    this.socket = void 0;
+    socket?.close();
+    for (const controller of this.calls.values()) controller.abort();
+    this.calls.clear();
+  }
+  fail(error) {
+    for (const waiter of this.waiters) waiter.reject(error);
+    this.waiters.clear();
+    try {
+      this.options.onError?.(error);
+    } catch {
+    }
+  }
+  open() {
+    if (this.disposed) return;
+    const endpoint = buildBackendUrl(this.client.options.baseUrl, "/api/app-tools/connect");
+    endpoint.protocol = endpoint.protocol === "https:" ? "wss:" : "ws:";
+    let socket;
+    try {
+      const token = this.client.token;
+      if (!token) throw new Error("Tool provider requires a token");
+      const encoded = btoa(Array.from(new TextEncoder().encode(token), (byte) => String.fromCharCode(byte)).join("")).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+      socket = new WebSocket(endpoint, ["blade-rpc", `blade-bearer.${encoded}`]);
+    } catch {
+      this.fail(new Error("Tool provider WebSocket unavailable"));
+      this.schedule();
+      return;
+    }
+    this.socket = socket;
+    this.registrationTimer = setTimeout(() => {
+      if (this.socket === socket) {
+        this.fail(new Error("Tool provider registration timed out"));
+        socket.close();
+      }
+    }, 15e3);
+    socket.addEventListener("open", () => {
+      if (this.socket !== socket) return;
+      socket.send(JSON.stringify({ jsonrpc: "2.0", id: "register", method: "provider/register", params: { providerId: this.options.providerId, capability: this.options.capability } }));
+    });
+    socket.addEventListener("message", (event) => {
+      if (this.socket !== socket || typeof event.data !== "string") return;
+      void this.receive(socket, event.data).catch(() => {
+        this.fail(new Error("Invalid application tool RPC message"));
+        socket.close();
+      });
+    });
+    socket.addEventListener("error", () => {
+      if (this.socket === socket) this.fail(new Error("Application tool connection failed"));
+    });
+    socket.addEventListener("close", () => {
+      if (this.socket !== socket) return;
+      this.reset();
+      this.fail(new Error("Application tool connection closed; unfinished calls will not be replayed"));
+      this.schedule();
+    });
+  }
+  schedule() {
+    if (this.disposed) return;
+    this.timer = setTimeout(() => this.open(), Math.min(1e4, 500 * 2 ** Math.min(this.attempts++, 5)));
+  }
+  async receive(socket, text) {
+    const message = JSON.parse(text);
+    if (message.jsonrpc !== "2.0") throw new Error("Invalid JSON-RPC envelope");
+    if (message.id === "register" && !message.method) {
+      clearTimeout(this.registrationTimer);
+      if (message.error || !message.result?.registered) {
+        this.fail(new Error(message.error?.message ?? "Tool provider registration rejected"));
+        socket.close();
+        return;
+      }
+      this.registered = true;
+      this.attempts = 0;
+      for (const waiter of this.waiters) waiter.resolve();
+      this.waiters.clear();
+      return;
+    }
+    if (!this.registered) throw new Error("Provider not registered");
+    if (message.method === "notifications/cancelled") {
+      this.calls.get(String(message.params?.requestId))?.abort();
+      return;
+    }
+    if (!message.id || typeof message.id !== "string" || this.calls.has(message.id)) throw new Error("Invalid RPC request ID");
+    const controller = new AbortController();
+    this.calls.set(message.id, controller);
+    let response = { jsonrpc: "2.0", id: message.id };
+    try {
+      if (message.method === "tools/list") {
+        response.result = { tools: this.options.tools.map(({ name, description, inputSchema }) => ({ name, description, inputSchema })) };
+      } else if (message.method === "tools/call") {
+        const params = message.params;
+        const tool = this.options.tools.find((t) => t.name === params?.name);
+        if (!tool || typeof params?.sessionId !== "string" || !params.sessionId || !params.arguments || typeof params.arguments !== "object" || Array.isArray(params.arguments)) throw new Error("Invalid or unauthorized tool call");
+        response.result = await tool.handler(params.arguments, { sessionId: params.sessionId, signal: controller.signal });
+      } else {
+        response.error = { code: -32601, message: "Method not found" };
+      }
+    } catch {
+      response = { jsonrpc: "2.0", id: message.id, error: { code: -32e3, message: "Application tool execution failed" } };
+    } finally {
+      this.calls.delete(message.id);
+    }
+    if (this.socket === socket && socket.readyState === WebSocket.OPEN && !controller.signal.aborted) socket.send(JSON.stringify(response));
+  }
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    clearTimeout(this.timer);
+    this.reset();
+    this.fail(new Error("Tool provider disposed"));
+    this.onDispose();
+  }
+};
+
 // src/version.ts
 var SDK_NAME = "agent-client";
-var SDK_VERSION = true ? "2612.0.0-beta.2" : "1.1.1";
+var SDK_VERSION = true ? "2612.0.0-beta.20" : "1.1.1";
 
 // src/auth-login.ts
 function isAuthCallbackMessage(value) {
@@ -128,54 +341,6 @@ async function loginWithPopup(client, options = {}) {
   });
 }
 
-// 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;
-}
-function buildBackendUrl(baseUrl, path) {
-  const base = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
-  return new URL(path.startsWith("/") ? path.slice(1) : path, base);
-}
-
 // src/resources/auth.ts
 var AuthResource = class {
   constructor(client) {
@@ -227,404 +392,167 @@ function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
-// src/resources/headless.ts
-var HeadlessError = class extends Error {
-  constructor(message, detail) {
-    super(message);
-    this.detail = detail;
-    this.name = "HeadlessError";
+// src/session/log-cursor.ts
+function positive(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+}
+var LogCursor = class {
+  sequence = 0;
+  epoch = 0;
+  deltas = /* @__PURE__ */ new Map();
+  subscription() {
+    return this.sequence > 0 ? { after_log_seq: this.sequence } : {};
+  }
+  consume(events) {
+    const accepted = [];
+    let reload = false;
+    for (const event of events) {
+      if (event.type === "log:retract") {
+        this.deltas.clear();
+        reload = true;
+        continue;
+      }
+      if (event.type === "log:record") {
+        if (!positive(event.log_seq) || event.log_seq <= this.sequence) continue;
+        const nested = event.payload.events;
+        if (!Array.isArray(nested)) continue;
+        if (positive(event.payload.epoch) && event.payload.epoch !== this.epoch) {
+          this.epoch = event.payload.epoch;
+          this.deltas.clear();
+          reload = true;
+        }
+        accepted.push(...nested);
+        if (["step_end", "run_end", "truncate"].includes(String(event.payload.kind))) {
+          for (const step of this.deltas.keys()) if (step <= event.log_seq) this.deltas.delete(step);
+        }
+        this.sequence = event.log_seq;
+        continue;
+      }
+      if (event.type === "llm:stream:reset" && positive(event.step_log_seq)) {
+        this.deltas.delete(event.step_log_seq);
+      }
+      if (positive(event.step_log_seq) && positive(event.delta_seq)) {
+        if (event.delta_seq <= (this.deltas.get(event.step_log_seq) ?? 0)) continue;
+        this.deltas.set(event.step_log_seq, event.delta_seq);
+      }
+      if (event.type === "log:delta" && Array.isArray(event.payload.events)) {
+        accepted.push(...event.payload.events);
+      } else {
+        accepted.push(event);
+      }
+    }
+    return { events: accepted, reload };
   }
-  detail;
 };
-var SYSTEM_ERROR_CHAT_END_GRACE_MS = 1e3;
-var HeadlessResource = class {
-  constructor(client) {
-    this.client = client;
+
+// src/schemas/context-attachments.ts
+function snapshotContextAttachments(value) {
+  const snapshot2 = JSON.parse(JSON.stringify(value));
+  if (!Array.isArray(snapshot2) || snapshot2.length > 20) throw new Error("\u6BCF\u6761\u6D88\u606F\u6700\u591A\u63D0\u4F9B 20 \u4EFD\u8D44\u6599");
+  const ids = /* @__PURE__ */ new Set();
+  const validText = (text, limit) => typeof text === "string" && [...text].length > 0 && [...text].length <= limit;
+  for (const item of snapshot2) {
+    if (!item || !validText(item.id, 128) || !validText(item.label, 512) || !validText(item.content, 64e3) || ids.has(item.id)) throw new Error("\u9644\u52A0\u8D44\u6599\u683C\u5F0F\u9519\u8BEF\u6216 ID \u91CD\u590D");
+    ids.add(item.id);
+    if (item.data != null && (typeof item.data !== "object" || Array.isArray(item.data))) throw new Error("\u8D44\u6599\u6570\u636E\u5FC5\u987B\u662F JSON \u5BF9\u8C61");
+    if (item.files != null && (!Array.isArray(item.files) || item.files.length > 20)) throw new Error("\u8D44\u6599\u6587\u4EF6\u683C\u5F0F\u9519\u8BEF");
+    for (const file of item.files ?? []) {
+      if (!validText(file.name, 512)) throw new Error("\u8D44\u6599\u6587\u4EF6\u540D\u683C\u5F0F\u9519\u8BEF");
+      if (file.session_id == null && file.path == null) continue;
+      if (!validText(file.session_id, 128) || !validText(file.path, 2048) || /[\\:]/.test(file.path) || file.path.replace(/^\//, "").split("/").some((part) => !part || part === "." || part === "..")) throw new Error("\u8D44\u6599\u6587\u4EF6\u5FC5\u987B\u4F7F\u7528\u6709\u6548\u7684\u4F1A\u8BDD\u6587\u4EF6\u8DEF\u5F84");
+    }
+  }
+  if (new TextEncoder().encode(JSON.stringify(snapshot2)).length > 256 * 1024) throw new Error("\u6D88\u606F\u9644\u52A0\u8D44\u6599\u4E0D\u80FD\u8D85\u8FC7 256 KiB");
+  return snapshot2;
+}
+function normalizeContextAttachments(value) {
+  return Array.isArray(value) ? value : [];
+}
+
+// src/schemas/plugin-refs.ts
+function normalizePluginRefs(value) {
+  if (!Array.isArray(value)) return [];
+  const seen = /* @__PURE__ */ new Set();
+  return value.flatMap((item) => {
+    if (!item || typeof item !== "object" || item.provider !== "plugin" || ![item.plugin, item.server, item.id, item.label].every((part) => typeof part === "string" && part)) return [];
+    const key = JSON.stringify([item.plugin, item.server, item.id]);
+    if (seen.has(key)) return [];
+    seen.add(key);
+    return [{ provider: "plugin", plugin: item.plugin, server: item.server, id: item.id, label: item.label }];
+  });
+}
+function normalizeMessageRefs(value) {
+  if (!Array.isArray(value)) return [];
+  const seen = /* @__PURE__ */ new Set();
+  return value.flatMap((item) => {
+    if (!item || typeof item !== "object") return [];
+    const ref = item.provider === "skill" && typeof item.id === "string" && item.id && typeof item.label === "string" && item.label ? { provider: "skill", id: item.id, label: item.label } : normalizePluginRefs([item])[0];
+    if (!ref) return [];
+    const key = ref.provider === "skill" ? JSON.stringify([ref.provider, ref.id]) : JSON.stringify([ref.provider, ref.plugin, ref.server, ref.id]);
+    if (seen.has(key)) return [];
+    seen.add(key);
+    return [ref];
+  });
+}
+
+// src/schemas/topic-assets.ts
+function normalizeTopicAssetRefs(value) {
+  if (!Array.isArray(value)) return [];
+  const seen = /* @__PURE__ */ new Set();
+  return value.flatMap((item) => {
+    if (!item || typeof item !== "object" || typeof item.topic_id !== "string" || !item.topic_id || typeof item.path !== "string" || !item.path) return [];
+    const key = JSON.stringify([item.topic_id, item.path]);
+    if (seen.has(key)) return [];
+    seen.add(key);
+    return [{ topic_id: item.topic_id, path: item.path }];
+  });
+}
+
+// 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;
   }
-  client;
-  async run(prompt, options = {}) {
-    const { session_id } = await this.client.sessions.createSessionWithRequest({
-      intent: prompt,
-      model: options.model ?? null
+  if (!found) {
+    state.toolCalls.push({
+      id: toolCallId,
+      tool_name: toolName,
+      display_name: displayName,
+      arguments: args,
+      status: "pending"
     });
-    return this.runTracked(session_id, prompt, options, false);
   }
-  async runInSession(sessionId, prompt, options = {}) {
-    return this.runTracked(sessionId, prompt, options, false);
+  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;
   }
-  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
-        },
-        (response) => {
-          if (response.status === "accepted") return;
-          rejectAfterChatEnd(
-            new HeadlessError(response.message ?? "headless run was not accepted", response)
-          );
-        }
-      );
-    });
-  }
-};
-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 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/resources/computers.ts
-function computerState(computer) {
-  if (computer.is_primary) return "primary";
-  if (computer.enabled) return "enabled";
-  return computer.online ? "idle" : "offline";
-}
-function computerOS(computer) {
-  const os = (computer.os ?? "").toLowerCase();
-  if (os.startsWith("darwin") || os.startsWith("mac")) return "macos";
-  if (os.startsWith("windows")) return "windows";
-  if (os.startsWith("linux")) return "linux";
-  return "unknown";
-}
-function computerPlatformLabel(computer) {
-  const os = (computer.os ?? "").trim();
-  const arch = (computer.arch ?? "").trim();
-  if (os && arch) return `${os}/${arch}`;
-  return os || arch || "";
-}
-function computerDaemonVersion(computer) {
-  return (computer.daemon_version ?? "").trim();
-}
-function canToggleComputer(computer) {
-  return !computer.is_primary;
-}
-function sortComputers(computers) {
-  return [...computers].sort((a, b) => {
-    const byCreated = (a.created_at ?? "").localeCompare(b.created_at ?? "");
-    if (byCreated !== 0) return byCreated;
-    return a.label.localeCompare(b.label);
-  });
-}
-var ComputersResource = class {
-  constructor(client) {
-    this.client = client;
-  }
-  client;
-  /**
-   * 列出当前账号登记过的全部电脑及其在线状态。
-   *
-   * 首页还没有会话，也要能看到同一份清单——判定各写一份必然分叉，一边的兜底会把
-   * 另一边的错误盖住（#1597）。所以账号事实只从这一个接口读。
-   */
-  async listAccount() {
-    const data = await this.client.json("GET", "/api/daemon/instances");
-    return {
-      computers: (data.instances ?? []).map((instance) => ({
-        ...instance,
-        online: Boolean(instance.online)
-      }))
-    };
-  }
-  /**
-   * 列出当前用户的全部电脑，带上"在不在线"和"这次会话能不能用"。
-   * 服务端只查库，电脑离线时同样返回，所以拿得到"它离线了"这个结论。
-   */
-  list(sessionId) {
-    return this.client.json(
-      "GET",
-      `/api/sessions/${encodeURIComponent(sessionId)}/computers`
-    );
-  }
-  /**
-   * 启动或停止一台电脑。只改这次会话的可用范围，不会碰远程机器，
-   * 电脑离线时同样能登记，等它上线就直接可用。
-   */
-  setEnabled(sessionId, computer, enabled) {
-    return this.client.json(
-      "PUT",
-      `/api/sessions/${encodeURIComponent(sessionId)}/computers/${encodeURIComponent(computer)}/enabled`,
-      { enabled }
-    );
-  }
-};
-
-// src/resources/models.ts
-var ModelsResource = class {
-  constructor(client) {
-    this.client = client;
-  }
-  client;
-  list() {
-    return this.client.json("GET", "/api/config/models");
-  }
-};
-
-// src/schemas/session.ts
-import { type } from "arktype";
-var SessionStatus = type(
-  "'created' | 'running' | 'completed' | 'failed' | 'interrupted' | 'waiting_for_input'"
-);
-var DEFAULT_REPLAY_SPEED = 5;
-var SessionInfo = type({
-  id: "string",
-  intent: "string",
-  status: SessionStatus,
-  created_at: "string",
-  updated_at: "string",
-  "shared?": "boolean",
-  "memory_enabled?": "boolean",
-  "is_persistent?": "boolean",
-  "initiator?": "'ui' | 'sdk' | 'unknown' | null",
-  "is_headless?": "boolean",
-  "viewer_role?": "'owner' | 'viewer'",
-  "template_id?": "string | null",
-  "model?": "string | null",
-  "enable_thinking?": "boolean | null",
-  "solution_id?": "string | null",
-  "solution_ref?": "unknown",
-  "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",
-  "agent_runtime_id?": "string | null",
-  "workspace_path?": "string | null",
-  "ba_version?": "string | null",
-  "sandbox_version?": "string | null",
-  "chat_group_id?": "string | null",
-  "match?": "unknown"
-});
-
-// src/session/definition.ts
-var SessionSetupError = class extends Error {
-  constructor(message, stage, sessionId, options) {
-    super(message);
-    this.stage = stage;
-    this.sessionId = sessionId;
-    this.cause = options?.cause;
-  }
-  stage;
-  sessionId;
-  name = "SessionSetupError";
-  cause;
-};
-
-// 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
+  if (!blockFound) {
+    state.blocks.push({
+      type: "tool_use",
+      content: args,
+      tool_call_id: toolCallId,
+      tool_name: toolName || null,
+      display_name: displayName || null
     });
   }
 }
@@ -1115,6 +1043,10 @@ function normalizeChildPause(pausePayload) {
   }
   return { pauseToolData, childLoopName, childToolCallId, description };
 }
+function attachToolEvidence(call, evidence) {
+  if (!call) return;
+  call.evidence = call.status === "done" && Array.isArray(evidence) ? evidence : void 0;
+}
 
 // src/schemas/message.ts
 function inferToolStatus(resultStr) {
@@ -1316,7 +1248,7 @@ function acknowledgeTurnEvents(acknowledge) {
 }
 function hasChatRunEvent(events) {
   return events.some(
-    (event) => event.type !== "llm:first_token:delivered" && event.type !== "session:post_chat_followup" && !event.type.startsWith("compaction:")
+    (event) => event.type !== "llm:first_token:delivered" && event.type !== "session:post_chat_followup" && event.type !== "loop:tool_bridge" && !event.type.startsWith("compaction:")
   );
 }
 function acceptedPostChatFollowupCompletesLatestRun(events, updates) {
@@ -1556,6 +1488,19 @@ var ClientProjectionBuilder = class {
     this.seq = 0;
     this.syntheticCounter = 0;
   }
+  /** A durable snapshot supersedes only this turn's temporary overlay. */
+  acceptDurableTurn(turn) {
+    this.seedSequence(turn.sequence);
+    if (!isConversationTurn(turn)) return;
+    const active = this.activeTurns.get(turn.loop_id);
+    if (active?.turnId === turn.turn_id) this.activeTurns.delete(turn.loop_id);
+    this.turnsById.set(turn.turn_id, turn);
+    const latest = this.latestTurns.get(turn.loop_id);
+    if ((!active || active.turnId === turn.turn_id) && (!latest || latest.turn_id === turn.turn_id || turn.sequence >= latest.sequence)) {
+      this.latestTurns.set(turn.loop_id, turn);
+      this.lastTurnIds.set(turn.loop_id, turn.turn_id);
+    }
+  }
   seedSequence(maxSeq) {
     if (maxSeq > this.seq) {
       this.seq = maxSeq;
@@ -1802,6 +1747,7 @@ var ClientProjectionBuilder = class {
   onUserMessage(_loopId, payload) {
     const entryId = String(payload.entry_id ?? this.nextTurnId("user"));
     const displayContent = payload.display_content ?? payload.content ?? "";
+    const refs = normalizeMessageRefs(payload.refs);
     const turn = {
       id: entryId,
       sequence: this.nextSeq(),
@@ -1811,6 +1757,9 @@ var ClientProjectionBuilder = class {
       role: "user",
       status: "completed",
       blocks: [{ type: "text", content: displayContent }],
+      ...refs.length ? { refs } : {},
+      context_attachments: normalizeContextAttachments(payload.context_attachments),
+      topic_asset_refs: normalizeTopicAssetRefs(payload.topic_asset_refs),
       tool_calls: [],
       model: null,
       usage: null,
@@ -1945,6 +1894,7 @@ var ClientProjectionBuilder = class {
     const sl = sourceLoopFor(state.loopId, this.loopDescriptions);
     const startedAt = typeof payload.started_at === "string" && payload.started_at ? payload.started_at : null;
     applyToolResult(state, toolCallId, content, status, durationMs, ranInParallel, sl, startedAt);
+    attachToolEvidence(state.toolCalls.find((call) => call.id === toolCallId), payload.evidence);
     const pendingChild = [...this.pendingChildPauses.values()].find(
       (pause) => pause.parentLoopName === loopId && pause.parentToolCallId === toolCallId
     );
@@ -2466,6 +2416,7 @@ function projectHistory(entries) {
         if (owner && toolCall) {
           toolCall.status = message._error ? "error" : inferToolStatus(String(message.content ?? ""));
           toolCall.result = message.content ?? "";
+          attachToolEvidence(toolCall, message._evidence);
           const duration = numberOrNull(message._duration_ms);
           if (duration !== null) toolCall.duration_ms = duration;
           if (typeof message._started_at === "string") {
@@ -2493,6 +2444,7 @@ function projectHistory(entries) {
         loop_id: loopId,
         kind: "message",
         role,
+        client_request_id: stringOrNull(entry.client_request_id),
         status: message._error ? "failed" : message._interrupted ? "interrupted" : "completed",
         blocks,
         tool_calls: toolCalls,
@@ -2509,6 +2461,11 @@ function projectHistory(entries) {
         // root Agent 工具调用兜底配对,工作流 fork 没有,子智能体卡会整体消失)。
         parent_fork_tool_call_id: stringOrNull(message._parent_fork_tool_call_id)
       };
+      if (role === "user") {
+        const refs = normalizeMessageRefs(message.refs);
+        if (refs.length) turn.refs = refs;
+        turn.context_attachments = normalizeContextAttachments(message.context_attachments);
+      }
       const isNativeToolEntry = role === "assistant" && Array.isArray(message.tool_calls) && message.tool_calls.some(
         (toolCall) => isRecord(toolCall) && typeof toolCall.provider === "string"
       );
@@ -2566,6 +2523,33 @@ function projectHistory(entries) {
       }
       continue;
     }
+    if (kind === "workflow_step") {
+      const data = entry.data ?? {};
+      const toolCallId = String(data.tool_call_id ?? "");
+      const owner = toolOwners.get(toolCallId) ?? findLatestAssistant(turns, loopId);
+      if (owner && toolCallId) {
+        const index = owner.tool_calls.findIndex((call) => call.id === toolCallId);
+        if (index >= 0) {
+          const call = owner.tool_calls[index];
+          owner.tool_calls[index] = {
+            ...call,
+            workflow_steps: [
+              ...call.workflow_steps ?? [],
+              {
+                step_id: String(data.step_id ?? ""),
+                desc: String(data.desc ?? ""),
+                step_kind: String(data.step_kind ?? "step"),
+                status: String(data.status ?? "done"),
+                output: String(data.output ?? ""),
+                ...typeof data.seq === "number" ? { seq: data.seq } : {},
+                ...typeof data.log_seq === "number" ? { log_seq: data.log_seq } : {}
+              }
+            ]
+          };
+        }
+      }
+      continue;
+    }
     if (kind === "mode_change") {
       turns.push(markerTurn(id, ++sequence, loopId, "mode_change", entry.data ?? {}));
     } else if (kind === "workspace_change") {
@@ -2728,117 +2712,654 @@ function projectHistory(entries) {
           pauseArguments.questions = resultArguments.questions;
         }
       }
-      applyAskUserPauseToTurn(
-        rootAssistant,
+      applyAskUserPauseToTurn(
+        rootAssistant,
+        {
+          name: toolCall.tool_name,
+          tool_call_id: toolCall.id,
+          arguments: pauseArguments
+        },
+        toolCall.id,
+        "",
+        "",
+        (name) => name
+      );
+    }
+  }
+  return turns;
+}
+function parseToolArguments(value) {
+  if (!value) return {};
+  try {
+    const parsed = JSON.parse(value);
+    return isRecord(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function buildToolCalls(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter(isRecord).map((raw) => {
+    const fn = isRecord(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 = [];
+  const storedToolCallIds = /* @__PURE__ */ new Set();
+  if (displayContent !== void 0) {
+    blocks.push({ type: "text", content: displayContent });
+  } else if (Array.isArray(stored)) {
+    for (const raw of stored) {
+      if (!isRecord(raw)) continue;
+      const type2 = String(raw.type ?? "");
+      if (type2 === "thinking") blocks.push({ type: type2, content: raw.thinking ?? raw.content ?? "" });
+      if (type2 === "text") blocks.push({ type: type2, content: raw.text ?? raw.content ?? "" });
+      if (type2 === "tool_call") {
+        const toolCallId = String(raw.id ?? "");
+        const toolCall = toolCalls.find((candidate) => candidate.id === toolCallId);
+        if (!toolCall) continue;
+        storedToolCallIds.add(toolCallId);
+        blocks.push({
+          type: "tool_use",
+          content: toolCall.arguments,
+          tool_call_id: toolCall.id,
+          tool_name: toolCall.tool_name,
+          display_name: toolCall.display_name
+        });
+      }
+    }
+  } else if (message.content !== void 0 && message.content !== "") {
+    blocks.push({ type: "text", content: message.content });
+  }
+  for (const toolCall of toolCalls) {
+    if (storedToolCallIds.has(toolCall.id)) continue;
+    blocks.push({
+      type: "tool_use",
+      content: toolCall.arguments,
+      tool_call_id: toolCall.id,
+      tool_name: toolCall.tool_name,
+      display_name: toolCall.display_name
+    });
+  }
+  return blocks;
+}
+function markerTurn(id, sequence, loopId, type2, content, toolCallId = null) {
+  return {
+    id,
+    sequence,
+    turn_id: id,
+    loop_id: loopId,
+    kind: type2,
+    role: "system",
+    status: "completed",
+    blocks: [{ type: type2, content, tool_call_id: toolCallId }],
+    tool_calls: [],
+    model: null,
+    usage: null,
+    duration_ms: 0
+  };
+}
+function stringOrNull(value) {
+  return typeof value === "string" ? value : null;
+}
+function numberOrNull(value) {
+  return typeof value === "number" && value >= 0 ? value : null;
+}
+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/shared/projection/workflow.ts
+var STEP_KINDS = /* @__PURE__ */ new Set(["agent", "step", "parallel", "choice", "end"]);
+function workflowEntriesFromSteps(steps) {
+  const items = [];
+  const ordered = steps.every((step) => typeof step.seq === "number");
+  steps.forEach((step, index) => {
+    const base = ordered ? step.seq : index * 2;
+    const stepKind = step.step_kind && STEP_KINDS.has(step.step_kind) ? step.step_kind : "step";
+    items.push({
+      key: base,
+      entry: { kind: "step", stepId: step.step_id, desc: step.desc ?? "", stepKind, status: step.status }
+    });
+    const logKey = ordered && typeof step.log_seq === "number" ? step.log_seq : base + 0.5;
+    const output = step.output ?? "";
+    if (step.status === "done" && stepKind === "step") {
+      const shown = output.length <= 300 ? output : `${output.slice(0, 300)}\u2026(\u5171${output.length}\u5B57)`;
+      items.push({ key: logKey, entry: { kind: "log", text: `  \u2514 \u8F93\u51FA: ${shown || "(\u7A7A)"}`, stepId: step.step_id } });
+    }
+    if (step.status === "error" && output) {
+      items.push({ key: logKey, entry: { kind: "log", text: `\u5931\u8D25: ${output}`, stepId: step.step_id } });
+    }
+  });
+  return items.sort((a, b) => a.key - b.key).map((item) => item.entry);
+}
+function workflowRunCancelled(steps) {
+  return steps.some((step) => step.status === "cancelled") && !steps.some((step) => step.status === "error");
+}
+
+// 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 CLEANUP_ACK_TIMEOUT_MS = 35e3;
+var HeadlessResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  subscriptions = /* @__PURE__ */ new Map();
+  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) {
+    if ((options.refs?.length ?? 0) > 20) throw new HeadlessError("\u6BCF\u6761\u6D88\u606F\u6700\u591A\u9009\u62E9 20 \u4E2A\u5F15\u7528");
+    if ((options.topicAssetRefs?.length ?? 0) > 20) throw new HeadlessError("\u6BCF\u6761\u6D88\u606F\u6700\u591A\u5F15\u7528 20 \u4E2A\u4E3B\u9898\u8D44\u4EA7");
+    const timeoutMs = options.timeoutMs ?? 3e5;
+    const session_id = sessionId;
+    const socket = this.client.socket();
+    await ensureSocketConnected(socket, timeoutMs, { session_id });
+    const cursor = new LogCursor();
+    const subscriptions = this.subscriptions.get(session_id) ?? /* @__PURE__ */ new Set();
+    subscriptions.add(cursor);
+    this.subscriptions.set(session_id, subscriptions);
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      let cleanupPromise;
+      let stopAttempt;
+      let handleLateAck;
+      let acknowledgeSend = () => void 0;
+      const sendAck = new Promise((resolveAck) => {
+        acknowledgeSend = resolveAck;
+      });
+      let started = false;
+      let chatRunId = null;
+      let systemErrorTimeout = null;
+      const beforeAck = /* @__PURE__ */ new Map();
+      const timeout = setTimeout(() => {
+        fail(new HeadlessError(`headless run timed out after ${timeoutMs}ms`, { session_id, chat_run_id: chatRunId }));
+      }, timeoutMs);
+      const stopOwnedRun = (runId, deadline) => {
+        stopAttempt ??= (async () => {
+          const stopped = await waitForCleanupAck(socket, deadline, (ack2) => {
+            socket.emit("chat:stop", { session_id, chat_run_id: runId }, ack2);
+          });
+          if (stopped.status !== "received") return { ...stopped, phase: "stop_ack", chat_run_id: runId };
+          const ack = stopped.ack;
+          const confirmed = isRecord(ack) && ack.ok !== false && (!Object.hasOwn(ack, "chat_run_id") || ack.chat_run_id === runId) && typeof ack.status === "string" && ["stopping", "stopped", "idle", "done", "interrupted"].includes(ack.status);
+          return {
+            status: confirmed ? "confirmed" : "unconfirmed",
+            phase: "stop_ack",
+            chat_run_id: runId,
+            ...confirmed ? {} : { reason: "invalid_stop_ack" },
+            ack
+          };
+        })().finally(releaseSubscription).catch((error) => ({
+          status: "unconfirmed",
+          phase: "stop_ack",
+          chat_run_id: runId,
+          reason: "cleanup_failed",
+          error
+        }));
+        return stopAttempt;
+      };
+      const cancelRun = async (deadline) => {
+        if (chatRunId === null) {
+          const sent = await waitForCleanupAck(socket, deadline, (ack) => {
+            void sendAck.then(ack);
+          });
+          if (sent.status !== "received") return { ...sent, phase: "send_ack", chat_run_id: null };
+          const runId = acceptedRunId(sent.ack);
+          if (runId === null) {
+            return { status: "unconfirmed", phase: "send_ack", chat_run_id: null, reason: "no_accepted_run", ack: sent.ack };
+          }
+          chatRunId = runId;
+        }
+        const attempt = stopOwnedRun(chatRunId, deadline);
+        const stopped = await waitForCleanupAck(socket, deadline, (ack) => {
+          void attempt.then(ack);
+        });
+        return stopped.status === "received" ? stopped.ack : { ...stopped, phase: "stop_ack", chat_run_id: chatRunId };
+      };
+      const releaseSubscription = () => {
+        const current = this.subscriptions.get(session_id);
+        current?.delete(cursor);
+        if (current?.size === 0) {
+          this.subscriptions.delete(session_id);
+          socket.emit("session:unsubscribe", { session_id });
+        }
+      };
+      const reportDelivery = (error, delivery) => {
+        let detailUpdated = true;
+        try {
+          if (error instanceof HeadlessError && isRecord(error.detail)) error.detail.stop_delivery = delivery;
+        } catch {
+          detailUpdated = false;
+        }
+        if (delivery.status !== "confirmed" || !detailUpdated) {
+          console.warn(delivery.status !== "confirmed" ? "[agent-client] headless stop delivery unconfirmed; the run may still be active" : "[agent-client] late headless stop delivery confirmed; error detail is read-only", { session_id, ...delivery });
+        }
+      };
+      const cleanup = (error) => {
+        cleanupPromise ??= (async () => {
+          clearTimeout(timeout);
+          if (systemErrorTimeout) clearTimeout(systemErrorTimeout);
+          systemErrorTimeout = null;
+          socket.off("chat:start", onChatStart);
+          socket.off("chat:end", onChatEnd);
+          socket.off("system:error", onSystemError);
+          socket.off("turn:events", onTurnEvents);
+          socket.off("connect", subscribe);
+          beforeAck.clear();
+          if (error !== void 0) {
+            const deadline = Date.now() + CLEANUP_ACK_TIMEOUT_MS;
+            handleLateAck = (ack) => {
+              const runId = acceptedRunId(ack);
+              if (runId === null || !socket.connected || stopAttempt) return;
+              const late = Date.now() >= deadline;
+              const current = this.subscriptions.get(session_id) ?? /* @__PURE__ */ new Set();
+              current.add(cursor);
+              this.subscriptions.set(session_id, current);
+              void stopOwnedRun(runId, late ? Date.now() + CLEANUP_ACK_TIMEOUT_MS : deadline).then((delivery) => {
+                if (late) reportDelivery(error, { ...delivery, late: true });
+              }).catch((error2) => {
+                console.warn("[agent-client] late headless stop cleanup failed", { session_id, chat_run_id: runId, error: error2 });
+              });
+            };
+            reportDelivery(error, await cancelRun(deadline));
+          }
+          if (!stopAttempt) releaseSubscription();
+        })();
+        return cleanupPromise;
+      };
+      const finish = (value) => {
+        if (settled) return;
+        settled = true;
+        void cleanup().then(() => resolve(returnEnvelope ? { session_id, chat_run_id: chatRunId, result: value } : value), reject);
+      };
+      const rejectRun = (error, sendStop = false) => {
+        if (settled) return;
+        settled = true;
+        void cleanup(sendStop ? error : void 0).then(() => reject(error), () => reject(error));
+      };
+      const fail = (error) => rejectRun(error, true);
+      const accept = (event) => {
+        if (settled) return;
+        const payload = event.payload;
+        if (event.type === "chat:start") {
+          started = true;
+          return;
+        }
+        if (event.type === "system:error") {
+          const error = new HeadlessError(String(payload.message || "headless run failed"), {
+            session_id,
+            chat_run_id: chatRunId,
+            event: payload
+          });
+          if (!started) {
+            rejectRun(error);
+          } else {
+            if (systemErrorTimeout) clearTimeout(systemErrorTimeout);
+            systemErrorTimeout = setTimeout(() => fail(error), SYSTEM_ERROR_CHAT_END_GRACE_MS);
+          }
+          return;
+        }
+        if (event.type !== "chat:end") return;
+        if (payload.status !== "completed") {
+          rejectRun(new HeadlessError(errorMessageFromResult(payload.result) ?? `headless run ${String(payload.status || "failed")}`, {
+            session_id,
+            chat_run_id: chatRunId,
+            event: payload
+          }));
+          return;
+        }
+        try {
+          finish(normalizeResult(payload.result, Boolean(options.schema)));
+        } catch (error) {
+          rejectRun(error);
+        }
+      };
+      const observe = (type2, payload) => {
+        if (settled || payload.session_id && payload.session_id !== session_id) return;
+        const runId = payload.chat_run_id;
+        const event = { type: type2, payload };
+        if (typeof runId !== "string" || !runId) {
+          if (!runId && chatRunId === null && type2 === "system:error" && payload.session_id === session_id && !beforeAck.has("")) {
+            beforeAck.set("", [event]);
+          }
+          return;
+        }
+        if (chatRunId === null) {
+          const pending = beforeAck.get(runId) ?? [];
+          pending.push(event);
+          beforeAck.set(runId, pending);
+        } else if (runId === chatRunId) {
+          accept(event);
+        }
+      };
+      function onChatStart(payload) {
+        observe("chat:start", payload);
+      }
+      function onChatEnd(payload) {
+        observe("chat:end", payload);
+      }
+      function onSystemError(payload) {
+        observe("system:error", payload);
+      }
+      function onTurnEvents(data, acknowledge) {
+        acknowledgeTurnEvents(acknowledge);
+        if (data.session_id !== session_id) return;
+        for (const event of cursor.consume(data.events.map((event2) => ({
+          ...event2,
+          log_seq: event2.log_seq ?? void 0,
+          step_log_seq: event2.step_log_seq ?? void 0,
+          delta_seq: event2.delta_seq ?? void 0
+        }))).events) {
+          if (["chat:start", "chat:end", "system:error"].includes(event.type)) observe(event.type, event.payload);
+        }
+      }
+      function subscribe() {
+        if (settled) return;
+        const after = Math.min(...[...subscriptions].map((item) => item.subscription().after_log_seq ?? 0));
+        socket.emit("session:subscribe", {
+          session_id,
+          event_format: "raw",
+          ...after > 0 ? { after_log_seq: after } : {}
+        });
+      }
+      socket.on("chat:start", onChatStart);
+      socket.on("chat:end", onChatEnd);
+      socket.on("system:error", onSystemError);
+      socket.on("turn:events", onTurnEvents);
+      socket.on("connect", subscribe);
+      subscribe();
+      socket.emit(
+        "chat:send",
         {
-          name: toolCall.tool_name,
-          tool_call_id: toolCall.id,
-          arguments: pauseArguments
+          session_id,
+          message: prompt,
+          headless: true,
+          output_schema: options.schema ?? null,
+          model: options.model ?? null,
+          refs: options.refs,
+          topic_asset_refs: options.topicAssetRefs
         },
-        toolCall.id,
-        "",
-        "",
-        (name) => name
+        (response) => {
+          acknowledgeSend(response);
+          if (settled) {
+            handleLateAck?.(response);
+            return;
+          }
+          if (response?.status !== "accepted") {
+            const validationError = beforeAck.get("")?.[0];
+            if ((response == null || isRecord(response) && Object.keys(response).length === 0) && validationError) {
+              accept(validationError);
+              return;
+            }
+            rejectRun(new HeadlessError(response?.message ?? "headless run was not accepted", response));
+            return;
+          }
+          if (typeof response.chat_run_id !== "string" || !response.chat_run_id) {
+            rejectRun(new HeadlessError("headless run acknowledgement has no run ID", response));
+            return;
+          }
+          chatRunId = response.chat_run_id;
+          const pending = beforeAck.get(chatRunId) ?? [];
+          beforeAck.clear();
+          for (const event of pending) accept(event);
+        }
       );
-    }
+    });
   }
-  return turns;
+};
+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 parseToolArguments(value) {
-  if (!value) return {};
-  try {
-    const parsed = JSON.parse(value);
-    return isRecord(parsed) ? parsed : {};
-  } catch {
-    return {};
+function errorMessageFromResult(result) {
+  if (isRecord(result) && typeof result.err_msg === "string" && result.err_msg) {
+    return result.err_msg;
   }
+  return null;
 }
-function buildToolCalls(value) {
-  if (!Array.isArray(value)) return [];
-  return value.filter(isRecord).map((raw) => {
-    const fn = isRecord(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 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();
   });
 }
-function buildBlocks(message, toolCalls) {
-  const displayContent = message.role === "user" ? message._display_content : void 0;
-  const stored = message._blocks;
-  const blocks = [];
-  const storedToolCallIds = /* @__PURE__ */ new Set();
-  if (displayContent !== void 0) {
-    blocks.push({ type: "text", content: displayContent });
-  } else if (Array.isArray(stored)) {
-    for (const raw of stored) {
-      if (!isRecord(raw)) continue;
-      const type2 = String(raw.type ?? "");
-      if (type2 === "thinking") blocks.push({ type: type2, content: raw.thinking ?? raw.content ?? "" });
-      if (type2 === "text") blocks.push({ type: type2, content: raw.text ?? raw.content ?? "" });
-      if (type2 === "tool_call") {
-        const toolCallId = String(raw.id ?? "");
-        const toolCall = toolCalls.find((candidate) => candidate.id === toolCallId);
-        if (!toolCall) continue;
-        storedToolCallIds.add(toolCallId);
-        blocks.push({
-          type: "tool_use",
-          content: toolCall.arguments,
-          tool_call_id: toolCall.id,
-          tool_name: toolCall.tool_name,
-          display_name: toolCall.display_name
-        });
-      }
+function acceptedRunId(ack) {
+  return isRecord(ack) && ack.status === "accepted" && typeof ack.chat_run_id === "string" && ack.chat_run_id ? ack.chat_run_id : null;
+}
+function waitForCleanupAck(socket, deadline, request) {
+  if (!socket.connected) return Promise.resolve({ status: "unconfirmed", reason: "disconnected" });
+  if (Date.now() >= deadline) return Promise.resolve({ status: "unconfirmed", reason: "ack_timeout" });
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => finish({ status: "unconfirmed", reason: "ack_timeout" }), Math.max(0, deadline - Date.now()));
+    let finished = false;
+    const finish = (outcome) => {
+      if (finished) return;
+      finished = true;
+      clearTimeout(timer);
+      socket.off("disconnect", onDisconnect);
+      resolve(outcome);
+    };
+    const onDisconnect = () => finish({ status: "unconfirmed", reason: "disconnected" });
+    socket.on("disconnect", onDisconnect);
+    try {
+      request((ack) => finish({ status: "received", ack }));
+    } catch (error) {
+      finish({ status: "unconfirmed", reason: "emit_failed", error });
     }
-  } else if (message.content !== void 0 && message.content !== "") {
-    blocks.push({ type: "text", content: message.content });
-  }
-  for (const toolCall of toolCalls) {
-    if (storedToolCallIds.has(toolCall.id)) continue;
-    blocks.push({
-      type: "tool_use",
-      content: toolCall.arguments,
-      tool_call_id: toolCall.id,
-      tool_name: toolCall.tool_name,
-      display_name: toolCall.display_name
-    });
-  }
-  return blocks;
+  });
 }
-function markerTurn(id, sequence, loopId, type2, content, toolCallId = null) {
-  return {
-    id,
-    sequence,
-    turn_id: id,
-    loop_id: loopId,
-    kind: type2,
-    role: "system",
-    status: "completed",
-    blocks: [{ type: type2, content, tool_call_id: toolCallId }],
-    tool_calls: [],
-    model: null,
-    usage: null,
-    duration_ms: 0
-  };
+
+// src/resources/computers.ts
+function computerState(computer) {
+  if (computer.is_primary) return "primary";
+  if (computer.enabled) return "enabled";
+  return computer.online ? "idle" : "offline";
 }
-function stringOrNull(value) {
-  return typeof value === "string" ? value : null;
+function computerOS(computer) {
+  const os = (computer.os ?? "").toLowerCase();
+  if (os.startsWith("darwin") || os.startsWith("mac")) return "macos";
+  if (os.startsWith("windows")) return "windows";
+  if (os.startsWith("linux")) return "linux";
+  return "unknown";
 }
-function numberOrNull(value) {
-  return typeof value === "number" && value >= 0 ? value : null;
+function computerPlatformLabel(computer) {
+  const os = (computer.os ?? "").trim();
+  const arch = (computer.arch ?? "").trim();
+  if (os && arch) return `${os}/${arch}`;
+  return os || arch || "";
 }
-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;
+function computerDaemonVersion(computer) {
+  return (computer.daemon_version ?? "").trim();
+}
+function canToggleComputer(computer) {
+  return !computer.is_primary;
+}
+function sortComputers(computers) {
+  return [...computers].sort((a, b) => {
+    const byCreated = (a.created_at ?? "").localeCompare(b.created_at ?? "");
+    if (byCreated !== 0) return byCreated;
+    return a.label.localeCompare(b.label);
+  });
+}
+var ComputersResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * 列出当前账号登记过的全部电脑及其在线状态。
+   *
+   * 首页还没有会话，也要能看到同一份清单——判定各写一份必然分叉，一边的兜底会把
+   * 另一边的错误盖住（#1597）。所以账号事实只从这一个接口读。
+   */
+  async listAccount() {
+    const data = await this.client.json("GET", "/api/daemon/instances");
+    return {
+      computers: (data.instances ?? []).map((instance) => ({
+        ...instance,
+        online: Boolean(instance.online)
+      }))
+    };
+  }
+  /**
+   * 列出当前用户的全部电脑，带上"在不在线"和"这次会话能不能用"。
+   * 服务端只查库，电脑离线时同样返回，所以拿得到"它离线了"这个结论。
+   */
+  list(sessionId) {
+    return this.client.json(
+      "GET",
+      `/api/sessions/${encodeURIComponent(sessionId)}/computers`
+    );
+  }
+  /**
+   * 启动或停止一台电脑。只改这次会话的可用范围，不会碰远程机器，
+   * 电脑离线时同样能登记，等它上线就直接可用。
+   */
+  setEnabled(sessionId, computer, enabled) {
+    return this.client.json(
+      "PUT",
+      `/api/sessions/${encodeURIComponent(sessionId)}/computers/${encodeURIComponent(computer)}/enabled`,
+      { enabled }
+    );
+  }
+};
+
+// src/resources/models.ts
+var ModelsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  list() {
+    return this.client.json("GET", "/api/config/models");
   }
-  return void 0;
-}
+};
+
+// src/schemas/session.ts
+import { type } from "arktype";
+var SessionStatus = type(
+  "'created' | 'running' | 'completed' | 'failed' | 'interrupted' | 'waiting_for_input'"
+);
+var DEFAULT_REPLAY_SPEED = 5;
+var SessionInfo = type({
+  id: "string",
+  intent: "string",
+  status: SessionStatus,
+  created_at: "string",
+  updated_at: "string",
+  "shared?": "boolean",
+  "anonymous?": "boolean",
+  "memory_enabled?": "boolean",
+  "is_persistent?": "boolean",
+  "initiator?": "'ui' | 'sdk' | 'unknown' | null",
+  "is_headless?": "boolean",
+  "viewer_role?": "'owner' | 'viewer'",
+  "model?": "string | null",
+  "enable_thinking?": "boolean | null",
+  "solution_id?": "string | null",
+  "solution_ref?": "unknown",
+  "biz_role_id?": "string | null",
+  "solution?": "unknown",
+  "plan_summary?": "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",
+  "agent_runtime_id?": "string | null",
+  "workspace_path?": "string | null",
+  "ba_version?": "string | null",
+  "sandbox_version?": "string | null",
+  "chat_group_id?": "string | null",
+  "match?": "unknown"
+});
+
+// src/session/definition.ts
+var SessionSetupError = class extends Error {
+  constructor(message, stage, sessionId, options) {
+    super(message);
+    this.stage = stage;
+    this.sessionId = sessionId;
+    this.cause = options?.cause;
+  }
+  stage;
+  sessionId;
+  name = "SessionSetupError";
+  cause;
+};
 
 // src/resources/sessions.ts
 function isEntryGoneError(error) {
@@ -2849,16 +3370,18 @@ function toCreateSessionPayload(request) {
   const solutionRef = request.solution_ref ?? externalSolutionRef(request.solution_id);
   return {
     intent: request.intent ?? "",
-    template_id: request.template_id,
+    initiator: request.initiator ?? "sdk",
+    anonymous: request.anonymous,
     solution_id: solutionRef ? void 0 : request.solution_id,
     solution_ref: solutionRef,
     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,
+    mcp_sources: request.mcp_sources,
+    skip_confirmations: request.skip_confirmations,
     session_solution_asset_id: request.session_solution_asset_id ?? null,
     solution_snapshot_session_id: request.solution_snapshot_session_id ?? null,
     compaction_ratio: request.compaction_ratio ?? null,
@@ -2985,18 +3508,21 @@ var SessionsResource = class {
    *
    * Secrets are never returned: `write_only` lists the pointers that hold one.
    */
-  getSessionPluginConfig(sessionId, name, init) {
-    return this.client.jsonFromInit(`/api/sessions/${encodeURIComponent(sessionId)}/plugins/${encodeURIComponent(name)}/config`, init);
+  getSessionPluginConfig(sessionId, name, init, scope = "personal") {
+    return this.client.jsonFromInit(`/api/sessions/${encodeURIComponent(sessionId)}/plugins/${encodeURIComponent(name)}/config?scope=${scope}`, init);
   }
   /**
-   * Publish explicit set/remove operations to the user's keychain file.
+   * Save explicit set/remove operations to encrypted server storage.
    *
    * Fields absent from both lists keep their stored value, so a form never has
-   * to round-trip a secret. Rejections leave the previous file untouched; the
-   * call never restarts MCP servers.
+   * to round-trip a secret. Rejections preserve the previous values; the
+   * shared settings restart only the affected hosted plugin.
    */
-  updateSessionPluginConfig(sessionId, name, update, init) {
-    return this.client.jsonFromInit(`/api/sessions/${encodeURIComponent(sessionId)}/plugins/${encodeURIComponent(name)}/config`, { method: "PUT", body: JSON.stringify(update), ...init });
+  updateSessionPluginConfig(sessionId, name, update, init, scope = "personal") {
+    return this.client.jsonFromInit(`/api/sessions/${encodeURIComponent(sessionId)}/plugins/${encodeURIComponent(name)}/config?scope=${scope}`, { method: "PUT", body: JSON.stringify(update), ...init });
+  }
+  restartSessionPluginHost(sessionId, name) {
+    return this.client.jsonFromInit(`/api/sessions/${encodeURIComponent(sessionId)}/plugins/${encodeURIComponent(name)}/host`, { method: "POST" });
   }
   /** 创建新会话并直接连接，返回可收发消息的 AgentSession。 */
   async create(request = {}) {
@@ -3004,7 +3530,7 @@ var SessionsResource = class {
       return this.createDeclared(request);
     }
     const { session_id } = await this.createSessionWithRequest(request);
-    return this.connect(session_id);
+    return request.anonymous ? this.client.forAnonymousSession(session_id).sessions.connect(session_id) : this.connect(session_id);
   }
   async createDeclared(definition) {
     const { intent, solution, skills = [], config } = definition;
@@ -3091,7 +3617,6 @@ var SessionsResource = class {
   fetchSessionsPage({
     limit,
     offset,
-    template_id_prefix,
     solution_id,
     solution_registry_id,
     q,
@@ -3100,7 +3625,6 @@ var SessionsResource = class {
     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_registry_id) {
       searchParams.set("solution_registry_id", solution_registry_id);
     } else if (solution_id) {
@@ -3111,12 +3635,12 @@ var SessionsResource = class {
     if (chat_group_id) searchParams.set("chat_group_id", chat_group_id);
     return this.client.json("GET", `/api/sessions?${searchParams.toString()}`);
   }
-  async listSessions(template_id_prefix, solution_id) {
+  async listSessions(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 });
+      const page = await this.fetchSessionsPage({ limit: pageSize, offset, solution_id });
       sessions.push(...page.items);
       if (sessions.length >= page.total || page.items.length === 0) return sessions;
       offset += page.items.length;
@@ -3133,8 +3657,8 @@ var SessionsResource = class {
     if (params.limit !== void 0) searchParams.set("limit", String(params.limit));
     return this.client.json("GET", `/api/search?${searchParams.toString()}`);
   }
-  createSession(intent, template_id, primary_skill_id) {
-    return this.createSessionWithRequest({ intent, template_id, primary_skill_id });
+  createSession(intent) {
+    return this.createSessionWithRequest({ intent });
   }
   createSessionWithRequest(request) {
     return this.client.json("POST", "/api/sessions", toCreateSessionPayload(request));
@@ -3152,6 +3676,13 @@ var SessionsResource = class {
   updateSession(sessionId, payload) {
     return this.client.json("PATCH", `/api/sessions/${sessionId}`, payload);
   }
+  getSessionConfiguration(sessionId, init) {
+    return this.client.jsonFromInit(`/api/sessions/${encodeURIComponent(sessionId)}/configuration`, init);
+  }
+  /** Updates atomically between turns. A running/handoff session returns HTTP 409. */
+  updateSessionConfiguration(sessionId, request) {
+    return this.client.json("PATCH", `/api/sessions/${encodeURIComponent(sessionId)}/configuration`, request);
+  }
   setSessionEnv(sessionId, env) {
     return this.client.json("PUT", `/api/sessions/${sessionId}/env`, { env });
   }
@@ -3289,13 +3820,25 @@ var SessionsResource = class {
   }
   async rewindSession(sessionId, checkpointId) {
     const result = await this.checkoutSession(sessionId, checkpointId, "before");
-    return { id: result.id, content: result.content };
+    return {
+      id: result.id,
+      content: result.content,
+      ...result.history_committed !== void 0 ? { history_committed: result.history_committed } : {},
+      ...result.file_checkpoint_cleanup_failed !== void 0 ? { file_checkpoint_cleanup_failed: result.file_checkpoint_cleanup_failed } : {},
+      ...result.warning !== void 0 ? { warning: result.warning } : {}
+    };
   }
   switchBranch(sessionId, checkpointId) {
     return this.client.json("POST", `/api/sessions/${sessionId}/switch-branch`, {
       checkpoint_id: checkpointId
     });
   }
+  listAnonymousSessions() {
+    return this.client.json("GET", "/api/anonymous-sessions");
+  }
+  deleteAnonymousSession(sessionId) {
+    return this.client.json("DELETE", `/api/anonymous-sessions/${encodeURIComponent(sessionId)}`);
+  }
   deleteSession(sessionId, options) {
     const query = options?.deleteWorkspace ? "?delete_workspace=true" : "";
     return this.client.json("DELETE", `/api/sessions/${sessionId}${query}`);
@@ -3543,6 +4086,9 @@ var ChatGroupsResource = class {
     this.client = client;
   }
   client;
+  path(groupId) {
+    return `/api/chat-groups/${encodeURIComponent(groupId)}`;
+  }
   list() {
     return this.client.json("GET", "/api/chat-groups");
   }
@@ -3550,11 +4096,124 @@ var ChatGroupsResource = class {
     return this.client.json("POST", "/api/chat-groups", payload);
   }
   update(groupId, payload) {
-    return this.client.json("PATCH", `/api/chat-groups/${encodeURIComponent(groupId)}`, payload);
+    return this.client.json("PATCH", this.path(groupId), payload);
   }
   delete(groupId, options) {
     const query = options?.deleteWorkspace ? "?delete_workspace=true" : "";
-    return this.client.json("DELETE", `/api/chat-groups/${encodeURIComponent(groupId)}${query}`);
+    return this.client.json("DELETE", `${this.path(groupId)}${query}`);
+  }
+  listMembers(groupId) {
+    return this.client.json("GET", `${this.path(groupId)}/members`);
+  }
+  addMembers(groupId, userIds, role) {
+    return this.client.json("POST", `${this.path(groupId)}/members`, { user_ids: userIds, role });
+  }
+  updateMember(groupId, userId, role) {
+    return this.client.json("PATCH", `${this.path(groupId)}/members/${encodeURIComponent(userId)}`, { role });
+  }
+  removeMember(groupId, userId) {
+    return this.client.json("DELETE", `${this.path(groupId)}/members/${encodeURIComponent(userId)}`);
+  }
+  listTasks(groupId) {
+    return this.client.json("GET", `${this.path(groupId)}/tasks`);
+  }
+  async createTask(groupId, payload) {
+    try {
+      return await this.client.json("POST", `${this.path(groupId)}/tasks`, payload);
+    } catch (error) {
+      if (error instanceof BladeApiError && error.status === 502) {
+        const data = await error.response.clone().json().catch(() => null);
+        if (typeof data?.detail?.message === "string") error.message = data.detail.message;
+      }
+      throw error;
+    }
+  }
+  updateTask(groupId, taskId, payload) {
+    return this.client.json("PATCH", `${this.path(groupId)}/tasks/${encodeURIComponent(taskId)}`, payload);
+  }
+  deleteTask(groupId, taskId) {
+    return this.client.json("DELETE", `${this.path(groupId)}/tasks/${encodeURIComponent(taskId)}`);
+  }
+  listAssets(groupId) {
+    return this.client.json("GET", `${this.path(groupId)}/assets`);
+  }
+  async readAsset(groupId, path, signal) {
+    const response = await this.client.fetch(
+      "GET",
+      `${this.path(groupId)}/assets/file?${new URLSearchParams({ path })}`,
+      { signal }
+    );
+    return response.blob();
+  }
+  /** Read at most the first 1 MiB. Full downloads continue to use readAsset. */
+  async readAssetPreview(groupId, path, signal) {
+    const limit = 1024 * 1024;
+    let response;
+    try {
+      response = await this.client.fetch(
+        "GET",
+        `${this.path(groupId)}/assets/file?${new URLSearchParams({ path })}`,
+        { signal, headers: { Range: `bytes=0-${limit - 1}` } }
+      );
+    } catch (error) {
+      if (error instanceof BladeApiError && error.status === 416 && error.response.headers.get("content-range") === "bytes */0") {
+        await error.response.body?.cancel();
+        return { blob: new Blob(), truncated: false };
+      }
+      throw error;
+    }
+    const reader = response.body?.getReader();
+    if (!reader) return { blob: new Blob(), truncated: false };
+    const chunks = [];
+    let bytes = 0;
+    let ended = false;
+    let overflow = false;
+    try {
+      while (bytes < limit) {
+        signal?.throwIfAborted();
+        const { done, value } = await reader.read();
+        if (done) {
+          ended = true;
+          break;
+        }
+        const remaining = limit - bytes;
+        overflow = value.byteLength > remaining;
+        const chunk = value.slice(0, remaining);
+        chunks.push(chunk);
+        bytes += chunk.byteLength;
+      }
+      signal?.throwIfAborted();
+    } finally {
+      if (!ended) await reader.cancel().catch(() => void 0);
+      reader.releaseLock();
+    }
+    const range = response.headers.get("content-range")?.match(/^bytes 0-\d+\/(\d+)$/);
+    const length = response.headers.get("content-length");
+    const total = range ? Number(range[1]) : response.status === 200 && length && !response.headers.has("content-encoding") ? Number(length) : null;
+    return {
+      blob: new Blob(chunks, { type: response.headers.get("content-type") ?? "" }),
+      truncated: overflow || (total !== null && Number.isFinite(total) ? total > bytes : !ended)
+    };
+  }
+  async uploadAsset(groupId, file, path, message = "") {
+    const form = new FormData();
+    form.append("file", file);
+    form.append("message", message);
+    const response = await this.client.formData(
+      "POST",
+      `${this.path(groupId)}/assets/upload?${new URLSearchParams({ path })}`,
+      form
+    );
+    return response.json();
+  }
+  createAssetFolder(groupId, path) {
+    return this.client.json("POST", `${this.path(groupId)}/assets/folders`, { path });
+  }
+  deleteAsset(groupId, path) {
+    return this.client.json("DELETE", `${this.path(groupId)}/assets/file?${new URLSearchParams({ path })}`);
+  }
+  submitSessionAsset(payload) {
+    return this.client.json("POST", "/api/topic-agent/files/submit", payload);
   }
 };
 
@@ -3595,6 +4254,34 @@ var SiteVisitsResource = class {
   }
 };
 
+// src/session/background.ts
+var BACKGROUND_STATUSES = [
+  "starting",
+  "running",
+  "cancelling",
+  "succeeded",
+  "failed",
+  "cancelled",
+  "lost"
+];
+function normalizeBackgroundStatus(value) {
+  return BACKGROUND_STATUSES.includes(value) ? value : "running";
+}
+function completedBackgroundTask(task) {
+  const taskId = typeof task.id === "string" ? task.id : typeof task.task_id === "string" ? task.task_id : "";
+  if (!taskId) return null;
+  return {
+    id: taskId,
+    command: typeof task.command === "string" ? task.command : "",
+    description: typeof task.description === "string" ? task.description : void 0,
+    status: normalizeBackgroundStatus(task.status),
+    failureReason: typeof task.failure_reason === "string" ? task.failure_reason : void 0,
+    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
+  };
+}
+
 // src/shared/auth-busy.ts
 var DEFAULT_RETRY_AFTER_SECONDS = 1;
 var MAX_TIMER_DELAY_MS = 2147483647;
@@ -4011,15 +4698,8 @@ function contentPreview(content, maxLen = 80) {
   const text = getTextContent(content).trim();
   return text.length > maxLen ? `${text.slice(0, maxLen)}\u2026` : text;
 }
-function transformSlashCommand(skillName, rawInput, { local = true, installed = true } = {}) {
-  const prompt = rawInput.replace(`<skill>${skillName}</skill>`, "").trim();
-  if (local) {
-    return prompt ? `\u8BF7\u4F7F\u7528 ${skillName} skill \u5B8C\u6210\u4EFB\u52A1
-${prompt}` : `\u8BF7\u4F7F\u7528 ${skillName} skill \u5B8C\u6210\u4EFB\u52A1`;
-  }
-  const steps = installed ? `\u8BF7\u5148\u8FD0\u884C blade hub skill use ${skillName} \u52A0\u8F7D\u6280\u80FD` : `\u8BE5\u6280\u80FD\u5C1A\u672A\u5B89\u88C5\u3002\u8BF7\u5148\u8FD0\u884C blade hub skill install ${skillName} \u5B89\u88C5\uFF0C\u518D\u8FD0\u884C blade hub skill use ${skillName} \u52A0\u8F7D`;
-  return prompt ? `${steps}\uFF0C\u7136\u540E\u5B8C\u6210\u4EFB\u52A1\uFF1A
-${prompt}` : `${steps}\uFF0C\u7136\u540E\u4F7F\u7528\u5B83\u5B8C\u6210\u4EFB\u52A1`;
+function transformSlashCommand(skillName, rawInput, _availability = {}) {
+  return rawInput.replace(`<skill>${skillName}</skill>`, `@${skillName}`).trim();
 }
 var ATTACHMENT_TAG_RE = /\[附件:\s*([^\]]+)\](?:[ \t]*已上传到工作区路径:[ \t]*([^\r\n]+))?/g;
 var CONTEXT_PART_RE = /^\[上下文:\s*([^\]]+)\]\n([\s\S]*)$/;
@@ -4147,7 +4827,13 @@ function workflowEntriesFromOutput(output) {
 }
 function workflowNameFromArguments(argumentsJson) {
   try {
-    const name = JSON.parse(argumentsJson)?.name;
+    const args = JSON.parse(argumentsJson);
+    const skillId = typeof args?.skill_id === "string" ? args.skill_id.trim() : "";
+    if (skillId) {
+      const flow = typeof args?.flow === "string" ? args.flow.trim() : "";
+      return `\u6280\u80FD\u300C${skillId}\u300D${flow && flow !== "main" ? ` \xB7 \u6D41\u7A0B ${flow}` : ""}`;
+    }
+    const name = args?.name;
     return typeof name === "string" ? name : "";
   } catch {
     return "";
@@ -4171,6 +4857,15 @@ function applyWorkflowEvent(current, toolCallId, type2, payload) {
   }
   const base = current ?? { toolCallId, name: "", status: "running", entries: [] };
   if (type2 === "workflow:step") {
+    const settled = asText(payload.status);
+    const stepId = asText(payload.step_id);
+    if (stepId && isFinished(settled)) {
+      const index = base.entries.findIndex((entry) => entry.kind === "step" && entry.stepId === stepId);
+      if (index === -1) return null;
+      const entries = [...base.entries];
+      entries[index] = { ...entries[index], status: settled };
+      return { ...base, entries };
+    }
     return {
       ...base,
       entries: [
@@ -4185,7 +4880,9 @@ function applyWorkflowEvent(current, toolCallId, type2, payload) {
     };
   }
   if (type2 === "workflow:log") {
-    return { ...base, entries: [...base.entries, { kind: "log", text: asText(payload.text) }] };
+    const stepId = asText(payload.step_id);
+    const entry = stepId ? { kind: "log", text: asText(payload.text), stepId } : { kind: "log", text: asText(payload.text) };
+    return { ...base, entries: [...base.entries, entry] };
   }
   if (type2 === "workflow:run:end") {
     const status = asText(payload.status);
@@ -4207,10 +4904,10 @@ function rebuildWorkflowRuns(turns, previous) {
       const name = workflowNameFromArguments(toolCall.arguments);
       const prior = previous[toolCall.id];
       if (isFinished(toolCall.status)) {
-        const entries = workflowEntriesFromOutput(
-          typeof toolCall.result === "string" ? toolCall.result.trim() : ""
-        );
-        runs[toolCall.id] = prior && prior.status === toolCall.status && prior.name === name && JSON.stringify(prior.entries) === JSON.stringify(entries) ? prior : { toolCallId: toolCall.id, name, status: toolCall.status, entries };
+        const steps = toolCall.workflow_steps ?? [];
+        const entries = steps.length > 0 ? workflowEntriesFromSteps(steps) : workflowEntriesFromOutput(typeof toolCall.result === "string" ? toolCall.result.trim() : "");
+        const status = toolCall.status === "error" && workflowRunCancelled(steps) ? "cancelled" : toolCall.status;
+        runs[toolCall.id] = prior && prior.status === status && prior.name === name && JSON.stringify(prior.entries) === JSON.stringify(entries) ? prior : { toolCallId: toolCall.id, name, status, entries };
         continue;
       }
       runs[toolCall.id] = prior && prior.name === name ? prior : { toolCallId: toolCall.id, name, status: prior?.status ?? "running", entries: prior?.entries ?? [] };
@@ -4461,7 +5158,9 @@ function projectionToMessage(turn) {
     display_name: toolCall.display_name,
     arguments: toolCall.arguments,
     result: toolCall.result ?? void 0,
+    ...toolCall.evidence ? { evidence: toolCall.evidence } : {},
     pending_question_ref: toolCall.pending_question_ref ?? void 0,
+    workflow_steps: toolCall.workflow_steps ?? 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;
@@ -4476,10 +5175,14 @@ function projectionToMessage(turn) {
     ...toolCalls ? { tool_calls: toolCalls } : {},
     loop_name: turn.loop_id,
     entry_id: turn.turn_id,
+    ...turn.client_request_id ? { client_request_id: turn.client_request_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 } : {}
+    ...turn.memory_refs?.length ? { memory_refs: turn.memory_refs } : {},
+    ...turn.refs?.length ? { refs: turn.refs } : {},
+    ...turn.context_attachments?.length ? { context_attachments: turn.context_attachments } : {},
+    ...turn.topic_asset_refs?.length ? { topic_asset_refs: turn.topic_asset_refs } : {}
   };
 }
 var messageProjectionCache = /* @__PURE__ */ new WeakMap();
@@ -4716,7 +5419,7 @@ function withQueue(state, snapshot2) {
   return { ...state, queue: snapshot2 };
 }
 var localTurnCounter = 0;
-function addUserMessage(state, content, clientRequestId) {
+function addUserMessage(state, content, clientRequestId, topicAssetRefs, refs, contextAttachments) {
   localTurnCounter += 1;
   const turnId = `local-user-${clientRequestId ?? `${Date.now()}-${localTurnCounter}`}`;
   const optimisticTurn = {
@@ -4727,6 +5430,9 @@ function addUserMessage(state, content, clientRequestId) {
     // client_render_id（= 乐观 turn 自己的 turn_id）保持同一个值，
     // 消费方才能拿它当"确认前后不变"的稳定标识使用。
     client_render_id: turnId,
+    ...refs ? { refs } : {},
+    ...contextAttachments?.length ? { context_attachments: contextAttachments } : {},
+    ...topicAssetRefs?.length ? { topic_asset_refs: topicAssetRefs } : {},
     loop_id: "root",
     role: "user",
     status: "streaming",
@@ -4910,6 +5616,9 @@ function sessionStatusFromChatEnd(status) {
   if (status === "failed") return "failed";
   return "completed";
 }
+function isCompactionFinished(type2) {
+  return type2 === "compaction:end" || type2 === "compaction:error" || type2 === "compaction:abort";
+}
 function extractTerminalChatEndStatus(events) {
   for (let i = events.length - 1; i >= 0; i--) {
     const event = events[i];
@@ -4920,6 +5629,7 @@ function extractTerminalChatEndStatus(events) {
   return null;
 }
 var AgentSession = class _AgentSession {
+  logCursor = new LogCursor();
   sessionId;
   state;
   /** status 每变化一次加一（单调递增）。异步读取会话详情时据此判断请求期间状态是否变过，避免 running→终态→running 这类来回被误认为「没变」。 */
@@ -4932,6 +5642,7 @@ var AgentSession = class _AgentSession {
   emitter = new Emitter();
   commands = new CommandRegistry();
   runtime;
+  activeReplayPlaybackId = null;
   projectionBuilder = new ClientProjectionBuilder();
   pendingTurnPatches = /* @__PURE__ */ new Map();
   patchFlushHandle = null;
@@ -4970,7 +5681,10 @@ var AgentSession = class _AgentSession {
   bufferedCommandDeliveries = null;
   pendingReplayMessage = null;
   pendingReplayMode;
-  pendingReplayKbIds;
+  pendingReplayRequestId;
+  pendingReplayAttachments;
+  pendingReplayRefs;
+  pendingReplayTopicAssetRefs;
   recentChatEndAt = 0;
   /**
    * 最近一次已经通过 `error` 事件投递过的服务端失败（`message` + `code`）。
@@ -4990,12 +5704,24 @@ var AgentSession = class _AgentSession {
   disposed = false;
   getAppContext = null;
   sendPending = false;
-  manualCompactionPending = false;
+  manualCompactionRequest = null;
+  /** Reload requests from retracts/epoch changes; done only when a reload started after the latest one succeeds. */
+  epochReloadRequested = 0;
+  epochReloadDone = 0;
+  epochReloadRunning = false;
   /** 手动整理的在途标记，同时写进状态（界面据此保持「正在整理」，见 SessionState.compactionPending）。 */
-  setManualCompactionPending(pending) {
-    this.manualCompactionPending = pending;
+  setManualCompactionRequest(request) {
+    this.manualCompactionRequest = request;
+    const pending = request !== null;
     if (this.state.compactionPending !== pending) this.update((s) => ({ ...s, compactionPending: pending }));
   }
+  handleManualCompactionFinished(event) {
+    const request = this.manualCompactionRequest;
+    const runId = event.payload.run_id;
+    if (!request || !isCompactionFinished(event.type) || typeof runId !== "string" || !runId) return;
+    if (request.runId === null) request.finishedBeforeAck.add(runId);
+    else if (request.runId === runId) this.setManualCompactionRequest(null);
+  }
   /** 最近一次还在等服务端结果的发送请求 id；排队中断的 chat:end 据此判断回滚是否过期。 */
   pendingChatRequestId = null;
   /** 会话详情给出的运行时类型；"native" 时启用原生智能体的投影规则（见 _handleTurnEvents / _handleChatEnd）。 */
@@ -5153,6 +5879,11 @@ var AgentSession = class _AgentSession {
    * chat:end 会让界面停在「运行中」）。
    */
   async reloadHistory() {
+    const replaced = await this.reloadHistoryWindow();
+    await this.refreshRunningState().catch(() => void 0);
+    return replaced;
+  }
+  async reloadHistoryWindow() {
     if (this.disposed) return false;
     this.invalidateTimeline();
     this.invalidateOlderPaging();
@@ -5162,9 +5893,7 @@ var AgentSession = class _AgentSession {
       loadingOlder: false,
       timelineRevision: state.timelineRevision + 1
     }));
-    const replaced = await this.replaceFromHistory();
-    await this.refreshRunningState().catch(() => void 0);
-    return replaced;
+    return this.replaceFromHistory();
   }
   /**
    * 向服务端确认会话此刻是否在运行，校准流式状态（残留的「运行中」会被清掉）。只在已加入房间时
@@ -5255,10 +5984,78 @@ var AgentSession = class _AgentSession {
     this.getAppContext = options.getContext;
     return attachment;
   }
+  /** Prepare a durable text input without sending any network request. */
+  prepareSend(content, options = {}) {
+    if (!content.trim()) throw new Error("\u6D88\u606F\u4E0D\u80FD\u4E3A\u7A7A");
+    if (Object.keys(options).some((key) => !["mode", "model", "thinkingOverride", "reasoningLevel", "contextAttachments"].includes(key))) {
+      throw new Error("\u53EF\u9760\u6587\u672C\u53D1\u9001\u4E0D\u652F\u6301\u8FD9\u4E9B\u53C2\u6570\uFF0C\u8BF7\u4F7F\u7528 send()");
+    }
+    const snapshot2 = JSON.parse(JSON.stringify(options));
+    if (snapshot2.contextAttachments) snapshot2.contextAttachments = snapshotContextAttachments(snapshot2.contextAttachments);
+    return { sessionId: this.sessionId, requestId: createClientRequestId(), content, options: snapshot2 };
+  }
+  /** Durably enqueue an ordinary text input. Retries must reuse the saved request. */
+  async sendPrepared(request) {
+    if (request.sessionId !== this.sessionId) throw new Error("\u53D1\u9001\u8BF7\u6C42\u4E0D\u5C5E\u4E8E\u5F53\u524D\u4F1A\u8BDD");
+    try {
+      this.runtime.ensureConnected();
+      const response = await this.runtime.emitWithAck("chat:append", {
+        session_id: this.sessionId,
+        client_request_id: request.requestId,
+        message: request.content,
+        prepared_options: {
+          mode: request.options.mode,
+          model: request.options.model,
+          thinking_override: request.options.thinkingOverride,
+          reasoning_level: request.options.reasoningLevel,
+          ...request.options.contextAttachments ? { context_attachments: request.options.contextAttachments } : {}
+        }
+      }, QUEUE_ACK_TIMEOUT_MS);
+      const result = parseQueueAck(response, this.sessionId);
+      if (result.snapshot) this.update((state) => withQueue(state, result.snapshot));
+      if (!result.ok) return {
+        requestId: request.requestId,
+        status: response?.status === "conflict" ? "rejected" : "unknown",
+        message: result.message ?? void 0
+      };
+      const delivery = response?.delivery;
+      if (!isRecord(delivery) || delivery.status !== "accepted") return { requestId: request.requestId, status: "unknown" };
+      return {
+        requestId: request.requestId,
+        status: "accepted",
+        itemId: typeof delivery.item_id === "string" ? delivery.item_id : void 0,
+        queueStatus: typeof delivery.queue_status === "string" ? delivery.queue_status : void 0,
+        executionId: typeof delivery.execution_id === "string" ? delivery.execution_id : null
+      };
+    } catch {
+      return { requestId: request.requestId, status: "unknown" };
+    }
+  }
+  /** Owner-authorized lookup; receipts remain until the session is deleted. */
+  async getDelivery(requestId) {
+    try {
+      this.runtime.ensureConnected();
+      const response = await this.runtime.emitWithAck("chat:queue:request", {
+        session_id: this.sessionId,
+        client_request_id: requestId
+      }, QUEUE_ACK_TIMEOUT_MS);
+      if (response?.status === "accepted") return {
+        requestId,
+        status: "accepted",
+        itemId: typeof response.item_id === "string" ? response.item_id : void 0,
+        queueStatus: typeof response.queue_status === "string" ? response.queue_status : void 0,
+        executionId: typeof response.execution_id === "string" ? response.execution_id : null
+      };
+      if (response?.status === "not_found") return { requestId, status: "not_found" };
+      return { requestId, status: "unknown", message: typeof response?.message === "string" ? response.message : void 0 };
+    } catch {
+      return { requestId, status: "unknown" };
+    }
+  }
   /** 发送一条消息。字符串或多模态内容均可。 */
   async send(content, options = {}) {
     this.runtime.ensureConnected();
-    if (this.state.isStreaming && options.queueWhenRunning !== true || this.state.activeCompaction || this.sendPending || this.manualCompactionPending) {
+    if (this.state.isStreaming && options.queueWhenRunning !== true || this.state.activeCompaction || this.sendPending || this.manualCompactionRequest) {
       this.update(
         (s) => addErrorMessage(s, "\u5F53\u524D\u56DE\u590D\u5C1A\u672A\u7ED3\u675F\u6216\u5BF9\u8BDD\u6B63\u5728\u6574\u7406\uFF0C\u8BF7\u7A0D\u540E\u518D\u53D1\u9001\u3002")
       );
@@ -5388,8 +6185,9 @@ var AgentSession = class _AgentSession {
     }
   }
   async sendUnlocked(content, options) {
+    const contextAttachments = options.contextAttachments ? snapshotContextAttachments(options.contextAttachments) : void 0;
     await this.ensureIdleBeforeSend();
-    if (this.state.isStreaming && options.queueWhenRunning !== true || this.state.activeCompaction || this.manualCompactionPending) {
+    if (this.state.isStreaming && options.queueWhenRunning !== true || this.state.activeCompaction || this.manualCompactionRequest) {
       this.update(
         (s) => addErrorMessage(s, "\u5F53\u524D\u56DE\u590D\u5C1A\u672A\u7ED3\u675F\u6216\u5BF9\u8BDD\u6B63\u5728\u6574\u7406\uFF0C\u8BF7\u7A0D\u540E\u518D\u53D1\u9001\u3002")
       );
@@ -5424,7 +6222,7 @@ var AgentSession = class _AgentSession {
     let optimisticAskAnswer;
     let previousAskAnswer;
     this.update((state) => {
-      const next = addUserMessage(state, content, clientRequestId);
+      const next = addUserMessage(state, content, clientRequestId, options.topicAssetRefs, options.refs, contextAttachments);
       optimisticTurnId = next.turns.at(-1)?.turn_id ?? null;
       return next;
     });
@@ -5442,7 +6240,10 @@ var AgentSession = class _AgentSession {
     if (!options.replayDecision) {
       this.pendingReplayMessage = content;
       this.pendingReplayMode = options.mode;
-      this.pendingReplayKbIds = options.kbIds;
+      this.pendingReplayRequestId = clientRequestId;
+      this.pendingReplayAttachments = contextAttachments;
+      this.pendingReplayRefs = options.refs;
+      this.pendingReplayTopicAssetRefs = options.topicAssetRefs;
     }
     this.pendingChatRequestId = clientRequestId;
     const payload = {
@@ -5457,7 +6258,9 @@ var AgentSession = class _AgentSession {
       whatif: options.whatif,
       replay_decision: options.replayDecision,
       app_context: appContext,
-      kb_ids: options.kbIds,
+      context_attachments: contextAttachments,
+      refs: options.refs,
+      topic_asset_refs: options.topicAssetRefs,
       // 运行中提交不必由客户端挑命令：服务端按会话运行状态决定直接执行还是入队。
       queue_when_running: options.queueWhenRunning === true
     };
@@ -5541,7 +6344,10 @@ var AgentSession = class _AgentSession {
     }
     this.pendingReplayMessage = null;
     this.pendingReplayMode = void 0;
-    this.pendingReplayKbIds = void 0;
+    this.pendingReplayRequestId = void 0;
+    this.pendingReplayAttachments = void 0;
+    this.pendingReplayRefs = void 0;
+    this.pendingReplayTopicAssetRefs = void 0;
     this.update((current) => {
       const filtered = optimisticTurnId ? current.turns.filter((turn) => turn.turn_id !== optimisticTurnId) : current.turns;
       let next = optimisticTurnId ? withTurns({ ...current, turns: filtered }, filtered) : current;
@@ -5563,22 +6369,62 @@ var AgentSession = class _AgentSession {
     }
   }
   /** 停止当前回复。 */
-  stop() {
-    return this.runtime.emitWithAck("chat:stop", { session_id: this.sessionId }, 35e3).then((response) => {
-      const result = response ?? {};
-      if (result.status !== "accepted") this.setManualCompactionPending(false);
-      return result;
-    });
+  async stop() {
+    const request = this.manualCompactionRequest;
+    if (request) {
+      const ack = await request.ack;
+      if (ack.status !== "accepted") return ack;
+      if (this.manualCompactionRequest !== request) return { status: "idle" };
+      return await this.runtime.emitWithAck("chat:stop", {
+        session_id: this.sessionId,
+        chat_run_id: request.runId
+      }, 35e3) ?? {};
+    }
+    const response = await this.runtime.emitWithAck("chat:stop", { session_id: this.sessionId }, 35e3) ?? {};
+    const cancelled = response.cancelled_client_request_ids;
+    if (response.status === "stopped" && Array.isArray(cancelled) && this.pendingChatRequestId !== null && cancelled.includes(this.pendingChatRequestId)) {
+      this.pendingChatRequestId = null;
+      this.update((state) => ({ ...withoutOptimisticUserTurns(state, cancelled), isStreaming: false }));
+      this.applyDesiredStreamTokens();
+    }
+    return response;
   }
   /** 手动触发上下文压缩。 */
   compact() {
-    if (this.state.isStreaming || this.state.activeCompaction || this.manualCompactionPending) {
+    if (this.state.isStreaming || this.state.activeCompaction || this.manualCompactionRequest) {
       return Promise.resolve({
         status: "error",
         message: "\u5F53\u524D\u56DE\u590D\u5C1A\u672A\u7ED3\u675F\u6216\u5BF9\u8BDD\u6B63\u5728\u6574\u7406\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5\u3002"
       });
     }
-    this.setManualCompactionPending(true);
+    const request = {
+      runId: null,
+      finishedBeforeAck: /* @__PURE__ */ new Set(),
+      ack: Promise.resolve().then(() => this.runtime.emitWithAck("chat:compact", { session_id: this.sessionId }, 3e4)).then((response) => {
+        const result = response ?? {};
+        if (result.status !== "accepted") {
+          if (this.manualCompactionRequest === request) this.setManualCompactionRequest(null);
+          return result;
+        }
+        if (typeof result.run_id !== "string" || !result.run_id) {
+          throw new AgentSessionError("\u6574\u7406\u8BF7\u6C42\u786E\u8BA4\u7F3A\u5C11 run_id\uFF0C\u65E0\u6CD5\u786E\u8BA4\u8FD0\u884C\u72B6\u6001");
+        }
+        request.runId = result.run_id;
+        if (request.finishedBeforeAck.has(request.runId) && this.manualCompactionRequest === request) {
+          this.setManualCompactionRequest(null);
+        }
+        request.finishedBeforeAck.clear();
+        return result;
+      }).catch((error) => {
+        if (this.manualCompactionRequest === request) this.setManualCompactionRequest(null);
+        throw error;
+      }).finally(() => {
+        if ((!this.manualCompactionRequest || this.manualCompactionRequest === request) && this.state.activeCompaction?.compaction_id === "pending-manual-compaction") {
+          this.update((state) => ({ ...state, activeCompaction: null }));
+        }
+      })
+    };
+    this.setManualCompactionRequest(request);
     this.update((state) => ({
       ...state,
       activeCompaction: {
@@ -5588,18 +6434,7 @@ var AgentSession = class _AgentSession {
         trigger: "manual"
       }
     }));
-    return this.runtime.emitWithAck("chat:compact", { session_id: this.sessionId }, 3e4).then((response) => {
-      const result = response ?? {};
-      if (result.status !== "accepted") this.setManualCompactionPending(false);
-      return result;
-    }).catch((error) => {
-      this.setManualCompactionPending(false);
-      throw error;
-    }).finally(() => {
-      if (this.state.activeCompaction?.compaction_id === "pending-manual-compaction") {
-        this.update((state) => ({ ...state, activeCompaction: null }));
-      }
-    });
+    return request.ack;
   }
   /**
    * 把一段业务数据作为附件放进聊天输入框（比如地图上选中的点位）。
@@ -5799,14 +6634,86 @@ var AgentSession = class _AgentSession {
   _handleTurnEnd(turn) {
     this.applyTurn(turn);
   }
+  runEpochReload() {
+    if (this.disposed || this.epochReloadRunning || this.epochReloadDone >= this.epochReloadRequested) return;
+    const target = this.epochReloadRequested;
+    this.epochReloadRunning = true;
+    void this.reloadHistoryWindow().then((replaced) => {
+      if (replaced) this.epochReloadDone = Math.max(this.epochReloadDone, target);
+    }).catch(() => void 0).finally(() => {
+      this.epochReloadRunning = false;
+      if (this.epochReloadRequested > target) this.runEpochReload();
+    });
+  }
   /** @internal 历史回放通道（event_format: raw）。 */
-  _handleTurnEvents(events, replayed = false) {
-    if (!events.length) return;
-    if (events.some(
-      (event) => event.type === "compaction:end" || event.type === "compaction:error" || event.type === "compaction:abort"
-    )) {
-      this.setManualCompactionPending(false);
+  _handleTurnEvents(incoming, replayed = false) {
+    const delivery = this.logCursor.consume(incoming);
+    let events = delivery.events;
+    if (delivery.reload) {
+      this.activeReplayPlaybackId = null;
+      this.projectionBuilder.reset();
+      this.pendingTurnPatches.clear();
+      this.epochReloadRequested += 1;
+    }
+    this.runEpochReload();
+    for (const event of events) {
+      const playbackId = typeof event.payload.playback_id === "string" ? event.payload.playback_id : null;
+      if (event.type === "chat:start") this.activeReplayPlaybackId = null;
+      if (event.type === "replay:start" && playbackId) {
+        this.activeReplayPlaybackId = playbackId;
+        this._handleChatStart();
+      } else if (event.type === "replay:state") {
+        const status = event.payload.status;
+        if (event.payload.reconciled === true && typeof status === "string") {
+          if (status === "running") this._handleChatStart();
+          else {
+            this.activeReplayPlaybackId = null;
+            this.finishStreaming(status);
+          }
+        }
+        this._handleSessionUpdated(event.payload);
+      } else if (event.type === "replay:end" && playbackId && (!this.activeReplayPlaybackId || this.activeReplayPlaybackId === playbackId)) {
+        this.activeReplayPlaybackId = null;
+        const status = event.payload.status === "interrupted" ? "interrupted" : event.payload.status === "failed" ? "failed" : "completed";
+        this._handleChatEnd({ status });
+      }
+      if (event.type === "log:notification") {
+        const notification = event.payload.event;
+        if (isCompactionFinished(notification.type)) {
+          this.handleManualCompactionFinished(notification);
+        } else if (notification.type === "artifact:created" || notification.type === "artifact:updated") {
+          this._handleArtifact(notification.payload, notification.type === "artifact:created" ? "created" : "updated", replayed);
+        } else if (notification.type === "workspace:changed") {
+          const change = notification.payload.workspace_change;
+          const paths = Array.isArray(notification.payload.paths) ? notification.payload.paths.filter((path) => typeof path === "string") : [];
+          this.emitter.emit("workspaceChanged", {
+            ...paths.length ? { paths } : {},
+            ...typeof change?.to === "string" && change.to ? { workspacePath: change.to } : {}
+          });
+        } else if (notification.type === "task:updated" && Array.isArray(notification.payload.tasks)) {
+          this._handleTaskUpdated(notification.payload.tasks);
+        } else if (notification.type === "bg:tasks_completed" && Array.isArray(notification.payload.tasks)) {
+          for (const task of notification.payload.tasks) {
+            const completed = completedBackgroundTask(task);
+            if (completed) this._handleBackgroundTask(completed);
+          }
+        } else {
+          this.applyWorkflowEvents([notification]);
+        }
+      }
+      if (event.type === "turn:snapshot") {
+        const turn = event.payload.turn;
+        this.projectionBuilder.acceptDurableTurn(turn);
+        this.pendingTurnPatches.delete(turn.turn_id);
+        this.applyTurn(
+          turn,
+          replayed ? this.subscriptionReplaySource ?? "bootstrap_replay" : "live"
+        );
+      }
     }
+    events = events.filter((event) => event.type !== "turn:snapshot" && event.type !== "log:notification" && !event.type.startsWith("replay:"));
+    if (!events.length) return;
+    for (const event of events) this.handleManualCompactionFinished(event);
     this.dispatchRawCommands(events);
     const terminalChatEndStatus = extractTerminalChatEndStatus(events);
     if (!terminalChatEndStatus && hasChatRunEvent(events) && this.state.status !== "waiting_for_input") {
@@ -5949,7 +6856,6 @@ var AgentSession = class _AgentSession {
       intent: data.intent,
       status: data.status,
       model: data.model,
-      boundSkillId: data.bound_skill_id,
       replayState: data.replay_state
     });
   }
@@ -5972,10 +6878,16 @@ var AgentSession = class _AgentSession {
   _handleReplayMismatch(data) {
     const message = this.pendingReplayMessage ?? data.actual_message ?? "";
     const mode = this.pendingReplayMode;
-    const kbIds = this.pendingReplayKbIds;
+    const requestId = this.pendingReplayRequestId ?? createClientRequestId();
+    const contextAttachments = this.pendingReplayAttachments;
+    const refs = this.pendingReplayRefs;
+    const topicAssetRefs = this.pendingReplayTopicAssetRefs;
     this.pendingReplayMessage = null;
     this.pendingReplayMode = void 0;
-    this.pendingReplayKbIds = void 0;
+    this.pendingReplayRequestId = void 0;
+    this.pendingReplayAttachments = void 0;
+    this.pendingReplayRefs = void 0;
+    this.pendingReplayTopicAssetRefs = void 0;
     const respond = (decision) => {
       void this.runtime.emitWithAck(
         "chat:send",
@@ -5984,7 +6896,10 @@ var AgentSession = class _AgentSession {
           message,
           mode,
           replay_decision: decision,
-          kb_ids: kbIds
+          client_request_id: requestId,
+          refs,
+          topic_asset_refs: topicAssetRefs,
+          context_attachments: contextAttachments
         },
         3e4
       ).then((response) => {
@@ -6045,8 +6960,20 @@ var AgentSession = class _AgentSession {
     this.emitter.emit("backgroundTask", task);
   }
   /** @internal */
-  _handleArtifact(event) {
-    this.emitter.emit("artifact", event);
+  _handleArtifact(data, kind, replayed = false) {
+    const filePath = typeof data.file_path === "string" ? data.file_path : "";
+    if (!filePath) return;
+    this._handleWorkspaceFilesChanged(filePath);
+    if (replayed) return;
+    this.emitter.emit("artifact", {
+      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
+    });
   }
   /** @internal 加入房间的应答里带 is_running，据此校准流式状态。 */
   _applyRunningState(isRunning, liveRevisionAtJoin = this.liveRevision) {
@@ -6248,6 +7175,7 @@ var AgentSession = class _AgentSession {
         display_name: toolCall.display_name,
         arguments: toolCall.arguments,
         result: toolCall.result ?? void 0,
+        ...toolCall.evidence ? { evidence: toolCall.evidence } : {},
         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)) {
@@ -6514,6 +7442,7 @@ var AgentSession = class _AgentSession {
         session_id: this.sessionId,
         event_format: "raw",
         resume: true,
+        ...this.logCursor.subscription(),
         ...streamTokens === null ? {} : { internal_stream_tokens: streamTokens }
       },
       5e3
@@ -6547,18 +7476,6 @@ var AgentSession = class _AgentSession {
 };
 
 // src/session/hub.ts
-var BACKGROUND_STATUSES = [
-  "starting",
-  "running",
-  "cancelling",
-  "succeeded",
-  "failed",
-  "cancelled",
-  "lost"
-];
-function normalizeBackgroundStatus(value) {
-  return BACKGROUND_STATUSES.includes(value) ? value : "running";
-}
 var SessionHub = class {
   client;
   sessions = /* @__PURE__ */ new Map();
@@ -6576,6 +7493,8 @@ var SessionHub = class {
   streamTokens = null;
   /** 状态订阅（mode: "status"）的持有计数。 */
   statusWatchCounts = /* @__PURE__ */ new Map();
+  statusLogCursors = /* @__PURE__ */ new Map();
+  replayPlaybackIds = /* @__PURE__ */ new Map();
   /** 启动连接门控：扣住期间只登记「需要连接」，放开后连一次。 */
   connectionHeld = false;
   connectDeferred = false;
@@ -6627,6 +7546,7 @@ var SessionHub = class {
         return;
       }
       this.statusWatchCounts.delete(sessionId);
+      this.statusLogCursors.delete(sessionId);
       if (!this.sessions.has(sessionId)) {
         ;
         this.client.socket().emit("session:unsubscribe", { session_id: sessionId });
@@ -6753,6 +7673,7 @@ var SessionHub = class {
     this.authBusyReconnect.cancel();
     this.bootstrapPending.clear();
     this.statusWatchCounts.clear();
+    this.statusLogCursors.clear();
     for (const session of [...this.sessions.values()]) {
       this.forceRelease(session);
     }
@@ -6814,17 +7735,32 @@ var SessionHub = class {
     ;
     this.client.socket().emit("session:unsubscribe", { session_id: session.sessionId });
     if (this.statusWatchCounts.has(session.sessionId)) this.emitStatusSubscribe([session.sessionId]);
+    else this.statusLogCursors.delete(session.sessionId);
+    if (this.client.options.anonymousSessionId && !this.needsConnection()) this.disconnect();
     return true;
   }
+  statusCursor(sessionId) {
+    let cursor = this.statusLogCursors.get(sessionId);
+    if (!cursor) {
+      cursor = new LogCursor();
+      this.statusLogCursors.set(sessionId, cursor);
+    }
+    return cursor;
+  }
   emitStatusSubscribe(sessionIds) {
     if (sessionIds.length === 0) return;
     const socket = this.client.socket();
+    const payload = (sessionId) => ({
+      session_id: sessionId,
+      mode: "status",
+      ...this.statusCursor(sessionId).subscription()
+    });
     if (sessionIds.length === 1) {
-      socket.emit("session:subscribe", { session_id: sessionIds[0], mode: "status" });
+      socket.emit("session:subscribe", payload(sessionIds[0]));
       return;
     }
     socket.emit("session:subscribe_batch", {
-      sessions: sessionIds.map((sessionId) => ({ session_id: sessionId, mode: "status" }))
+      sessions: sessionIds.map(payload)
     });
   }
   /** 不管还有几方持有都立即释放（启动失败、切换身份）。 */
@@ -6922,6 +7858,49 @@ var SessionHub = class {
       "turn:events",
       (data, acknowledge) => {
         acknowledgeTurnEvents(acknowledge);
+        if (data.session_id && (this.statusWatchCounts.has(data.session_id) || this.sessions.has(data.session_id)) && data.events?.some((event) => event.type === "log:record")) {
+          const delivery = this.statusCursor(data.session_id).consume(data.events ?? []);
+          for (const event of delivery.events) {
+            if (event.type === "chat:start") {
+              this.replayPlaybackIds.delete(data.session_id);
+              this.hubEmitter.emit("runStarted", { sessionId: data.session_id });
+            } else if (event.type === "chat:end") {
+              this.hubEmitter.emit("runEnded", {
+                sessionId: data.session_id,
+                status: typeof event.payload.status === "string" ? event.payload.status : void 0,
+                queued: false,
+                replayed: data.replayed === true,
+                ...typeof event.payload.chat_run_id === "string" ? { chatRunId: event.payload.chat_run_id } : {}
+              });
+            }
+          }
+        }
+        if (data.session_id) {
+          for (const event of data.events ?? []) {
+            if (event.type === "log:retract") this.replayPlaybackIds.delete(data.session_id);
+            if (event.type === "replay:state") {
+              this.hubEmitter.emit("sessionUpdated", { sessionId: data.session_id, data: event.payload });
+            }
+            const playbackId = event.payload.playback_id;
+            if (typeof playbackId !== "string") continue;
+            if (event.type === "replay:start") {
+              if (this.replayPlaybackIds.get(data.session_id) !== playbackId) {
+                this.replayPlaybackIds.set(data.session_id, playbackId);
+                this.hubEmitter.emit("runStarted", { sessionId: data.session_id });
+              }
+            } else if (event.type === "replay:end") {
+              const current = this.replayPlaybackIds.get(data.session_id);
+              if (current && current !== playbackId) continue;
+              this.replayPlaybackIds.delete(data.session_id);
+              this.hubEmitter.emit("runEnded", {
+                sessionId: data.session_id,
+                status: typeof event.payload.status === "string" ? event.payload.status : "completed",
+                queued: false,
+                replayed: true
+              });
+            }
+          }
+        }
         for (const session of this.route(data.session_id)) {
           session._handleTurnEvents(data.events ?? [], data.replayed === true);
         }
@@ -7039,40 +8018,16 @@ var SessionHub = class {
       (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,
-              // Pass the server's status through unchanged. Collapsing it here
-              // made subscribers see a successful-looking "done" for tasks the
-              // REST API correctly reported as cancelled or lost.
-              status: normalizeBackgroundStatus(task.status),
-              failureReason: typeof task.failure_reason === "string" ? task.failure_reason : void 0,
-              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
-            });
+            const completed = completedBackgroundTask(task);
+            if (completed) session._handleBackgroundTask(completed);
           }
         }
       }
     );
   }
   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
-      });
+      session._handleArtifact(data, kind);
     }
   }
 };
@@ -7103,12 +8058,14 @@ function createSocket(options) {
 
 // src/blade-client.ts
 var REFRESH_PATH = "/api/auth/refresh";
-var BladeClient = class {
+var BladeClient = class _BladeClient {
+  anonymousClients = /* @__PURE__ */ new Map();
+  toolProviders = /* @__PURE__ */ new Set();
   refreshPromise = null;
   socketInstance = null;
   socketReplacementListeners = /* @__PURE__ */ new Set();
   /** login() / setToken() 热挂载的令牌，优先级高于构造参数。 */
-  runtimeToken = null;
+  runtimeToken = void 0;
   options;
   auth;
   headless;
@@ -7126,6 +8083,9 @@ var BladeClient = class {
   /** 实时会话中枢：client.sessions.connect() 内部使用，一般不直接访问。 */
   hub;
   constructor(options) {
+    if (options.anonymousSessionId !== void 0 && !/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(options.anonymousSessionId)) {
+      throw new Error("\u533F\u540D\u4F1A\u8BDD ID \u5FC5\u987B\u662F UUID v4");
+    }
     this.options = {
       ...options,
       baseUrl: normalizeBaseUrl(options.baseUrl)
@@ -7139,10 +8099,16 @@ var BladeClient = class {
     this.chatGroups = new ChatGroupsResource(this);
     this.siteVisits = new SiteVisitsResource(this);
     this.hub = new SessionHub(this);
-    if (this.options.token === void 0) {
-      this.runtimeToken = readStoredToken(this.options.baseUrl);
+    if (this.options.token === void 0 && !this.options.anonymousSessionId) {
+      this.runtimeToken = readStoredToken(this.options.baseUrl) ?? void 0;
     }
   }
+  /** Backend application tools, callable over an outbound WebSocket. */
+  connectToolProvider(options) {
+    const provider = new ToolProvider(this, options, () => this.toolProviders.delete(provider));
+    this.toolProviders.add(provider);
+    return provider;
+  }
   /**
    * 弹窗授权登录：用户在弹出的授权页点击"许可授权"后自动取得 PAT，
    * REST 与 Socket.IO 立即生效。只在浏览器可用。
@@ -7162,7 +8128,12 @@ var BladeClient = class {
     const previousToken = this.resolveToken();
     this.runtimeToken = token;
     const nextToken = this.resolveToken();
+    if (token === null) for (const provider of this.toolProviders) provider.dispose();
     if (previousToken !== nextToken) {
+      for (const provider of this.toolProviders) {
+        if (nextToken) provider.reconnect();
+        else provider.dispose();
+      }
       this.hub.disposeAll();
     }
     writeStoredToken(this.options.baseUrl, token, this.options.tokenStorage ?? "local");
@@ -7195,12 +8166,27 @@ var BladeClient = class {
   get token() {
     return this.resolveRestToken();
   }
+  /** 获取只访问指定匿名会话的客户端；创建仍由已认证的原客户端完成。 */
+  forAnonymousSession(sessionId) {
+    let client = this.anonymousClients.get(sessionId);
+    if (!client) {
+      client = new _BladeClient({ baseUrl: this.options.baseUrl, anonymousSessionId: sessionId, fetchImpl: this.options.fetchImpl, commandTransport: this.options.commandTransport });
+      this.anonymousClients.set(sessionId, client);
+    }
+    return client;
+  }
   setBaseUrl(baseUrl) {
     const nextBaseUrl = normalizeBaseUrl(baseUrl);
     if (nextBaseUrl === this.options.baseUrl) {
       return;
     }
+    for (const provider of this.toolProviders) provider.dispose();
     this.hub.disposeAll();
+    for (const client of this.anonymousClients.values()) {
+      client.hub.disposeAll();
+      client.hub.disconnect();
+    }
+    this.anonymousClients.clear();
     this.options.baseUrl = nextBaseUrl;
     if (this.socketInstance) {
       this.socketInstance.removeAllListeners();
@@ -7240,7 +8226,10 @@ var BladeClient = class {
         else resolve(ack ?? {});
       });
     });
-    return this.options.commandTransport?.(event, payload, send) ?? send();
+    const transport = this.options.commandTransport;
+    if (!transport) return send();
+    const handled = this.options.anonymousSessionId ? transport(event, payload, send, { anonymousSessionId: this.options.anonymousSessionId }) : transport(event, payload, send);
+    return handled ?? send();
   }
   async json(method, path, body) {
     const response = await this.fetch(method, path, {
@@ -7383,6 +8372,7 @@ var BladeClient = class {
     }
   }
   async tryRefresh() {
+    if (this.options.anonymousSessionId) return false;
     if (this.refreshPromise) {
       return this.refreshPromise;
     }
@@ -7417,14 +8407,16 @@ var BladeClient = class {
     return this.resolveRestToken();
   }
   resolveRestToken() {
+    if (this.options.anonymousSessionId) return `ba-anonymous-${this.options.anonymousSessionId}`;
     return this.resolveToken();
   }
   resolveSocketToken() {
-    if (this.runtimeToken) return this.runtimeToken;
+    if (this.options.anonymousSessionId) return `ba-anonymous-${this.options.anonymousSessionId}`;
+    if (this.runtimeToken !== void 0) return this.runtimeToken;
     return resolveTokenOption(this.options.socketToken ?? this.options.token);
   }
   resolveToken() {
-    if (this.runtimeToken) return this.runtimeToken;
+    if (this.runtimeToken !== void 0) return this.runtimeToken;
     return resolveTokenOption(this.options.token);
   }
   formDataWithUploadProgress(method, path, form, options, isRetry = false) {
@@ -7522,22 +8514,14 @@ function parseXhrHeaders(rawHeaders) {
 }
 
 export {
+  BladeApiError,
+  ToolProvider,
   SDK_NAME,
   SDK_VERSION,
-  BladeApiError,
   isRecord,
-  computerState,
-  computerOS,
-  computerPlatformLabel,
-  computerDaemonVersion,
-  canToggleComputer,
-  sortComputers,
-  ComputersResource,
-  ModelsResource,
-  SessionStatus,
-  DEFAULT_REPLAY_SPEED,
-  SessionInfo,
-  SessionSetupError,
+  normalizePluginRefs,
+  normalizeMessageRefs,
+  normalizeTopicAssetRefs,
   inferToolStatus,
   contextProjectionData,
   getContextDisplayState,
@@ -7555,6 +8539,18 @@ export {
   isAppDevToolUiCard,
   collectInlineToolUiCards,
   collectPreviewToolUiCards,
+  computerState,
+  computerOS,
+  computerPlatformLabel,
+  computerDaemonVersion,
+  canToggleComputer,
+  sortComputers,
+  ComputersResource,
+  ModelsResource,
+  SessionStatus,
+  DEFAULT_REPLAY_SPEED,
+  SessionInfo,
+  SessionSetupError,
   isEntryGoneError,
   PluginsResource,
   ChatGroupsResource,
@@ -7604,4 +8600,4 @@ export {
   createSocket,
   BladeClient
 };
-//# sourceMappingURL=chunk-PWJJJATA.js.map
+//# sourceMappingURL=chunk-2VIJBVAC.js.map