@anthropic-ai/sdk 0.125.0 → 0.127.0

package/lib/tools/BetaToolRunner.mjs

@@ -1,10 +1,11 @@
-var _BetaToolRunner_instances, _BetaToolRunner_consumed, _BetaToolRunner_mutated, _BetaToolRunner_state, _BetaToolRunner_options, _BetaToolRunner_message, _BetaToolRunner_toolResponse, _BetaToolRunner_completion, _BetaToolRunner_iterationCount, _BetaToolRunner_checkAndCompact, _BetaToolRunner_generateToolResponse;
+var _BetaToolRunner_instances, _BetaToolRunner_consumed, _BetaToolRunner_mutated, _BetaToolRunner_state, _BetaToolRunner_options, _BetaToolRunner_message, _BetaToolRunner_stream, _BetaToolRunner_toolResponse, _BetaToolRunner_completion, _BetaToolRunner_iterationCount, _BetaToolRunner_compaction, _BetaToolRunner_turnPaused, _BetaToolRunner_checkAndCompact, _BetaToolRunner_send, _BetaToolRunner_compact, _BetaToolRunner_compactAfterFinalTurn, _BetaToolRunner_generateToolResponse;
 import { __classPrivateFieldGet, __classPrivateFieldSet } from "../../internal/tslib.mjs";
 import { ToolError } from "./ToolError.mjs";
 import { AnthropicError } from "../../core/error.mjs";
 import { buildHeaders } from "../../internal/headers.mjs";
 import { promiseWithResolvers } from "../../internal/utils/promise.mjs";
 import { checkNever } from "../../internal/utils/values.mjs";
+import { loggerFor } from "../../internal/utils/log.mjs";
 import { DEFAULT_SUMMARY_PROMPT, DEFAULT_TOKEN_THRESHOLD } from "./CompactionControl.mjs";
 import { collectStainlessHelpers, helperHeader, STAINLESS_HELPER_HEADER, } from "../../internal/stainless-helper-header.mjs";
 /**
@@ -13,343 +14,453 @@ import { collectStainlessHelpers, helperHeader, STAINLESS_HELPER_HEADER, } from
  * A ToolRunner is an async iterable that yields either BetaMessage or BetaMessageStream objects
  * depending on the streaming configuration.
  */
-export class BetaToolRunner {
-    constructor(client, params, options) {
-        _BetaToolRunner_instances.add(this);
-        this.client = client;
-        /** Whether the async iterator has been consumed */
-        _BetaToolRunner_consumed.set(this, false);
-        /** Whether parameters have been mutated since the last API call */
-        _BetaToolRunner_mutated.set(this, false);
-        /** Current state containing the request parameters */
-        _BetaToolRunner_state.set(this, void 0);
-        _BetaToolRunner_options.set(this, void 0);
-        /** Promise for the last message received from the assistant */
-        _BetaToolRunner_message.set(this, void 0);
-        /** Cached tool response to avoid redundant executions */
-        _BetaToolRunner_toolResponse.set(this, void 0);
-        /** Promise resolvers for waiting on completion */
-        _BetaToolRunner_completion.set(this, void 0);
-        /** Number of iterations (API requests) made so far */
-        _BetaToolRunner_iterationCount.set(this, 0);
-        __classPrivateFieldSet(this, _BetaToolRunner_state, {
-            params: {
-                // You can't clone the entire params since there are functions as handlers.
-                // You also don't really need to clone params.messages, but it probably will prevent a foot gun
-                // somewhere.
-                ...params,
-                messages: structuredClone(params.messages),
-            },
-        }, "f");
-        // structuredClone drops symbol-keyed properties, so collect helper marks
-        // from the original params here — the create()-side collector won't see
-        // them on the cloned messages.
-        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");
-        __classPrivateFieldSet(this, _BetaToolRunner_completion, promiseWithResolvers(), "f");
-        if (params.compactionControl?.enabled) {
-            console.warn('Anthropic: The `compactionControl` parameter is deprecated and will be removed in a future version. ' +
-                'Use server-side compaction instead by passing `edits: [{ type: "compact_20260112" }]` in the params passed to `toolRunner()`. ' +
-                'See https://platform.claude.com/docs/en/build-with-claude/compaction');
-        }
-    }
-    async *[(_BetaToolRunner_consumed = new WeakMap(), _BetaToolRunner_mutated = new WeakMap(), _BetaToolRunner_state = new WeakMap(), _BetaToolRunner_options = new WeakMap(), _BetaToolRunner_message = new WeakMap(), _BetaToolRunner_toolResponse = new WeakMap(), _BetaToolRunner_completion = new WeakMap(), _BetaToolRunner_iterationCount = new WeakMap(), _BetaToolRunner_instances = new WeakSet(), _BetaToolRunner_checkAndCompact = async function _BetaToolRunner_checkAndCompact() {
-        const compactionControl = __classPrivateFieldGet(this, _BetaToolRunner_state, "f").params.compactionControl;
-        if (!compactionControl || !compactionControl.enabled) {
-            return false;
-        }
-        let tokensUsed = 0;
-        if (__classPrivateFieldGet(this, _BetaToolRunner_message, "f") !== undefined) {
-            try {
-                const message = await __classPrivateFieldGet(this, _BetaToolRunner_message, "f");
-                const totalInputTokens = message.usage.input_tokens +
-                    (message.usage.cache_creation_input_tokens ?? 0) +
-                    (message.usage.cache_read_input_tokens ?? 0);
-                tokensUsed = totalInputTokens + message.usage.output_tokens;
+export var BetaToolRunner = /* @__PURE__ */ (() => {
+    /**
+     * A ToolRunner handles the automatic conversation loop between the assistant and tools.
+     *
+     * A ToolRunner is an async iterable that yields either BetaMessage or BetaMessageStream objects
+     * depending on the streaming configuration.
+     */
+    class BetaToolRunner {
+        constructor(client, params, options) {
+            _BetaToolRunner_instances.add(this);
+            this.client = client;
+            /** Whether the async iterator has been consumed */
+            _BetaToolRunner_consumed.set(this, false);
+            /** Whether parameters have been mutated since the last API call */
+            _BetaToolRunner_mutated.set(this, false);
+            /** Current state containing the request parameters */
+            _BetaToolRunner_state.set(this, void 0);
+            _BetaToolRunner_options.set(this, void 0);
+            /** Promise for the last message received from the assistant */
+            _BetaToolRunner_message.set(this, void 0);
+            /** The stream of the request in progress, when streaming */
+            _BetaToolRunner_stream.set(this, void 0);
+            /** Cached tool response to avoid redundant executions */
+            _BetaToolRunner_toolResponse.set(this, void 0);
+            /** Promise resolvers for waiting on completion */
+            _BetaToolRunner_completion.set(this, void 0);
+            /** Number of iterations (API requests) made so far */
+            _BetaToolRunner_iterationCount.set(this, 0);
+            /** A compaction scheduled with `compactBeforeNextTurn()`, in flight until its response has been handled */
+            _BetaToolRunner_compaction.set(this, { status: 'idle' });
+            /** Whether the last turn was paused; a scheduled compaction waits for it to be resumed */
+            _BetaToolRunner_turnPaused.set(this, false);
+            rejectCompactionParam(params);
+            __classPrivateFieldSet(this, _BetaToolRunner_state, {
+                params: {
+                    // You can't clone the entire params since there are functions as handlers.
+                    // You also don't really need to clone params.messages, but it probably will prevent a foot gun
+                    // somewhere.
+                    ...params,
+                    messages: structuredClone(params.messages),
+                },
+            }, "f");
+            // structuredClone drops symbol-keyed properties, so collect helper marks
+            // from the original params here — the create()-side collector won't see
+            // them on the cloned messages.
+            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");
+            __classPrivateFieldSet(this, _BetaToolRunner_completion, promiseWithResolvers(), "f");
+            if (params.compactionControl?.enabled) {
+                console.warn('Anthropic: The `compactionControl` parameter is deprecated and will be removed in a future version. ' +
+                    'Use server-side compaction instead by passing `edits: [{ type: "compact_20260112" }]` in the params passed to `toolRunner()`. ' +
+                    'See https://platform.claude.com/docs/en/build-with-claude/compaction');
             }
-            catch {
-                // If we can't get the message, skip compaction
+        }
+        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_compaction = new WeakMap(), _BetaToolRunner_turnPaused = new WeakMap(), _BetaToolRunner_instances = new WeakSet(), _BetaToolRunner_checkAndCompact = async function _BetaToolRunner_checkAndCompact() {
+            const compactionControl = __classPrivateFieldGet(this, _BetaToolRunner_state, "f").params.compactionControl;
+            if (!compactionControl || !compactionControl.enabled) {
                 return false;
             }
-        }
-        const threshold = compactionControl.contextTokenThreshold ?? DEFAULT_TOKEN_THRESHOLD;
-        if (tokensUsed < threshold) {
-            return false;
-        }
-        const model = compactionControl.model ?? __classPrivateFieldGet(this, _BetaToolRunner_state, "f").params.model;
-        const summaryPrompt = compactionControl.summaryPrompt ?? DEFAULT_SUMMARY_PROMPT;
-        const messages = __classPrivateFieldGet(this, _BetaToolRunner_state, "f").params.messages;
-        if (messages[messages.length - 1].role === 'assistant') {
-            // Remove tool_use blocks from the last message to avoid 400 error
-            // (tool_use requires tool_result, which we don't have yet)
-            const lastMessage = messages[messages.length - 1];
-            if (Array.isArray(lastMessage.content)) {
-                const nonToolBlocks = lastMessage.content.filter((block) => block.type !== 'tool_use');
-                if (nonToolBlocks.length === 0) {
-                    // If all blocks were tool_use, just remove the message entirely
-                    messages.pop();
+            let tokensUsed = 0;
+            if (__classPrivateFieldGet(this, _BetaToolRunner_message, "f") !== undefined) {
+                try {
+                    const message = await __classPrivateFieldGet(this, _BetaToolRunner_message, "f");
+                    const totalInputTokens = message.usage.input_tokens +
+                        (message.usage.cache_creation_input_tokens ?? 0) +
+                        (message.usage.cache_read_input_tokens ?? 0);
+                    tokensUsed = totalInputTokens + message.usage.output_tokens;
                 }
-                else {
-                    lastMessage.content = nonToolBlocks;
+                catch {
+                    // If we can't get the message, skip compaction
+                    return false;
                 }
             }
-        }
-        const response = await this.client.beta.messages.create({
-            model,
-            messages: [
-                ...messages,
-                {
-                    role: 'user',
-                    content: [
-                        {
-                            type: 'text',
-                            text: summaryPrompt,
-                        },
-                    ],
-                },
-            ],
-            max_tokens: __classPrivateFieldGet(this, _BetaToolRunner_state, "f").params.max_tokens,
-        }, {
-            signal: __classPrivateFieldGet(this, _BetaToolRunner_options, "f").signal,
-            headers: buildHeaders([__classPrivateFieldGet(this, _BetaToolRunner_options, "f").headers, helperHeader('compaction')]),
-        });
-        if (response.content[0]?.type !== 'text') {
-            throw new AnthropicError('Expected text response for compaction');
-        }
-        __classPrivateFieldGet(this, _BetaToolRunner_state, "f").params.messages = [
-            {
-                role: 'user',
-                content: response.content,
-            },
-        ];
-        return true;
-    }, Symbol.asyncIterator)]() {
-        var _a;
-        if (__classPrivateFieldGet(this, _BetaToolRunner_consumed, "f")) {
-            throw new AnthropicError('Cannot iterate over a consumed stream');
-        }
-        __classPrivateFieldSet(this, _BetaToolRunner_consumed, true, "f");
-        __classPrivateFieldSet(this, _BetaToolRunner_mutated, true, "f");
-        __classPrivateFieldSet(this, _BetaToolRunner_toolResponse, undefined, "f");
-        try {
-            while (true) {
-                let stream;
-                try {
-                    if (__classPrivateFieldGet(this, _BetaToolRunner_state, "f").params.max_iterations &&
-                        __classPrivateFieldGet(this, _BetaToolRunner_iterationCount, "f") >= __classPrivateFieldGet(this, _BetaToolRunner_state, "f").params.max_iterations) {
-                        break;
-                    }
-                    __classPrivateFieldSet(this, _BetaToolRunner_mutated, false, "f");
-                    __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, compactionControl, ...params } = __classPrivateFieldGet(this, _BetaToolRunner_state, "f").params;
-                    if (params.stream) {
-                        stream = this.client.beta.messages.stream({ ...params }, __classPrivateFieldGet(this, _BetaToolRunner_options, "f"));
-                        __classPrivateFieldSet(this, _BetaToolRunner_message, stream.finalMessage(), "f");
-                        // Make sure that this promise doesn't throw before we get the option to do something about it.
-                        // Error will be caught when we call await this.#message ultimately
-                        __classPrivateFieldGet(this, _BetaToolRunner_message, "f").catch(() => { });
-                        yield stream;
+            const threshold = compactionControl.contextTokenThreshold ?? DEFAULT_TOKEN_THRESHOLD;
+            if (tokensUsed < threshold) {
+                return false;
+            }
+            const model = compactionControl.model ?? __classPrivateFieldGet(this, _BetaToolRunner_state, "f").params.model;
+            const summaryPrompt = compactionControl.summaryPrompt ?? DEFAULT_SUMMARY_PROMPT;
+            const messages = __classPrivateFieldGet(this, _BetaToolRunner_state, "f").params.messages;
+            if (messages[messages.length - 1].role === 'assistant') {
+                // Remove tool_use blocks from the last message to avoid 400 error
+                // (tool_use requires tool_result, which we don't have yet)
+                const lastMessage = messages[messages.length - 1];
+                if (Array.isArray(lastMessage.content)) {
+                    const nonToolBlocks = lastMessage.content.filter((block) => block.type !== 'tool_use');
+                    if (nonToolBlocks.length === 0) {
+                        // If all blocks were tool_use, just remove the message entirely
+                        messages.pop();
                     }
                     else {
-                        __classPrivateFieldSet(this, _BetaToolRunner_message, this.client.beta.messages.create({ ...params, stream: false }, __classPrivateFieldGet(this, _BetaToolRunner_options, "f")), "f");
-                        yield __classPrivateFieldGet(this, _BetaToolRunner_message, "f");
+                        lastMessage.content = nonToolBlocks;
                     }
-                    const isCompacted = await __classPrivateFieldGet(this, _BetaToolRunner_instances, "m", _BetaToolRunner_checkAndCompact).call(this);
-                    if (!isCompacted) {
-                        if (!__classPrivateFieldGet(this, _BetaToolRunner_mutated, "f")) {
-                            const message = await __classPrivateFieldGet(this, _BetaToolRunner_message, "f");
-                            const nextStep = determineNextStepFromStopReason(message.stop_reason);
-                            __classPrivateFieldGet(this, _BetaToolRunner_state, "f").params.messages.push({ role: message.role, content: message.content });
-                            // Container-bound server tools reject a follow-up request that omits the container the
-                            // previous turn ran in, so carry its id forward unless the caller pinned one themselves.
-                            const { container } = __classPrivateFieldGet(this, _BetaToolRunner_state, "f").params;
-                            if (message.container) {
-                                if (container == null) {
-                                    __classPrivateFieldGet(this, _BetaToolRunner_state, "f").params.container = message.container.id;
+                }
+            }
+            const response = await this.client.beta.messages.create({
+                model,
+                messages: [
+                    ...messages,
+                    {
+                        role: 'user',
+                        content: [
+                            {
+                                type: 'text',
+                                text: summaryPrompt,
+                            },
+                        ],
+                    },
+                ],
+                max_tokens: __classPrivateFieldGet(this, _BetaToolRunner_state, "f").params.max_tokens,
+            }, {
+                signal: __classPrivateFieldGet(this, _BetaToolRunner_options, "f").signal,
+                headers: buildHeaders([__classPrivateFieldGet(this, _BetaToolRunner_options, "f").headers, helperHeader('compaction')]),
+            });
+            if (response.content[0]?.type !== 'text') {
+                throw new AnthropicError('Expected text response for compaction');
+            }
+            __classPrivateFieldGet(this, _BetaToolRunner_state, "f").params.messages = [
+                {
+                    role: 'user',
+                    content: response.content,
+                },
+            ];
+            return true;
+        }, Symbol.asyncIterator)]() {
+            var _a;
+            if (__classPrivateFieldGet(this, _BetaToolRunner_consumed, "f")) {
+                throw new AnthropicError('Cannot iterate over a consumed stream');
+            }
+            __classPrivateFieldSet(this, _BetaToolRunner_consumed, true, "f");
+            __classPrivateFieldSet(this, _BetaToolRunner_mutated, true, "f");
+            __classPrivateFieldSet(this, _BetaToolRunner_toolResponse, undefined, "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) {
+                            break;
+                        }
+                        // The API can't compact a conversation that ends mid-turn, so a paused turn is resumed first.
+                        if (__classPrivateFieldGet(this, _BetaToolRunner_compaction, "f").status === 'scheduled' && !__classPrivateFieldGet(this, _BetaToolRunner_turnPaused, "f")) {
+                            yield* __classPrivateFieldGet(this, _BetaToolRunner_instances, "m", _BetaToolRunner_compact).call(this, __classPrivateFieldGet(this, _BetaToolRunner_compaction, "f").config);
+                            continue;
+                        }
+                        __classPrivateFieldSet(this, _BetaToolRunner_mutated, false, "f");
+                        __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, compactionControl, ...params } = __classPrivateFieldGet(this, _BetaToolRunner_state, "f").params;
+                        yield* __classPrivateFieldGet(this, _BetaToolRunner_instances, "m", _BetaToolRunner_send).call(this, params);
+                        const isCompacted = await __classPrivateFieldGet(this, _BetaToolRunner_instances, "m", _BetaToolRunner_checkAndCompact).call(this);
+                        if (!isCompacted) {
+                            if (!__classPrivateFieldGet(this, _BetaToolRunner_mutated, "f")) {
+                                const message = await __classPrivateFieldGet(this, _BetaToolRunner_message, "f");
+                                const nextStep = determineNextStepFromStopReason(message.stop_reason);
+                                __classPrivateFieldSet(this, _BetaToolRunner_turnPaused, nextStep === 'resume', "f");
+                                __classPrivateFieldGet(this, _BetaToolRunner_state, "f").params.messages.push({ role: message.role, content: message.content });
+                                // Container-bound server tools reject a follow-up request that omits the container the
+                                // previous turn ran in, so carry its id forward unless the caller pinned one themselves.
+                                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 };
+                                    }
                                 }
-                                else if (typeof container === 'object' && container.id == null) {
-                                    __classPrivateFieldGet(this, _BetaToolRunner_state, "f").params.container = { ...container, id: message.container.id };
+                                if (nextStep === 'stop') {
+                                    yield* __classPrivateFieldGet(this, _BetaToolRunner_instances, "m", _BetaToolRunner_compactAfterFinalTurn).call(this);
+                                    break;
+                                }
+                                if (nextStep === 'resume') {
+                                    continue;
                                 }
                             }
-                            if (nextStep === 'stop') {
-                                break;
+                            else {
+                                // The caller has taken over the history, so the last response no longer says how it ends.
+                                __classPrivateFieldSet(this, _BetaToolRunner_turnPaused, false, "f");
                             }
-                            if (nextStep === 'resume') {
-                                continue;
+                            const toolMessage = await __classPrivateFieldGet(this, _BetaToolRunner_instances, "m", _BetaToolRunner_generateToolResponse).call(this, __classPrivateFieldGet(this, _BetaToolRunner_state, "f").params.messages.at(-1));
+                            if (toolMessage) {
+                                __classPrivateFieldGet(this, _BetaToolRunner_state, "f").params.messages.push(toolMessage);
+                            }
+                            else if (!__classPrivateFieldGet(this, _BetaToolRunner_mutated, "f")) {
+                                yield* __classPrivateFieldGet(this, _BetaToolRunner_instances, "m", _BetaToolRunner_compactAfterFinalTurn).call(this);
+                                break;
                             }
-                        }
-                        const toolMessage = await __classPrivateFieldGet(this, _BetaToolRunner_instances, "m", _BetaToolRunner_generateToolResponse).call(this, __classPrivateFieldGet(this, _BetaToolRunner_state, "f").params.messages.at(-1));
-                        if (toolMessage) {
-                            __classPrivateFieldGet(this, _BetaToolRunner_state, "f").params.messages.push(toolMessage);
-                        }
-                        else if (!__classPrivateFieldGet(this, _BetaToolRunner_mutated, "f")) {
-                            break;
                         }
                     }
-                }
-                finally {
-                    if (stream) {
-                        stream.abort();
+                    finally {
+                        __classPrivateFieldGet(this, _BetaToolRunner_stream, "f")?.abort();
+                        __classPrivateFieldSet(this, _BetaToolRunner_stream, undefined, "f");
                     }
                 }
+                if (!__classPrivateFieldGet(this, _BetaToolRunner_message, "f")) {
+                    throw new AnthropicError('ToolRunner concluded without a message from the server');
+                }
+                __classPrivateFieldGet(this, _BetaToolRunner_completion, "f").resolve(await __classPrivateFieldGet(this, _BetaToolRunner_message, "f"));
             }
-            if (!__classPrivateFieldGet(this, _BetaToolRunner_message, "f")) {
-                throw new AnthropicError('ToolRunner concluded without a message from the server');
+            catch (error) {
+                __classPrivateFieldSet(this, _BetaToolRunner_consumed, false, "f");
+                // Silence unhandled promise errors
+                __classPrivateFieldGet(this, _BetaToolRunner_completion, "f").promise.catch(() => { });
+                __classPrivateFieldGet(this, _BetaToolRunner_completion, "f").reject(error);
+                __classPrivateFieldSet(this, _BetaToolRunner_completion, promiseWithResolvers(), "f");
+                throw error;
             }
-            __classPrivateFieldGet(this, _BetaToolRunner_completion, "f").resolve(await __classPrivateFieldGet(this, _BetaToolRunner_message, "f"));
         }
-        catch (error) {
-            __classPrivateFieldSet(this, _BetaToolRunner_consumed, false, "f");
-            // Silence unhandled promise errors
-            __classPrivateFieldGet(this, _BetaToolRunner_completion, "f").promise.catch(() => { });
-            __classPrivateFieldGet(this, _BetaToolRunner_completion, "f").reject(error);
-            __classPrivateFieldSet(this, _BetaToolRunner_completion, promiseWithResolvers(), "f");
-            throw error;
+        setMessagesParams(paramsOrMutator) {
+            const params = typeof paramsOrMutator === 'function' ? paramsOrMutator(__classPrivateFieldGet(this, _BetaToolRunner_state, "f").params) : paramsOrMutator;
+            rejectCompactionParam(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.');
+            }
+            __classPrivateFieldGet(this, _BetaToolRunner_state, "f").params = params;
+            __classPrivateFieldSet(this, _BetaToolRunner_mutated, true, "f");
+            // Invalidate cached tool response since parameters changed
+            __classPrivateFieldSet(this, _BetaToolRunner_toolResponse, undefined, "f");
         }
-    }
-    setMessagesParams(paramsOrMutator) {
-        if (typeof paramsOrMutator === 'function') {
-            __classPrivateFieldGet(this, _BetaToolRunner_state, "f").params = paramsOrMutator(__classPrivateFieldGet(this, _BetaToolRunner_state, "f").params);
+        setRequestOptions(optionsOrMutator) {
+            if (typeof optionsOrMutator === 'function') {
+                __classPrivateFieldSet(this, _BetaToolRunner_options, optionsOrMutator(__classPrivateFieldGet(this, _BetaToolRunner_options, "f")), "f");
+            }
+            else {
+                __classPrivateFieldSet(this, _BetaToolRunner_options, { ...__classPrivateFieldGet(this, _BetaToolRunner_options, "f"), ...optionsOrMutator }, "f");
+            }
         }
-        else {
-            __classPrivateFieldGet(this, _BetaToolRunner_state, "f").params = paramsOrMutator;
+        /**
+         * Get the tool response for the last message from the assistant.
+         * Avoids redundant tool executions by caching results.
+         *
+         * @returns A promise that resolves to a BetaMessageParam containing tool results, or null if no tools need to be executed
+         *
+         * @example
+         * const toolResponse = await runner.generateToolResponse();
+         * if (toolResponse) {
+         *   console.log('Tool results:', toolResponse.content);
+         * }
+         */
+        async generateToolResponse(signal = __classPrivateFieldGet(this, _BetaToolRunner_options, "f").signal) {
+            const message = (await __classPrivateFieldGet(this, _BetaToolRunner_message, "f")) ?? this.params.messages.at(-1);
+            if (!message) {
+                return null;
+            }
+            return __classPrivateFieldGet(this, _BetaToolRunner_instances, "m", _BetaToolRunner_generateToolResponse).call(this, message, signal);
         }
-        __classPrivateFieldSet(this, _BetaToolRunner_mutated, true, "f");
-        // Invalidate cached tool response since parameters changed
-        __classPrivateFieldSet(this, _BetaToolRunner_toolResponse, undefined, "f");
-    }
-    setRequestOptions(optionsOrMutator) {
-        if (typeof optionsOrMutator === 'function') {
-            __classPrivateFieldSet(this, _BetaToolRunner_options, optionsOrMutator(__classPrivateFieldGet(this, _BetaToolRunner_options, "f")), "f");
+        /**
+         * Wait for the async iterator to complete. This works even if the async iterator hasn't yet started, and
+         * will wait for an instance to start and go to completion.
+         *
+         * @returns A promise that resolves to the final BetaMessage when the iterator completes
+         *
+         * @example
+         * // Start consuming the iterator
+         * for await (const message of runner) {
+         *   console.log('Message:', message.content);
+         * }
+         *
+         * // Meanwhile, wait for completion from another part of the code
+         * const finalMessage = await runner.done();
+         * console.log('Final response:', finalMessage.content);
+         */
+        done() {
+            return __classPrivateFieldGet(this, _BetaToolRunner_completion, "f").promise;
         }
-        else {
-            __classPrivateFieldSet(this, _BetaToolRunner_options, { ...__classPrivateFieldGet(this, _BetaToolRunner_options, "f"), ...optionsOrMutator }, "f");
+        /**
+         * Returns a promise indicating that the stream is done. Unlike .done(), this will eagerly read the stream:
+         * * If the iterator has not been consumed, consume the entire iterator and return the final message from the
+         * assistant.
+         * * If the iterator has been consumed, waits for it to complete and returns the final message.
+         *
+         * @returns A promise that resolves to the final BetaMessage from the conversation
+         * @throws {AnthropicError} If no messages were processed during the conversation
+         *
+         * @example
+         * const finalMessage = await runner.runUntilDone();
+         * console.log('Final response:', finalMessage.content);
+         */
+        async runUntilDone() {
+            // If not yet consumed, start consuming and wait for completion
+            if (!__classPrivateFieldGet(this, _BetaToolRunner_consumed, "f")) {
+                for await (const _ of this) {
+                    // Iterator naturally populates this.#message
+                }
+            }
+            // If consumed but not completed, wait for completion
+            return this.done();
         }
-    }
-    /**
-     * Get the tool response for the last message from the assistant.
-     * Avoids redundant tool executions by caching results.
-     *
-     * @returns A promise that resolves to a BetaMessageParam containing tool results, or null if no tools need to be executed
-     *
-     * @example
-     * const toolResponse = await runner.generateToolResponse();
-     * if (toolResponse) {
-     *   console.log('Tool results:', toolResponse.content);
-     * }
-     */
-    async generateToolResponse(signal = __classPrivateFieldGet(this, _BetaToolRunner_options, "f").signal) {
-        const message = (await __classPrivateFieldGet(this, _BetaToolRunner_message, "f")) ?? this.params.messages.at(-1);
-        if (!message) {
-            return null;
+        /**
+         * Get the current parameters being used by the ToolRunner.
+         *
+         * @returns A readonly view of the current ToolRunnerParams
+         *
+         * @example
+         * const currentParams = runner.params;
+         * console.log('Current model:', currentParams.model);
+         * console.log('Message count:', currentParams.messages.length);
+         */
+        get params() {
+            return __classPrivateFieldGet(this, _BetaToolRunner_state, "f").params;
         }
-        return __classPrivateFieldGet(this, _BetaToolRunner_instances, "m", _BetaToolRunner_generateToolResponse).call(this, message, signal);
-    }
-    /**
-     * Wait for the async iterator to complete. This works even if the async iterator hasn't yet started, and
-     * will wait for an instance to start and go to completion.
-     *
-     * @returns A promise that resolves to the final BetaMessage when the iterator completes
-     *
-     * @example
-     * // Start consuming the iterator
-     * for await (const message of runner) {
-     *   console.log('Message:', message.content);
-     * }
-     *
-     * // Meanwhile, wait for completion from another part of the code
-     * const finalMessage = await runner.done();
-     * console.log('Final response:', finalMessage.content);
-     */
-    done() {
-        return __classPrivateFieldGet(this, _BetaToolRunner_completion, "f").promise;
-    }
-    /**
-     * Returns a promise indicating that the stream is done. Unlike .done(), this will eagerly read the stream:
-     * * If the iterator has not been consumed, consume the entire iterator and return the final message from the
-     * assistant.
-     * * If the iterator has been consumed, waits for it to complete and returns the final message.
-     *
-     * @returns A promise that resolves to the final BetaMessage from the conversation
-     * @throws {AnthropicError} If no messages were processed during the conversation
-     *
-     * @example
-     * const finalMessage = await runner.runUntilDone();
-     * console.log('Final response:', finalMessage.content);
-     */
-    async runUntilDone() {
-        // If not yet consumed, start consuming and wait for completion
-        if (!__classPrivateFieldGet(this, _BetaToolRunner_consumed, "f")) {
-            for await (const _ of this) {
-                // Iterator naturally populates this.#message
+        /**
+         * Add one or more messages to the conversation history.
+         *
+         * @param messages - One or more BetaMessageParam objects to add to the conversation
+         *
+         * @example
+         * runner.pushMessages(
+         *   { role: 'user', content: 'Also, what about the weather in NYC?' }
+         * );
+         *
+         * @example
+         * // Adding multiple messages
+         * runner.pushMessages(
+         *   { role: 'user', content: 'What about NYC?' },
+         *   { role: 'user', content: 'And Boston?' }
+         * );
+         */
+        pushMessages(...messages) {
+            this.setMessagesParams((params) => ({
+                ...params,
+                messages: [...params.messages, ...messages],
+            }));
+        }
+        /**
+         * Schedule a compaction of the conversation. Once the current turn has finished, including any tool
+         * calls, the runner requests a summary and replaces the message history with the compaction response,
+         * which is yielded like any other message. Requires the `compact-2026-09-04` beta.
+         *
+         * @param compaction - The config to send, as `messages.create()` takes it. Defaults to `{ type: 'summarize' }`
+         *
+         * @example
+         * for await (const message of runner) {
+         *   if (message.usage.input_tokens > 100_000) {
+         *     runner.compactBeforeNextTurn();
+         *   }
+         * }
+         */
+        compactBeforeNextTurn(compaction) {
+            if (__classPrivateFieldGet(this, _BetaToolRunner_compaction, "f").status === 'in_flight') {
+                return;
             }
+            rejectCompactionEdit(__classPrivateFieldGet(this, _BetaToolRunner_state, "f").params);
+            __classPrivateFieldSet(this, _BetaToolRunner_compaction, { status: 'scheduled', config: compaction ?? { type: 'summarize' } }, "f");
+        }
+        /**
+         * Makes the ToolRunner directly awaitable, equivalent to calling .runUntilDone()
+         * This allows using `await runner` instead of `await runner.runUntilDone()`
+         */
+        then(onfulfilled, onrejected) {
+            return this.runUntilDone().then(onfulfilled, onrejected);
         }
-        // If consumed but not completed, wait for completion
-        return this.done();
-    }
-    /**
-     * Get the current parameters being used by the ToolRunner.
-     *
-     * @returns A readonly view of the current ToolRunnerParams
-     *
-     * @example
-     * const currentParams = runner.params;
-     * console.log('Current model:', currentParams.model);
-     * console.log('Message count:', currentParams.messages.length);
-     */
-    get params() {
-        return __classPrivateFieldGet(this, _BetaToolRunner_state, "f").params;
-    }
-    /**
-     * Add one or more messages to the conversation history.
-     *
-     * @param messages - One or more BetaMessageParam objects to add to the conversation
-     *
-     * @example
-     * runner.pushMessages(
-     *   { role: 'user', content: 'Also, what about the weather in NYC?' }
-     * );
-     *
-     * @example
-     * // Adding multiple messages
-     * runner.pushMessages(
-     *   { role: 'user', content: 'What about NYC?' },
-     *   { role: 'user', content: 'And Boston?' }
-     * );
-     */
-    pushMessages(...messages) {
-        this.setMessagesParams((params) => ({
-            ...params,
-            messages: [...params.messages, ...messages],
-        }));
     }
+    _BetaToolRunner_send = 
     /**
-     * Makes the ToolRunner directly awaitable, equivalent to calling .runUntilDone()
-     * This allows using `await runner` instead of `await runner.runUntilDone()`
+     * Sends one request and yields its message, or its stream when streaming. `#message` and `#stream` are set
+     * before the yield, so they are there while the caller handles the item; the loop aborts the stream at the
+     * end of the iteration.
      */
-    then(onfulfilled, onrejected) {
-        return this.runUntilDone().then(onfulfilled, onrejected);
+    async function* _BetaToolRunner_send(params) {
+        if (params.stream) {
+            __classPrivateFieldSet(this, _BetaToolRunner_stream, this.client.beta.messages.stream({ ...params }, __classPrivateFieldGet(this, _BetaToolRunner_options, "f")), "f");
+            __classPrivateFieldSet(this, _BetaToolRunner_message, __classPrivateFieldGet(this, _BetaToolRunner_stream, "f").finalMessage(), "f");
+            // Make sure that this promise doesn't throw before we get the option to do something about it.
+            // Error will be caught when we call await this.#message ultimately
+            __classPrivateFieldGet(this, _BetaToolRunner_message, "f").catch(() => { });
+            yield __classPrivateFieldGet(this, _BetaToolRunner_stream, "f");
+        }
+        else {
+            __classPrivateFieldSet(this, _BetaToolRunner_message, this.client.beta.messages.create({ ...params, stream: false }, __classPrivateFieldGet(this, _BetaToolRunner_options, "f")), "f");
+            yield __classPrivateFieldGet(this, _BetaToolRunner_message, "f");
+        }
+    }, _BetaToolRunner_compact = async function* _BetaToolRunner_compact(compaction) {
+        rejectCompactionEdit(__classPrivateFieldGet(this, _BetaToolRunner_state, "f").params);
+        // The API refuses `compaction` alongside `context_management`; later requests keep it.
+        const { max_iterations, compactionControl, context_management, ...params } = __classPrivateFieldGet(this, _BetaToolRunner_state, "f").params;
+        __classPrivateFieldSet(this, _BetaToolRunner_compaction, { status: 'in_flight' }, "f");
+        __classPrivateFieldSet(this, _BetaToolRunner_toolResponse, undefined, "f");
+        const lastMessage = __classPrivateFieldGet(this, _BetaToolRunner_message, "f");
+        try {
+            yield* __classPrivateFieldGet(this, _BetaToolRunner_instances, "m", _BetaToolRunner_send).call(this, { ...params, compaction });
+            const message = await __classPrivateFieldGet(this, _BetaToolRunner_message, "f");
+            if (message.content.some((block) => block.type === 'compaction' && block.content)) {
+                // The response has to be sent back as it came, first, replacing the messages it summarizes.
+                __classPrivateFieldGet(this, _BetaToolRunner_state, "f").params.messages = [{ role: message.role, content: message.content }];
+            }
+            else {
+                loggerFor(this.client).warn('Compaction produced no summary; keeping the conversation as it is.');
+                // If the run ends here, `done()` resolves to the last real message rather than this response.
+                __classPrivateFieldSet(this, _BetaToolRunner_message, lastMessage, "f");
+            }
+        }
+        finally {
+            __classPrivateFieldSet(this, _BetaToolRunner_compaction, { status: 'idle' }, "f");
+        }
+    }, _BetaToolRunner_compactAfterFinalTurn = async function* _BetaToolRunner_compactAfterFinalTurn() {
+        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')) {
+            // A turn that was cut short can end with tool calls that are never run, and the API can't
+            // compact a conversation whose last turn has an unanswered tool call.
+            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.');
+            __classPrivateFieldSet(this, _BetaToolRunner_compaction, { status: 'idle' }, "f");
+            return;
+        }
+        yield* __classPrivateFieldGet(this, _BetaToolRunner_instances, "m", _BetaToolRunner_compact).call(this, __classPrivateFieldGet(this, _BetaToolRunner_compaction, "f").config);
+    }, _BetaToolRunner_generateToolResponse = async function _BetaToolRunner_generateToolResponse(lastMessage, signal = __classPrivateFieldGet(this, _BetaToolRunner_options, "f").signal) {
+        if (__classPrivateFieldGet(this, _BetaToolRunner_toolResponse, "f") !== undefined) {
+            return __classPrivateFieldGet(this, _BetaToolRunner_toolResponse, "f");
+        }
+        __classPrivateFieldSet(this, _BetaToolRunner_toolResponse, generateToolResponse(__classPrivateFieldGet(this, _BetaToolRunner_state, "f").params, lastMessage, {
+            ...__classPrivateFieldGet(this, _BetaToolRunner_options, "f"),
+            signal,
+        }), "f");
+        return __classPrivateFieldGet(this, _BetaToolRunner_toolResponse, "f");
+    };
+    return BetaToolRunner;
+})();
+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.');
     }
 }
-_BetaToolRunner_generateToolResponse = async function _BetaToolRunner_generateToolResponse(lastMessage, signal = __classPrivateFieldGet(this, _BetaToolRunner_options, "f").signal) {
-    if (__classPrivateFieldGet(this, _BetaToolRunner_toolResponse, "f") !== undefined) {
-        return __classPrivateFieldGet(this, _BetaToolRunner_toolResponse, "f");
+function rejectCompactionEdit(params) {
+    // The compaction request is sent without `context_management`, so the API can't refuse the pair there:
+    // it would run and bill the compaction, then refuse the next request.
+    if (params.context_management?.edits?.some((edit) => edit.type.startsWith('compact_'))) {
+        throw new AnthropicError("`compactBeforeNextTurn()` can't be used while `context_management` has a compaction edit, " +
+            "because the API doesn't accept a compaction block together with one. Remove the edit first.");
     }
-    __classPrivateFieldSet(this, _BetaToolRunner_toolResponse, generateToolResponse(__classPrivateFieldGet(this, _BetaToolRunner_state, "f").params, lastMessage, {
-        ...__classPrivateFieldGet(this, _BetaToolRunner_options, "f"),
-        signal,
-    }), "f");
-    return __classPrivateFieldGet(this, _BetaToolRunner_toolResponse, "f");
-};
+}
 async function generateToolResponse(params, lastMessage = params.messages.at(-1), requestOptions) {
     // Only process if the last message is from the assistant and has tool use blocks
     if (!lastMessage ||