@axiom-lattice/client-sdk 5.0.1 → 7.0.0

package/dist/index.js

@@ -1888,6 +1888,116 @@ var ScheduledTaskStatus = /* @__PURE__ */ ((ScheduledTaskStatus2) => {
 
 // src/abstract-client.ts
 var import_protocols = require("@axiom-lattice/protocols");
+
+// src/sse-parser.ts
+var SseParseError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.code = "INVALID_EVENT";
+    this.name = "SseParseError";
+  }
+};
+async function* parseSseBody(body, options = {}) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let event = "";
+  let id;
+  let retry;
+  let data = [];
+  const dispatch = () => {
+    if (data.length === 0) {
+      event = "";
+      id = void 0;
+      retry = void 0;
+      return void 0;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(data.join("\n"));
+    } catch {
+      throw new SseParseError("Invalid SSE JSON");
+    }
+    if (options.strictJsonObject && (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)))
+      throw new SseParseError("SSE data must be an object");
+    const result = { event, data: parsed, ...id === void 0 ? {} : { id }, ...retry === void 0 ? {} : { retry } };
+    event = "";
+    id = void 0;
+    retry = void 0;
+    data = [];
+    return result;
+  };
+  const processLine = (raw) => {
+    const line = raw.endsWith("\r") ? raw.slice(0, -1) : raw;
+    if (line === "")
+      return dispatch();
+    if (line.startsWith(":"))
+      return void 0;
+    const separator = line.indexOf(":");
+    const field = separator < 0 ? line : line.slice(0, separator);
+    let value = separator < 0 ? "" : line.slice(separator + 1);
+    if (value.startsWith(" "))
+      value = value.slice(1);
+    if (field === "event")
+      event = value;
+    else if (field === "data")
+      data.push(value);
+    else if (field === "id")
+      id = value;
+    else if (field === "retry") {
+      const parsed = Number(value);
+      if (!Number.isInteger(parsed) || parsed < 0 || !Number.isFinite(parsed))
+        throw new SseParseError("Invalid SSE retry");
+      retry = parsed;
+    }
+    return void 0;
+  };
+  try {
+    while (true) {
+      const chunk = await reader.read();
+      if (chunk.done) {
+        buffer += decoder.decode();
+        break;
+      }
+      buffer += decoder.decode(chunk.value, { stream: true });
+      let index = findLineBreak(buffer);
+      while (index >= 0) {
+        if (buffer[index] === "\r" && index === buffer.length - 1)
+          break;
+        const frame2 = processLine(buffer.slice(0, index));
+        buffer = buffer.slice(index + lineBreakLength(buffer, index));
+        if (frame2)
+          yield frame2;
+        index = findLineBreak(buffer);
+      }
+    }
+    if (buffer) {
+      const frame2 = processLine(buffer);
+      if (frame2)
+        yield frame2;
+    }
+    const frame = processLine("");
+    if (frame)
+      yield frame;
+  } finally {
+    await reader.cancel().catch(() => void 0);
+    reader.releaseLock();
+  }
+}
+function findLineBreak(value) {
+  const lf = value.indexOf("\n");
+  const cr = value.indexOf("\r");
+  if (lf < 0)
+    return cr;
+  if (cr < 0)
+    return lf;
+  return Math.min(lf, cr);
+}
+function lineBreakLength(value, index) {
+  return value[index] === "\r" && value[index + 1] === "\n" ? 2 : 1;
+}
+
+// src/abstract-client.ts
 var AbstractClient = class {
   /**
    * Creates a new AbstractClient instance
@@ -1955,7 +2065,7 @@ var AbstractClient = class {
         if (!response.success) {
           throw new Error(response.error || "Failed to enqueue message");
         }
-        return { messageId: response.messageId, queued: response.queued };
+        return { messageId: response.messageId, queued: response.queued, ...response.runId ? { runId: response.runId } : {} };
       },
       /**
        * Sends a message to a thread and streams the response
@@ -2859,6 +2969,300 @@ var AbstractClient = class {
         return response.success;
       }
     };
+    /**
+     * Agent cron resources (`/api/runs/crons` and thread-bound crons).
+     */
+    this.crons = {
+      /**
+       * Creates a cron bound to an existing thread.
+       * @param threadId - Thread that receives follow-up runs.
+       * @param body - Cron definition.
+       * @returns The created cron.
+       */
+      createForThread: async (threadId, body) => {
+        const response = await this.makeRequest(
+          `/api/threads/${threadId}/runs/crons`,
+          { method: "POST", body }
+        );
+        return response.data;
+      },
+      /**
+       * Creates a stateless cron that starts a fresh thread per fire.
+       * @param body - Cron definition including the assistant id.
+       * @returns The created cron.
+       */
+      createStateless: async (body) => {
+        const response = await this.makeRequest(
+          "/api/runs/crons",
+          { method: "POST", body }
+        );
+        return response.data;
+      },
+      /**
+       * Searches tenant-scoped Agent crons.
+       * @param body - Optional assistant/thread/enabled/pagination filters.
+       * @returns Matching crons.
+       */
+      search: async (body = {}) => {
+        const response = await this.makeRequest("/api/runs/crons/search", { method: "POST", body });
+        return response.data.items;
+      },
+      /**
+       * Counts tenant-scoped Agent crons.
+       * @param body - Optional assistant/thread/enabled filters.
+       * @returns Matching cron count.
+       */
+      count: async (body = {}) => {
+        const response = await this.makeRequest("/api/runs/crons/count", { method: "POST", body });
+        return response.data.count;
+      },
+      /**
+       * Reads one Agent cron.
+       * @param cronId - Cron id.
+       * @returns The cron resource.
+       */
+      get: async (cronId) => {
+        const response = await this.makeRequest(
+          `/api/runs/crons/${cronId}`
+        );
+        return response.data;
+      },
+      /**
+       * Pauses or resumes a cron.
+       * @param cronId - Cron id.
+       * @param enabled - Desired enabled state.
+       * @returns The updated cron.
+       */
+      updateEnabled: async (cronId, enabled) => {
+        const body = { enabled };
+        const response = await this.makeRequest(
+          `/api/runs/crons/${cronId}`,
+          { method: "PATCH", body }
+        );
+        return response.data;
+      },
+      /**
+       * Cancels/deletes a cron.
+       * @param cronId - Cron id.
+       * @returns True when the gateway reports success.
+       */
+      delete: async (cronId) => {
+        const response = await this.makeRequest(
+          `/api/runs/crons/${cronId}`,
+          { method: "DELETE" }
+        );
+        return response.success;
+      }
+    };
+    /**
+     * Thread command surface (`run.start`, `input.respond`, `agent.getTree`).
+     */
+    this.commands = {
+      /**
+       * Starts a run on a thread.
+       * @param threadId - Thread id.
+       * @param args - Input/config/metadata/strategy.
+       * @returns Queued message id and mode.
+       */
+      runStart: async (threadId, args) => {
+        const response = await this.makeRequest(
+          `/api/assistants/${this.assistantId}/threads/${threadId}/commands`,
+          { method: "POST", body: { command: "run.start", args } }
+        );
+        return response.data;
+      },
+      /**
+       * Answers a pending interrupt.
+       * @param threadId - Thread id.
+       * @param args - Interrupt id and response/resume payload.
+       * @returns Queued message id and interrupt id.
+       */
+      respond: async (threadId, args) => {
+        const response = await this.makeRequest(
+          `/api/assistants/${this.assistantId}/threads/${threadId}/commands`,
+          { method: "POST", body: { command: "input.respond", args } }
+        );
+        return response.data;
+      },
+      /**
+       * Reads the structured Agent graph.
+       * @param threadId - Thread id.
+       * @returns Nodes, edges, Mermaid, and namespace placeholder.
+       */
+      getTree: async (threadId) => {
+        const response = await this.makeRequest(
+          `/api/assistants/${this.assistantId}/threads/${threadId}/commands`,
+          { method: "POST", body: { command: "agent.getTree" } }
+        );
+        return response.data;
+      }
+    };
+    /**
+     * Single-run surface (`POST/GET /threads/:id/runs`, cancellation).
+     */
+    this.runs = {
+      /**
+       * Enqueues one run-bound input or HITL resume command.
+       * @param threadId - Thread id.
+       * @param input - Message or messages accepted by the run API; omit for command runs.
+       * @param options - Optional config, mode, command, and multitask strategy.
+       * @param assistantId - Assistant id override (defaults to the client's).
+       * @returns Pending run id and the optional input message id.
+       */
+      create: async (threadId, input, options, assistantId) => {
+        const body = {};
+        if (input !== void 0)
+          body.input = input;
+        if (options?.command !== void 0)
+          body.command = options.command;
+        if (options?.config !== void 0)
+          body.config = options.config;
+        if (options?.mode !== void 0)
+          body.mode = options.mode;
+        if (options?.multitaskStrategy !== void 0) {
+          body.multitask_strategy = options.multitaskStrategy;
+        }
+        const response = await this.makeRequest(
+          `/api/assistants/${assistantId ?? this.assistantId}/threads/${threadId}/runs`,
+          { method: "POST", body }
+        );
+        return response.data;
+      },
+      /**
+       * Lists run ledger records for a thread.
+       * @param threadId - Thread id.
+       * @param assistantId - Assistant id override (defaults to the client's).
+       * @returns Safe run records.
+       */
+      list: async (threadId, assistantId) => {
+        const response = await this.makeRequest(
+          `/api/assistants/${assistantId ?? this.assistantId}/threads/${threadId}/runs`
+        );
+        return response.data.runs;
+      },
+      /**
+       * Reads one run ledger record.
+       * @param threadId - Thread id.
+       * @param runId - Run id.
+       * @param assistantId - Assistant id override (defaults to the client's).
+       * @returns The safe run record.
+       */
+      get: async (threadId, runId, assistantId) => {
+        const response = await this.makeRequest(
+          `/api/assistants/${assistantId ?? this.assistantId}/threads/${threadId}/runs/${runId}`
+        );
+        return response.data;
+      },
+      /**
+       * Waits for a run to reach a terminal status (server-capped).
+       * @param threadId - Thread id.
+       * @param runId - Run id.
+       * @param assistantId - Assistant id override (defaults to the client's).
+       * @returns The terminal run record.
+       * @throws {ApiError} On `504 RUN_JOIN_TIMEOUT` or `404 RUN_NOT_FOUND`.
+       */
+      join: async (threadId, runId, assistantId) => {
+        const response = await this.makeRequest(
+          `/api/assistants/${assistantId ?? this.assistantId}/threads/${threadId}/runs/${runId}/join`
+        );
+        return response.data;
+      },
+      /**
+       * Requests cancellation of one run.
+       * @param threadId - Thread id.
+       * @param runId - Run id.
+       * @param options - Optional `wait` and `action` (`interrupt` or `rollback`).
+       * @param assistantId - Assistant id override (defaults to the client's).
+       * @returns Acceptance, terminal status, and optional latest run.
+       */
+      cancel: async (threadId, runId, options, assistantId) => {
+        const params = new URLSearchParams();
+        if (options?.action !== void 0)
+          params.set("action", options.action);
+        if (options?.wait !== void 0)
+          params.set("wait", String(options.wait));
+        const query = params.toString();
+        const response = await this.makeRequest(
+          `/api/assistants/${assistantId ?? this.assistantId}/threads/${threadId}/runs/${runId}/cancel${query ? `?${query}` : ""}`,
+          { method: "POST" }
+        );
+        return response;
+      }
+    };
+    /**
+     * Tenant-scoped namespaced key-value store (viewer/editor surface).
+     */
+    this.store = {
+      /**
+       * Creates or replaces a store item.
+       * @param input - Namespace, key, value, optional TTL/index hint.
+       * @returns The persisted item.
+       */
+      put: async (input) => {
+        const response = await this.makeRequest(
+          "/api/store/items",
+          { method: "PUT", body: input }
+        );
+        return response.data;
+      },
+      /**
+       * Reads one item by namespace and key.
+       * @param namespace - Namespace path.
+       * @param key - Item key.
+       * @returns The item.
+       */
+      get: async (namespace, key) => {
+        const params = namespace.map((segment) => `namespace=${encodeURIComponent(segment)}`).concat(`key=${encodeURIComponent(key)}`).join("&");
+        const response = await this.makeRequest(
+          `/api/store/items?${params}`
+        );
+        return response.data;
+      },
+      /**
+       * Deletes one item.
+       * @param namespace - Namespace path.
+       * @param key - Item key.
+       * @returns True when deleted.
+       */
+      delete: async (namespace, key) => {
+        const response = await this.makeRequest(
+          "/api/store/items",
+          { method: "DELETE", body: { namespace, key } }
+        );
+        return response.data?.deleted === true;
+      },
+      /**
+       * Searches items under a namespace prefix.
+       * @param input - Prefix/filter/query/pagination.
+       * @returns Matching items.
+       */
+      search: async (input = {}) => {
+        const response = await this.makeRequest(
+          "/api/store/items/search",
+          { method: "POST", body: input }
+        );
+        return response.data.items;
+      },
+      /**
+       * Lists distinct namespace paths.
+       * @param prefix - Optional namespace prefix.
+       * @param limit - Optional result cap (gateway clamps).
+       * @returns Namespace paths.
+       */
+      namespaces: async (prefix, limit) => {
+        const response = await this.makeRequest(
+          "/api/store/namespaces",
+          {
+            method: "POST",
+            body: {
+              ...prefix === void 0 ? {} : { prefix },
+              ...limit === void 0 ? {} : { limit }
+            }
+          }
+        );
+        return response.data.namespaces;
+      }
+    };
     this.config = {
       timeout: 3e5,
       // Default timeout
@@ -3235,6 +3639,94 @@ var AbstractClient = class {
     });
     return clonedClient;
   }
+  /**
+   * Headers for thread event SSE requests. Concrete clients may add live
+   * tenant/workspace/auth state.
+   *
+   * @returns Request headers.
+   */
+  getThreadEventHeaders() {
+    return { ...this.config.headers ?? {} };
+  }
+  /**
+   * Stream thread-wide projected events over SSE.
+   *
+   * The caller owns reconnection: pass the last `event.seq` as `since`.
+   * There is no automatic retry. Browser WebSocket auth is not covered here;
+   * this SSE path uses `fetch` and the normal Authorization headers.
+   *
+   * @param threadId - Thread id.
+   * @param options - Channel/namespace/depth filters and resume cursor.
+   * @param onEvent - Callback for each projected event.
+   * @param onError - Callback for stream/cursor errors (stream stops).
+   * @returns Abort function.
+   */
+  streamThreadEvents(threadId, options, onEvent, onError) {
+    const controller = new AbortController();
+    const headers = {
+      "Content-Type": "application/json",
+      Accept: "text/event-stream",
+      ...this.getThreadEventHeaders()
+    };
+    void (async () => {
+      try {
+        const response = await fetch(
+          `${this.config.baseURL}/api/assistants/${this.assistantId}/threads/${threadId}/stream/events`,
+          {
+            method: "POST",
+            headers,
+            body: JSON.stringify(options),
+            signal: controller.signal
+          }
+        );
+        if (!response.ok) {
+          const errorData = await response.json().catch(() => ({}));
+          throw Object.assign(
+            new Error(
+              errorData.error ?? errorData.message ?? `HTTP error! Status: ${response.status}`
+            ),
+            { status: response.status, responseBody: errorData }
+          );
+        }
+        if (!response.body)
+          throw new Error("Response body is null");
+        for await (const frame of parseSseBody(response.body, { strictJsonObject: true })) {
+          if (frame.event === "error") {
+            const data = frame.data;
+            const error = Object.assign(
+              new Error(typeof data.message === "string" ? data.message : "Thread event stream error"),
+              { code: typeof data.code === "string" ? data.code : "stream_error" }
+            );
+            onError?.(error);
+            return;
+          }
+          const event = frame.data;
+          if (event.type === "event") {
+            onEvent(event);
+          } else if (event.type === "error") {
+            const data = event;
+            const error = Object.assign(
+              new Error(typeof data.message === "string" ? data.message : "Thread event stream error"),
+              { code: typeof data.code === "string" ? data.code : "stream_error" }
+            );
+            onError?.(error);
+            return;
+          }
+        }
+      } catch (error) {
+        if (controller.signal.aborted)
+          return;
+        if (error instanceof DOMException && error.name === "AbortError")
+          return;
+        if (error instanceof SseParseError) {
+          onError?.(Object.assign(new Error(error.message), { code: "INVALID_EVENT" }));
+          return;
+        }
+        onError?.(error instanceof Error ? error : new Error(String(error)));
+      }
+    })();
+    return () => controller.abort();
+  }
   /**
    * Abstract method for streaming API requests
    * To be implemented by concrete client classes
@@ -3309,6 +3801,98 @@ var AbstractClient = class {
     );
     return response.data.records;
   }
+  /**
+   * Reads a thread's run status, pending message count, and interrupts.
+   * @param threadId - Thread identifier.
+   * @returns Thread status projection.
+   */
+  async getThreadStatus(threadId) {
+    const response = await this.makeRequest(
+      `/api/assistants/${this.assistantId}/threads/${threadId}/status`
+    );
+    return response.data;
+  }
+  /**
+   * Reads a page of thread checkpoint history.
+   * @param threadId - Thread identifier.
+   * @param options - Optional limit and before-checkpoint cursor.
+   * @returns Checkpoint snapshots, newest first.
+   */
+  async getThreadHistory(threadId, options = {}) {
+    const params = new URLSearchParams();
+    if (options.limit !== void 0)
+      params.append("limit", String(options.limit));
+    if (options.before !== void 0)
+      params.append("before", options.before);
+    const query = params.toString();
+    const response = await this.makeRequest(
+      `/api/assistants/${this.assistantId}/threads/${threadId}/history${query ? `?${query}` : ""}`
+    );
+    return response.data.history;
+  }
+  /**
+   * Reads the raw snapshot at one checkpoint.
+   * @param threadId - Thread identifier.
+   * @param checkpointId - Checkpoint identifier.
+   * @returns The raw checkpoint snapshot.
+   */
+  async getThreadStateAtCheckpoint(threadId, checkpointId) {
+    const response = await this.makeRequest(
+      `/api/assistants/${this.assistantId}/threads/${threadId}/state/${encodeURIComponent(checkpointId)}`
+    );
+    return response.data;
+  }
+  /**
+   * Reads checkpoint storage accounting for a thread.
+   * @param threadId - Thread identifier.
+   * @returns Storage byte/count projection.
+   */
+  async getThreadStorage(threadId) {
+    const response = await this.makeRequest(
+      `/api/assistants/${this.assistantId}/threads/${threadId}/storage`
+    );
+    return response.data;
+  }
+  /**
+   * Copies a thread's checkpoints and row into a new thread.
+   * @param threadId - Source thread identifier.
+   * @returns The created thread.
+   */
+  async copyThread(threadId) {
+    const response = await this.makeRequest(
+      `/api/assistants/${this.assistantId}/threads/${threadId}/copy`,
+      { method: "POST" }
+    );
+    return response.data;
+  }
+  /**
+   * Prunes a thread's checkpoints or deletes the thread.
+   * @param threadId - Thread identifier.
+   * @param input - Prune strategy and optional keep count.
+   * @returns Prune result.
+   */
+  async pruneThread(threadId, input) {
+    const response = await this.makeRequest(
+      `/api/assistants/${this.assistantId}/threads/${threadId}/prune`,
+      { method: "POST", body: input }
+    );
+    return response.data;
+  }
+  /**
+   * Reads the public gateway info surface.
+   * @returns Service identity, flags, capabilities, endpoints, and metadata.
+   */
+  async getInfo() {
+    const response = await this.makeRequest("/info");
+    return response.data;
+  }
+  /**
+   * Reads the current gateway replica's runtime metrics.
+   * @returns Run counts, pending threads, worker posture, and chunk posture.
+   */
+  async getSystemMetrics() {
+    return this.makeRequest("/metrics?format=json");
+  }
   /**
    * Deletes a thread
    * @deprecated Use threads.delete() instead
@@ -3801,6 +4385,7 @@ var ProjectRoomsClient = class {
           method: "POST",
           body: {
             ...target,
+            ...input.interruptId === void 0 ? {} : { interruptId: input.interruptId },
             ...input.answers === void 0 ? {} : { answers: input.answers }
           }
         });
@@ -3936,114 +4521,6 @@ var WorkspaceMembersClient = class {
   }
 };
 
-// src/sse-parser.ts
-var SseParseError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.code = "INVALID_EVENT";
-    this.name = "SseParseError";
-  }
-};
-async function* parseSseBody(body, options = {}) {
-  const reader = body.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
-  let event = "";
-  let id;
-  let retry;
-  let data = [];
-  const dispatch = () => {
-    if (data.length === 0) {
-      event = "";
-      id = void 0;
-      retry = void 0;
-      return void 0;
-    }
-    let parsed;
-    try {
-      parsed = JSON.parse(data.join("\n"));
-    } catch {
-      throw new SseParseError("Invalid SSE JSON");
-    }
-    if (options.strictJsonObject && (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)))
-      throw new SseParseError("SSE data must be an object");
-    const result = { event, data: parsed, ...id === void 0 ? {} : { id }, ...retry === void 0 ? {} : { retry } };
-    event = "";
-    id = void 0;
-    retry = void 0;
-    data = [];
-    return result;
-  };
-  const processLine = (raw) => {
-    const line = raw.endsWith("\r") ? raw.slice(0, -1) : raw;
-    if (line === "")
-      return dispatch();
-    if (line.startsWith(":"))
-      return void 0;
-    const separator = line.indexOf(":");
-    const field = separator < 0 ? line : line.slice(0, separator);
-    let value = separator < 0 ? "" : line.slice(separator + 1);
-    if (value.startsWith(" "))
-      value = value.slice(1);
-    if (field === "event")
-      event = value;
-    else if (field === "data")
-      data.push(value);
-    else if (field === "id")
-      id = value;
-    else if (field === "retry") {
-      const parsed = Number(value);
-      if (!Number.isInteger(parsed) || parsed < 0 || !Number.isFinite(parsed))
-        throw new SseParseError("Invalid SSE retry");
-      retry = parsed;
-    }
-    return void 0;
-  };
-  try {
-    while (true) {
-      const chunk = await reader.read();
-      if (chunk.done) {
-        buffer += decoder.decode();
-        break;
-      }
-      buffer += decoder.decode(chunk.value, { stream: true });
-      let index = findLineBreak(buffer);
-      while (index >= 0) {
-        if (buffer[index] === "\r" && index === buffer.length - 1)
-          break;
-        const frame2 = processLine(buffer.slice(0, index));
-        buffer = buffer.slice(index + lineBreakLength(buffer, index));
-        if (frame2)
-          yield frame2;
-        index = findLineBreak(buffer);
-      }
-    }
-    if (buffer) {
-      const frame2 = processLine(buffer);
-      if (frame2)
-        yield frame2;
-    }
-    const frame = processLine("");
-    if (frame)
-      yield frame;
-  } finally {
-    await reader.cancel().catch(() => void 0);
-    reader.releaseLock();
-  }
-}
-function findLineBreak(value) {
-  const lf = value.indexOf("\n");
-  const cr = value.indexOf("\r");
-  if (lf < 0)
-    return cr;
-  if (cr < 0)
-    return lf;
-  return Math.min(lf, cr);
-}
-function lineBreakLength(value, index) {
-  return value[index] === "\r" && value[index + 1] === "\n" ? 2 : 1;
-}
-
 // src/room-events.ts
 var invalidFrame = (message) => new ProjectRoomClientError(message, 200, "INVALID_EVENT", false);
 var requiredString3 = (row, field) => {
@@ -4181,6 +4658,8 @@ var _Client = class extends AbstractClient {
    */
   constructor(config) {
     super(config);
+    /** Last SSE event id observed per thread, for automatic resume. */
+    this.resumeEventIds = /* @__PURE__ */ new Map();
     this.headers = {
       "Content-Type": "application/json",
       Authorization: `Bearer ${this.config.apiKey}`,
@@ -4204,7 +4683,7 @@ var _Client = class extends AbstractClient {
       } else {
         const errorData = await response.json().catch(() => ({}));
         throw new ApiError(
-          errorData.message || "API Error",
+          errorData.error ?? errorData.message ?? "API Error",
           response.status,
           errorData
         );
@@ -4314,6 +4793,14 @@ var _Client = class extends AbstractClient {
   getWorkspaceHeaders() {
     return { ..._Client.globalWorkspaceHeaders, ...this.workspaceHeaders };
   }
+  /**
+   * Instance-only workspace headers (never merged with the process-global
+   * Console context). Runtime transports use this so a web-app scope cannot
+   * inherit a Console tenant/project selection from another client.
+   */
+  getInstanceWorkspaceHeaders() {
+    return { ...this.workspaceHeaders };
+  }
   /**
    * Get global workspace headers (legacy static API)
    */
@@ -4375,11 +4862,13 @@ var _Client = class extends AbstractClient {
    * @returns A function that can be called to stop the stream
    */
   resumeStream(options, onEvent, onComplete, onError) {
+    const lastEventId = options.lastEventId?.trim() || this.resumeEventIds.get(options.threadId);
     const headers = {
       "Content-Type": "application/json",
       Accept: "text/event-stream",
       ...this.getAllHeaders(),
-      ...(0, import_protocols2.threadAffinityHeaders)(options.threadId)
+      ...(0, import_protocols2.threadAffinityHeaders)(options.threadId),
+      ...lastEventId ? { "Last-Event-ID": lastEventId } : {}
     };
     const controller = new AbortController();
     const { signal } = controller;
@@ -4402,15 +4891,27 @@ var _Client = class extends AbstractClient {
         );
         if (!response.ok) {
           const errorData = await response.json().catch(() => ({}));
-          throw new Error(
-            errorData.error || errorData.message || `HTTP error! Status: ${response.status}`
+          throw Object.assign(
+            new Error(
+              errorData.error || errorData.message || `HTTP error! Status: ${response.status}`
+            ),
+            { status: response.status, responseBody: errorData }
           );
         }
         if (!response.body) {
           throw new Error("Response body is null");
         }
-        for await (const frame of parseSseBody(response.body, { strictJsonObject: true }))
-          onEvent(frame.data);
+        for await (const frame of parseSseBody(response.body, { strictJsonObject: true })) {
+          if (typeof frame.id === "string" && frame.id !== "") {
+            this.resumeEventIds.set(options.threadId, frame.id);
+          }
+          const chunk = frame.data;
+          if (chunk.type === "error" && chunk.data?.code === "CURSOR_EXPIRED") {
+            this.resumeEventIds.delete(options.threadId);
+          }
+          onEvent(chunk);
+        }
+        this.resumeEventIds.delete(options.threadId);
         if (onComplete) {
           onComplete();
         }
@@ -4424,6 +4925,7 @@ var _Client = class extends AbstractClient {
       }
     })();
     return () => {
+      this.resumeEventIds.delete(options.threadId);
       controller.abort();
     };
   }
@@ -4477,6 +4979,9 @@ var _Client = class extends AbstractClient {
       ...workspaceHeaders
     };
   }
+  getThreadEventHeaders() {
+    return this.getAllHeaders();
+  }
   bodyAffinityHeaders(body) {
     if (!body || typeof body !== "object" || body instanceof FormData)
       return {};
@@ -4589,11 +5094,7 @@ var RuntimeAxiomClient = class extends Client {
     return { "X-Axiom-External-User-Id": this.identity.userId };
   }
   getAllHeaders() {
-    const workspace = this.getWorkspaceHeaders();
-    return {
-      ...this.identityHeaders(),
-      ...workspace
-    };
+    return { ...this.identityHeaders() };
   }
   async makeRequest(url, options) {
     await this.primeToken();
@@ -4601,7 +5102,7 @@ var RuntimeAxiomClient = class extends Client {
     const affinity = this.bodyAffinityHeaders(options?.body);
     const headers = {
       "Content-Type": "application/json",
-      ...this.identityHeaders(),
+      ...this.getAllHeaders(),
       ...affinity,
       ...options?.headers ?? {}
     };