@desplega.ai/agent-swarm 2.5.1 → 2.5.3

package/dist/{cli-3qv8naq8.js → cli-p6zs9h4y.js}

@@ -71,7 +71,7 @@ var sleep = (ms, signal) => new Promise((resolve) => {
 });
 
 // node_modules/@anthropic-ai/sdk/version.mjs
-var VERSION = "1.1.0";
+var VERSION = "1.2.0";
 
 // node_modules/@anthropic-ai/sdk/internal/detect-platform.mjs
 var isRunningInBrowser = () => {
@@ -3051,6 +3051,9 @@ var APIPromise = /* @__PURE__ */ (() => {
       _APIPromise_client.set(this, undefined);
       __classPrivateFieldSet(this, _APIPromise_client, client, "f");
     }
+    _responseProps() {
+      return this.responsePromise;
+    }
     _thenUnwrap(transform) {
       return new APIPromise(__classPrivateFieldGet(this, _APIPromise_client, "f"), this.responsePromise, async (client, props) => addResponseIDs(transform(await this.parseResponse(client, props), props), props.response));
     }
@@ -7165,9 +7168,7 @@ function transformOutputFormat(params) {
   if (!params.output_format) {
     return params;
   }
-  if (params.output_config?.format) {
-    throw new AnthropicError("Both output_format and output_config.format were provided. " + "Please use only output_config.format (output_format is deprecated).");
-  }
+  assertOneOutputFormat(params);
   const { output_format, ...rest } = params;
   return {
     ...rest,
@@ -7177,6 +7178,11 @@ function transformOutputFormat(params) {
     }
   };
 }
+function assertOneOutputFormat(params) {
+  if (params.output_format && params.output_config?.format) {
+    throw new AnthropicError("Both output_format and output_config.format were provided. " + "Please use only output_config.format (output_format is deprecated).");
+  }
+}
 
 // node_modules/@anthropic-ai/sdk/lib/BetaMessageStream.mjs
 var _BetaMessageStream_instances;
@@ -7199,6 +7205,7 @@ var _BetaMessageStream_workspace_id;
 var _BetaMessageStream_logger;
 var _BetaMessageStream_client;
 var _BetaMessageStream_span;
+var _BetaMessageStream_spanBody;
 var _BetaMessageStream_getFinalMessage;
 var _BetaMessageStream_getFinalText;
 var _BetaMessageStream_handleError;
@@ -7237,6 +7244,7 @@ var BetaMessageStream = /* @__PURE__ */ (() => {
       _BetaMessageStream_logger.set(this, undefined);
       _BetaMessageStream_client.set(this, undefined);
       _BetaMessageStream_span.set(this, undefined);
+      _BetaMessageStream_spanBody.set(this, undefined);
       _BetaMessageStream_handleError.set(this, (error) => {
         __classPrivateFieldSet(this, _BetaMessageStream_errored, true, "f");
         if (__classPrivateFieldGet(this, _BetaMessageStream_span, "f")) {
@@ -7309,9 +7317,23 @@ var BetaMessageStream = /* @__PURE__ */ (() => {
         runner._addMessageParam(message);
       }
       __classPrivateFieldSet(runner, _BetaMessageStream_params, { ...params, stream: true }, "f");
-      runner._run(() => runner._createMessage(messages, { ...params, stream: true }, { ...options, headers: { ...options?.headers, [STAINLESS_HELPER_METHOD_HEADER]: "stream" } }));
+      runner._run(() => runner._createMessage((body, options) => messages.create(body, options), { ...params, stream: true }, { ...options, headers: { ...options?.headers, [STAINLESS_HELPER_METHOD_HEADER]: "stream" } }));
       return runner;
     }
+    _start(create, params, options, onRequestEnd) {
+      for (const message of params.messages) {
+        this._addMessageParam(message);
+      }
+      const client = __classPrivateFieldGet(this, _BetaMessageStream_client, "f");
+      __classPrivateFieldSet(this, _BetaMessageStream_client, undefined, "f");
+      const send = (body, options) => create(body, options)._thenUnwrap((stream, { options: sent }) => {
+        __classPrivateFieldSet(this, _BetaMessageStream_client, client, "f");
+        __classPrivateFieldSet(this, _BetaMessageStream_span, sent.__span, "f");
+        __classPrivateFieldSet(this, _BetaMessageStream_spanBody, sent.body, "f");
+        return stream;
+      });
+      this._run(() => this._createMessage(send, { ...params, stream: true }, options).finally(onRequestEnd));
+    }
     _run(executor) {
       executor().then(() => {
         this._emitFinal();
@@ -7327,7 +7349,7 @@ var BetaMessageStream = /* @__PURE__ */ (() => {
         this._emit("message", message);
       }
     }
-    async _createMessage(messages, params, options) {
+    async _createMessage(create, params, options) {
       const signal = options?.signal;
       let abortHandler;
       if (signal) {
@@ -7339,7 +7361,7 @@ var BetaMessageStream = /* @__PURE__ */ (() => {
       try {
         __classPrivateFieldGet(this, _BetaMessageStream_instances, "m", _BetaMessageStream_beginRequest).call(this);
         __classPrivateFieldSet(this, _BetaMessageStream_span, options?.__span ?? (__classPrivateFieldGet(this, _BetaMessageStream_client, "f") && startMessagesStreamSpan2(__classPrivateFieldGet(this, _BetaMessageStream_client, "f"), params, options)), "f");
-        const { response, data: stream } = await messages.create({ ...params, stream: true }, { ...options, __span: __classPrivateFieldGet(this, _BetaMessageStream_span, "f"), signal: this.controller.signal }).withResponse();
+        const { response, data: stream } = await create({ ...params, stream: true }, { ...options, __span: __classPrivateFieldGet(this, _BetaMessageStream_span, "f"), signal: this.controller.signal }).withResponse();
         try {
           this._connected(response);
         } catch (error) {
@@ -7501,7 +7523,7 @@ var BetaMessageStream = /* @__PURE__ */ (() => {
         }
       }
     }
-    [(_BetaMessageStream_currentMessageSnapshot = new WeakMap, _BetaMessageStream_params = new WeakMap, _BetaMessageStream_connectedPromise = new WeakMap, _BetaMessageStream_resolveConnectedPromise = new WeakMap, _BetaMessageStream_rejectConnectedPromise = new WeakMap, _BetaMessageStream_endPromise = new WeakMap, _BetaMessageStream_resolveEndPromise = new WeakMap, _BetaMessageStream_rejectEndPromise = new WeakMap, _BetaMessageStream_listeners = new WeakMap, _BetaMessageStream_ended = new WeakMap, _BetaMessageStream_errored = new WeakMap, _BetaMessageStream_aborted = new WeakMap, _BetaMessageStream_catchingPromiseCreated = new WeakMap, _BetaMessageStream_response = new WeakMap, _BetaMessageStream_request_id = new WeakMap, _BetaMessageStream_workspace_id = new WeakMap, _BetaMessageStream_logger = new WeakMap, _BetaMessageStream_client = new WeakMap, _BetaMessageStream_span = new WeakMap, _BetaMessageStream_handleError = new WeakMap, _BetaMessageStream_instances = new WeakSet, _BetaMessageStream_getFinalMessage = function _BetaMessageStream_getFinalMessage2() {
+    [(_BetaMessageStream_currentMessageSnapshot = new WeakMap, _BetaMessageStream_params = new WeakMap, _BetaMessageStream_connectedPromise = new WeakMap, _BetaMessageStream_resolveConnectedPromise = new WeakMap, _BetaMessageStream_rejectConnectedPromise = new WeakMap, _BetaMessageStream_endPromise = new WeakMap, _BetaMessageStream_resolveEndPromise = new WeakMap, _BetaMessageStream_rejectEndPromise = new WeakMap, _BetaMessageStream_listeners = new WeakMap, _BetaMessageStream_ended = new WeakMap, _BetaMessageStream_errored = new WeakMap, _BetaMessageStream_aborted = new WeakMap, _BetaMessageStream_catchingPromiseCreated = new WeakMap, _BetaMessageStream_response = new WeakMap, _BetaMessageStream_request_id = new WeakMap, _BetaMessageStream_workspace_id = new WeakMap, _BetaMessageStream_logger = new WeakMap, _BetaMessageStream_client = new WeakMap, _BetaMessageStream_span = new WeakMap, _BetaMessageStream_spanBody = new WeakMap, _BetaMessageStream_handleError = new WeakMap, _BetaMessageStream_instances = new WeakSet, _BetaMessageStream_getFinalMessage = function _BetaMessageStream_getFinalMessage2() {
       if (this.receivedMessages.length === 0) {
         throw new AnthropicError("stream ended without producing a Message with role=assistant");
       }
@@ -7580,7 +7602,7 @@ var BetaMessageStream = /* @__PURE__ */ (() => {
         }
         case "message_stop": {
           if (__classPrivateFieldGet(this, _BetaMessageStream_client, "f") && __classPrivateFieldGet(this, _BetaMessageStream_span, "f") && __classPrivateFieldGet(this, _BetaMessageStream_params, "f")) {
-            recordStreamedMessageContent(__classPrivateFieldGet(this, _BetaMessageStream_client, "f"), __classPrivateFieldGet(this, _BetaMessageStream_span, "f"), __classPrivateFieldGet(this, _BetaMessageStream_params, "f"), messageSnapshot);
+            recordStreamedMessageContent(__classPrivateFieldGet(this, _BetaMessageStream_client, "f"), __classPrivateFieldGet(this, _BetaMessageStream_span, "f"), __classPrivateFieldGet(this, _BetaMessageStream_spanBody, "f") ?? __classPrivateFieldGet(this, _BetaMessageStream_params, "f"), messageSnapshot);
           }
           this._addMessageParam(messageSnapshot);
           this._addMessage(maybeParseBetaMessage(messageSnapshot, __classPrivateFieldGet(this, _BetaMessageStream_params, "f"), { logger: __classPrivateFieldGet(this, _BetaMessageStream_logger, "f") }), true);
@@ -7593,7 +7615,7 @@ var BetaMessageStream = /* @__PURE__ */ (() => {
         case "message_start": {
           __classPrivateFieldSet(this, _BetaMessageStream_currentMessageSnapshot, messageSnapshot, "f");
           if (__classPrivateFieldGet(this, _BetaMessageStream_span, "f") && __classPrivateFieldGet(this, _BetaMessageStream_params, "f")) {
-            __classPrivateFieldGet(this, _BetaMessageStream_span, "f").streamed = { body: __classPrivateFieldGet(this, _BetaMessageStream_params, "f"), message: messageSnapshot };
+            __classPrivateFieldGet(this, _BetaMessageStream_span, "f").streamed = { body: __classPrivateFieldGet(this, _BetaMessageStream_spanBody, "f") ?? __classPrivateFieldGet(this, _BetaMessageStream_params, "f"), message: messageSnapshot };
           }
           break;
         }
@@ -8301,6 +8323,54 @@ class Connectors extends APIResource {
   }
 }
 
+// node_modules/@anthropic-ai/sdk/resources/beta/organization/analytics/cost.mjs
+class Cost extends APIResource {
+  list(params, options) {
+    const { betas, ...query } = params;
+    return this._client.getAPIList("/v1/organizations/analytics/cost?beta=true", ReportPageCursor, {
+      query,
+      ...options,
+      headers: buildHeaders([
+        { "anthropic-beta": [...betas ?? [], "analytics-usage-cost-2026-08-24"].toString() },
+        options?.headers
+      ]),
+      __span: startApiCallSpan(this._client, "anthropic.organization.analytics.cost.list", options, {
+        route: "/v1/organizations/analytics/cost",
+        queryParams: [
+          "actor_ids",
+          "actor_types",
+          "agent_ids",
+          "api_key_ids",
+          "claude_tag_categories",
+          "claude_tag_user_ids",
+          "context_windows",
+          "deployment_ids",
+          "ending_at",
+          "environment_ids",
+          "exclude_deleted_users",
+          "group_by",
+          "inference_geos",
+          "limit",
+          "models",
+          "order",
+          "order_by",
+          "page",
+          "products",
+          "rbac_group_ids",
+          "service_tiers",
+          "session_ids",
+          "slack_channel_ids",
+          "speeds",
+          "starting_at",
+          "time_bucket_width",
+          "user_profile_ids",
+          "workspace_ids"
+        ]
+      })
+    });
+  }
+}
+
 // node_modules/@anthropic-ai/sdk/resources/beta/organization/analytics/cost-report.mjs
 class CostReport extends APIResource {
   list(query, options) {
@@ -8396,6 +8466,54 @@ class Summaries extends APIResource {
   }
 }
 
+// node_modules/@anthropic-ai/sdk/resources/beta/organization/analytics/usage.mjs
+class Usage extends APIResource {
+  list(params, options) {
+    const { betas, ...query } = params;
+    return this._client.getAPIList("/v1/organizations/analytics/usage?beta=true", ReportPageCursor, {
+      query,
+      ...options,
+      headers: buildHeaders([
+        { "anthropic-beta": [...betas ?? [], "analytics-usage-cost-2026-08-24"].toString() },
+        options?.headers
+      ]),
+      __span: startApiCallSpan(this._client, "anthropic.organization.analytics.usage.list", options, {
+        route: "/v1/organizations/analytics/usage",
+        queryParams: [
+          "actor_ids",
+          "actor_types",
+          "agent_ids",
+          "api_key_ids",
+          "claude_tag_categories",
+          "claude_tag_user_ids",
+          "context_windows",
+          "deployment_ids",
+          "ending_at",
+          "environment_ids",
+          "exclude_deleted_users",
+          "group_by",
+          "inference_geos",
+          "limit",
+          "models",
+          "order",
+          "order_by",
+          "page",
+          "products",
+          "rbac_group_ids",
+          "service_tiers",
+          "session_ids",
+          "slack_channel_ids",
+          "speeds",
+          "starting_at",
+          "time_bucket_width",
+          "user_profile_ids",
+          "workspace_ids"
+        ]
+      })
+    });
+  }
+}
+
 // node_modules/@anthropic-ai/sdk/resources/beta/organization/analytics/usage-report.mjs
 class UsageReport extends APIResource {
   list(query, options) {
@@ -8580,6 +8698,8 @@ var Analytics = /* @__PURE__ */ (() => {
       this.plugins = new Plugins(this._client);
       this.skills = new Skills(this._client);
       this.artifacts = new Artifacts(this._client);
+      this.usage = new Usage(this._client);
+      this.cost = new Cost(this._client);
       this.usageReport = new UsageReport(this._client);
       this.userUsageReport = new UserUsageReport(this._client);
       this.costReport = new CostReport(this._client);
@@ -8593,6 +8713,8 @@ var Analytics = /* @__PURE__ */ (() => {
   Analytics.Plugins = Plugins;
   Analytics.Skills = Skills;
   Analytics.Artifacts = Artifacts;
+  Analytics.Usage = Usage;
+  Analytics.Cost = Cost;
   Analytics.UsageReport = UsageReport;
   Analytics.UserUsageReport = UserUsageReport;
   Analytics.CostReport = CostReport;
@@ -11162,14 +11284,6 @@ var BetaToolRunnerStream = /* @__PURE__ */ (() => {
     get toolCalls() {
       return __classPrivateFieldGet(this, _BetaToolRunnerStream_toolCalls, "f");
     }
-    static start(client, params, options, onToolCall) {
-      const stream = new BetaToolRunnerStream({ ...params, stream: true }, onToolCall, client);
-      for (const message of params.messages) {
-        stream._addMessageParam(message);
-      }
-      stream._run(() => stream._createMessage(client.beta.messages, { ...params, stream: true }, { ...options, headers: { ...options?.headers, [STAINLESS_HELPER_METHOD_HEADER]: "stream" } }));
-      return stream;
-    }
     _deliverEvent(event, snapshot) {
       var _a;
       __classPrivateFieldSet(this, _BetaToolRunnerStream_emitted, (_a = __classPrivateFieldGet(this, _BetaToolRunnerStream_emitted, "f"), _a++, _a), "f");
@@ -11249,12 +11363,422 @@ var BetaToolRunnerStream = /* @__PURE__ */ (() => {
   return BetaToolRunnerStream;
 })();
 
+// node_modules/@anthropic-ai/sdk/lib/internal/threads/ThreadState.mjs
+var _ThreadState_instances;
+var _ThreadState_fields;
+var _ThreadState_stored;
+var _ThreadState_staged;
+var _ThreadState_anchor;
+var _ThreadState_turn;
+var _ThreadState_logger;
+var _ThreadState_lastReply_get;
+var _ThreadState_repeatsLastReply;
+var _ThreadState_startNewThread;
+var _ThreadState_retryPartialTurn;
+var _ThreadState_dropsRefusedTurn;
+var _ThreadState_storeTurn;
+var _ThreadState_adoptContainer;
+var _ThreadState_checkCreateOnly;
+var _ThreadState_requestOptions;
+
+class Turn {
+  constructor(fields, ownMessages, ownCreateOnly) {
+    this.fields = fields;
+    this.ownMessages = ownMessages;
+    this.ownCreateOnly = ownCreateOnly;
+    this.deferredMessages = [];
+    this.replacementHistory = null;
+    this.createOnly = createOnlyJSON(fields);
+  }
+}
+var ThreadState = /* @__PURE__ */ (() => {
+
+  class ThreadState {
+    constructor({ params, options, threading, logger }) {
+      _ThreadState_instances.add(this);
+      _ThreadState_fields.set(this, undefined);
+      _ThreadState_stored.set(this, []);
+      _ThreadState_staged.set(this, []);
+      _ThreadState_anchor.set(this, undefined);
+      _ThreadState_turn.set(this, null);
+      _ThreadState_logger.set(this, undefined);
+      const { messages, unsupportedRequestBehavior, ...fields } = params;
+      rejectThreadField(fields);
+      this.options = options;
+      this.unsupportedRequestBehavior = unsupportedRequestBehavior ?? "error";
+      __classPrivateFieldSet(this, _ThreadState_fields, fields, "f");
+      __classPrivateFieldSet(this, _ThreadState_anchor, threading ? { type: "create", replacesLostThread: false } : { type: "never_threaded" }, "f");
+      __classPrivateFieldSet(this, _ThreadState_logger, logger, "f");
+      this.push(messages ?? []);
+    }
+    get threading() {
+      return __classPrivateFieldGet(this, _ThreadState_anchor, "f").type === "create" || __classPrivateFieldGet(this, _ThreadState_anchor, "f").type === "continue";
+    }
+    get previousMessageId() {
+      return __classPrivateFieldGet(this, _ThreadState_anchor, "f").type === "continue" ? __classPrivateFieldGet(this, _ThreadState_anchor, "f").previousMessageId : null;
+    }
+    get messages() {
+      const messages = __classPrivateFieldGet(this, _ThreadState_turn, "f")?.replacementHistory?.slice() ?? [...__classPrivateFieldGet(this, _ThreadState_stored, "f"), ...__classPrivateFieldGet(this, _ThreadState_staged, "f")].map((entry) => entry.param);
+      if (__classPrivateFieldGet(this, _ThreadState_turn, "f"))
+        messages.push(...__classPrivateFieldGet(this, _ThreadState_turn, "f").deferredMessages.map(toMessageParam));
+      return messages;
+    }
+    get params() {
+      const ownCreateOnly = __classPrivateFieldGet(this, _ThreadState_anchor, "f").type === "create" ? __classPrivateFieldGet(this, _ThreadState_turn, "f")?.ownCreateOnly : undefined;
+      return { ...__classPrivateFieldGet(this, _ThreadState_fields, "f"), ...ownCreateOnly, messages: this.messages };
+    }
+    push(messages) {
+      if (__classPrivateFieldGet(this, _ThreadState_turn, "f")) {
+        __classPrivateFieldGet(this, _ThreadState_turn, "f").deferredMessages.push(...messages);
+        return;
+      }
+      for (const message of messages) {
+        if (__classPrivateFieldGet(this, _ThreadState_instances, "m", _ThreadState_repeatsLastReply).call(this, message))
+          continue;
+        __classPrivateFieldGet(this, _ThreadState_staged, "f").push({ param: toMessageParam(message), reply: null });
+      }
+    }
+    update(fields = {}, options = {}) {
+      rejectThreadField(fields);
+      __classPrivateFieldSet(this, _ThreadState_fields, { ...__classPrivateFieldGet(this, _ThreadState_fields, "f"), ...definedEntries(fields) }, "f");
+      this.options = { ...this.options, ...definedEntries(options) };
+      for (const field of CREATE_ONLY_FIELDS) {
+        if (fields[field] !== undefined)
+          delete __classPrivateFieldGet(this, _ThreadState_turn, "f")?.ownCreateOnly[field];
+      }
+    }
+    fork(fields = __classPrivateFieldGet(this, _ThreadState_fields, "f")) {
+      const fork = new ThreadState({
+        params: { ...fields, unsupportedRequestBehavior: this.unsupportedRequestBehavior },
+        options: this.options,
+        threading: __classPrivateFieldGet(this, _ThreadState_anchor, "f").type !== "never_threaded",
+        logger: __classPrivateFieldGet(this, _ThreadState_logger, "f")
+      });
+      if (!this.threading)
+        fork.stopThreading();
+      if (__classPrivateFieldGet(this, _ThreadState_turn, "f")?.replacementHistory) {
+        __classPrivateFieldSet(fork, _ThreadState_staged, __classPrivateFieldGet(this, _ThreadState_turn, "f").replacementHistory.map((param) => ({ param, reply: null })), "f");
+      } else {
+        __classPrivateFieldSet(fork, _ThreadState_stored, [...__classPrivateFieldGet(this, _ThreadState_stored, "f")], "f");
+        __classPrivateFieldSet(fork, _ThreadState_staged, [...__classPrivateFieldGet(this, _ThreadState_staged, "f")], "f");
+      }
+      if (__classPrivateFieldGet(this, _ThreadState_turn, "f"))
+        fork.push(__classPrivateFieldGet(this, _ThreadState_turn, "f").deferredMessages);
+      return fork;
+    }
+    setParams({ messages, ...fields }) {
+      __classPrivateFieldSet(this, _ThreadState_fields, fields, "f");
+      if (__classPrivateFieldGet(this, _ThreadState_turn, "f"))
+        __classPrivateFieldGet(this, _ThreadState_turn, "f").ownCreateOnly = {};
+      this.setMessages(messages);
+    }
+    setMessages(messages) {
+      const entries = [...__classPrivateFieldGet(this, _ThreadState_stored, "f"), ...__classPrivateFieldGet(this, _ThreadState_staged, "f")];
+      if (__classPrivateFieldGet(this, _ThreadState_turn, "f")) {
+        const sent = entries.map((entry) => entry.param);
+        if (startsWith(messages, sent)) {
+          __classPrivateFieldGet(this, _ThreadState_turn, "f").replacementHistory = null;
+          __classPrivateFieldGet(this, _ThreadState_turn, "f").deferredMessages = messages.slice(sent.length);
+        } else {
+          __classPrivateFieldGet(this, _ThreadState_turn, "f").replacementHistory = messages;
+          __classPrivateFieldGet(this, _ThreadState_turn, "f").deferredMessages = [];
+        }
+        return;
+      }
+      if (!startsWith(messages, __classPrivateFieldGet(this, _ThreadState_stored, "f").map((entry) => entry.param))) {
+        __classPrivateFieldSet(this, _ThreadState_stored, [], "f");
+        if (this.threading)
+          __classPrivateFieldSet(this, _ThreadState_anchor, { type: "create", replacesLostThread: false }, "f");
+      }
+      __classPrivateFieldSet(this, _ThreadState_staged, [], "f");
+      const replies = new Map(entries.filter((entry) => entry.reply).map((entry) => [entry.param.content, entry]));
+      for (const message of messages.slice(__classPrivateFieldGet(this, _ThreadState_stored, "f").length)) {
+        if (__classPrivateFieldGet(this, _ThreadState_instances, "m", _ThreadState_repeatsLastReply).call(this, message))
+          continue;
+        __classPrivateFieldGet(this, _ThreadState_staged, "f").push({
+          ...replies.get(message.content) ?? { reply: null },
+          param: toMessageParam(message)
+        });
+      }
+    }
+    get hasTurnToSend() {
+      return __classPrivateFieldGet(this, _ThreadState_staged, "f").length > 0 || isUnfinishedStopReason(__classPrivateFieldGet(this, _ThreadState_stored, "f").at(-1)?.reply?.stop_reason);
+    }
+    startTurn(messages, fields) {
+      if (__classPrivateFieldGet(this, _ThreadState_turn, "f")) {
+        throw new AnthropicError("Another `send()`, `parse()` or `stream()` is already in progress on this thread");
+      }
+      rejectThreadField(fields);
+      const alreadyStaged = __classPrivateFieldGet(this, _ThreadState_staged, "f").length;
+      this.push(messages);
+      const ownMessages = __classPrivateFieldGet(this, _ThreadState_staged, "f").slice(alreadyStaged);
+      __classPrivateFieldGet(this, _ThreadState_instances, "m", _ThreadState_retryPartialTurn).call(this);
+      const ownCreateOnly = {};
+      if (fields.system !== undefined)
+        ownCreateOnly.system = fields.system;
+      if (fields.tools !== undefined)
+        ownCreateOnly.tools = fields.tools;
+      return __classPrivateFieldSet(this, _ThreadState_turn, new Turn({ ...__classPrivateFieldGet(this, _ThreadState_fields, "f"), ...definedEntries(fields) }, ownMessages, ownCreateOnly), "f");
+    }
+    endTurn(turn) {
+      __classPrivateFieldSet(this, _ThreadState_turn, null, "f");
+      __classPrivateFieldSet(this, _ThreadState_staged, __classPrivateFieldGet(this, _ThreadState_staged, "f").filter((entry) => !turn.ownMessages.includes(entry)), "f");
+      if (turn.replacementHistory)
+        this.setMessages(turn.replacementHistory);
+      this.push(turn.deferredMessages);
+    }
+    recoversFrom(error) {
+      if (!(error instanceof APIError))
+        return false;
+      const continuesUnthreaded = this.unsupportedRequestBehavior === "continue_unthreaded";
+      const reason = replayReason(error);
+      if (reason !== null && __classPrivateFieldGet(this, _ThreadState_anchor, "f").type === "continue") {
+        if (reason === "thread_not_found" && __classPrivateFieldGet(this, _ThreadState_anchor, "f").replacesLostThread && continuesUnthreaded) {
+          __classPrivateFieldGet(this, _ThreadState_logger, "f").info(`The server lost the thread again right after a replay; continuing without a thread: previous_message_id=${__classPrivateFieldGet(this, _ThreadState_anchor, "f").previousMessageId}`);
+          this.stopThreading();
+        } else {
+          __classPrivateFieldGet(this, _ThreadState_instances, "m", _ThreadState_startNewThread).call(this, reason);
+        }
+        return true;
+      }
+      const unsupported = unsupportedFeatures(error);
+      if (unsupported !== null && this.threading && continuesUnthreaded) {
+        __classPrivateFieldGet(this, _ThreadState_logger, "f").info(`The server cannot thread this request; continuing without a thread: unsupported=${unsupported.join(",")}`);
+        this.stopThreading();
+        return true;
+      }
+      return false;
+    }
+    stopThreading() {
+      if (this.threading)
+        __classPrivateFieldSet(this, _ThreadState_anchor, { type: "unthreaded" }, "f");
+    }
+    recordPartialReply(snapshot, completedBlocks) {
+      if (__classPrivateFieldGet(this, _ThreadState_instances, "m", _ThreadState_dropsRefusedTurn).call(this, snapshot))
+        return;
+      __classPrivateFieldGet(this, _ThreadState_instances, "m", _ThreadState_storeTurn).call(this, partialReply(snapshot, completedBlocks), { partial: true });
+      if (this.previousMessageId !== null) {
+        __classPrivateFieldGet(this, _ThreadState_instances, "m", _ThreadState_startNewThread).call(this, "stream_ended_before_message_stop");
+      }
+    }
+    recordReply(turn, message) {
+      if (__classPrivateFieldGet(this, _ThreadState_instances, "m", _ThreadState_dropsRefusedTurn).call(this, message))
+        return;
+      __classPrivateFieldGet(this, _ThreadState_instances, "m", _ThreadState_storeTurn).call(this, message, { partial: false });
+      if (__classPrivateFieldGet(this, _ThreadState_anchor, "f").type === "create") {
+        __classPrivateFieldSet(this, _ThreadState_fields, { ...__classPrivateFieldGet(this, _ThreadState_fields, "f"), ...turn.ownCreateOnly }, "f");
+      }
+      if (this.threading) {
+        __classPrivateFieldSet(this, _ThreadState_anchor, {
+          type: "continue",
+          previousMessageId: message.id,
+          createdWith: turn.createOnly,
+          replacesLostThread: __classPrivateFieldGet(this, _ThreadState_anchor, "f").type === "create" && __classPrivateFieldGet(this, _ThreadState_anchor, "f").replacesLostThread
+        }, "f");
+        if (message.usage.iterations?.some((iteration) => iteration.type === "fallback_message")) {
+          __classPrivateFieldGet(this, _ThreadState_instances, "m", _ThreadState_startNewThread).call(this, "fallback_message");
+        }
+      }
+      if (message.container) {
+        __classPrivateFieldGet(this, _ThreadState_instances, "m", _ThreadState_adoptContainer).call(this, message.container.id);
+      }
+    }
+    buildCreateArguments(turn, options, { stream }) {
+      __classPrivateFieldGet(this, _ThreadState_instances, "m", _ThreadState_checkCreateOnly).call(this, turn.createOnly);
+      const anchor = __classPrivateFieldGet(this, _ThreadState_anchor, "f");
+      let stored = anchor.type === "continue" ? [] : __classPrivateFieldGet(this, _ThreadState_stored, "f").map((entry) => entry.param);
+      if (anchor.type !== "never_threaded") {
+        const answered = __classPrivateFieldGet(this, _ThreadState_stored, "f").map((entry) => entry.reply !== null).lastIndexOf(true) + 1;
+        stored = stored.map((message, i) => i < answered ? withoutCacheControl(message) : message);
+      }
+      const params = {
+        ...turn.fields,
+        messages: [...stored, ...__classPrivateFieldGet(this, _ThreadState_staged, "f").map((entry) => entry.param)]
+      };
+      if (this.threading && !params.betas?.includes(MESSAGE_THREADS_BETA)) {
+        params.betas = [...params.betas ?? [], MESSAGE_THREADS_BETA];
+      }
+      if (anchor.type === "create") {
+        params.thread = { type: "create" };
+      } else if (anchor.type === "continue") {
+        params.thread = { type: "continue", previous_message_id: anchor.previousMessageId };
+        for (const field of CREATE_ONLY_FIELDS)
+          delete params[field];
+      }
+      return { params, options: __classPrivateFieldGet(this, _ThreadState_instances, "m", _ThreadState_requestOptions).call(this, options, { stream }) };
+    }
+    checkNextTurn(fields) {
+      __classPrivateFieldGet(this, _ThreadState_instances, "m", _ThreadState_checkCreateOnly).call(this, createOnlyJSON({ ...__classPrivateFieldGet(this, _ThreadState_fields, "f"), ...definedEntries(fields) }));
+    }
+  }
+  _ThreadState_fields = new WeakMap, _ThreadState_stored = new WeakMap, _ThreadState_staged = new WeakMap, _ThreadState_anchor = new WeakMap, _ThreadState_turn = new WeakMap, _ThreadState_logger = new WeakMap, _ThreadState_instances = new WeakSet, _ThreadState_lastReply_get = function _ThreadState_lastReply_get() {
+    for (const entries of [__classPrivateFieldGet(this, _ThreadState_staged, "f"), __classPrivateFieldGet(this, _ThreadState_stored, "f")]) {
+      for (let i = entries.length - 1;i >= 0; i--) {
+        if (entries[i].reply)
+          return entries[i].reply;
+      }
+    }
+    return null;
+  }, _ThreadState_repeatsLastReply = function _ThreadState_repeatsLastReply(message) {
+    if ("id" in message)
+      return message.id === __classPrivateFieldGet(this, _ThreadState_instances, "a", _ThreadState_lastReply_get)?.id;
+    const last = __classPrivateFieldGet(this, _ThreadState_staged, "f").at(-1) ?? __classPrivateFieldGet(this, _ThreadState_stored, "f").at(-1);
+    return last?.reply != null && sameMessage(message, last.param);
+  }, _ThreadState_startNewThread = function _ThreadState_startNewThread(reason) {
+    __classPrivateFieldGet(this, _ThreadState_logger, "f").info(`Replaying the full message history under a new thread: reason=${reason} previous_message_id=${this.previousMessageId}`);
+    __classPrivateFieldSet(this, _ThreadState_anchor, { type: "create", replacesLostThread: reason === "thread_not_found" }, "f");
+  }, _ThreadState_retryPartialTurn = function _ThreadState_retryPartialTurn() {
+    const tail = __classPrivateFieldGet(this, _ThreadState_stored, "f").at(-1);
+    if (__classPrivateFieldGet(this, _ThreadState_staged, "f").length || !tail || tail.reply && !tail.partial)
+      return;
+    if (tail.reply)
+      __classPrivateFieldGet(this, _ThreadState_stored, "f").pop();
+    let turnStart = __classPrivateFieldGet(this, _ThreadState_stored, "f").length;
+    while (turnStart > 0 && !__classPrivateFieldGet(this, _ThreadState_stored, "f")[turnStart - 1].reply)
+      turnStart -= 1;
+    __classPrivateFieldSet(this, _ThreadState_staged, __classPrivateFieldGet(this, _ThreadState_stored, "f").splice(turnStart), "f");
+    __classPrivateFieldGet(this, _ThreadState_logger, "f").info(`Re-sending the turn whose reply ended before \`message_stop\`: partial_reply_id=${tail.reply?.id ?? null}`);
+  }, _ThreadState_dropsRefusedTurn = function _ThreadState_dropsRefusedTurn(reply) {
+    if (reply.stop_reason !== "refusal" || __classPrivateFieldGet(this, _ThreadState_anchor, "f").type === "never_threaded")
+      return false;
+    if (this.previousMessageId !== null)
+      __classPrivateFieldGet(this, _ThreadState_instances, "m", _ThreadState_startNewThread).call(this, "refusal");
+    return true;
+  }, _ThreadState_storeTurn = function _ThreadState_storeTurn(reply, { partial }) {
+    __classPrivateFieldGet(this, _ThreadState_stored, "f").push(...__classPrivateFieldGet(this, _ThreadState_staged, "f"));
+    __classPrivateFieldSet(this, _ThreadState_staged, [], "f");
+    if (reply)
+      __classPrivateFieldGet(this, _ThreadState_stored, "f").push({ param: toMessageParam(reply), reply, partial });
+  }, _ThreadState_adoptContainer = function _ThreadState_adoptContainer(containerId) {
+    const { container } = __classPrivateFieldGet(this, _ThreadState_fields, "f");
+    if (container == null) {
+      __classPrivateFieldSet(this, _ThreadState_fields, { ...__classPrivateFieldGet(this, _ThreadState_fields, "f"), container: containerId }, "f");
+    } else if (typeof container === "object" && container.id == null) {
+      __classPrivateFieldSet(this, _ThreadState_fields, { ...__classPrivateFieldGet(this, _ThreadState_fields, "f"), container: { ...container, id: containerId } }, "f");
+    }
+  }, _ThreadState_checkCreateOnly = function _ThreadState_checkCreateOnly(createOnly) {
+    if (__classPrivateFieldGet(this, _ThreadState_anchor, "f").type !== "continue")
+      return;
+    const { createdWith } = __classPrivateFieldGet(this, _ThreadState_anchor, "f");
+    const changed = CREATE_ONLY_FIELDS.filter((field) => createOnly[field] !== createdWith[field]);
+    if (changed.length) {
+      const names = changed.map((field) => `\`${field}\``).join(" and ");
+      throw new AnthropicError(`Cannot change ${names} on a thread: the server keeps the \`system\` and \`tools\` the thread was created ` + "with. To change them, start a new thread from `thread.params`." + (changed.includes("tools") ? " To add or remove tools on this thread, send `tool_addition` or `tool_removal` blocks in a " + "`system` message." : ""));
+    }
+  }, _ThreadState_requestOptions = function _ThreadState_requestOptions(overrides, { stream }) {
+    const options = { ...this.options, ...definedEntries(overrides) };
+    if (stream) {
+      options.headers = buildHeaders([{ [STAINLESS_HELPER_METHOD_HEADER]: "stream" }, options.headers]);
+    }
+    if (__classPrivateFieldGet(this, _ThreadState_anchor, "f").type !== "never_threaded") {
+      options.headers = buildHeaders([options.headers, helperHeader("message-thread")]);
+    }
+    if (this.threading) {
+      options.headers = withThreadsBeta(options.headers);
+    }
+    return options;
+  };
+  return ThreadState;
+})();
+var UNFINISHED_STOP_REASONS = ["pause_turn", "compaction"];
+function isUnfinishedStopReason(stopReason) {
+  return UNFINISHED_STOP_REASONS.some((unfinished) => unfinished === stopReason);
+}
+var MESSAGE_THREADS_BETA = "message-threads-2026-08-12";
+var CREATE_ONLY_FIELDS = ["system", "tools"];
+function createOnlyJSON(fields) {
+  return { system: JSON.stringify(fields.system), tools: JSON.stringify(fields.tools) };
+}
+function withThreadsBeta(headers) {
+  const callerBetas = buildHeaders([headers]).values.get("anthropic-beta");
+  if (callerBetas === null)
+    return headers;
+  return buildHeaders([headers, { "anthropic-beta": appendHeaderValue(callerBetas, MESSAGE_THREADS_BETA) }]);
+}
+function replayReason(error) {
+  const errorCode = errorDetails(error)?.["error_code"];
+  return REPLAY_ERROR_CODES.find((code) => code === errorCode) ?? null;
+}
+var REPLAY_ERROR_CODES = [
+  "thread_not_found",
+  "thread_already_continued",
+  "thread_continue_in_flight"
+];
+function unsupportedFeatures(error) {
+  const details = errorDetails(error);
+  if (details?.["error_code"] !== "thread_unsupported_request")
+    return null;
+  const unsupported = details["unsupported"];
+  return Array.isArray(unsupported) ? unsupported.map(String) : [];
+}
+function errorDetails(error) {
+  const body = error.error;
+  const details = body?.error?.details;
+  return isObj(details) ? details : null;
+}
+function rejectThreadField(fields) {
+  if ("thread" in fields && fields.thread !== undefined) {
+    throw new TypeError("`thread` cannot be set here. The message thread sets it for each request itself.");
+  }
+}
+function definedEntries(object) {
+  return Object.fromEntries(Object.entries(object).filter(([, value]) => value !== undefined));
+}
+function partialReply(snapshot, completedBlocks) {
+  const content = snapshot.content.slice(0, completedBlocks);
+  const unfinished = snapshot.content[completedBlocks];
+  if (unfinished?.type === "text" && unfinished.text)
+    content.push(unfinished);
+  return content.length ? { ...snapshot, content } : null;
+}
+function withoutCacheControl(value) {
+  if (!isObj(value))
+    return value;
+  const { cache_control, ...copy } = value;
+  for (const key of ["content", "source", "tool", "definition", "tool_references"]) {
+    const nested = copy[key];
+    if (Array.isArray(nested))
+      copy[key] = nested.map(withoutCacheControl);
+    else if (isObj(nested))
+      copy[key] = withoutCacheControl(nested);
+  }
+  return copy;
+}
+function startsWith(messages, prefix) {
+  return prefix.length <= messages.length && prefix.every((message, i) => sameMessage(message, messages[i]));
+}
+function sameMessage(a, b) {
+  const [left, right] = [toMessageParam(a), toMessageParam(b)];
+  const keys = Object.keys({ ...left, ...right });
+  return keys.every((key) => left[key] === right[key] || JSON.stringify(left[key]) === JSON.stringify(right[key]));
+}
+function toMessageParam(message) {
+  return "id" in message ? { role: message.role, content: message.content } : message;
+}
+function toMessageList(input) {
+  if (input === undefined)
+    return [];
+  return isReadonlyArray(input) ? input : [input];
+}
+
+// node_modules/@anthropic-ai/sdk/lib/internal/threads/tool-runner-params.mjs
+function splitToolRunnerParams(params) {
+  const { stream, max_iterations, runToolsEagerly, thread, ...threadParams } = params;
+  if (thread !== undefined && thread !== false) {
+    throw new TypeError("`thread` cannot be set in the params of a tool runner. The runner sets it for each request itself. " + "To run without a message thread, pass `thread: false`.");
+  }
+  return { settings: { stream, max_iterations, runToolsEagerly }, thread, threadParams };
+}
+
 // node_modules/@anthropic-ai/sdk/lib/tools/BetaToolRunner.mjs
 var _BetaToolRunner_instances;
 var _BetaToolRunner_consumed;
 var _BetaToolRunner_mutated;
-var _BetaToolRunner_state;
+var _BetaToolRunner_thread;
+var _BetaToolRunner_settings;
 var _BetaToolRunner_options;
+var _BetaToolRunner_helperHeader;
+var _BetaToolRunner_messagesWithoutReply;
 var _BetaToolRunner_message;
 var _BetaToolRunner_stream;
 var _BetaToolRunner_toolResponse;
@@ -11268,15 +11792,18 @@ var _BetaToolRunner_toolOverrides;
 var _BetaToolRunner_pendingToolChanges;
 var _BetaToolRunner_withToolRunnerSpan;
 var _BetaToolRunner_send;
+var _BetaToolRunner_turnOptions;
 var _BetaToolRunner_streamThatStartsTools;
 var _BetaToolRunner_startedCallsSettled;
 var _BetaToolRunner_compact;
+var _BetaToolRunner_compactionThread;
 var _BetaToolRunner_runnableTools;
 var _BetaToolRunner_availableToolNames;
 var _BetaToolRunner_recordRemovalsFromHistory;
 var _BetaToolRunner_compactAfterFinalTurn;
 var _BetaToolRunner_generateToolResponse;
 var _BetaToolRunner_toolsetFamilies;
+var _BetaToolRunner_toolsetParams;
 var _BetaToolRunner_flushPendingToolChanges;
 var _BetaToolRunner_pendingToolChangesMessage;
 var USE_A_NEW_RUNNER = "a tool runner's toolsets come only from its tools param; change them with setMessagesParams(), or build a new runner";
@@ -11284,13 +11811,15 @@ var REMOVE_WITH_A_NEW_RUNNER = "a tool runner's toolsets come only from its tool
 var BetaToolRunner2 = /* @__PURE__ */ (() => {
 
   class BetaToolRunner {
-    constructor(client, params, options) {
+    constructor(clientOrThread, paramsOrSettings, options) {
       _BetaToolRunner_instances.add(this);
-      this.client = client;
       _BetaToolRunner_consumed.set(this, false);
       _BetaToolRunner_mutated.set(this, false);
-      _BetaToolRunner_state.set(this, undefined);
+      _BetaToolRunner_thread.set(this, undefined);
+      _BetaToolRunner_settings.set(this, undefined);
       _BetaToolRunner_options.set(this, undefined);
+      _BetaToolRunner_helperHeader.set(this, undefined);
+      _BetaToolRunner_messagesWithoutReply.set(this, undefined);
       _BetaToolRunner_message.set(this, undefined);
       _BetaToolRunner_stream.set(this, undefined);
       _BetaToolRunner_toolResponse.set(this, undefined);
@@ -11302,26 +11831,24 @@ var BetaToolRunner2 = /* @__PURE__ */ (() => {
       _BetaToolRunner_lastStopReason.set(this, null);
       _BetaToolRunner_toolOverrides.set(this, new Map);
       _BetaToolRunner_pendingToolChanges.set(this, []);
-      rejectCompactionParam(params);
-      rejectRunToolsEagerlyWithoutStream(params);
-      __classPrivateFieldSet(this, _BetaToolRunner_state, {
-        params: {
-          ...params,
-          messages: JSON.parse(JSON.stringify(withToolDefinitions(params.messages)))
-        }
-      }, "f");
-      const collected = collectStainlessHelpers(params.tools, params.messages);
-      __classPrivateFieldSet(this, _BetaToolRunner_options, {
-        ...options,
-        headers: buildHeaders([
-          helperHeader("BetaToolRunner"),
-          collected.length ? { [STAINLESS_HELPER_HEADER]: collected.join(", ") } : undefined,
-          options?.headers
-        ])
-      }, "f");
+      const { thread, settings } = "_state" in clientOrThread ? { thread: clientOrThread, settings: paramsOrSettings } : clientOrThread.beta.messages._toolRunnerThread(paramsOrSettings);
+      rejectCompactionParam(thread._state.params);
+      rejectRunToolsEagerlyWithoutStream(settings);
+      __classPrivateFieldSet(this, _BetaToolRunner_thread, thread, "f");
+      __classPrivateFieldSet(this, _BetaToolRunner_settings, definedEntries(settings), "f");
+      const { tools, messages } = thread._state.params;
+      const collected = collectStainlessHelpers(tools, messages);
+      if (!("_state" in clientOrThread)) {
+        thread._state.setMessages(JSON.parse(JSON.stringify(withToolDefinitions(messages))));
+      }
+      __classPrivateFieldSet(this, _BetaToolRunner_options, { ...options }, "f");
+      __classPrivateFieldSet(this, _BetaToolRunner_helperHeader, buildHeaders([
+        helperHeader("BetaToolRunner"),
+        collected.length ? { [STAINLESS_HELPER_HEADER]: collected.join(", ") } : undefined
+      ]), "f");
       __classPrivateFieldSet(this, _BetaToolRunner_completion, promiseWithResolvers(), "f");
     }
-    async* [(_BetaToolRunner_consumed = new WeakMap, _BetaToolRunner_mutated = new WeakMap, _BetaToolRunner_state = new WeakMap, _BetaToolRunner_options = new WeakMap, _BetaToolRunner_message = new WeakMap, _BetaToolRunner_stream = new WeakMap, _BetaToolRunner_toolResponse = new WeakMap, _BetaToolRunner_completion = new WeakMap, _BetaToolRunner_iterationCount = new WeakMap, _BetaToolRunner_toolRunnerOtelContext = new WeakMap, _BetaToolRunner_compaction = new WeakMap, _BetaToolRunner_calls = new WeakMap, _BetaToolRunner_lastStopReason = new WeakMap, _BetaToolRunner_toolOverrides = new WeakMap, _BetaToolRunner_pendingToolChanges = new WeakMap, _BetaToolRunner_instances = new WeakSet, _BetaToolRunner_withToolRunnerSpan = function _BetaToolRunner_withToolRunnerSpan2(fn) {
+    async* [(_BetaToolRunner_consumed = new WeakMap, _BetaToolRunner_mutated = new WeakMap, _BetaToolRunner_thread = new WeakMap, _BetaToolRunner_settings = new WeakMap, _BetaToolRunner_options = new WeakMap, _BetaToolRunner_helperHeader = new WeakMap, _BetaToolRunner_messagesWithoutReply = new WeakMap, _BetaToolRunner_message = new WeakMap, _BetaToolRunner_stream = new WeakMap, _BetaToolRunner_toolResponse = new WeakMap, _BetaToolRunner_completion = new WeakMap, _BetaToolRunner_iterationCount = new WeakMap, _BetaToolRunner_toolRunnerOtelContext = new WeakMap, _BetaToolRunner_compaction = new WeakMap, _BetaToolRunner_calls = new WeakMap, _BetaToolRunner_lastStopReason = new WeakMap, _BetaToolRunner_toolOverrides = new WeakMap, _BetaToolRunner_pendingToolChanges = new WeakMap, _BetaToolRunner_instances = new WeakSet, _BetaToolRunner_withToolRunnerSpan = function _BetaToolRunner_withToolRunnerSpan2(fn) {
       if (!__classPrivateFieldGet(this, _BetaToolRunner_toolRunnerOtelContext, "f")) {
         return fn();
       }
@@ -11334,12 +11861,12 @@ var BetaToolRunner2 = /* @__PURE__ */ (() => {
       __classPrivateFieldSet(this, _BetaToolRunner_consumed, true, "f");
       __classPrivateFieldSet(this, _BetaToolRunner_mutated, true, "f");
       __classPrivateFieldSet(this, _BetaToolRunner_toolResponse, undefined, "f");
-      const toolRunnerSpan = guardTracing(this.client, () => startToolRunnerSpan(this.client, __classPrivateFieldGet(this, _BetaToolRunner_state, "f").params, __classPrivateFieldGet(this, _BetaToolRunner_options, "f").openTelemetry?.conversationId));
+      const toolRunnerSpan = guardTracing(__classPrivateFieldGet(this, _BetaToolRunner_thread, "f")._client, () => startToolRunnerSpan(__classPrivateFieldGet(this, _BetaToolRunner_thread, "f")._client, this.params, __classPrivateFieldGet(this, _BetaToolRunner_options, "f").openTelemetry?.conversationId));
       __classPrivateFieldSet(this, _BetaToolRunner_toolRunnerOtelContext, toolRunnerSpan && import_api8.trace.setSpan(import_api8.context.active(), toolRunnerSpan), "f");
       try {
         while (true) {
           try {
-            if (__classPrivateFieldGet(this, _BetaToolRunner_state, "f").params.max_iterations && __classPrivateFieldGet(this, _BetaToolRunner_iterationCount, "f") >= __classPrivateFieldGet(this, _BetaToolRunner_state, "f").params.max_iterations) {
+            if (__classPrivateFieldGet(this, _BetaToolRunner_settings, "f").max_iterations && __classPrivateFieldGet(this, _BetaToolRunner_iterationCount, "f") >= __classPrivateFieldGet(this, _BetaToolRunner_settings, "f").max_iterations) {
               break;
             }
             __classPrivateFieldGet(this, _BetaToolRunner_instances, "m", _BetaToolRunner_flushPendingToolChanges).call(this);
@@ -11351,38 +11878,41 @@ var BetaToolRunner2 = /* @__PURE__ */ (() => {
             __classPrivateFieldSet(this, _BetaToolRunner_toolResponse, undefined, "f");
             __classPrivateFieldSet(this, _BetaToolRunner_iterationCount, (_a = __classPrivateFieldGet(this, _BetaToolRunner_iterationCount, "f"), _a++, _a), "f");
             __classPrivateFieldSet(this, _BetaToolRunner_message, undefined, "f");
-            const { max_iterations, runToolsEagerly, ...params } = __classPrivateFieldGet(this, _BetaToolRunner_state, "f").params;
-            yield* __classPrivateFieldGet(this, _BetaToolRunner_instances, "m", _BetaToolRunner_send).call(this, params);
+            yield* __classPrivateFieldGet(this, _BetaToolRunner_instances, "m", _BetaToolRunner_send).call(this, __classPrivateFieldGet(this, _BetaToolRunner_thread, "f"));
+            const callerMessages = __classPrivateFieldGet(this, _BetaToolRunner_messagesWithoutReply, "f");
+            __classPrivateFieldSet(this, _BetaToolRunner_messagesWithoutReply, undefined, "f");
             const next = await __classPrivateFieldGet(this, _BetaToolRunner_instances, "m", _BetaToolRunner_withToolRunnerSpan).call(this, async () => {
+              let toAnswer;
               if (!__classPrivateFieldGet(this, _BetaToolRunner_mutated, "f")) {
                 const message = await __classPrivateFieldGet(this, _BetaToolRunner_message, "f");
                 const nextStep = determineNextStepFromStopReason(message.stop_reason);
                 __classPrivateFieldSet(this, _BetaToolRunner_lastStopReason, message.stop_reason, "f");
-                __classPrivateFieldGet(this, _BetaToolRunner_state, "f").params.messages.push({
-                  role: message.role,
-                  content: asContentParam(message.content)
-                });
-                const { container } = __classPrivateFieldGet(this, _BetaToolRunner_state, "f").params;
-                if (message.container) {
-                  if (container == null) {
-                    __classPrivateFieldGet(this, _BetaToolRunner_state, "f").params.container = message.container.id;
-                  } else if (typeof container === "object" && container.id == null) {
-                    __classPrivateFieldGet(this, _BetaToolRunner_state, "f").params.container = { ...container, id: message.container.id };
-                  }
-                }
                 if (nextStep === "stop") {
                   return "stop";
                 }
                 if (nextStep === "resume") {
                   return "continue";
                 }
+                toAnswer = lastAssistantMessage(__classPrivateFieldGet(this, _BetaToolRunner_thread, "f").messages);
               } else {
                 __classPrivateFieldSet(this, _BetaToolRunner_lastStopReason, null, "f");
+                __classPrivateFieldGet(this, _BetaToolRunner_stream, "f")?.abort();
+                __classPrivateFieldGet(this, _BetaToolRunner_thread, "f")._state.checkNextTurn(turnParams(__classPrivateFieldGet(this, _BetaToolRunner_thread, "f")));
+                __classPrivateFieldGet(this, _BetaToolRunner_thread, "f")._state.setMessages(callerMessages);
+                toAnswer = callerMessages.at(-1);
               }
-              const toolMessage = await __classPrivateFieldGet(this, _BetaToolRunner_instances, "m", _BetaToolRunner_generateToolResponse).call(this, __classPrivateFieldGet(this, _BetaToolRunner_state, "f").params.messages.at(-1), __classPrivateFieldGet(this, _BetaToolRunner_options, "f").signal, __classPrivateFieldGet(this, _BetaToolRunner_toolRunnerOtelContext, "f"));
+              if (hasToolUse(toAnswer))
+                __classPrivateFieldGet(this, _BetaToolRunner_thread, "f")._state.checkNextTurn(turnParams(__classPrivateFieldGet(this, _BetaToolRunner_thread, "f")));
+              const toolMessage = await __classPrivateFieldGet(this, _BetaToolRunner_instances, "m", _BetaToolRunner_generateToolResponse).call(this, toAnswer, __classPrivateFieldGet(this, _BetaToolRunner_options, "f").signal, __classPrivateFieldGet(this, _BetaToolRunner_toolRunnerOtelContext, "f"));
               if (toolMessage) {
-                __classPrivateFieldGet(this, _BetaToolRunner_state, "f").params.messages.push(toolMessage);
-              } else if (!__classPrivateFieldGet(this, _BetaToolRunner_mutated, "f")) {
+                const history = __classPrivateFieldGet(this, _BetaToolRunner_thread, "f").messages;
+                const answered = history.map((message) => message.role).lastIndexOf("assistant") + 1;
+                __classPrivateFieldGet(this, _BetaToolRunner_thread, "f")._state.setMessages([
+                  ...history.slice(0, answered),
+                  toolMessage,
+                  ...history.slice(answered)
+                ]);
+              } else if (!__classPrivateFieldGet(this, _BetaToolRunner_mutated, "f") && !__classPrivateFieldGet(this, _BetaToolRunner_thread, "f")._state.hasTurnToSend) {
                 return "stop";
               }
               return "continue";
@@ -11401,32 +11931,40 @@ var BetaToolRunner2 = /* @__PURE__ */ (() => {
           throw new AnthropicError("ToolRunner concluded without a message from the server");
         }
         __classPrivateFieldGet(this, _BetaToolRunner_completion, "f").resolve(await __classPrivateFieldGet(this, _BetaToolRunner_message, "f"));
-        guardTracing(this.client, () => toolRunnerSpan?.setStatus({ code: import_api8.SpanStatusCode.OK }));
+        guardTracing(__classPrivateFieldGet(this, _BetaToolRunner_thread, "f")._client, () => toolRunnerSpan?.setStatus({ code: import_api8.SpanStatusCode.OK }));
       } catch (error) {
         if (toolRunnerSpan) {
-          guardTracing(this.client, () => setErrorStatus(toolRunnerSpan, error));
+          guardTracing(__classPrivateFieldGet(this, _BetaToolRunner_thread, "f")._client, () => setErrorStatus(toolRunnerSpan, error));
         }
         __classPrivateFieldSet(this, _BetaToolRunner_consumed, false, "f");
+        __classPrivateFieldSet(this, _BetaToolRunner_messagesWithoutReply, undefined, "f");
         __classPrivateFieldGet(this, _BetaToolRunner_completion, "f").promise.catch(() => {});
         __classPrivateFieldGet(this, _BetaToolRunner_completion, "f").reject(error);
         __classPrivateFieldSet(this, _BetaToolRunner_completion, promiseWithResolvers(), "f");
         throw error;
       } finally {
-        guardTracing(this.client, () => toolRunnerSpan?.end());
+        guardTracing(__classPrivateFieldGet(this, _BetaToolRunner_thread, "f")._client, () => toolRunnerSpan?.end());
         __classPrivateFieldSet(this, _BetaToolRunner_toolRunnerOtelContext, undefined, "f");
       }
     }
     setMessagesParams(paramsOrMutator) {
-      const params = typeof paramsOrMutator === "function" ? paramsOrMutator(__classPrivateFieldGet(this, _BetaToolRunner_state, "f").params) : paramsOrMutator;
+      const params = typeof paramsOrMutator === "function" ? paramsOrMutator(this.params) : paramsOrMutator;
       rejectCompactionParam(params);
-      rejectRunToolsEagerlyWithoutStream(params);
       if (__classPrivateFieldGet(this, _BetaToolRunner_compaction, "f").status !== "idle") {
         rejectCompactionEdit(params);
       }
-      if (__classPrivateFieldGet(this, _BetaToolRunner_compaction, "f").status === "in_flight" && params.messages !== __classPrivateFieldGet(this, _BetaToolRunner_state, "f").params.messages) {
-        throw new AnthropicError("Message params can't be changed while the conversation is being compacted, because the compaction " + "response is about to replace them. Change them after this iteration instead.");
+      if (__classPrivateFieldGet(this, _BetaToolRunner_compaction, "f").status === "in_flight" && !sameMessages(params.messages, __classPrivateFieldGet(this, _BetaToolRunner_thread, "f").messages)) {
+        throw new AnthropicError(MESSAGES_CHANGED_WHILE_COMPACTING);
+      }
+      const { settings, threadParams } = splitToolRunnerParams(params);
+      rejectRunToolsEagerlyWithoutStream(settings);
+      __classPrivateFieldSet(this, _BetaToolRunner_settings, definedEntries(settings), "f");
+      if (__classPrivateFieldGet(this, _BetaToolRunner_messagesWithoutReply, "f")) {
+        __classPrivateFieldSet(this, _BetaToolRunner_messagesWithoutReply, threadParams.messages, "f");
+        __classPrivateFieldGet(this, _BetaToolRunner_thread, "f")._state.setParams({ ...threadParams, messages: __classPrivateFieldGet(this, _BetaToolRunner_thread, "f").messages });
+      } else {
+        __classPrivateFieldGet(this, _BetaToolRunner_thread, "f")._state.setParams(threadParams);
       }
-      __classPrivateFieldGet(this, _BetaToolRunner_state, "f").params = params;
       __classPrivateFieldSet(this, _BetaToolRunner_mutated, true, "f");
       __classPrivateFieldSet(this, _BetaToolRunner_toolResponse, undefined, "f");
     }
@@ -11438,8 +11976,8 @@ var BetaToolRunner2 = /* @__PURE__ */ (() => {
       }
     }
     async generateToolResponse(signal = __classPrivateFieldGet(this, _BetaToolRunner_options, "f").signal) {
-      const callerOtelContext = this.client._tracer ? import_api8.context.active() : undefined;
-      const message = await __classPrivateFieldGet(this, _BetaToolRunner_message, "f") ?? this.params.messages.at(-1);
+      const callerOtelContext = __classPrivateFieldGet(this, _BetaToolRunner_thread, "f")._client._tracer ? import_api8.context.active() : undefined;
+      const message = await __classPrivateFieldGet(this, _BetaToolRunner_message, "f") ?? __classPrivateFieldGet(this, _BetaToolRunner_thread, "f").messages.at(-1);
       if (!message) {
         return null;
       }
@@ -11469,7 +12007,11 @@ var BetaToolRunner2 = /* @__PURE__ */ (() => {
       return this.done();
     }
     get params() {
-      return __classPrivateFieldGet(this, _BetaToolRunner_state, "f").params;
+      return {
+        ...__classPrivateFieldGet(this, _BetaToolRunner_thread, "f")._state.params,
+        ...__classPrivateFieldGet(this, _BetaToolRunner_messagesWithoutReply, "f") && { messages: [...__classPrivateFieldGet(this, _BetaToolRunner_messagesWithoutReply, "f")] },
+        ...__classPrivateFieldGet(this, _BetaToolRunner_settings, "f")
+      };
     }
     pushMessages(...messages) {
       this.setMessagesParams((params) => ({
@@ -11481,7 +12023,7 @@ var BetaToolRunner2 = /* @__PURE__ */ (() => {
       if (__classPrivateFieldGet(this, _BetaToolRunner_compaction, "f").status === "in_flight") {
         return;
       }
-      rejectCompactionEdit(__classPrivateFieldGet(this, _BetaToolRunner_state, "f").params);
+      rejectCompactionEdit(this.params);
       __classPrivateFieldSet(this, _BetaToolRunner_compaction, { status: "scheduled", config: compaction ?? { type: "summarize" } }, "f");
     }
     addTools(...tools) {
@@ -11520,28 +12062,39 @@ var BetaToolRunner2 = /* @__PURE__ */ (() => {
       return this.runUntilDone().then(onfulfilled, onrejected);
     }
   }
-  _BetaToolRunner_send = async function* _BetaToolRunner_send(params) {
+  _BetaToolRunner_send = async function* _BetaToolRunner_send(thread) {
     await __classPrivateFieldGet(this, _BetaToolRunner_instances, "m", _BetaToolRunner_startedCallsSettled).call(this);
     __classPrivateFieldSet(this, _BetaToolRunner_calls, undefined, "f");
-    params = __classPrivateFieldGet(this, _BetaToolRunner_instances, "m", _BetaToolRunner_withToolRunnerSpan).call(this, () => ({
-      ...params,
-      ...params.tools && { tools: params.tools.map(toolDefinition) },
-      messages: withToolDefinitions(params.messages)
-    }));
-    if (params.stream) {
-      __classPrivateFieldSet(this, _BetaToolRunner_stream, __classPrivateFieldGet(this, _BetaToolRunner_instances, "m", _BetaToolRunner_withToolRunnerSpan).call(this, () => __classPrivateFieldGet(this, _BetaToolRunner_state, "f").params.runToolsEagerly ? __classPrivateFieldGet(this, _BetaToolRunner_instances, "m", _BetaToolRunner_streamThatStartsTools).call(this, params) : this.client.beta.messages.stream({ ...params }, __classPrivateFieldGet(this, _BetaToolRunner_options, "f"))), "f");
+    const messages = thread.messages;
+    if (messages.some(addsRunnableTool)) {
+      __classPrivateFieldGet(this, _BetaToolRunner_instances, "m", _BetaToolRunner_withToolRunnerSpan).call(this, () => thread._state.setMessages(withToolDefinitions(messages)));
+    }
+    const { tools } = thread._state.params;
+    if (__classPrivateFieldGet(this, _BetaToolRunner_settings, "f").stream) {
+      __classPrivateFieldSet(this, _BetaToolRunner_stream, __classPrivateFieldGet(this, _BetaToolRunner_instances, "m", _BetaToolRunner_withToolRunnerSpan).call(this, () => __classPrivateFieldGet(this, _BetaToolRunner_settings, "f").runToolsEagerly ? __classPrivateFieldGet(this, _BetaToolRunner_instances, "m", _BetaToolRunner_streamThatStartsTools).call(this, thread) : thread.stream(undefined, turnParams(thread), __classPrivateFieldGet(this, _BetaToolRunner_instances, "m", _BetaToolRunner_turnOptions).call(this, thread))), "f");
+      if (tools)
+        thread.update({ tools });
+      if (thread === __classPrivateFieldGet(this, _BetaToolRunner_thread, "f"))
+        __classPrivateFieldSet(this, _BetaToolRunner_messagesWithoutReply, thread.messages, "f");
       __classPrivateFieldSet(this, _BetaToolRunner_message, __classPrivateFieldGet(this, _BetaToolRunner_stream, "f").finalMessage(), "f");
       __classPrivateFieldGet(this, _BetaToolRunner_message, "f").catch(() => {});
       yield __classPrivateFieldGet(this, _BetaToolRunner_stream, "f");
     } else {
-      __classPrivateFieldSet(this, _BetaToolRunner_message, __classPrivateFieldGet(this, _BetaToolRunner_instances, "m", _BetaToolRunner_withToolRunnerSpan).call(this, () => this.client.beta.messages.create({ ...params, stream: false }, __classPrivateFieldGet(this, _BetaToolRunner_options, "f"))), "f");
+      __classPrivateFieldSet(this, _BetaToolRunner_message, __classPrivateFieldGet(this, _BetaToolRunner_instances, "m", _BetaToolRunner_withToolRunnerSpan).call(this, () => thread.send(undefined, turnParams(thread), __classPrivateFieldGet(this, _BetaToolRunner_instances, "m", _BetaToolRunner_turnOptions).call(this, thread))), "f");
+      if (tools)
+        thread.update({ tools });
+      if (thread === __classPrivateFieldGet(this, _BetaToolRunner_thread, "f"))
+        __classPrivateFieldSet(this, _BetaToolRunner_messagesWithoutReply, thread.messages, "f");
       yield __classPrivateFieldGet(this, _BetaToolRunner_message, "f");
     }
-  }, _BetaToolRunner_streamThatStartsTools = function _BetaToolRunner_streamThatStartsTools(params) {
+  }, _BetaToolRunner_turnOptions = function _BetaToolRunner_turnOptions(thread) {
+    const { headers = thread._state.options.headers } = __classPrivateFieldGet(this, _BetaToolRunner_options, "f");
+    return { ...__classPrivateFieldGet(this, _BetaToolRunner_options, "f"), headers: buildHeaders([__classPrivateFieldGet(this, _BetaToolRunner_helperHeader, "f"), headers]) };
+  }, _BetaToolRunner_streamThatStartsTools = function _BetaToolRunner_streamThatStartsTools(thread) {
     const calls = new Map;
     __classPrivateFieldSet(this, _BetaToolRunner_calls, calls, "f");
     const toolsets = new Map;
-    return BetaToolRunnerStream.start(this.client, params, __classPrivateFieldGet(this, _BetaToolRunner_options, "f"), (toolUse) => {
+    const onToolCall = (toolUse) => {
       const known = calls.has(toolUse.id);
       const malformed = !toolUse.toolset_name && __classPrivateFieldGet(this, _BetaToolRunner_instances, "m", _BetaToolRunner_toolsetFamilies).call(this).has(toolUse.name);
       const family = malformed ? toolUse.name : toolUse.toolset_name;
@@ -11551,7 +12104,7 @@ var BetaToolRunner2 = /* @__PURE__ */ (() => {
           return;
         }
         toolsets.set(family, "running");
-        const result = runToolsetCall(__classPrivateFieldGet(this, _BetaToolRunner_state, "f").params, family, toolUse, __classPrivateFieldGet(this, _BetaToolRunner_options, "f"), this.client, __classPrivateFieldGet(this, _BetaToolRunner_toolRunnerOtelContext, "f"));
+        const result = runToolsetCall(__classPrivateFieldGet(this, _BetaToolRunner_instances, "m", _BetaToolRunner_toolsetParams).call(this), family, toolUse, __classPrivateFieldGet(this, _BetaToolRunner_options, "f"), __classPrivateFieldGet(this, _BetaToolRunner_thread, "f")._client, __classPrivateFieldGet(this, _BetaToolRunner_toolRunnerOtelContext, "f"));
         calls.set(toolUse.id, { status: "started", result });
         result.then(({ is_error }) => {
           if (is_error || toolsets.get(family) === "waiting")
@@ -11564,36 +12117,48 @@ var BetaToolRunner2 = /* @__PURE__ */ (() => {
       if (known) {
         return;
       }
-      const result = runToolCall(__classPrivateFieldGet(this, _BetaToolRunner_instances, "m", _BetaToolRunner_runnableTools).call(this), __classPrivateFieldGet(this, _BetaToolRunner_instances, "m", _BetaToolRunner_availableToolNames).call(this), toolUse, __classPrivateFieldGet(this, _BetaToolRunner_options, "f"), this.client, __classPrivateFieldGet(this, _BetaToolRunner_toolRunnerOtelContext, "f"));
+      const result = runToolCall(__classPrivateFieldGet(this, _BetaToolRunner_instances, "m", _BetaToolRunner_runnableTools).call(this), __classPrivateFieldGet(this, _BetaToolRunner_instances, "m", _BetaToolRunner_availableToolNames).call(this), toolUse, __classPrivateFieldGet(this, _BetaToolRunner_options, "f"), __classPrivateFieldGet(this, _BetaToolRunner_thread, "f")._client, __classPrivateFieldGet(this, _BetaToolRunner_toolRunnerOtelContext, "f"));
       result.catch(() => {});
       calls.set(toolUse.id, { status: "started", result });
-    });
+    };
+    const stream = new BetaToolRunnerStream(thread._state.params, onToolCall, thread._client);
+    thread._stream(stream, undefined, turnParams(thread), __classPrivateFieldGet(this, _BetaToolRunner_instances, "m", _BetaToolRunner_turnOptions).call(this, thread));
+    return stream;
   }, _BetaToolRunner_startedCallsSettled = async function _BetaToolRunner_startedCallsSettled() {
     const started = [...__classPrivateFieldGet(this, _BetaToolRunner_calls, "f")?.values() ?? []].filter((call) => call.status === "started");
     await Promise.allSettled(started.map((call) => call.result));
   }, _BetaToolRunner_compact = async function* _BetaToolRunner_compact(compaction) {
-    rejectCompactionEdit(__classPrivateFieldGet(this, _BetaToolRunner_state, "f").params);
-    const { max_iterations, runToolsEagerly, ...requestParams } = __classPrivateFieldGet(this, _BetaToolRunner_state, "f").params;
-    const params = withoutCompactionIncompatibleParams(requestParams);
+    rejectCompactionEdit(this.params);
     __classPrivateFieldSet(this, _BetaToolRunner_compaction, { status: "in_flight" }, "f");
     __classPrivateFieldSet(this, _BetaToolRunner_toolResponse, undefined, "f");
     const lastMessage = __classPrivateFieldGet(this, _BetaToolRunner_message, "f");
+    const thread = __classPrivateFieldGet(this, _BetaToolRunner_instances, "m", _BetaToolRunner_compactionThread).call(this, compaction);
+    const summarized = __classPrivateFieldGet(this, _BetaToolRunner_thread, "f").messages.length;
     try {
-      yield* __classPrivateFieldGet(this, _BetaToolRunner_instances, "m", _BetaToolRunner_send).call(this, { ...params, compaction });
+      yield* __classPrivateFieldGet(this, _BetaToolRunner_instances, "m", _BetaToolRunner_send).call(this, thread);
       const message = await __classPrivateFieldGet(this, _BetaToolRunner_message, "f");
       if (message.content.some((block) => block.type === "compaction" && block.content)) {
         __classPrivateFieldGet(this, _BetaToolRunner_instances, "m", _BetaToolRunner_recordRemovalsFromHistory).call(this);
-        __classPrivateFieldGet(this, _BetaToolRunner_state, "f").params.messages = [{ role: message.role, content: message.content }];
+        const response = { role: message.role, content: message.content };
+        const appended = __classPrivateFieldGet(this, _BetaToolRunner_thread, "f").messages.slice(summarized).filter((m) => !sameMessage(m, response));
+        __classPrivateFieldGet(this, _BetaToolRunner_thread, "f")._state.setMessages([response, ...appended]);
       } else {
-        loggerFor(this.client).warn("Compaction produced no summary; keeping the conversation as it is.");
+        loggerFor(__classPrivateFieldGet(this, _BetaToolRunner_thread, "f")._client).warn("Compaction produced no summary; keeping the conversation as it is.");
         __classPrivateFieldSet(this, _BetaToolRunner_message, lastMessage, "f");
       }
     } finally {
       __classPrivateFieldSet(this, _BetaToolRunner_compaction, { status: "idle" }, "f");
-    }
+      if (!thread._state.threading)
+        __classPrivateFieldGet(this, _BetaToolRunner_thread, "f")._state.stopThreading();
+    }
+  }, _BetaToolRunner_compactionThread = function _BetaToolRunner_compactionThread(compaction) {
+    const { messages, ...fields } = withoutCompactionIncompatibleParams(__classPrivateFieldGet(this, _BetaToolRunner_thread, "f")._state.params);
+    const thread = __classPrivateFieldGet(this, _BetaToolRunner_thread, "f").fork();
+    thread._state = __classPrivateFieldGet(this, _BetaToolRunner_thread, "f")._state.fork({ ...fields, compaction });
+    return thread;
   }, _BetaToolRunner_runnableTools = function _BetaToolRunner_runnableTools() {
     const runnable = new Map;
-    for (const tool of __classPrivateFieldGet(this, _BetaToolRunner_state, "f").params.tools) {
+    for (const tool of __classPrivateFieldGet(this, _BetaToolRunner_thread, "f")._state.params.tools ?? []) {
       if ("run" in tool && "name" in tool) {
         runnable.set(tool.name, tool);
       }
@@ -11608,7 +12173,7 @@ var BetaToolRunner2 = /* @__PURE__ */ (() => {
     return runnable;
   }, _BetaToolRunner_availableToolNames = function _BetaToolRunner_availableToolNames() {
     const available = new Set(__classPrivateFieldGet(this, _BetaToolRunner_instances, "m", _BetaToolRunner_runnableTools).call(this).keys());
-    for (const message of [...__classPrivateFieldGet(this, _BetaToolRunner_state, "f").params.messages, __classPrivateFieldGet(this, _BetaToolRunner_instances, "m", _BetaToolRunner_pendingToolChangesMessage).call(this)]) {
+    for (const message of [...this.params.messages, __classPrivateFieldGet(this, _BetaToolRunner_instances, "m", _BetaToolRunner_pendingToolChangesMessage).call(this)]) {
       if (!Array.isArray(message.content)) {
         continue;
       }
@@ -11634,9 +12199,8 @@ var BetaToolRunner2 = /* @__PURE__ */ (() => {
     if (__classPrivateFieldGet(this, _BetaToolRunner_compaction, "f").status !== "scheduled") {
       return;
     }
-    const lastContent = __classPrivateFieldGet(this, _BetaToolRunner_state, "f").params.messages.at(-1)?.content;
-    if (Array.isArray(lastContent) && lastContent.some((block) => block.type === "tool_use")) {
-      loggerFor(this.client).warn("The pending compaction was skipped because the last turn ended with tool calls that were not run. " + "Call `compactBeforeNextTurn()` again if you continue the conversation.");
+    if (hasToolUse(__classPrivateFieldGet(this, _BetaToolRunner_thread, "f").messages.at(-1))) {
+      loggerFor(__classPrivateFieldGet(this, _BetaToolRunner_thread, "f")._client).warn("The pending compaction was skipped because the last turn ended with tool calls that were not run. " + "Call `compactBeforeNextTurn()` again if you continue the conversation.");
       __classPrivateFieldSet(this, _BetaToolRunner_compaction, { status: "idle" }, "f");
       return;
     }
@@ -11645,15 +12209,17 @@ var BetaToolRunner2 = /* @__PURE__ */ (() => {
     if (__classPrivateFieldGet(this, _BetaToolRunner_toolResponse, "f") !== undefined) {
       return __classPrivateFieldGet(this, _BetaToolRunner_toolResponse, "f");
     }
-    __classPrivateFieldSet(this, _BetaToolRunner_toolResponse, generateToolResponse(__classPrivateFieldGet(this, _BetaToolRunner_state, "f").params, __classPrivateFieldGet(this, _BetaToolRunner_instances, "m", _BetaToolRunner_runnableTools).call(this), __classPrivateFieldGet(this, _BetaToolRunner_instances, "m", _BetaToolRunner_availableToolNames).call(this), lastMessage, { ...__classPrivateFieldGet(this, _BetaToolRunner_options, "f"), signal }, __classPrivateFieldGet(this, _BetaToolRunner_calls, "f"), this.client, toolOtelContext), "f");
+    __classPrivateFieldSet(this, _BetaToolRunner_toolResponse, generateToolResponse(__classPrivateFieldGet(this, _BetaToolRunner_instances, "m", _BetaToolRunner_toolsetParams).call(this), __classPrivateFieldGet(this, _BetaToolRunner_instances, "m", _BetaToolRunner_runnableTools).call(this), __classPrivateFieldGet(this, _BetaToolRunner_instances, "m", _BetaToolRunner_availableToolNames).call(this), lastMessage, { ...__classPrivateFieldGet(this, _BetaToolRunner_options, "f"), signal }, __classPrivateFieldGet(this, _BetaToolRunner_calls, "f"), __classPrivateFieldGet(this, _BetaToolRunner_thread, "f")._client, toolOtelContext), "f");
     return __classPrivateFieldGet(this, _BetaToolRunner_toolResponse, "f");
   }, _BetaToolRunner_toolsetFamilies = function _BetaToolRunner_toolsetFamilies() {
-    return new Set(__classPrivateFieldGet(this, _BetaToolRunner_state, "f").params.tools.filter(isRunnableToolset).map(toolsetFamily));
+    return new Set(__classPrivateFieldGet(this, _BetaToolRunner_instances, "m", _BetaToolRunner_toolsetParams).call(this).tools.filter(isRunnableToolset).map(toolsetFamily));
+  }, _BetaToolRunner_toolsetParams = function _BetaToolRunner_toolsetParams() {
+    return { ...this.params, tools: __classPrivateFieldGet(this, _BetaToolRunner_thread, "f")._state.params.tools ?? [] };
   }, _BetaToolRunner_flushPendingToolChanges = function _BetaToolRunner_flushPendingToolChanges() {
     if (__classPrivateFieldGet(this, _BetaToolRunner_lastStopReason, "f") === "pause_turn" || __classPrivateFieldGet(this, _BetaToolRunner_pendingToolChanges, "f").length === 0) {
       return;
     }
-    __classPrivateFieldGet(this, _BetaToolRunner_state, "f").params.messages.push(__classPrivateFieldGet(this, _BetaToolRunner_instances, "m", _BetaToolRunner_pendingToolChangesMessage).call(this));
+    __classPrivateFieldGet(this, _BetaToolRunner_thread, "f").append(__classPrivateFieldGet(this, _BetaToolRunner_instances, "m", _BetaToolRunner_pendingToolChangesMessage).call(this));
     __classPrivateFieldSet(this, _BetaToolRunner_pendingToolChanges, [], "f");
   }, _BetaToolRunner_pendingToolChangesMessage = function _BetaToolRunner_pendingToolChangesMessage() {
     const content = [];
@@ -11669,13 +12235,17 @@ var BetaToolRunner2 = /* @__PURE__ */ (() => {
   };
   return BetaToolRunner;
 })();
+var MESSAGES_CHANGED_WHILE_COMPACTING = "Message params can't be changed while the conversation is being compacted, because the compaction " + "response is about to replace them. Change them after this iteration instead.";
+function sameMessages(a, b) {
+  return a.length === b.length && a.every((message, i) => sameMessage(message, b[i]));
+}
 function rejectCompactionParam(params) {
   if ("compaction" in params && params.compaction != null) {
     throw new AnthropicError("`compaction` cannot be set on a tool runner: every request in the loop would compact again. " + "Call `runner.compactBeforeNextTurn()` when the conversation should be compacted instead.");
   }
 }
-function rejectRunToolsEagerlyWithoutStream(params) {
-  if (params.runToolsEagerly && !params.stream) {
+function rejectRunToolsEagerlyWithoutStream(settings) {
+  if (settings.runToolsEagerly && !settings.stream) {
     throw new TypeError("`runToolsEagerly: true` needs `stream: true` in the tool runner's params, because a reply that " + "isn't streamed arrives whole.");
   }
 }
@@ -11709,6 +12279,10 @@ function toolDefinition(tool) {
     ...wasCreatedByStainlessHelper(tool) && { [SDK_HELPER_SYMBOL]: tool[SDK_HELPER_SYMBOL] }
   };
 }
+function turnParams(thread) {
+  const { tools } = thread._state.params;
+  return tools ? { tools: tools.map(toolDefinition) } : {};
+}
 function withToolDefinitions(messages) {
   return messages.map((message) => {
     if (message.role !== "system" || !Array.isArray(message.content)) {
@@ -11718,6 +12292,9 @@ function withToolDefinitions(messages) {
     return { ...message, content };
   });
 }
+function addsRunnableTool(message) {
+  return message.role === "system" && Array.isArray(message.content) && message.content.some((block) => block.type === "tool_addition" && block.tool.type === "tool_definition" && ("run" in block.tool.definition));
+}
 async function generateToolResponse(params, runnable, available, lastMessage, requestOptions, calls, client, toolOtelContext) {
   if (!lastMessage || lastMessage.role !== "assistant" || !lastMessage.content || typeof lastMessage.content === "string") {
     return null;
@@ -11804,8 +12381,19 @@ async function runToolCall(runnable, available, toolUse, requestOptions, client,
     ...outcome.isError ? { is_error: true } : undefined
   };
 }
-function asContentParam(content) {
-  return content;
+function lastAssistantMessage(messages) {
+  for (let i = messages.length - 1;i >= 0; i--) {
+    const message = messages[i];
+    if (message.role === "assistant")
+      return message;
+    if (message.role === "user" && Array.isArray(message.content) && message.content.some((block) => block.type === "tool_result")) {
+      return;
+    }
+  }
+  return;
+}
+function hasToolUse(message) {
+  return Array.isArray(message?.content) && message.content.some((block) => block.type === "tool_use");
 }
 function definitionFamily(tool) {
   return (tool.type ?? "custom").replace(/_\d{8}$/, "").replace(/_toolset$/, "");
@@ -11880,12 +12468,11 @@ function changedToolName(tool) {
 function determineNextStepFromStopReason(stopReason) {
   if (stopReason === null)
     return "stop";
+  if (isUnfinishedStopReason(stopReason))
+    return "resume";
   switch (stopReason) {
     case "tool_use":
       return "run_tools";
-    case "pause_turn":
-    case "compaction":
-      return "resume";
     case "end_turn":
     case "stop_sequence":
     case "max_tokens":
@@ -11898,6 +12485,123 @@ function determineNextStepFromStopReason(stopReason) {
   }
 }
 
+// node_modules/@anthropic-ai/sdk/lib/threads/BetaMessageThread.mjs
+class BetaMessageThread2 {
+  constructor(client, params, options) {
+    if (!client._supportsMessageThreads) {
+      throw new AnthropicError("Message threads are not available on this client; use `client.beta.messages.create()` with the full `messages` instead");
+    }
+    assertOneOutputFormat(params);
+    this._client = client;
+    this._state = new ThreadState({
+      params,
+      options: options ?? {},
+      threading: true,
+      logger: loggerFor(client)
+    });
+  }
+  static _fromState(client, state) {
+    const thread = Object.create(BetaMessageThread2.prototype);
+    return Object.assign(thread, { _client: client, _state: state });
+  }
+  get messages() {
+    return this._state.messages;
+  }
+  get previousMessageId() {
+    return this._state.previousMessageId;
+  }
+  get params() {
+    return { ...this._state.params, unsupportedRequestBehavior: this._state.unsupportedRequestBehavior };
+  }
+  append(...messages) {
+    this._state.push(messages);
+  }
+  send(messages, params = {}, options = {}) {
+    return this._send(messages, params, options, (reply) => reply);
+  }
+  parse(messages, params = {}, options = {}) {
+    return this._send(messages, params, options, (reply) => parseBetaMessage(reply, this._state.params, {
+      logger: loggerFor(this._client)
+    }));
+  }
+  _send(messages, params, options, parseReply) {
+    const turn = this._state.startTurn(toMessageList(messages), params);
+    const received = (async () => {
+      try {
+        const { request, props } = await this._createWithRecovery(turn, options, { stream: false });
+        const reply = await request;
+        this._state.recordReply(turn, reply);
+        return { props, reply };
+      } finally {
+        this._state.endTurn(turn);
+      }
+    })();
+    return new APIPromise(this._client, received.then(({ props }) => props), async () => {
+      const { props, reply } = await received;
+      return addResponseIDs(parseReply(reply), props.response);
+    });
+  }
+  stream(messages, params = {}, options = {}) {
+    const stream = new BetaMessageStream(this._state.params, {
+      logger: loggerFor(this._client),
+      client: this._client
+    });
+    this._stream(stream, messages, params, options);
+    return stream;
+  }
+  _stream(stream, messages, turnParams, turnOptions) {
+    const turn = this._state.startTurn(toMessageList(messages), turnParams);
+    let received;
+    let completedBlocks = 0;
+    let stopped = false;
+    stream.on("streamEvent", (event, snapshot) => {
+      if (stopped)
+        return;
+      received = snapshot;
+      if (event.type === "content_block_stop")
+        completedBlocks += 1;
+      if (event.type === "message_stop") {
+        stopped = true;
+        this._state.recordReply(turn, snapshot);
+        this._state.endTurn(turn);
+      }
+    });
+    const endEarly = () => {
+      if (stopped)
+        return;
+      stopped = true;
+      if (received)
+        this._state.recordPartialReply(received, completedBlocks);
+      this._state.endTurn(turn);
+    };
+    stream.controller.signal.addEventListener("abort", endEarly, { once: true });
+    const createTurn = (_body, options) => new APIPromise(this._client, this._createWithRecovery(turn, { ...turnOptions, signal: options?.signal }, { stream: true }).then(({ props }) => props));
+    stream._start(createTurn, this._state.params, { signal: turnOptions.signal ?? this._state.options.signal }, endEarly);
+  }
+  update(params = {}, options = {}) {
+    this._state.update(params, options);
+  }
+  toolRunner(params = {}, options = {}) {
+    rejectThreadField(params);
+    return new BetaToolRunner2(this, params, options);
+  }
+  fork() {
+    return BetaMessageThread2._fromState(this._client, this._state.fork());
+  }
+  async _createWithRecovery(turn, turnOptions, { stream }) {
+    for (;; ) {
+      const { params, options } = this._state.buildCreateArguments(turn, turnOptions, { stream });
+      const request = this._client.beta.messages.create({ ...params, stream }, options);
+      try {
+        return { request, props: await request._responseProps() };
+      } catch (error) {
+        if (!this._state.recoversFrom(error))
+          throw error;
+      }
+    }
+  }
+}
+
 // node_modules/@anthropic-ai/sdk/resources/beta/messages/messages.mjs
 var DEPRECATED_MODELS2 = {
   "claude-sonnet-4-5": "November 30th, 2026",
@@ -11984,6 +12688,20 @@ Please migrate to a newer model. Visit https://docs.anthropic.com/en/docs/resour
     toolRunner(body, options) {
       return new BetaToolRunner2(this._client, body, options);
     }
+    _toolRunnerThread(body) {
+      assertOneOutputFormat(body);
+      const { settings, thread, threadParams } = splitToolRunnerParams(body);
+      const state = new ThreadState({
+        params: { ...threadParams, unsupportedRequestBehavior: "continue_unthreaded" },
+        options: {},
+        threading: thread !== false && this._client._supportsMessageThreads,
+        logger: loggerFor(this._client)
+      });
+      return { thread: BetaMessageThread2._fromState(this._client, state), settings };
+    }
+    thread(params, options) {
+      return new BetaMessageThread2(this._client, params, options);
+    }
   }
   Messages.Batches = Batches2;
   Messages.BetaToolRunner = BetaToolRunner2;
@@ -13166,6 +13884,7 @@ var BaseAnthropic = /* @__PURE__ */ (() => {
       _BaseAnthropic_apiKeyFunction.set(this, undefined);
       _BaseAnthropic_openTelemetry.set(this, undefined);
       this._genAIProviderName = "anthropic";
+      this._supportsMessageThreads = false;
       const given = { apiKey, authToken, ...opts };
       const passed = CREDENTIAL_OPTIONS.filter((name) => given[name] != null);
       if (passed.length > 1) {
@@ -13869,6 +14588,7 @@ var Anthropic = /* @__PURE__ */ (() => {
   class Anthropic extends BaseAnthropic {
     constructor() {
       super(...arguments);
+      this._supportsMessageThreads = true;
       this.messages = new Messages(this);
       this.models = new Models2(this);
       this.files = new Files2(this);