@blade-hq/agent-client 2612.0.0-beta.4 → 2612.0.0-beta.40

package/dist/{chunk-4LJNZA3I.js → chunk-SNMDYU6W.js}

@@ -1,6 +1,230 @@
+// src/resources/sandbox.ts
+var SandboxResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  execute(input) {
+    return this.client.json("POST", "/api/sandbox/execute", input);
+  }
+};
+
+// 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 = this.client.options.applicationTransport?.provider() ?? 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, outputSchema }) => ({ name, description, inputSchema, ...outputSchema ? { outputSchema } : {} })) };
+      } 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.4" : "1.1.1";
+var SDK_VERSION = true ? "2612.0.0-beta.40" : "1.1.1";
 
 // src/auth-login.ts
 function isAuthCallbackMessage(value) {
@@ -128,54 +352,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) {
@@ -214,8 +390,8 @@ var AuthResource = class {
   getProviders() {
     return this.client.json("GET", "/api/auth/providers");
   }
-  getMe() {
-    return this.client.json("GET", "/api/auth/me");
+  getMe(options = {}) {
+    return this.client.jsonFromInit("/api/auth/me", { signal: options.signal });
   }
   logout() {
     return this.client.json("POST", "/api/auth/logout");
@@ -227,404 +403,168 @@ 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.update_format !== void 0 && item.update_format !== "snapshot" && item.update_format !== "diff") throw new Error("\u8D44\u6599\u66F4\u65B0\u683C\u5F0F\u65E0\u6548");
+    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
     });
   }
 }
@@ -941,14 +881,14 @@ function applyAskUserPauseToTurn(turn, pauseToolData, toolCallId, childLoopName,
 }
 function spacedJson(value) {
   try {
-    const encode = (item) => {
-      if (Array.isArray(item)) return `[${item.map(encode).join(", ")}]`;
+    const encode2 = (item) => {
+      if (Array.isArray(item)) return `[${item.map(encode2).join(", ")}]`;
       if (item && typeof item === "object") {
-        return `{${Object.entries(item).map(([key, part]) => `${JSON.stringify(key)}: ${encode(part)}`).join(", ")}}`;
+        return `{${Object.entries(item).map(([key, part]) => `${JSON.stringify(key)}: ${encode2(part)}`).join(", ")}}`;
       }
       return JSON.stringify(item) ?? "null";
     };
-    return encode(JSON.parse(value));
+    return encode2(JSON.parse(value));
   } catch {
     return value;
   }
@@ -1115,6 +1055,10 @@ function normalizeChildPause(pausePayload) {
   }
   return { pauseToolData, childLoopName, childToolCallId, description };
 }
+function attachToolEvidence(call, evidence) {
+  if (!call) return;
+  call.evidence = (call.status === "done" || call.status === "error") && Array.isArray(evidence) ? evidence : void 0;
+}
 
 // src/schemas/message.ts
 function inferToolStatus(resultStr) {
@@ -1173,8 +1117,8 @@ function snapshot(state, sequence, status) {
     first_token_ms: state.firstTokenMs,
     stream_duration_ms: state.streamDurationMs,
     first_token_delivery_ms: state.firstTokenDeliveryMs,
-    started_at: state.modelStartedAt ?? new Date(state.startedAt).toISOString(),
-    // 没有 payload 上报时用的是 loop:turn 的浏览器事件时间，标记出来供瀑布区分。
+    started_at: state.modelStartedAt,
+    // 未上报时不伪造服务器起点；浏览器时钟不能与服务器时钟混用。
     has_reported_timing: state.modelStartedAtReported,
     context_window: state.contextWindow,
     memory_refs: state.memoryRefs,
@@ -1316,7 +1260,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) {
@@ -1400,10 +1344,8 @@ var ClientProjectionBuilder = class {
   latestTurns = /* @__PURE__ */ new Map();
   turnsById = /* @__PURE__ */ new Map();
   loopDescriptions = /* @__PURE__ */ new Map();
-  /** loop_name → 正在运行的子智能体起点，agent:end 结算并挂到父工具调用上。 */
   activeSubagentRuns = /* @__PURE__ */ new Map();
   pendingChildPauses = /* @__PURE__ */ new Map();
-  /** 作答后子回路续跑，最终回复就是随后落盘的父 Agent 工具结果。 */
   answeredChildParents = /* @__PURE__ */ new Map();
   pendingMemoryRefs = /* @__PURE__ */ new Map();
   activeCompactions = /* @__PURE__ */ new Map();
@@ -1556,6 +1498,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;
@@ -1576,7 +1531,6 @@ var ClientProjectionBuilder = class {
     this.latestTurns = latestTurns;
     this.turnsById = turnsById;
   }
-  // --- Event handlers ---
   onMemoryInject(loopId, payload) {
     const refs = payload.memory_refs;
     const turnId = String(payload.turn_id ?? "");
@@ -1802,6 +1756,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 +1766,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,
@@ -1838,7 +1796,6 @@ var ClientProjectionBuilder = class {
     this.latestTurns.set("root", turn);
     return [{ kind: "upsert", turn }];
   }
-  // --- Delta / streaming events ---
   onDelta(state, blockType, _toolCallId, content) {
     if (!content) return null;
     appendTextBlock(state, blockType, content);
@@ -1890,10 +1847,7 @@ var ClientProjectionBuilder = class {
     if (!applyResponseBlockOrder(state, payload.response_blocks) && "content" in payload) {
       replaceTextContent(state, completedResponseText(payload.content));
     }
-    const isNativeProviderResponse = typeof payload.provider === "string" && payload.provider !== "";
-    if (state.toolCalls.length === 0 || isNativeProviderResponse && state.toolCalls.every(
-      (toolCall) => toolCall.status !== "pending" && toolCall.status !== "awaiting_answer"
-    )) {
+    if (state.toolCalls.length === 0) {
       const childParent = this.answeredChildParents.get(loopId);
       if (childParent) {
         this.answeredChildParents.delete(loopId);
@@ -1910,6 +1864,7 @@ var ClientProjectionBuilder = class {
     return this.syncPatch(state);
   }
   applyFirstTokenDelivery(state, payload) {
+    this.applyStreamTiming(state, payload);
     const firstTokenMs = payload.first_token_ms;
     if (state.firstTokenMs === null && typeof firstTokenMs === "number" && firstTokenMs >= 0) {
       state.firstTokenMs = Math.round(firstTokenMs);
@@ -1938,13 +1893,14 @@ var ClientProjectionBuilder = class {
     const toolCallId = String(payload.tool_call_id ?? "");
     const streamedResult = state.toolCalls.find((toolCall) => toolCall.id === toolCallId)?.result;
     const content = payload.content_from_deltas === true ? streamedResult ?? "" : payload.content ?? "";
-    const status = payload.is_error === true ? "error" : toolStatusFromResult(content);
+    const status = payload.is_error === true ? "error" : payload._tool_pending === true ? "pending" : toolStatusFromResult(content);
     const rawDuration = payload.duration_ms;
     const durationMs = typeof rawDuration === "number" && rawDuration >= 0 ? Math.round(rawDuration) : null;
     const ranInParallel = typeof payload.ran_in_parallel === "boolean" ? payload.ran_in_parallel : null;
     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
     );
@@ -1958,8 +1914,7 @@ var ClientProjectionBuilder = class {
         this.displayNameResolver
       );
     }
-    const isNativeProviderResult = typeof payload.provider === "string" && payload.provider !== "";
-    if (!isNativeProviderResult && this.shouldFinalizeAfterToolResults(state)) {
+    if (this.shouldFinalizeAfterToolResults(state)) {
       return this.finalize(loopId, "completed");
     }
     return this.syncPatch(state);
@@ -2218,7 +2173,6 @@ var ClientProjectionBuilder = class {
     const turn = buildCompactionTurn(this.nextSeq(), compactionId, loopId, status, current);
     return [{ kind: "upsert", turn }];
   }
-  // --- Internal helpers ---
   syncPatch(state) {
     const turn = snapshot(state, this.nextSeq(), "streaming");
     this.latestTurns.set(state.loopId, turn);
@@ -2398,7 +2352,6 @@ function projectHistory(entries) {
   const pendingChildPauses = /* @__PURE__ */ new Map();
   const childPauseEntries = [];
   const answeredToolCallIds = /* @__PURE__ */ new Set();
-  const nativeToolTurns = /* @__PURE__ */ new Set();
   const turnEntryAliases = /* @__PURE__ */ new Map();
   let latestRootMessage = null;
   let latestRootAssistant = null;
@@ -2464,19 +2417,18 @@ function projectHistory(entries) {
         const owner = toolOwners.get(toolCallId);
         const toolCall = owner?.tool_calls.find((item) => item.id === toolCallId);
         if (owner && toolCall) {
-          toolCall.status = message._error ? "error" : inferToolStatus(String(message.content ?? ""));
+          toolCall.status = message._error ? "error" : message._tool_pending === true ? "pending" : 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") {
             toolCall.started_at = message._started_at;
           }
           if (message._ran_in_parallel === true) toolCall.ran_in_parallel = true;
-          owner.blocks.push({
-            type: "tool_result",
-            content: message.content ?? "",
-            tool_call_id: toolCallId
-          });
+          const existing = owner.blocks.find((block) => block.type === "tool_result" && block.tool_call_id === toolCallId);
+          if (existing) existing.content = message.content ?? "";
+          else owner.blocks.push({ type: "tool_result", content: message.content ?? "", tool_call_id: toolCallId });
         }
         continue;
       }
@@ -2493,56 +2445,29 @@ 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,
         model: stringOrNull(message.model),
         usage: isRecord(message._usage) ? { ...message._usage } : null,
-        // 模型请求区间来自持久化字段；旧会话缺失时为 null，不用落盘时刻冒充（#2581 A1）。
         duration_ms: numberOrNull(message._duration_ms),
         first_token_ms: numberOrNull(message._first_token_ms),
         stream_duration_ms: numberOrNull(message._stream_duration_ms),
         started_at: typeof message._started_at === "string" ? message._started_at : typeof entry.timestamp === "string" ? entry.timestamp : void 0,
         has_reported_timing: typeof message._started_at === "string",
-        // fork 子会话的父锚点:历史里落在消息级 _parent_fork_tool_call_id。丢掉它,
-        // 刷新后工作流步骤 fork 就配不回 workflow:run 工具调用(普通 Agent fork 有
-        // root Agent 工具调用兜底配对,工作流 fork 没有,子智能体卡会整体消失)。
         parent_fork_tool_call_id: stringOrNull(message._parent_fork_tool_call_id)
       };
-      const isNativeToolEntry = role === "assistant" && Array.isArray(message.tool_calls) && message.tool_calls.some(
-        (toolCall) => isRecord(toolCall) && typeof toolCall.provider === "string"
-      );
-      const previousTurn = turns[turns.length - 1];
-      if (role === "assistant" && previousTurn?.role === "assistant" && previousTurn.loop_id === loopId && nativeToolTurns.has(previousTurn)) {
-        nativeToolTurns.delete(previousTurn);
-        previousTurn.blocks.push(...turn.blocks);
-        previousTurn.tool_calls.push(...turn.tool_calls);
-        previousTurn.status = turn.status;
-        previousTurn.model = turn.model ?? previousTurn.model;
-        previousTurn.usage = turn.usage ?? previousTurn.usage;
-        if (turn.duration_ms) previousTurn.duration_ms = turn.duration_ms;
-        previousTurn.first_token_ms = turn.first_token_ms ?? previousTurn.first_token_ms;
-        previousTurn.stream_duration_ms = turn.stream_duration_ms ?? previousTurn.stream_duration_ms;
-        if (turn.has_reported_timing) {
-          previousTurn.started_at = turn.started_at;
-          previousTurn.has_reported_timing = true;
-        } else if (!previousTurn.has_reported_timing) {
-          previousTurn.started_at = previousTurn.started_at ?? turn.started_at;
-        }
-        previousTurn.id = turn.id;
-        previousTurn.turn_id = turn.turn_id;
-        if (isNativeToolEntry) nativeToolTurns.add(previousTurn);
-        turnEntryAliases.set(id, previousTurn);
-        if (loopId === "root") latestRootMessage = previousTurn;
-        latestAssistantByLoop.set(loopId, previousTurn);
-        continue;
+      if (role === "user") {
+        const refs = normalizeMessageRefs(message.refs);
+        if (refs.length) turn.refs = refs;
+        turn.context_attachments = normalizeContextAttachments(message.context_attachments);
       }
       if (loopId === "root" && (role === "user" || role === "assistant")) {
         latestRootMessage = turn;
       }
       turns.push(turn);
       turnEntryAliases.set(id, turn);
-      if (isNativeToolEntry) nativeToolTurns.add(turn);
       if (role === "assistant") latestAssistantByLoop.set(loopId, turn);
       if (loopId === "root") {
         if (role === "assistant") latestRootAssistant = turn;
@@ -2558,7 +2483,7 @@ function projectHistory(entries) {
       if (owner && toolCallId) {
         const rawContent = data.content;
         const content = typeof rawContent === "string" ? rawContent : Array.isArray(rawContent) ? rawContent : String(rawContent ?? "");
-        const status = data.is_error === true ? "error" : inferToolStatus(typeof content === "string" ? content : JSON.stringify(content));
+        const status = data.is_error === true ? "error" : data._tool_pending === true ? "pending" : inferToolStatus(typeof content === "string" ? content : JSON.stringify(content));
         setToolCallStatus(owner, toolCallId, status, content, null);
         if (!owner.blocks.some((block) => block.type === "tool_result" && block.tool_call_id === toolCallId)) {
           owner.blocks.push({ type: "tool_result", content, tool_call_id: toolCallId });
@@ -2566,6 +2491,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") {
@@ -2616,7 +2568,7 @@ function projectHistory(entries) {
       let content = isRecord(entry.message) ? entry.message.content : void 0;
       if (kind === "tool_result_archive") {
         const archivedCount = Array.isArray(data.archived_files) ? data.archived_files.length : 0;
-        content = `<compaction-summary>
+        content = typeof data.summary === "string" && data.summary ? data.summary : `<compaction-summary>
 \u5DF2\u5F52\u6863 ${archivedCount} \u4E2A\u5927\u578B\u5DE5\u5177\u7ED3\u679C\u3002
 </compaction-summary>`;
       }
@@ -2728,117 +2680,752 @@ 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 chars = Array.from(output);
+      const shown = chars.length <= 300 ? output : `${chars.slice(0, 300).join("")}\u2026(\u5171${chars.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 && 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 });
+    }
+  });
+}
+
+// src/resources/computers.ts
+function computerState(computer) {
+  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 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(options = {}) {
+    return this.client.jsonFromInit("/api/config/models", { signal: options.signal });
+  }
+};
+
+// src/resources/connectors.ts
+function isLocalConnectorName(name) {
+  return name.startsWith("connector.personal.") || name.startsWith("connector.builtin.");
+}
+var ConnectorsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  create(draft) {
+    return this.client.json("POST", "/api/connectors", draft);
+  }
+  update(name, draft) {
+    return this.client.json("PATCH", `/api/connectors/${encodeURIComponent(name)}`, draft);
+  }
+  delete(name) {
+    return this.client.json("DELETE", `/api/connectors/${encodeURIComponent(name)}`);
+  }
+  /** Create a generation conversation and send its visible Skill request.
+   * Hosts use onCreated only to register caches and navigate before sending. */
+  async startGeneration({ connector, onCreated, initiator = "sdk" } = {}) {
+    const intent = connector ? "\u4FEE\u6539\u8FDE\u63A5\u5668" : "\u521B\u5EFA\u8FDE\u63A5\u5668";
+    const request = connector ? "\u4FEE\u6539\u9009\u5B9A\u7684\u8FDE\u63A5\u5668" : "\u521B\u5EFA\u8FDE\u63A5\u5668";
+    const { session_id } = await this.client.sessions.createSessionWithRequest({ intent, solution_id: "connector_generate", initiator });
+    await onCreated?.({ session_id, intent });
+    const session = await this.client.sessions.connect(session_id);
+    try {
+      const sent = await session.send(`\u8BF7\u4F7F\u7528\u8FDE\u63A5\u5668\u751F\u6210\u5668\uFF0C\u5E2E\u6211${request}\u3002\u5148\u786E\u8BA4\u6211\u5E0C\u671B\u8FDE\u63A5\u7684\u7CFB\u7EDF\u548C\u9700\u8981\u7684\u529F\u80FD\uFF0C\u518D\u6309\u6280\u80FD\u5F15\u5BFC\u6211\u5B8C\u6210\u3002`, {
+        mode: "executing",
+        refs: [{ provider: "skill", id: "generate-connector", label: "\u8FDE\u63A5\u5668\u751F\u6210\u5668" }],
+        ...connector ? { contextAttachments: [{
+          id: "connector-generation-target",
+          label: "\u9009\u5B9A\u7684\u8FDE\u63A5\u5668",
+          content: JSON.stringify({ name: connector.name, display_name: connector.display_name }),
+          update_format: "snapshot"
+        }] } : {}
+      });
+      return { session_id, sent };
+    } finally {
+      session.dispose();
     }
-  } 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
+  list(init) {
+    return this.client.jsonFromInit("/api/connectors", init);
+  }
+  listForSession(sessionId, init) {
+    return this.client.jsonFromInit(`/api/connectors?session_id=${encodeURIComponent(sessionId)}`, init);
+  }
+  read(name, init) {
+    return this.client.jsonFromInit(`/api/connectors/${encodeURIComponent(name)}/connection`, init);
+  }
+  connect(name, update, init) {
+    return this.client.jsonFromInit(`/api/connectors/${encodeURIComponent(name)}/connection`, {
+      method: "PUT",
+      body: JSON.stringify(update),
+      ...init
     });
   }
-  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;
+  browserAuthorizationUrl(name) {
+    return new URL(`connector-auth/${encodeURIComponent(name)}`, `${this.client.options.baseUrl.replace(/\/$/, "")}/`).toString();
+  }
+  /** One-use, one-minute identity handoff to this client's trusted Blade origin.
+   * Tokens travel only through a source/origin-bound message, never a URL/storage. */
+  bindBrowserAuthorizationFrame(frame, name) {
+    const nonce = Array.from(crypto.getRandomValues(new Uint8Array(32)), (value) => value.toString(16).padStart(2, "0")).join("");
+    const url = new URL(this.browserAuthorizationUrl(name), window.location.href);
+    url.searchParams.set("embedded", "1");
+    url.searchParams.set("handoff", nonce);
+    url.searchParams.set("parent_origin", window.location.origin);
+    const receive = (event) => {
+      if (event.origin !== url.origin || event.source !== frame.contentWindow || event.data?.type !== "blade:connector-auth-ready" || event.data?.nonce !== nonce) return;
+      cleanup();
+      frame.contentWindow?.postMessage({ type: "blade:connector-auth-identity", nonce, token: this.client.token }, url.origin);
+    };
+    const timeout = window.setTimeout(() => cleanup(), 6e4);
+    const cleanup = () => {
+      window.clearTimeout(timeout);
+      window.removeEventListener("message", receive);
+    };
+    window.addEventListener("message", receive);
+    frame.src = url.toString();
+    return cleanup;
+  }
+  async startBrowserAuthorization(name, sessionId) {
+    const view = await this.read(name);
+    if (view.authorization?.type !== "browser") throw new Error("\u8BE5\u8FDE\u63A5\u5668\u6CA1\u6709\u7F51\u9875\u767B\u5F55\u5165\u53E3");
+    const id = sessionId ?? (await this.client.sessions.createSessionWithRequest({
+      intent: `\u8FDE\u63A5 ${view.display_name || "\u4E1A\u52A1\u7CFB\u7EDF"}`,
+      memory_enabled: false
+    })).session_id;
+    await this.client.json("POST", `/api/sessions/${encodeURIComponent(id)}/browser/wake`, {});
+    const tabs = await this.client.json("GET", `/api/sessions/${encodeURIComponent(id)}/browser/tabs`);
+    const hasBusinessTab = tabs.data?.some(({ url }) => url && url !== "about:blank" && !/^http:\/\/(?:127\.0\.0\.1|localhost):9223\/home(?:[/?#]|$)/.test(url));
+    if (!sessionId || !hasBusinessTab) await this.client.json("POST", `/api/sessions/${encodeURIComponent(id)}/browser/tabs`, { url: view.authorization.url });
+    return { session_id: id, view };
+  }
+  verify(name) {
+    return this.client.json("POST", `/api/connectors/${encodeURIComponent(name)}/connection:verify`);
+  }
+  disconnect(name) {
+    return this.client.json("DELETE", `/api/connectors/${encodeURIComponent(name)}/connection`);
   }
-  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[]",
+  "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,14 +3436,14 @@ 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,
@@ -2864,9 +3451,6 @@ function toCreateSessionPayload(request) {
     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,
-    ...request.runtime_type ? { runtime_type: request.runtime_type } : {},
-    ...request.daemon_id ? { daemon_id: request.daemon_id } : {},
-    ...request.agent_runtime_id ? { agent_runtime_id: request.agent_runtime_id } : {},
     ...request.chat_group_id ? { chat_group_id: request.chat_group_id } : {}
   };
 }
@@ -2954,7 +3538,8 @@ var SessionsResource = class {
     return this.client.jsonFromInit(`/api/sessions/${encodeURIComponent(sessionId)}/plugins`, init);
   }
   setSessionPluginActivation(sessionId, name, active, init) {
-    return this.client.jsonFromInit(`/api/sessions/${encodeURIComponent(sessionId)}/plugins/${encodeURIComponent(name)}:activation`, { method: "POST", body: JSON.stringify({ active }), ...init });
+    const kind = isLocalConnectorName(name) ? "connectors" : "plugins";
+    return this.client.jsonFromInit(`/api/sessions/${encodeURIComponent(sessionId)}/${kind}/${encodeURIComponent(name)}:activation`, { method: "POST", body: JSON.stringify({ active }), ...init });
   }
   /**
    * Fetch a plugin's package-local icon as bytes.
@@ -2987,18 +3572,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 = {}) {
@@ -3006,7 +3594,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;
@@ -3027,7 +3615,8 @@ var SessionsResource = class {
         memory_enabled: config?.memoryEnabled,
         compaction_ratio: config?.compactionRatio,
         env: config?.env,
-        disable_tools: config?.disableTools
+        disable_tools: config?.disableTools,
+        mcp_sources: config?.mcpSources
       });
       session_id = created.session_id;
     } catch (error) {
@@ -3093,7 +3682,6 @@ var SessionsResource = class {
   fetchSessionsPage({
     limit,
     offset,
-    template_id_prefix,
     solution_id,
     solution_registry_id,
     q,
@@ -3102,7 +3690,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) {
@@ -3113,12 +3700,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;
@@ -3135,8 +3722,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));
@@ -3154,6 +3741,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 });
   }
@@ -3291,13 +3885,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}`);
@@ -3545,6 +4151,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");
   }
@@ -3552,11 +4161,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);
   }
 };
 
@@ -3583,7 +4305,6 @@ var SiteVisitsResource = class {
     try {
       const response = await (this.client.options.fetchImpl ?? fetch)(url.toString(), {
         method,
-        // 访客 Cookie 是唯一的去重依据，必须随请求往返。
         credentials: "include",
         signal: controller.signal
       });
@@ -3597,6 +4318,48 @@ var SiteVisitsResource = class {
   }
 };
 
+// src/server-clock.ts
+var clocks = /* @__PURE__ */ new WeakMap();
+function syncServerTime(client, timestamp, receivedAt = performance.now()) {
+  if (typeof timestamp !== "string") return;
+  const serverTime = Date.parse(timestamp);
+  if (!Number.isFinite(serverTime)) return;
+  const current = getServerTime(client, receivedAt);
+  clocks.set(client, { serverTime: Math.max(serverTime, current ?? serverTime), receivedAt });
+}
+function getServerTime(client, now = performance.now()) {
+  const clock = client ? clocks.get(client) : void 0;
+  return clock ? clock.serverTime + Math.max(0, now - clock.receivedAt) : null;
+}
+
+// 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;
@@ -4013,15 +4776,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]*)$/;
@@ -4149,7 +4905,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 "";
@@ -4173,6 +4935,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: [
@@ -4187,7 +4958,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);
@@ -4209,10 +4982,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 ?? [] };
@@ -4463,7 +5236,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;
@@ -4478,10 +5253,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();
@@ -4708,8 +5487,6 @@ function withTurns(state, turns) {
     activeCompaction,
     askAnswers,
     mode: latestMode ?? state.mode,
-    // 历史恢复时 chat:end(paused) 可能已不在 socket replay 缓存中；
-    // awaiting_answer 是投影里的持久权威状态，必须据此恢复问答交互。
     status: isWaitingForInput ? "waiting_for_input" : state.status
   };
 }
@@ -4718,17 +5495,17 @@ 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 = {
     id: turnId,
     sequence: Math.max(0, ...state.turns.map((turn) => turn.sequence)) + 1,
     turn_id: turnId,
-    // 乐观态就自赋，跟服务端确认后 reconcileUserTurns 补上的
-    // 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",
@@ -4912,6 +5689,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];
@@ -4922,11 +5702,10 @@ function extractTerminalChatEndStatus(events) {
   return null;
 }
 var AgentSession = class _AgentSession {
+  logCursor = new LogCursor();
   sessionId;
   state;
-  /** status 每变化一次加一（单调递增）。异步读取会话详情时据此判断请求期间状态是否变过，避免 running→终态→running 这类来回被误认为「没变」。 */
   statusRevision = 0;
-  /** 实时事件写入 status 时调用：值不变也要记一次，才能识别请求期间收到过更新的状态。 */
   noteLiveStatus() {
     this.statusRevision += 1;
   }
@@ -4934,21 +5713,17 @@ var AgentSession = class _AgentSession {
   emitter = new Emitter();
   commands = new CommandRegistry();
   runtime;
+  activeReplayPlaybackId = null;
   projectionBuilder = new ClientProjectionBuilder();
   pendingTurnPatches = /* @__PURE__ */ new Map();
   patchFlushHandle = null;
   patchFlushCancel = null;
   joined = false;
   joinPending = null;
-  // bootstrap 与每次 reconnect 共用一条订阅生命周期队列。它们都会重置 join
-  // 状态并临时设置 replay source，禁止并发，否则较早操作的 finally 会清掉
-  // 较晚操作仍在使用的来源上下文。
   subscriptionQueue = Promise.resolve();
   replaceQueue = Promise.resolve();
   timelineEpoch = 0;
-  /** 定位请求的流水号：被后一次选择取代的那次定位不再提交窗口（见 locateEntry）。 */
   locateToken = 0;
-  /** 在途那次定位的请求句柄。**只**服务定位：权威刷新不共用它（见 cancelPendingLocate）。 */
   locateAbort = null;
   pagingGeneration = 0;
   liveRevision = 0;
@@ -4957,14 +5732,7 @@ var AgentSession = class _AgentSession {
   pendingOptimisticTurnIds = /* @__PURE__ */ new Set();
   olderPending = null;
   replaceInFlight = 0;
-  // 回放控制请求排成一条队列。连着点"5x"再点"退出回放"时，并发发出去的两个
-  // 请求响应可能乱序回来，晚到的旧值会把已经退出的会话又显示成回放中；用
-  // 序号丢弃过期响应又会在失败时留下中间态。串行执行就没有这些情况：每个
-  // 响应都是当时最新的，失败也只影响自己。
   replayQueue = Promise.resolve();
-  // Historical snapshots and live commands share one delivery barrier. A
-  // repair closes the barrier before joining, snapshots the raw command log
-  // after the join, then releases buffered commands in socket arrival order.
   commandRestoreQueue = Promise.resolve();
   commandRecoveryGeneration = 0;
   commandRestoreRetryAttempt = 0;
@@ -4972,42 +5740,35 @@ var AgentSession = class _AgentSession {
   bufferedCommandDeliveries = null;
   pendingReplayMessage = null;
   pendingReplayMode;
-  pendingReplayKbIds;
+  pendingReplayRequestId;
+  pendingReplayAttachments;
+  pendingReplayRefs;
+  pendingReplayTopicAssetRefs;
   recentChatEndAt = 0;
-  /**
-   * 最近一次已经通过 `error` 事件投递过的服务端失败（`message` + `code`）。
-   *
-   * `chat:send` 被代理时服务端会先发 `system:error`、再用同一条失败回 ack，两条
-   * 通道都会到达这里：前者走 `_handleSystemError`，后者走发送失败的回滚。不去重
-   * 的话调用方会收到两次同一个 `error`（重复提示、重试逻辑跑两遍）。
-   *
-   * 带代际边界，只认「本次 `emitWithAck` 等待期间」投递的那一条：否则队列/停止
-   * 失败留下的标记会一直挂着，之后一次无关的订阅失败只是文案码相同就被当成
-   * 重复而静音。用单调递增的代际号而不是时间戳，同一毫秒内的两条也不会混淆。
-   */
   lastDeliveredSystemError = null;
-  /** 每次投递 `system:error` 递增，用于判定某条失败是否属于本次等待。 */
   systemErrorGeneration = 0;
   subscriptionReplaySource = null;
   disposed = false;
   getAppContext = null;
   sendPending = false;
-  manualCompactionPending = false;
-  /** 手动整理的在途标记，同时写进状态（界面据此保持「正在整理」，见 SessionState.compactionPending）。 */
-  setManualCompactionPending(pending) {
-    this.manualCompactionPending = pending;
+  manualCompactionRequest = null;
+  epochReloadRequested = 0;
+  epochReloadDone = 0;
+  epochReloadRunning = false;
+  setManualCompactionRequest(request) {
+    this.manualCompactionRequest = request;
+    const pending = request !== null;
     if (this.state.compactionPending !== pending) this.update((s) => ({ ...s, compactionPending: pending }));
   }
-  /** 最近一次还在等服务端结果的发送请求 id；排队中断的 chat:end 据此判断回滚是否过期。 */
+  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);
+  }
   pendingChatRequestId = null;
-  /** 会话详情给出的运行时类型；"native" 时启用原生智能体的投影规则（见 _handleTurnEvents / _handleChatEnd）。 */
-  runtimeType = null;
-  /** workflow_run_id → 触发它的 workflow:run 工具调用 id（只有 run:start 事件带工具调用 id）。 */
   workflowRunToolCalls = /* @__PURE__ */ new Map();
-  /**
-   * 第一方 Web 的精简模式传输优化：订阅时是否要 token 级事件。null 表示宿主没设置，订阅时不带这个字段。
-   * `desiredStreamTokens` 是宿主最新的选择；运行中不切换，等这一轮结束再重订阅。
-   */
   desiredStreamTokens = null;
   joinedStreamTokens = null;
   deliveredCommandKeys = /* @__PURE__ */ new Set();
@@ -5045,11 +5806,8 @@ var AgentSession = class _AgentSession {
         emitWithAck: async () => readonlyError(),
         ensureConnected: readonlyError,
         fetchTurnsPage: async () => ({ turns, nextBefore: null, currentMode: "executing" }),
-        // 静态会话（分享页）没有会话目录接口，宿主用已加载的历史兜底条目。
         fetchTurnIndex: async () => ({ sessionId, items: [] }),
         fetchCommands: async () => [],
-        // 静态历史没有回放身份可言，给个空详情即可，不要抛错——_bootstrap
-        // 不会跑到这里，但保持只读语义一致。
         fetchSessionInfo: async () => ({ replay_state: null }),
         updateReplay: async () => readonlyError(),
         listDir: async () => readonlyError(),
@@ -5068,7 +5826,6 @@ var AgentSession = class _AgentSession {
     };
     return session;
   }
-  // ---------------------------------------------------------------- 状态订阅
   /** 返回当前会话快照。引用稳定：状态未变化时返回同一对象。 */
   getState() {
     return this.state;
@@ -5155,6 +5912,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();
@@ -5164,9 +5926,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();
   }
   /**
    * 向服务端确认会话此刻是否在运行，校准流式状态（残留的「运行中」会被清掉）。只在已加入房间时
@@ -5187,11 +5947,6 @@ var AgentSession = class _AgentSession {
     if (this.disposed || !response || response.ok === false || typeof response.is_running !== "boolean") return;
     this._applyRunningState(response.is_running, liveRevision);
   }
-  /**
-   * timeline 被整体改写（rewind / checkout / 释放）：推进纪元，并把在途定位请求一并中止
-   * ——它已经属于旧 timeline，却还占着替换队列，会让改写后的权威窗口排在后面等它跑完。
-   * 作废号仍然保留：中止只是让它更早结束。
-   */
   invalidateTimeline() {
     this.timelineEpoch += 1;
     this.locateAbort?.abort();
@@ -5229,7 +5984,6 @@ var AgentSession = class _AgentSession {
   update(fn) {
     this.setState(fn(this.state));
   }
-  // ---------------------------------------------------------------- 语义事件
   /** 监听语义事件（底层逃生舱，见 events.ts）。返回取消函数。 */
   on(name, handler) {
     return this.emitter.on(name, handler);
@@ -5246,7 +6000,6 @@ var AgentSession = class _AgentSession {
   onCommand(action, handler) {
     return this.commands.onCommand(action, handler);
   }
-  // ---------------------------------------------------------------- 动作
   /**
    * 声明当前应用提供的页面上下文和业务 CLI。
    *
@@ -5257,10 +6010,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.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")
       );
@@ -5369,10 +6190,6 @@ var AgentSession = class _AgentSession {
   async refreshQueue() {
     return this.runQueueCommand("chat:queue:list", { session_id: this.sessionId });
   }
-  /**
-   * 发出一条队列命令并安装 ack 里的快照。
-   * 传输层失败（超时 / 断线）会 reject，由调用方决定是否重试。
-   */
   async requestQueueAck(event, payload) {
     this.runtime.ensureConnected();
     const response = await this.runtime.emitWithAck(event, payload, QUEUE_ACK_TIMEOUT_MS);
@@ -5381,7 +6198,6 @@ var AgentSession = class _AgentSession {
     if (snapshot2) this.update((state) => withQueue(state, snapshot2));
     return result;
   }
-  /** 队列命令的对外入口：传输失败只体现为失败结果，不向调用方抛异常。 */
   async runQueueCommand(event, payload) {
     try {
       return await this.requestQueueAck(event, payload);
@@ -5390,15 +6206,16 @@ 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.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")
       );
       return false;
     }
     let appContext;
-    if (this.getAppContext) {
+    if (this.getAppContext && !this.state.isStreaming) {
       try {
         const rawContext = await this.getAppContext();
         if (!isRecord(rawContext)) {
@@ -5426,7 +6243,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;
     });
@@ -5444,7 +6261,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 = {
@@ -5459,8 +6279,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
     };
     try {
@@ -5502,6 +6323,14 @@ var AgentSession = class _AgentSession {
           typeof response?.code === "string" ? response.code : void 0
         );
       }
+      if (optimisticTurnId) {
+        this.update((state) => {
+          const next = withTurns(state, state.turns.map(
+            (turn) => turn.turn_id === optimisticTurnId ? { ...turn, status: "completed" } : turn
+          ));
+          return { ...next, askAnswers: state.askAnswers };
+        });
+      }
       return true;
     } catch (error) {
       const failure = describeSessionError(error, "\u6D88\u606F\u53D1\u9001\u5931\u8D25\uFF0C\u8BF7\u91CD\u8BD5");
@@ -5536,14 +6365,16 @@ var AgentSession = class _AgentSession {
     }
     this.emitter.emit("error", { message, ...code ? { code } : {} });
   }
-  /** 撤回一次乐观提交：移除乐观消息、恢复提问作答、清掉回放草稿。 */
   discardOptimisticSend(optimisticTurnId, askUserAnswer, optimisticAskAnswer, previousAskAnswer) {
     if (optimisticTurnId && this.pendingChatRequestId && optimisticTurnId === `local-user-${this.pendingChatRequestId}`) {
       this.pendingChatRequestId = null;
     }
     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;
@@ -5565,22 +6396,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: {
@@ -5590,18 +6461,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;
   }
   /**
    * 把一段业务数据作为附件放进聊天输入框（比如地图上选中的点位）。
@@ -5654,22 +6514,15 @@ var AgentSession = class _AgentSession {
   get isDisposed() {
     return this.disposed;
   }
-  // ------------------------------------------------------- Hub 回调（内部）
-  /** @internal 连接状态变化（同 client 下所有会话共享一条连接）。 */
   _setConnection(connection) {
     if (this.state.connection === connection) return;
     this.update((s) => ({ ...s, connection }));
   }
-  /**
-   * @internal 服务端广播的权威队列快照。
-   * 结构不合法或 revision 不新的一律丢弃，绝不用旧快照覆盖新状态。
-   */
   _handleQueueUpdated(payload) {
     if (!isSessionQueueSnapshot(payload)) return;
     const snapshot2 = payload;
     this.update((state) => withQueue(state, snapshot2));
   }
-  /** @internal socket 重连后由 Hub 调用：重新加入房间并补数。 */
   _rejoinAfterReconnect() {
     this.invalidateOlderPaging();
     this.update((state) => ({ ...state, nextBefore: null, loadingOlder: false }));
@@ -5698,7 +6551,6 @@ var AgentSession = class _AgentSession {
       }
     });
   }
-  /** @internal 首次连接：加载历史 + 加入房间。 */
   _bootstrap() {
     const commandRecoveryGeneration = this.beginCommandRecovery();
     return this.enqueueSubscription(async () => {
@@ -5709,7 +6561,6 @@ var AgentSession = class _AgentSession {
         Promise.resolve().then(fetchDetail).catch(() => fetchDetail()).catch(() => null)
       ]);
       if (this.disposed) return;
-      if (detail) this.runtimeType = detail.runtime_type ?? null;
       this.subscriptionReplaySource = "bootstrap_replay";
       try {
         await this.ensureJoined();
@@ -5723,17 +6574,14 @@ var AgentSession = class _AgentSession {
       ]);
     });
   }
-  /** 订阅生命周期串行执行；一次失败只由自己的调用方观察，不截断后续重连。 */
   enqueueSubscription(operation) {
     const run = this.subscriptionQueue.then(operation);
     this.subscriptionQueue = run.catch(() => void 0);
     return run;
   }
-  /** 改回放是 owner 专属（服务端 PATCH 走 _get_owned_session）。 */
   get canControlReplay() {
     return this.state.viewerRole !== "viewer";
   }
-  /** 拉一次会话详情，填会话状态、回放状态、只读身份和运行时类型；失败不挡启动。 */
   async syncSessionFromDetail(options) {
     const statusRevisionAtRequest = this.statusRevision;
     try {
@@ -5742,18 +6590,14 @@ var AgentSession = class _AgentSession {
     } catch {
     }
   }
-  /** 安装一份会话详情；`statusRevisionAtRequest` 是发出请求时的状态修订号。 */
   applySessionDetail(info, statusRevisionAtRequest) {
     if (this.disposed) return;
-    this.runtimeType = info.runtime_type ?? null;
     const replay = toReplaySnapshot(info.replay_state);
     const viewerRole = info.viewer_role ?? null;
     this.update((s) => ({
       ...s,
       replay,
       viewerRole,
-      // 请求期间 status 变过（哪怕又变回原值）就说明实时事件比这份详情更新，不覆盖。
-      // child_pause 已让提问进入等待态，而稍旧的详情仍可能写着 running。
       status: this.statusRevision === statusRevisionAtRequest && !(s.status === "waiting_for_input" && info.status === "running" && s.turns.some((turn) => turn.tool_calls.some((call) => call.status === "awaiting_answer"))) ? info.status ?? s.status : s.status
     }));
   }
@@ -5767,7 +6611,6 @@ var AgentSession = class _AgentSession {
     if (!this.state.replay?.isReplay || !this.canControlReplay) return;
     await this.applyReplayControl({ status: "autonomous" });
   }
-  /** 把一次回放控制请求排进队列；前一个完成后才发出，响应直接安装。 */
   applyReplayControl(payload) {
     const run = this.replayQueue.then(async () => {
       const result = await this.runtime.updateReplay(this.sessionId, payload);
@@ -5776,12 +6619,10 @@ var AgentSession = class _AgentSession {
     this.replayQueue = run.catch(() => void 0);
     return run;
   }
-  /** @internal */
   _handleTurnStart(turn) {
     this.markRunningIfIdle();
     this.applyTurn(turn);
   }
-  /** @internal */
   _handleTurnPatch(patch) {
     this.markRunningIfIdle();
     if (patch.data.workspace_changed) {
@@ -5795,20 +6636,90 @@ var AgentSession = class _AgentSession {
     if (!current || patch.sequence >= current.sequence) {
       this.pendingTurnPatches.set(patch.turn_id, patch);
     }
-    this.schedulePatchFlush();
-  }
-  /** @internal */
-  _handleTurnEnd(turn) {
-    this.applyTurn(turn);
-  }
-  /** @internal 历史回放通道（event_format: raw）。 */
-  _handleTurnEvents(events, replayed = false) {
+    this.schedulePatchFlush();
+  }
+  _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();
+    });
+  }
+  _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;
-    if (events.some(
-      (event) => event.type === "compaction:end" || event.type === "compaction:error" || event.type === "compaction:abort"
-    )) {
-      this.setManualCompactionPending(false);
-    }
+    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") {
@@ -5820,7 +6731,6 @@ var AgentSession = class _AgentSession {
     const updates = this.projectionBuilder.processBatch(events);
     for (const update of updates) {
       if (update.kind === "upsert") {
-        if (this.isNativeBootstrapTurn(update.turn)) continue;
         this.applyTurn(
           update.turn,
           replayed ? this.subscriptionReplaySource ?? "bootstrap_replay" : "live"
@@ -5843,7 +6753,6 @@ var AgentSession = class _AgentSession {
       this.completeChat(terminalChatEndStatus ?? "completed");
     }
   }
-  /** @internal */
   _handleChatStart() {
     this.noteLiveStatus();
     this.update((s) => ({
@@ -5853,10 +6762,6 @@ var AgentSession = class _AgentSession {
       isStreaming: true
     }));
   }
-  /**
-   * @internal 返回 false 表示这是一条过期的排队回滚（被取消的是更早的请求，当前运行不受影响），
-   * Hub 据此不把它当成一次运行结束广播出去。
-   */
   _handleChatEnd(payload = {}) {
     const status = payload.status ?? "completed";
     if (payload.queued === true) {
@@ -5875,29 +6780,9 @@ var AgentSession = class _AgentSession {
       this.emitter.emit("chatEnd", { status });
       return true;
     }
-    if (this.runtimeType === "native") {
-      const updates = this.projectionBuilder.processBatch([
-        {
-          type: "chat:end",
-          payload: {
-            loop_name: "root",
-            status,
-            ...payload.pause_tool_data ? { pause_tool_data: payload.pause_tool_data } : {}
-          }
-        }
-      ]);
-      for (const update of updates) {
-        if (update.kind === "upsert") this.applyTurn(update.turn);
-      }
-      this.finishStreaming(status);
-      this.recentChatEndAt = Date.now();
-      this.emitter.emit("chatEnd", { status });
-      return true;
-    }
     this.completeChat(status);
     return true;
   }
-  /** @internal */
   _handleSystemError(message, code) {
     this.pendingChatRequestId = null;
     this.noteLiveStatus();
@@ -5927,15 +6812,12 @@ var AgentSession = class _AgentSession {
       ...code ? { code } : {}
     });
   }
-  /** @internal */
   _handleTaskUpdated(tasks) {
     this.emitter.emit("taskListUpdated", { tasks });
   }
-  /** @internal */
   _handleWorkspaceFilesChanged(filePath, paths) {
     this.emitter.emit("workspaceChanged", paths?.length ? { filePath, paths } : { filePath });
   }
-  /** @internal */
   _handleSessionUpdated(data) {
     if (data.status) {
       this.noteLiveStatus();
@@ -5951,11 +6833,9 @@ var AgentSession = class _AgentSession {
       intent: data.intent,
       status: data.status,
       model: data.model,
-      boundSkillId: data.bound_skill_id,
       replayState: data.replay_state
     });
   }
-  /** @internal */
   _handleRewind(checkpointId) {
     this.invalidateTimeline();
     this.invalidateOlderPaging();
@@ -5970,14 +6850,19 @@ var AgentSession = class _AgentSession {
     void this.replaceFromHistory();
     this.emitter.emit("rewind", { checkpointId });
   }
-  /** @internal */
   _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",
@@ -5986,7 +6871,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) => {
@@ -6015,7 +6903,6 @@ var AgentSession = class _AgentSession {
       respond("continue_replay");
     }
   }
-  /** @internal */
   _handleSystemNotification(loopId, notification) {
     const notificationType = typeof notification.notification_type === "string" ? notification.notification_type : "system_notification";
     const title = typeof notification.title === "string" ? notification.title : notificationType;
@@ -6042,15 +6929,24 @@ var AgentSession = class _AgentSession {
       }
     }
   }
-  /** @internal */
   _handleBackgroundTask(task) {
     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) {
     const hasPendingQuestion = this.state.turns.some(
       (turn) => turn.tool_calls.some((call) => call.status === "awaiting_answer")
@@ -6063,7 +6959,6 @@ var AgentSession = class _AgentSession {
       void this.refreshAuthoritativeHistory({ liveRevisionAtStart: liveRevisionAtJoin });
     }
   }
-  // ---------------------------------------------------------------- 内部实现
   markRunningIfIdle() {
     if (!this.state.isStreaming) {
       this.noteLiveStatus();
@@ -6080,15 +6975,6 @@ var AgentSession = class _AgentSession {
     });
     this.applyDesiredStreamTokens();
   }
-  /**
-   * 原生智能体常在用户发言之前就宣告一个空的 assistant 回合（投影的起点），它的真实内容会随第一条
-   * 输出再发一次。消息列表在启动期间本来就显示一个「正在生成」占位，两者并存会出现两个占位，
-   * 所以只丢掉原生会话里这种空的流式回合。
-   */
-  isNativeBootstrapTurn(turn) {
-    return this.runtimeType === "native" && turn.role === "assistant" && turn.status === "streaming" && turn.blocks.length === 0 && turn.tool_calls.length === 0;
-  }
-  /** 实时 workflow:* 事件叠加到对应工具调用的时间线上（见 workflow.ts 的来源规则）。 */
   applyWorkflowEvents(events) {
     for (const event of events) {
       if (!isWorkflowEvent(event.type)) continue;
@@ -6103,10 +6989,6 @@ var AgentSession = class _AgentSession {
       this.update((state) => withWorkflowEvent(state, toolCallId, event.type, payload));
     }
   }
-  /**
-   * @internal 宿主改了 token 订阅偏好（精简模式）。空闲时立即重订阅；运行中等这一轮结束再换，
-   * 避免在输出中途丢掉 token 流。
-   */
   _setStreamTokens(enabled) {
     this.desiredStreamTokens = enabled;
     if (!this.state.isStreaming) this.applyDesiredStreamTokens();
@@ -6124,7 +7006,7 @@ var AgentSession = class _AgentSession {
   completeChat(status) {
     this.finishStreaming(status);
     this.recentChatEndAt = Date.now();
-    if (this.runtimeType !== "native") void this.refreshAuthoritativeHistory();
+    void this.refreshAuthoritativeHistory();
     this.emitter.emit("chatEnd", { status });
   }
   markTurnFresh(turnId) {
@@ -6202,7 +7084,6 @@ var AgentSession = class _AgentSession {
       this.patchFlushCancel = null;
     }
   }
-  /** turn 数据落地后统一派生语义事件（指令 / 工具调用 / 消息 / 模式 / 预览 / OOM）。 */
   emitTurnDerivedEvents(previous, turn, source = "live") {
     this.emitter.emit("turnUpdated", { turn, source });
     const mode = extractModeFromBlocks(turn.blocks);
@@ -6250,6 +7131,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)) {
@@ -6314,20 +7196,11 @@ var AgentSession = class _AgentSession {
     this.update((s) => addErrorMessage(s, OOM_MESSAGE));
     this.emitter.emit("sandboxOom", { toolCallId: key });
   }
-  /**
-   * 权威刷新（运行结束 / 重连补数）：**按当前窗口第一条发言取窗口**，不再另记"用户想看哪段"。
-   *
-   * 窗口本身就是"用户在看哪段"：首屏就是最新一页，向上翻页 / 定位之后首条就是用户滚到的位置。
-   * 直接拿 `from_entry_id = 当前窗口第一条 turn_id` 去取，运行结束、重连补数、翻页之后的对账
-   * 是同一条规则，不需要意图、锚点、已落地锚点这些状态；窗口首条已经不在分支上（404 / 409）时
-   * 回落到最新一页。
-   */
   refreshAuthoritativeHistory(options = {}) {
     let entryGone = false;
     const locateTokenAtStart = this.locateToken;
     return this.replaceFromHistory({
       ...options,
-      // 锚点在**这次操作真正开始**时采样：排队期间用户可能刚定位过，那时窗口首条才是他要的。
       fromEntryId: () => {
         const anchor = this.state.turns[0]?.turn_id;
         return anchor?.startsWith("local-user-") ? void 0 : anchor;
@@ -6495,7 +7368,6 @@ var AgentSession = class _AgentSession {
       this.bufferedCommandDeliveries = null;
     }
   }
-  /** 首次订阅前的 REST 历史建立语义事件基线，随后同一工具的订阅回放不再投递。 */
   seedToolCallDeliveryBaseline(turns) {
     for (const turn of turns) {
       for (const toolCall of turn.tool_calls) {
@@ -6516,6 +7388,7 @@ var AgentSession = class _AgentSession {
         session_id: this.sessionId,
         event_format: "raw",
         resume: true,
+        ...this.logCursor.subscription(),
         ...streamTokens === null ? {} : { internal_stream_tokens: streamTokens }
       },
       5e3
@@ -6549,23 +7422,10 @@ 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();
   bootstrapPending = /* @__PURE__ */ new Map();
-  /** 每个会话当前有多少方持有（connect 一次 +1，dispose 一次 -1）。 */
   holdCounts = /* @__PURE__ */ new Map();
   connection = "disconnected";
   connectionListeners = /* @__PURE__ */ new Set();
@@ -6574,17 +7434,12 @@ var SessionHub = class {
   authBusyReconnect = new AuthBusyReconnect();
   hubEmitter = new Emitter();
   options = { restoreHistoricalCommands: true };
-  /** token 订阅偏好（第一方 Web 精简模式）；null 表示不设置，订阅时不带字段。 */
   streamTokens = null;
-  /** 状态订阅（mode: "status"）的持有计数。 */
   statusWatchCounts = /* @__PURE__ */ new Map();
-  /** 启动连接门控：扣住期间只登记「需要连接」，放开后连一次。 */
+  statusLogCursors = /* @__PURE__ */ new Map();
+  replayPlaybackIds = /* @__PURE__ */ new Map();
   connectionHeld = false;
   connectDeferred = false;
-  /**
-   * 宿主显式要过连接（ensureConnected / reconnect，例如只收产品事件的页面）。有会话、状态订阅或这个需求时，
-   * 鉴权忙碌的临时拒绝都要按服务端建议重试，否则连接会一直停在断开，直到别的动作碰巧重连。
-   */
   connectionDemanded = false;
   constructor(client) {
     this.client = client;
@@ -6597,10 +7452,6 @@ var SessionHub = class {
   on(name, handler) {
     return this.hubEmitter.on(name, handler);
   }
-  /**
-   * @internal 第一方 Web 的精简模式传输优化：订阅时是否要 token 级事件。
-   * 空闲会话立即重订阅，运行中的会话等这一轮结束。
-   */
   setStreamTokens(enabled) {
     if (this.streamTokens === enabled) return;
     this.streamTokens = enabled;
@@ -6629,6 +7480,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 });
@@ -6755,15 +7607,11 @@ 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);
     }
   }
-  /**
-   * @internal 底层 socket 被换掉时由 BladeClient 调用（如 setBaseUrl）。
-   * 事件监听器绑在旧 socket 实例上，换新实例后必须重绑，否则所有
-   * turn:* / chat:* 事件都会静默丢弃。
-   */
   _handleSocketReplaced() {
     this.authBusyReconnect.cancel();
     this.bound = false;
@@ -6792,14 +7640,9 @@ var SessionHub = class {
       onDispose: (session) => this.release(session)
     };
   }
-  /** 记一份持有。 */
   hold(sessionId) {
     this.holdCounts.set(sessionId, (this.holdCounts.get(sessionId) ?? 0) + 1);
   }
-  /**
-   * 归还一份持有；还剩别的持有者时返回 false，让 AgentSession 保持可用。
-   * 归零才退订房间并从路由表移除。
-   */
   release(session) {
     const remaining = (this.holdCounts.get(session.sessionId) ?? 0) - 1;
     if (remaining > 0) {
@@ -6816,20 +7659,34 @@ 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)
     });
   }
-  /** 不管还有几方持有都立即释放（启动失败、切换身份）。 */
   forceRelease(session) {
     this.holdCounts.delete(session.sessionId);
     session.dispose();
@@ -6854,7 +7711,6 @@ var SessionHub = class {
       }
     }
   }
-  /** 事件带 session_id 时精确路由；缺省时按当前唯一活跃会话兜底。 */
   route(sessionId) {
     if (sessionId) {
       const session = this.sessions.get(sessionId);
@@ -6923,7 +7779,51 @@ var SessionHub = class {
     socket.on(
       "turn:events",
       (data, acknowledge) => {
+        syncServerTime(this.client, data.server_time);
         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);
         }
@@ -7041,40 +7941,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);
     }
   }
 };
@@ -7105,13 +7981,16 @@ 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;
+  cookieLogoutPending = 0;
   socketInstance = null;
   socketReplacementListeners = /* @__PURE__ */ new Set();
-  /** login() / setToken() 热挂载的令牌，优先级高于构造参数。 */
-  runtimeToken = null;
+  runtimeToken = void 0;
   options;
+  sandbox;
   auth;
   headless;
   computers;
@@ -7119,6 +7998,7 @@ var BladeClient = class {
   sessions;
   /** 按用户读取的插件目录与图标；没有会话时也能用。 */
   plugins;
+  connectors;
   chatGroups;
   /**
    * 全站访问统计：匿名读写，不带 bearer 也不触发登录刷新。
@@ -7128,23 +8008,34 @@ 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)
     };
+    this.sandbox = new SandboxResource(this);
     this.auth = new AuthResource(this);
     this.headless = new HeadlessResource(this);
     this.computers = new ComputersResource(this);
     this.models = new ModelsResource(this);
     this.sessions = new SessionsResource(this);
     this.plugins = new PluginsResource(this);
+    this.connectors = new ConnectorsResource(this);
     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 立即生效。只在浏览器可用。
@@ -7164,7 +8055,13 @@ 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) {
+      this.options.applicationTransport?.invalidate();
+      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");
@@ -7197,12 +8094,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();
@@ -7227,7 +8139,7 @@ var BladeClient = class {
   }
   socket() {
     if (!this.socketInstance) {
-      this.socketInstance = createSocket({
+      this.socketInstance = this.options.applicationTransport?.socket() ?? createSocket({
         baseUrl: this.options.baseUrl,
         token: () => this.resolveSocketToken()
       });
@@ -7242,7 +8154,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, {
@@ -7300,24 +8215,31 @@ var BladeClient = class {
   }
   async fetch(method, path, init = {}, isRetry = false) {
     const url = this.buildUrl(path);
-    const response = await (this.options.fetchImpl ?? fetch)(url.toString(), {
-      method,
-      body: init.body,
-      credentials: init.credentials ?? "include",
-      headers: this.buildHeaders(url, init.headers),
-      signal: init.signal
-    });
-    if (response.status === 401 && !isRetry && this.shouldRefreshFor401(url)) {
-      const refreshed = await this.tryRefreshUnlessAborted(init.signal);
-      if (refreshed) {
-        return this.fetch(method, path, init, true);
+    const isLogout = method === "POST" && url.pathname === this.buildUrl("/api/auth/logout").pathname && this.isSameBackendUrl(url);
+    if (isLogout) this.cookieLogoutPending += 1;
+    try {
+      if (isLogout) await this.refreshPromise;
+      const response = await (this.options.fetchImpl ?? fetch)(url.toString(), {
+        method,
+        body: init.body,
+        credentials: init.credentials ?? "include",
+        headers: this.buildHeaders(url, init.headers),
+        signal: init.signal
+      });
+      if (response.status === 401 && !isRetry && this.shouldRefreshFor401(url)) {
+        const refreshed = await this.tryRefreshUnlessAborted(init.signal);
+        if (refreshed) {
+          return this.fetch(method, path, init, true);
+        }
       }
+      if (init.expectOk !== false && !response.ok) {
+        const detail = await extractErrorDetail(response);
+        throw decorateAuthError(new BladeApiError(response, detail));
+      }
+      return response;
+    } finally {
+      if (isLogout) this.cookieLogoutPending -= 1;
     }
-    if (init.expectOk !== false && !response.ok) {
-      const detail = await extractErrorDetail(response);
-      throw decorateAuthError(new BladeApiError(response, detail));
-    }
-    return response;
   }
   buildAuthedUrl(path) {
     const url = buildBackendUrl(this.options.baseUrl, path);
@@ -7363,13 +8285,6 @@ var BladeClient = class {
   hasExplicitBearerToken() {
     return Boolean(this.resolveRestToken());
   }
-  /**
-   * 等一次令牌刷新，但调用方中止请求时不再等下去。
-   *
-   * 刷新本身是共享的（`refreshPromise`，别的请求也在等它），这里只是让这次已被取消的
-   * 请求尽早结束——否则它会一直挂在调用方（定位）的串行队列里，用户改选的新目标要等到
-   * 刷新结束才轮得到。
-   */
   async tryRefreshUnlessAborted(signal) {
     if (!signal) return this.tryRefresh();
     if (signal.aborted) throw new DOMException("The operation was aborted.", "AbortError");
@@ -7385,6 +8300,7 @@ var BladeClient = class {
     }
   }
   async tryRefresh() {
+    if (this.options.anonymousSessionId || this.cookieLogoutPending > 0) return false;
     if (this.refreshPromise) {
       return this.refreshPromise;
     }
@@ -7395,7 +8311,6 @@ var BladeClient = class {
           {
             method: "POST",
             credentials: "include",
-            // Refresh remains cookie-only; do not attach the REST bearer.
             headers: { "X-Blade-Client": `${SDK_NAME}/${SDK_VERSION}` }
           }
         );
@@ -7419,14 +8334,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) {
@@ -7523,23 +8440,601 @@ function parseXhrHeaders(rawHeaders) {
   return headers;
 }
 
+// src/application-client.ts
+var Events = class {
+  listeners = /* @__PURE__ */ new Map();
+  on(name, listener) {
+    let set = this.listeners.get(name);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.listeners.set(name, set);
+    }
+    set.add(listener);
+    return this;
+  }
+  off(name, listener) {
+    if (listener) this.listeners.get(name)?.delete(listener);
+    else this.listeners.delete(name);
+    return this;
+  }
+  once(name, listener) {
+    const wrapped = (...args) => {
+      this.off(name, wrapped);
+      listener(...args);
+    };
+    return this.on(name, wrapped);
+  }
+  fire(name, ...args) {
+    for (const listener of [...this.listeners.get(name) ?? []]) {
+      try {
+        listener(...args);
+      } catch (error) {
+        console.warn(
+          `[agent-client] "${name}" application handler failed:`,
+          error
+        );
+      }
+    }
+  }
+  removeAllListeners() {
+    this.listeners.clear();
+    return this;
+  }
+};
+function encode(input) {
+  const attachments = [];
+  const walk = (value) => {
+    if (value instanceof ArrayBuffer || ArrayBuffer.isView(value)) {
+      const bytes = value instanceof ArrayBuffer ? new Uint8Array(value) : new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+      let text = "";
+      for (let offset = 0; offset < bytes.length; offset += 8192)
+        text += String.fromCharCode(...bytes.subarray(offset, offset + 8192));
+      attachments.push(btoa(text));
+      return ["bytes", attachments.length - 1];
+    }
+    if (Array.isArray(value)) return ["list", value.map(walk)];
+    if (value && typeof value === "object")
+      return [
+        "dict",
+        Object.entries(value).map(([key, item]) => [key, walk(item)])
+      ];
+    return ["value", value ?? null];
+  };
+  return { value: walk(input), attachments };
+}
+function decode(wire) {
+  const walk = (node) => {
+    if (!Array.isArray(node) || node.length !== 2)
+      throw new Error("Invalid application value");
+    if (node[0] === "value") return node[1];
+    if (node[0] === "bytes")
+      return Uint8Array.from(
+        atob(wire.attachments[node[1]]),
+        (c) => c.charCodeAt(0)
+      );
+    if (node[0] === "list") return node[1].map(walk);
+    if (node[0] === "dict")
+      return Object.fromEntries(
+        node[1].map(([key, value2]) => [key, walk(value2)])
+      );
+    throw new Error("Invalid application value");
+  };
+  const value = walk(wire.value);
+  if (!Array.isArray(value)) throw new Error("Invalid application event");
+  return value;
+}
+var BladeApplicationClient = class {
+  constructor(options) {
+    this.options = options;
+    this.channels = [
+      new ApplicationChannel(this.options.baseUrl, this.applicationId),
+      new ApplicationChannel(this.options.baseUrl, this.applicationId)
+    ];
+  }
+  options;
+  channels;
+  clients = /* @__PURE__ */ new Map();
+  applicationId = crypto.randomUUID();
+  forUser(userId, options) {
+    const saved = this.clients.get(userId);
+    if (saved) return saved;
+    let hash = 0;
+    for (const character of userId)
+      hash = hash * 31 + character.charCodeAt(0) | 0;
+    const channel = this.channels[(hash >>> 0) % this.channels.length];
+    const user = new ApplicationUser(channel, userId, () => client);
+    const client = new BladeClient({
+      ...this.options,
+      ...options,
+      tokenStorage: options.tokenStorage ?? "memory",
+      applicationTransport: user
+    });
+    this.clients.set(userId, client);
+    return client;
+  }
+  get connectionCount() {
+    return this.channels.filter((channel) => channel.isConnected).length;
+  }
+  dispose() {
+    for (const client of this.clients.values()) {
+      client.hub.disposeAll();
+      client.logoutToken();
+    }
+    for (const channel of this.channels) channel.dispose();
+    this.clients.clear();
+  }
+};
+var ApplicationChannel = class {
+  constructor(baseUrl, applicationId) {
+    this.baseUrl = baseUrl;
+    this.applicationId = applicationId;
+  }
+  baseUrl;
+  applicationId;
+  socket;
+  opening;
+  timer;
+  stopped = false;
+  attempts = 0;
+  controlCount = 0;
+  controlWaiters = [];
+  async controlSlot() {
+    if (this.controlCount >= 16)
+      await new Promise((resolve) => this.controlWaiters.push(resolve));
+    else this.controlCount++;
+    return () => {
+      const next = this.controlWaiters.shift();
+      if (next) next();
+      else this.controlCount--;
+    };
+  }
+  pending = /* @__PURE__ */ new Map();
+  users = /* @__PURE__ */ new Map();
+  get isConnected() {
+    return this.socket?.readyState === WebSocket.OPEN;
+  }
+  ensure() {
+    if (this.stopped)
+      return Promise.reject(new Error("Application client disposed"));
+    if (this.isConnected) return Promise.resolve();
+    if (!this.opening) {
+      const work = this.open();
+      this.opening = work;
+      void work.finally(() => {
+        if (this.opening === work) this.opening = void 0;
+      }).catch(() => {
+      });
+    }
+    return this.opening;
+  }
+  async open() {
+    clearTimeout(this.timer);
+    this.timer = void 0;
+    const candidates = [...this.users.values()].filter(
+      (user2) => user2.demanded && user2.client().token
+    );
+    const user = candidates[this.attempts % candidates.length];
+    let ticket;
+    try {
+      if (!user)
+        throw new Error(
+          "Application channel requires a demanded user credential"
+        );
+      ticket = await user.client().jsonFromInit("/api/app-channels", {
+        method: "POST",
+        body: JSON.stringify({ application_id: this.applicationId }),
+        signal: AbortSignal.timeout(1e4)
+      });
+    } catch (error) {
+      this.schedule();
+      throw error;
+    }
+    if (this.stopped) throw new Error("Application client disposed");
+    const endpoint = buildBackendUrl(this.baseUrl, "/api/app-channels/connect");
+    endpoint.protocol = endpoint.protocol === "https:" ? "wss:" : "ws:";
+    const socket = new WebSocket(endpoint, [
+      "blade-application",
+      `blade-channel.${ticket.token}`
+    ]);
+    this.socket = socket;
+    await new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error("Application connection timed out"));
+        socket.close();
+      }, 15e3);
+      socket.addEventListener("open", () => {
+        if (this.socket !== socket || this.stopped) return;
+        clearTimeout(timeout);
+        this.attempts = 0;
+        resolve();
+        for (const user2 of this.users.values()) user2.restore();
+      });
+      socket.addEventListener("message", (event) => {
+        if (this.socket !== socket || typeof event.data !== "string") return;
+        try {
+          this.receive(JSON.parse(event.data));
+        } catch {
+          socket.close();
+        }
+      });
+      socket.addEventListener("error", () => {
+        clearTimeout(timeout);
+        reject(new Error("Application connection failed"));
+      });
+      socket.addEventListener("close", () => {
+        clearTimeout(timeout);
+        reject(new Error("Application connection closed"));
+        if (this.socket !== socket) return;
+        this.socket = void 0;
+        for (const request of this.pending.values()) {
+          clearTimeout(request.timer);
+          request.reject(new Error("Application connection closed"));
+        }
+        this.pending.clear();
+        for (const user2 of this.users.values()) user2.lost();
+        this.schedule();
+      });
+    });
+  }
+  schedule() {
+    if (this.stopped || this.timer || ![...this.users.values()].some((user) => user.demanded))
+      return;
+    this.timer = setTimeout(
+      () => {
+        this.timer = void 0;
+        void this.ensure().catch(() => this.schedule());
+      },
+      Math.min(1e4, 500 * 2 ** Math.min(this.attempts++, 5))
+    );
+  }
+  receive(frame) {
+    if (frame.id) {
+      const request = this.pending.get(frame.id);
+      if (!request || request.user !== frame.user) return;
+      this.pending.delete(frame.id);
+      clearTimeout(request.timer);
+      if (frame.error)
+        request.reject(
+          Object.assign(new Error(frame.error.message), {
+            code: frame.error.code,
+            data: {
+              code: frame.error.code,
+              status: frame.error.code === "auth_busy" ? 429 : 401,
+              retry_after: 1
+            }
+          })
+        );
+      else request.resolve(frame.result);
+      return;
+    }
+    const user = frame.user && this.users.get(frame.user);
+    if (user) user.receive(frame);
+  }
+  async request(user, method, params, timeoutMs = 3e4) {
+    const release = method === "socket/event" ? () => {
+    } : await this.controlSlot();
+    try {
+      return await new Promise((resolve, reject) => {
+        const id = crypto.randomUUID();
+        const timer = setTimeout(() => {
+          this.pending.delete(id);
+          reject(new Error("Application request timed out"));
+        }, timeoutMs);
+        this.pending.set(id, { user, resolve, reject, timer });
+        try {
+          this.send({ id, user, method, params });
+        } catch (error) {
+          clearTimeout(timer);
+          this.pending.delete(id);
+          reject(error);
+        }
+      });
+    } finally {
+      release();
+    }
+  }
+  send(frame) {
+    if (!this.isConnected || !this.socket)
+      throw new Error("Application connection unavailable");
+    this.socket.send(JSON.stringify(frame));
+  }
+  dispose() {
+    this.stopped = true;
+    clearTimeout(this.timer);
+    this.timer = void 0;
+    for (const user of this.users.values()) user.lost();
+    this.socket?.close();
+    for (const request of this.pending.values()) {
+      clearTimeout(request.timer);
+      request.reject(new Error("Application client disposed"));
+    }
+    this.pending.clear();
+    this.users.clear();
+  }
+};
+var ApplicationUser = class {
+  constructor(channel, userId, client) {
+    this.channel = channel;
+    this.userId = userId;
+    this.client = client;
+    this.events = new ApplicationSocket(this);
+    channel.users.set(this.key, this);
+  }
+  channel;
+  userId;
+  client;
+  key = crypto.randomUUID();
+  events;
+  providers = /* @__PURE__ */ new Map();
+  binding;
+  bindingToken;
+  get demanded() {
+    return this.events.active || this.providers.size > 0;
+  }
+  async bind() {
+    await this.channel.ensure();
+    if (!this.demanded) throw new Error("Application user no longer needed");
+    const token = this.client().token;
+    if (!token) throw new Error("Application user requires a token");
+    if (!this.binding || this.bindingToken !== token) {
+      this.bindingToken = token;
+      const work = this.channel.request(this.key, "user/bind", { user_id: this.userId, token }).then((result) => {
+        if (result.user_id !== this.userId)
+          throw new Error("Application user identity mismatch");
+        if (!this.demanded) {
+          this.binding = void 0;
+          this.bindingToken = void 0;
+          void this.channel.request(this.key, "user/unbind", {}).catch(() => {
+          });
+          throw new Error("Application user no longer needed");
+        }
+      });
+      this.binding = work;
+      void work.catch(() => {
+        if (this.binding === work) this.binding = void 0;
+      });
+    }
+    return this.binding;
+  }
+  socket() {
+    return this.events;
+  }
+  provider() {
+    const provider = new ApplicationProviderSocket(this);
+    this.providers.set(provider.handle, provider);
+    provider.open();
+    return provider;
+  }
+  invalidate() {
+    this.binding = void 0;
+    this.bindingToken = void 0;
+    if (!this.client().token && this.channel.isConnected)
+      void this.channel.request(this.key, "user/unbind", {}).catch(() => {
+      });
+  }
+  restore() {
+    if (this.events.active) this.events.connect();
+  }
+  lost() {
+    this.invalidate();
+    this.events.lost();
+    for (const provider of [...this.providers.values()]) provider.closeLocal();
+  }
+  receive(frame) {
+    if (frame.method === "socket/closed") {
+      this.events.lost();
+      if (this.events.active) this.events.connect();
+      return;
+    }
+    if (frame.method === "tool/closed") {
+      this.providers.get(frame.handle ?? "")?.closeLocal();
+      return;
+    }
+    if (frame.method === "tool/message") {
+      this.providers.get(frame.handle ?? "")?.message(frame.message);
+      return;
+    }
+    if (frame.event && frame.args) {
+      const args = decode(frame.args);
+      if (frame.ack_id)
+        args.push(
+          (...values) => this.channel.send({
+            method: "event/ack",
+            user: this.key,
+            ack_id: frame.ack_id,
+            params: encode(values)
+          })
+        );
+      this.events.fire(frame.event, ...args);
+    }
+  }
+};
+var ApplicationSocket = class extends Events {
+  constructor(user) {
+    super();
+    this.user = user;
+  }
+  user;
+  connected = false;
+  active = false;
+  io = new Events();
+  connecting;
+  generation = 0;
+  connect() {
+    this.active = true;
+    if (this.connected || this.connecting) return this;
+    const generation = ++this.generation;
+    const work = this.user.bind().then(() => {
+      if (generation !== this.generation || !this.active) return;
+      return this.user.channel.request(this.user.key, "socket/connect", {});
+    }).then(() => {
+      if (generation !== this.generation || !this.active) return;
+      this.connected = true;
+      this.fire("connect");
+    }).catch((error) => {
+      if (generation === this.generation && this.active) {
+        if (error?.code === "auth_busy" || error?.code === "unauthorized")
+          this.active = false;
+        this.fire("connect_error", error);
+      }
+    }).finally(() => {
+      if (this.connecting === work) this.connecting = void 0;
+    });
+    this.connecting = work;
+    return this;
+  }
+  disconnect() {
+    this.active = false;
+    this.lost();
+    if (this.user.channel.isConnected)
+      void this.user.channel.request(this.user.key, "socket/disconnect", {}).catch(() => {
+      });
+    return this;
+  }
+  lost() {
+    const wasConnected = this.connected;
+    this.connected = false;
+    this.connecting = void 0;
+    this.generation++;
+    if (wasConnected) this.fire("disconnect", "transport close");
+  }
+  emit(event, ...args) {
+    this.send(event, args);
+    return this;
+  }
+  timeout(timeoutMs) {
+    return {
+      emit: (event, ...args) => {
+        this.send(event, args, timeoutMs);
+        return this;
+      }
+    };
+  }
+  send(event, values, timeoutMs) {
+    const args = [...values];
+    const callback = typeof args.at(-1) === "function" ? args.pop() : void 0;
+    const generation = this.generation;
+    const deadline = Date.now() + (timeoutMs ?? 3e4);
+    const work = (async () => {
+      if (!this.active) throw new Error("Application user disconnected");
+      if (!this.connected) await this.connecting;
+      if (!this.connected || this.generation !== generation)
+        throw new Error("Application user disconnected");
+      const remaining = deadline - Date.now();
+      if (remaining <= 0) throw new Error("Application request timed out");
+      const params = { event, args: encode(args) };
+      if (!callback) {
+        this.user.channel.send({
+          user: this.user.key,
+          method: "socket/event",
+          params
+        });
+        return;
+      }
+      return this.user.channel.request(
+        this.user.key,
+        "socket/event",
+        params,
+        remaining
+      );
+    })();
+    void work.then(
+      (result) => {
+        if (!callback) return;
+        const values2 = decode(result);
+        if (timeoutMs !== void 0) callback?.(null, ...values2);
+        else callback?.(...values2);
+      },
+      (error) => {
+        if (timeoutMs !== void 0) callback?.(error);
+        else if (callback) callback(error);
+      }
+    );
+  }
+};
+var ApplicationProviderSocket = class extends Events {
+  constructor(user) {
+    super();
+    this.user = user;
+  }
+  user;
+  handle = crypto.randomUUID();
+  readyState = WebSocket.CONNECTING;
+  addEventListener(name, listener) {
+    this.on(name, listener);
+  }
+  open() {
+    void this.user.bind().then(
+      () => {
+        if (this.readyState !== WebSocket.CONNECTING) return;
+        this.readyState = WebSocket.OPEN;
+        this.fire("open", new Event("open"));
+      },
+      () => {
+        if (this.readyState !== WebSocket.CLOSED) {
+          this.fire("error", new Event("error"));
+          this.closeLocal();
+        }
+      }
+    );
+  }
+  send(text) {
+    if (this.readyState !== WebSocket.OPEN)
+      throw new Error("Application provider closed");
+    const message = JSON.parse(text);
+    if (message.method === "provider/register") {
+      void this.user.channel.request(this.user.key, "tool/register", {
+        ...message.params,
+        handle: this.handle
+      }).then(
+        (result) => this.message({ jsonrpc: "2.0", id: message.id, result }),
+        (error) => this.message({
+          jsonrpc: "2.0",
+          id: message.id,
+          error: { code: -32001, message: error.message }
+        })
+      );
+    } else
+      this.user.channel.send({
+        method: "tool/result",
+        user: this.user.key,
+        handle: this.handle,
+        message
+      });
+  }
+  message(message) {
+    if (this.readyState === WebSocket.OPEN)
+      this.fire(
+        "message",
+        new MessageEvent("message", { data: JSON.stringify(message) })
+      );
+  }
+  close() {
+    if (this.readyState === WebSocket.CLOSED) return;
+    if (this.user.channel.isConnected)
+      void this.user.channel.request(this.user.key, "tool/unregister", { handle: this.handle }).catch(() => {
+      });
+    this.closeLocal();
+  }
+  closeLocal() {
+    if (this.readyState === WebSocket.CLOSED) return;
+    this.readyState = WebSocket.CLOSED;
+    this.user.providers.delete(this.handle);
+    this.fire("close", new Event("close"));
+    this.removeAllListeners();
+  }
+};
+
 export {
+  SandboxResource,
+  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,
@@ -7557,9 +9052,24 @@ export {
   isAppDevToolUiCard,
   collectInlineToolUiCards,
   collectPreviewToolUiCards,
+  computerState,
+  computerOS,
+  computerPlatformLabel,
+  computerDaemonVersion,
+  sortComputers,
+  ComputersResource,
+  ModelsResource,
+  isLocalConnectorName,
+  ConnectorsResource,
+  SessionStatus,
+  DEFAULT_REPLAY_SPEED,
+  SessionInfo,
+  SessionSetupError,
   isEntryGoneError,
   PluginsResource,
   ChatGroupsResource,
+  syncServerTime,
+  getServerTime,
   authBusyRetryDelayMs,
   AuthBusyReconnect,
   prependOlder,
@@ -7604,6 +9114,7 @@ export {
   AgentSession,
   SessionHub,
   createSocket,
-  BladeClient
+  BladeClient,
+  BladeApplicationClient
 };
-//# sourceMappingURL=chunk-4LJNZA3I.js.map
+//# sourceMappingURL=chunk-SNMDYU6W.js.map