@agentionai/agents 1.6.0 → 1.7.0-beta.0

package/dist/agents/mistral/MistralAgent.js

@@ -6,6 +6,7 @@ const mistralai_1 = require("@mistralai/mistralai");
 const http_1 = require("@mistralai/mistralai/lib/http");
 const BaseAgent_1 = require("../BaseAgent");
 const AgentEvent_1 = require("../AgentEvent");
+const cancellation_1 = require("../cancellation");
 const AgentError_1 = require("../errors/AgentError");
 const transformers_1 = require("../../history/transformers");
 const components_1 = require("@mistralai/mistralai/models/components");
@@ -129,7 +130,7 @@ class MistralAgent extends BaseAgent_1.BaseAgent {
     async process(_input) {
         return "";
     }
-    async execute(input) {
+    async execute(input, options) {
         this.emit(AgentEvent_1.AgentEvent.BEFORE_EXECUTE, input);
         // Reset token usage for this execution
         this.resetTokenUsage();
@@ -169,11 +170,19 @@ class MistralAgent extends BaseAgent_1.BaseAgent {
                 randomSeed: this.config.randomSeed,
                 safePrompt: this.config.safePrompt,
                 stop: this.config.stopSequences,
-            });
+            }, { signal: options?.signal });
             this.emit(AgentEvent_1.AgentEvent.AFTER_EXECUTE, response);
-            return await this.handleResponse(response);
+            return await this.handleResponse(response, options);
         }
         catch (error) {
+            if ((0, cancellation_1.isAbortError)(error, options?.signal)) {
+                const abortError = this.abortError(error, options?.signal);
+                if (this.vizEventId) {
+                    VizReporter_1.vizReporter.agentError(this.vizEventId, "AbortError", abortError.message, false);
+                    this.vizEventId = undefined;
+                }
+                throw abortError;
+            }
             const err = error;
             if (err.status) {
                 const apiError = new AgentError_1.ApiError(`Mistral API error: ${err.message || "Unknown error"}`, err.status, error);
@@ -200,7 +209,7 @@ class MistralAgent extends BaseAgent_1.BaseAgent {
             this.history.endExecution();
         }
     }
-    async handleResponse(response) {
+    async handleResponse(response, options) {
         if (!response.choices || response.choices.length === 0) {
             const error = new AgentError_1.ExecutionError("Empty response from Mistral API");
             this.emit(AgentEvent_1.AgentEvent.ERROR, error);
@@ -255,18 +264,26 @@ class MistralAgent extends BaseAgent_1.BaseAgent {
         }
         else if (choice.finishReason === "tool_calls" || message.toolCalls) {
             try {
+                // Stop before the assistant turn is written: nothing else would notice
+                // a cancellation until the next provider call, and bailing out here
+                // avoids both running the tools' side effects and leaving a tool call
+                // in history with no tool message to answer it.
+                (0, cancellation_1.throwIfAborted)(options?.signal, `Execution of agent ${this.getName()}`);
                 this.emit(AgentEvent_1.AgentEvent.TOOL_USE, message.toolCalls);
                 // Add assistant message with tool calls to history (normalized)
                 const assistantEntry = transformers_1.mistralTransformer.fromProviderMessage(message);
                 this.addToHistory(assistantEntry);
-                const toolResults = await this.handleToolCalls(message.toolCalls || []);
+                const toolResults = await this.handleToolCalls(message.toolCalls || [], options);
                 // Add tool results to history (normalized)
                 for (const result of toolResults) {
                     const resultEntry = transformers_1.mistralTransformer.toolResultEntry(result.toolCallId, result.name, result.content);
                     this.addToHistory(resultEntry);
                 }
-                // Rate limiting delay for Mistral
-                await (0, promises_1.setTimeout)(this.config.rateLimitDelay || 1500);
+                // Rate limiting delay for Mistral. Aborting during the wait rejects
+                // immediately rather than sitting out the full delay first.
+                await (0, promises_1.setTimeout)(this.config.rateLimitDelay || 1500, undefined, {
+                    signal: options?.signal,
+                });
                 // Continue conversation
                 try {
                     const messages = transformers_1.mistralTransformer.toProvider(this.history.getEntries());
@@ -281,9 +298,9 @@ class MistralAgent extends BaseAgent_1.BaseAgent {
                         randomSeed: this.config.randomSeed,
                         safePrompt: this.config.safePrompt,
                         stop: this.config.stopSequences,
-                    });
+                    }, { signal: options?.signal });
                     this.emit(AgentEvent_1.AgentEvent.AFTER_EXECUTE, newResponse);
-                    return this.handleResponse(newResponse);
+                    return this.handleResponse(newResponse, options);
                 }
                 catch (error) {
                     const err = error;
@@ -316,7 +333,7 @@ class MistralAgent extends BaseAgent_1.BaseAgent {
         }
         throw error;
     }
-    async handleToolCalls(toolCalls) {
+    async handleToolCalls(toolCalls, options) {
         if (!toolCalls.length) {
             throw new AgentError_1.ExecutionError("No tool calls found in response");
         }
@@ -346,7 +363,7 @@ class MistralAgent extends BaseAgent_1.BaseAgent {
                 else {
                     args = toolCall.function.arguments;
                 }
-                const result = await tool.execute(this.getId(), this.getName(), args, toolCallId, this.config.model, "mistral");
+                const result = await tool.execute(this.getId(), this.getName(), args, toolCallId, this.config.model, "mistral", { signal: options?.signal });
                 return {
                     name: toolName,
                     toolCallId,

package/dist/agents/ollama/OllamaAgent.d.ts

@@ -1,4 +1,5 @@
 import { BaseAgent, BaseAgentConfig, ModelInfo, TokenUsage } from "../BaseAgent";
+import { ExecuteOptions } from "../cancellation";
 import { History, MessageContent } from "../../history/History";
 import { OllamaModel } from "../model-types";
 type AgentConfig = BaseAgentConfig & {
@@ -50,9 +51,22 @@ export declare class OllamaAgent extends BaseAgent {
     private vizEventId?;
     /** Count of tool calls in current execution */
     private currentToolCallCount;
-    /** Cached Ollama client instance */
+    /** Cached signal-less Ollama client instance */
     private _client;
+    /** Cached constructor from the optional `ollama` peer dependency */
+    private _clientClass;
     constructor(config: Omit<AgentConfig, "vendor">, history?: History);
+    private loadClientClass;
+    /**
+     * Get an Ollama client.
+     *
+     * The `ollama` package takes no per-request options — its own `abort()`
+     * cancels every streamed request on the client at once, which is too blunt
+     * for a per-run signal. A client does accept a `fetch` implementation
+     * though, so a run with a signal gets its own client whose `fetch` attaches
+     * that signal to each request. Clients are cheap (they open no connection),
+     * and the signal-less one is still cached and shared.
+     */
     private getClient;
     /**
      * List the models currently available on the Ollama server.
@@ -64,10 +78,10 @@ export declare class OllamaAgent extends BaseAgent {
     listModels(): Promise<ModelInfo<OllamaModelInfo>[]>;
     protected getToolDefinitions(): OllamaToolDefinition[];
     protected process(_input: string): Promise<string>;
-    execute(input: string | MessageContent[]): Promise<string>;
+    execute(input: string | MessageContent[], options?: ExecuteOptions): Promise<string>;
     private buildOptions;
     private callOllama;
-    protected handleResponse(response: unknown): Promise<string>;
+    protected handleResponse(response: unknown, options?: ExecuteOptions): Promise<string>;
     private handleToolCalls;
     protected parseUsage(input: unknown): TokenUsage;
 }

package/dist/agents/ollama/OllamaAgent.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.OllamaAgent = void 0;
 const BaseAgent_1 = require("../BaseAgent");
 const AgentEvent_1 = require("../AgentEvent");
+const cancellation_1 = require("../cancellation");
 const AgentError_1 = require("../errors/AgentError");
 const transformers_1 = require("../../history/transformers");
 const VizReporter_1 = require("../../viz/VizReporter");
@@ -73,8 +74,10 @@ class OllamaAgent extends BaseAgent_1.BaseAgent {
         super({ ...config, vendor: "ollama" }, history);
         /** Count of tool calls in current execution */
         this.currentToolCallCount = 0;
-        /** Cached Ollama client instance */
+        /** Cached signal-less Ollama client instance */
         this._client = null;
+        /** Cached constructor from the optional `ollama` peer dependency */
+        this._clientClass = null;
         const vendorConfig = config.vendorConfig?.ollama || {};
         const host = config.host ?? vendorConfig.host;
         this.config = {
@@ -91,8 +94,8 @@ class OllamaAgent extends BaseAgent_1.BaseAgent {
         };
         this.addSystemMessage(this.getSystemMessage());
     }
-    async getClient() {
-        if (!this._client) {
+    async loadClientClass() {
+        if (!this._clientClass) {
             const pkg = "ollama";
             try {
                 const mod = (await Promise.resolve(`${pkg}`).then(s => __importStar(require(s))));
@@ -100,15 +103,39 @@ class OllamaAgent extends BaseAgent_1.BaseAgent {
                 if (!OllamaClass) {
                     throw new Error("Could not find Ollama class in ollama package");
                 }
-                this._client = new OllamaClass({
-                    host: this.config.host,
-                    headers: this.config.defaultHeaders,
-                });
+                this._clientClass = OllamaClass;
             }
             catch (err) {
                 throw new AgentError_1.ExecutionError(`Failed to load 'ollama' package. Install it with: npm install ollama\n${err instanceof Error ? err.message : String(err)}`);
             }
         }
+        return this._clientClass;
+    }
+    /**
+     * Get an Ollama client.
+     *
+     * The `ollama` package takes no per-request options — its own `abort()`
+     * cancels every streamed request on the client at once, which is too blunt
+     * for a per-run signal. A client does accept a `fetch` implementation
+     * though, so a run with a signal gets its own client whose `fetch` attaches
+     * that signal to each request. Clients are cheap (they open no connection),
+     * and the signal-less one is still cached and shared.
+     */
+    async getClient(signal) {
+        if (!signal && this._client)
+            return this._client;
+        const OllamaClass = await this.loadClientClass();
+        if (signal) {
+            return new OllamaClass({
+                host: this.config.host,
+                headers: this.config.defaultHeaders,
+                fetch: fetchWithSignal(signal),
+            });
+        }
+        this._client ?? (this._client = new OllamaClass({
+            host: this.config.host,
+            headers: this.config.defaultHeaders,
+        }));
         return this._client;
     }
     /**
@@ -146,7 +173,7 @@ class OllamaAgent extends BaseAgent_1.BaseAgent {
     async process(_input) {
         return "";
     }
-    async execute(input) {
+    async execute(input, options) {
         this.emit(AgentEvent_1.AgentEvent.BEFORE_EXECUTE, input);
         this.resetTokenUsage();
         this.currentToolCallCount = 0;
@@ -167,12 +194,19 @@ class OllamaAgent extends BaseAgent_1.BaseAgent {
         this.history.setSessionAnchor();
         this.history.beginExecution();
         try {
-            await this.getClient(); // ensure client is cached before handleResponse loop
-            const response = await this.callOllama();
+            const response = await this.callOllama(options);
             this.emit(AgentEvent_1.AgentEvent.AFTER_EXECUTE, response);
-            return await this.handleResponse(response);
+            return await this.handleResponse(response, options);
         }
         catch (error) {
+            if ((0, cancellation_1.isAbortError)(error, options?.signal)) {
+                const abortError = this.abortError(error, options?.signal);
+                if (this.vizEventId) {
+                    VizReporter_1.vizReporter.agentError(this.vizEventId, "AbortError", abortError.message, false);
+                    this.vizEventId = undefined;
+                }
+                throw abortError;
+            }
             if (error instanceof AgentError_1.ExecutionError || error instanceof AgentError_1.ApiError) {
                 this.emit(AgentEvent_1.AgentEvent.ERROR, error);
                 if (this.vizEventId) {
@@ -211,8 +245,8 @@ class OllamaAgent extends BaseAgent_1.BaseAgent {
             opts.think = this.config.think;
         return opts;
     }
-    async callOllama() {
-        const client = await this.getClient();
+    async callOllama(executeOptions) {
+        const client = await this.getClient(executeOptions?.signal);
         const messages = transformers_1.ollamaTransformer.toProvider(this.history.getEntries());
         const tools = this.tools.size > 0 ? this.getToolDefinitions() : undefined;
         const options = this.buildOptions();
@@ -226,7 +260,7 @@ class OllamaAgent extends BaseAgent_1.BaseAgent {
             options: Object.keys(options).length > 0 ? options : undefined,
         });
     }
-    async handleResponse(response) {
+    async handleResponse(response, options) {
         const ollamaResponse = response;
         const usage = this.accumulateUsage(this.parseUsage(ollamaResponse));
         if (ollamaResponse.done_reason === "length") {
@@ -258,22 +292,27 @@ class OllamaAgent extends BaseAgent_1.BaseAgent {
         }
         // Tool calls detected
         const toolCalls = message.tool_calls;
+        // Stop before the assistant turn is written: nothing else would notice a
+        // cancellation until the next provider call, and bailing out here avoids
+        // both running the tools' side effects and leaving a tool call in history
+        // with no tool message to answer it.
+        (0, cancellation_1.throwIfAborted)(options?.signal, `Execution of agent ${this.getName()}`);
         this.emit(AgentEvent_1.AgentEvent.TOOL_USE, toolCalls);
         this.currentToolCallCount += toolCalls.length;
         // Generate IDs — Ollama doesn't provide tool call IDs
         const generatedIds = toolCalls.map((_, i) => `ollama_${Date.now()}_${i}`);
         const assistantEntry = transformers_1.ollamaTransformer.fromProviderMessage(message, generatedIds);
         this.addToHistory(assistantEntry);
-        const toolResults = await this.handleToolCalls(toolCalls, generatedIds);
+        const toolResults = await this.handleToolCalls(toolCalls, generatedIds, options);
         for (const result of toolResults) {
             const resultEntry = transformers_1.ollamaTransformer.toolResultEntry(result.toolCallId, result.content);
             this.addToHistory(resultEntry);
         }
         // Continue conversation with tool results
         try {
-            const newResponse = await this.callOllama();
+            const newResponse = await this.callOllama(options);
             this.emit(AgentEvent_1.AgentEvent.AFTER_EXECUTE, newResponse);
-            return this.handleResponse(newResponse);
+            return this.handleResponse(newResponse, options);
         }
         catch (error) {
             const executionError = new AgentError_1.ExecutionError(`Ollama error during tool response: ${error instanceof Error ? error.message : "Unknown error"}`);
@@ -281,7 +320,7 @@ class OllamaAgent extends BaseAgent_1.BaseAgent {
             throw executionError;
         }
     }
-    async handleToolCalls(toolCalls, generatedIds) {
+    async handleToolCalls(toolCalls, generatedIds, options) {
         return Promise.all(toolCalls.map(async (toolCall, idx) => {
             const toolName = toolCall.function.name;
             const tool = this.tools.get(toolName);
@@ -296,7 +335,7 @@ class OllamaAgent extends BaseAgent_1.BaseAgent {
                 const args = typeof toolCall.function.arguments === "string"
                     ? JSON.parse(toolCall.function.arguments)
                     : toolCall.function.arguments;
-                const result = await tool.execute(this.getId(), this.getName(), args, toolCallId, this.config.model, "ollama");
+                const result = await tool.execute(this.getId(), this.getName(), args, toolCallId, this.config.model, "ollama", { signal: options?.signal });
                 return { toolCallId, content: JSON.stringify(result) };
             }
             catch (error) {
@@ -329,4 +368,15 @@ class OllamaAgent extends BaseAgent_1.BaseAgent {
     }
 }
 exports.OllamaAgent = OllamaAgent;
+/**
+ * Wrap the global `fetch` so every request carries `signal`, keeping any
+ * signal the caller already set — the `ollama` package attaches its own to
+ * streamed requests so that its `abort()` keeps working.
+ */
+function fetchWithSignal(signal) {
+    return (input, init) => fetch(input, {
+        ...init,
+        signal: (0, cancellation_1.combineSignals)(init?.signal ?? undefined, signal),
+    });
+}
 //# sourceMappingURL=OllamaAgent.js.map

package/dist/agents/openai/OpenAiAgent.d.ts

@@ -1,4 +1,5 @@
 import { BaseAgent, BaseAgentConfig, ModelInfo, TokenUsage } from "../BaseAgent";
+import { ExecuteOptions } from "../cancellation";
 import { History, MessageContent } from "../../history/History";
 import { Tool, Response, ResponseUsage } from "openai/resources/responses/responses";
 import type { Model as OpenAIModelCard } from "openai/resources/models";
@@ -95,8 +96,8 @@ export declare class OpenAiAgent<M extends OpenAIModel = OpenAIModel> extends Ba
      */
     private buildReasoningParams;
     protected process(_input: string): Promise<string>;
-    execute(input: string | MessageContent[]): Promise<string>;
-    protected handleResponse(response: Response): Promise<string>;
+    execute(input: string | MessageContent[], options?: ExecuteOptions): Promise<string>;
+    protected handleResponse(response: Response, options?: ExecuteOptions): Promise<string>;
     private handleToolUse;
     /**
      * Stream a response as an async generator of `StreamChunk` objects.
@@ -110,7 +111,7 @@ export declare class OpenAiAgent<M extends OpenAIModel = OpenAIModel> extends Ba
      * }
      * ```
      */
-    executeStream(input: string | MessageContent[]): AsyncGenerator<StreamChunk>;
+    executeStream(input: string | MessageContent[], options?: ExecuteOptions): AsyncGenerator<StreamChunk>;
     private streamTurn;
     protected parseUsage(input: ResponseUsage): TokenUsage;
 }

package/dist/agents/openai/OpenAiAgent.js

@@ -8,6 +8,7 @@ exports.lowestReasoningEffort = lowestReasoningEffort;
 const openai_1 = __importDefault(require("openai"));
 const BaseAgent_1 = require("../BaseAgent");
 const AgentEvent_1 = require("../AgentEvent");
+const cancellation_1 = require("../cancellation");
 const AgentError_1 = require("../errors/AgentError");
 const transformers_1 = require("../../history/transformers");
 const VizReporter_1 = require("../../viz/VizReporter");
@@ -163,7 +164,7 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
     async process(_input) {
         return "";
     }
-    async execute(input) {
+    async execute(input, options) {
         this.emit(AgentEvent_1.AgentEvent.BEFORE_EXECUTE, input);
         // Reset token usage for this execution
         this.resetTokenUsage();
@@ -204,11 +205,19 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
                 // Note: Responses API doesn't support seed, presence_penalty, frequency_penalty, stop
                 user: this.config.user,
                 ...this.buildReasoningParams(),
-            });
+            }, { signal: options?.signal });
             this.emit(AgentEvent_1.AgentEvent.AFTER_EXECUTE, response);
-            return await this.handleResponse(response);
+            return await this.handleResponse(response, options);
         }
         catch (error) {
+            if ((0, cancellation_1.isAbortError)(error, options?.signal)) {
+                const abortError = this.abortError(error, options?.signal);
+                if (this.vizEventId) {
+                    VizReporter_1.vizReporter.agentError(this.vizEventId, "AbortError", abortError.message, false);
+                    this.vizEventId = undefined;
+                }
+                throw abortError;
+            }
             if (error && typeof error === "object" && "error" in error) {
                 const openAIError = error;
                 const apiError = new AgentError_1.ApiError(`OpenAI API error: ${openAIError.error.message || "Unknown error"}`, openAIError.status, openAIError.error);
@@ -239,7 +248,7 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
             this.history.endExecution();
         }
     }
-    async handleResponse(response) {
+    async handleResponse(response, options) {
         if (!response.output || !response.output.length) {
             const error = new AgentError_1.ExecutionError("Invalid response format: missing output");
             this.emit(AgentEvent_1.AgentEvent.ERROR, error);
@@ -288,6 +297,11 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
         }
         else if (toolCalls.length) {
             try {
+                // Stop before the assistant turn is written: nothing else would notice
+                // a cancellation until the next provider call, and bailing out here
+                // avoids both running the tools' side effects and leaving a function
+                // call in history with no output to answer it.
+                (0, cancellation_1.throwIfAborted)(options?.signal, `Execution of agent ${this.getName()}`);
                 // Add assistant message with tool calls to history (normalized)
                 const functionCalls = toolCalls.map((tc) => ({
                     id: tc.id || tc.call_id,
@@ -297,7 +311,7 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
                 }));
                 const assistantEntry = transformers_1.openAiTransformer.fromProviderMessage("assistant", response.output_text || "", functionCalls);
                 this.addToHistory(assistantEntry);
-                const toolResponses = await this.handleToolUse(toolCalls);
+                const toolResponses = await this.handleToolUse(toolCalls, options);
                 // Add tool results to history (normalized)
                 for (const result of toolResponses) {
                     const resultEntry = transformers_1.openAiTransformer.toolResultEntry(result.call_id, result.output, false);
@@ -318,9 +332,9 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
                         // Note: Responses API doesn't support seed, presence_penalty, frequency_penalty, stop
                         user: this.config.user,
                         ...this.buildReasoningParams(),
-                    });
+                    }, { signal: options?.signal });
                     this.emit(AgentEvent_1.AgentEvent.AFTER_EXECUTE, newResponse);
-                    return this.handleResponse(newResponse);
+                    return this.handleResponse(newResponse, options);
                 }
                 catch (error) {
                     if (error && typeof error === "object" && "error" in error) {
@@ -358,7 +372,7 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
             throw error;
         }
     }
-    async handleToolUse(content) {
+    async handleToolUse(content, options) {
         if (!content || !content.length) {
             throw new AgentError_1.ExecutionError("Invalid tool calls content");
         }
@@ -389,7 +403,7 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
                 catch (parseError) {
                     throw new AgentError_1.ToolExecutionError(`Invalid tool arguments: ${parseError instanceof Error ? parseError.message : "Parse error"}`, toolName, toolCall.arguments);
                 }
-                const result = await tool.execute(this.getId(), this.getName(), toolArgs, toolCall.id || "", this.config.model, "openai");
+                const result = await tool.execute(this.getId(), this.getName(), toolArgs, toolCall.id || "", this.config.model, "openai", { signal: options?.signal });
                 return {
                     call_id: toolCall.call_id,
                     output: JSON.stringify(result),
@@ -422,7 +436,7 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
      * }
      * ```
      */
-    async *executeStream(input) {
+    async *executeStream(input, options) {
         this.emit(AgentEvent_1.AgentEvent.BEFORE_EXECUTE, input);
         this.resetTokenUsage();
         this.currentToolCallCount = 0;
@@ -443,9 +457,17 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
         this.history.setSessionAnchor();
         this.history.beginExecution();
         try {
-            yield* this.streamTurn();
+            yield* this.streamTurn(options);
         }
         catch (error) {
+            if ((0, cancellation_1.isAbortError)(error, options?.signal)) {
+                const abortError = this.abortError(error, options?.signal);
+                if (this.vizEventId) {
+                    VizReporter_1.vizReporter.agentError(this.vizEventId, "AbortError", abortError.message, false);
+                    this.vizEventId = undefined;
+                }
+                throw abortError;
+            }
             if (error instanceof AgentError_1.AgentError) {
                 this.emit(AgentEvent_1.AgentEvent.ERROR, error);
                 if (this.vizEventId) {
@@ -476,7 +498,7 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
             this.history.endExecution();
         }
     }
-    async *streamTurn() {
+    async *streamTurn(options) {
         const inputMessages = transformers_1.openAiTransformer.toProvider(this.history.getEntries());
         this.startTurnTimer();
         const stream = await this.client.responses.create({
@@ -490,7 +512,7 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
             top_p: this.config.topP,
             user: this.config.user,
             ...this.buildReasoningParams("auto"),
-        });
+        }, { signal: options?.signal });
         let completedEvent = null;
         for await (const event of stream) {
             if (event.type === "response.output_text.delta") {
@@ -513,12 +535,19 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
                 throw new AgentError_1.MaxTokensExceededError("Response incomplete: max tokens reached", this.config.maxTokens || 1024);
             }
         }
+        // The SDK's stream iterator swallows the abort and simply stops yielding.
+        // Without this the turn would fail as a malformed stream instead of a
+        // cancellation — checked here so the tokens already spent are reported.
+        (0, cancellation_1.throwIfAborted)(options?.signal, `Execution of agent ${this.getName()}`);
         if (!completedEvent) {
             throw new AgentError_1.ExecutionError("OpenAI stream ended without a completed event");
         }
         const response = completedEvent.response;
         const toolCalls = response.output.filter((o) => o.type === "function_call");
         if (toolCalls.length > 0) {
+            // As in handleResponse(): bail out before the assistant turn is written,
+            // so a cancelled run leaves no unanswered function call in history.
+            (0, cancellation_1.throwIfAborted)(options?.signal, `Execution of agent ${this.getName()}`);
             this.emit(AgentEvent_1.AgentEvent.TOOL_USE, toolCalls);
             this.currentToolCallCount += toolCalls.length;
             const functionCalls = toolCalls.map((tc) => ({
@@ -529,11 +558,11 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
             }));
             const assistantEntry = transformers_1.openAiTransformer.fromProviderMessage("assistant", response.output_text || "", functionCalls);
             this.addToHistory(assistantEntry);
-            const toolResults = await this.handleToolUse(toolCalls);
+            const toolResults = await this.handleToolUse(toolCalls, options);
             for (const result of toolResults) {
                 this.addToHistory(transformers_1.openAiTransformer.toolResultEntry(result.call_id, result.output, false));
             }
-            yield* this.streamTurn();
+            yield* this.streamTurn(options);
         }
         else {
             const textContent = response.output_text || "";

package/dist/agents/openai-compatible/OpenAICompatibleAgent.d.ts

@@ -3,6 +3,7 @@ import { ChatCompletion, ChatCompletionTool } from "openai/resources/chat/comple
 import { Model } from "openai/resources/models";
 import { BaseAgent, BaseAgentConfig, ModelInfo, TokenUsage } from "../BaseAgent";
 import { AgentVendor } from "../AgentConfig";
+import { ExecuteOptions } from "../cancellation";
 import { History, MessageContent } from "../../history/History";
 /**
  * A single chunk yielded by `executeStream()`.
@@ -50,9 +51,9 @@ export declare abstract class OpenAICompatibleAgent extends BaseAgent {
     listModels(): Promise<ModelInfo<Model>[]>;
     protected getToolDefinitions(): ChatCompletionTool[];
     protected process(_input: string): Promise<string>;
-    execute(input: string | MessageContent[]): Promise<string>;
+    execute(input: string | MessageContent[], options?: ExecuteOptions): Promise<string>;
     private callProvider;
-    protected handleResponse(response: ChatCompletion): Promise<string>;
+    protected handleResponse(response: ChatCompletion, options?: ExecuteOptions): Promise<string>;
     private handleToolCalls;
     /**
      * Stream a response as an async generator of `StreamChunk` objects.
@@ -69,7 +70,7 @@ export declare abstract class OpenAICompatibleAgent extends BaseAgent {
      * }
      * ```
      */
-    executeStream(input: string | MessageContent[]): AsyncGenerator<StreamChunk>;
+    executeStream(input: string | MessageContent[], options?: ExecuteOptions): AsyncGenerator<StreamChunk>;
     private streamTurn;
     private accumulateStreamUsage;
     protected parseUsage(response: ChatCompletion): TokenUsage;