@agentionai/agents 1.6.0 → 1.8.0-beta-0

package/dist/agents/errors/AgentError.d.ts

@@ -22,12 +22,44 @@ export declare class ApiError extends AgentError {
     response?: any | undefined;
     constructor(message: string, statusCode?: number | undefined, response?: any | undefined);
 }
+/**
+ * Error thrown when the provider rate limits a request and the agent's retry
+ * policy did not manage to get past it.
+ *
+ * Extends {@link ApiError}, so existing `catch (e) { if (e instanceof ApiError) }`
+ * handling keeps working; the extra fields carry what the provider said about
+ * when to come back.
+ */
+export declare class RateLimitError extends ApiError {
+    retryAfterMs?: number | undefined;
+    limit?: number | undefined;
+    remaining?: number | undefined;
+    resetAt?: Date | undefined;
+    /**
+     * @param message      Error message
+     * @param retryAfterMs How long the provider asked you to wait, in
+     *                     milliseconds, from its `Retry-After` header. Undefined
+     *                     when it sent no hint.
+     * @param limit        Requests permitted in the window (`X-RateLimit-Limit`).
+     * @param remaining    Requests left in the window (`X-RateLimit-Remaining`).
+     * @param resetAt      When the window resets (`X-RateLimit-Reset`).
+     * @param response     The underlying provider error.
+     */
+    constructor(message: string, retryAfterMs?: number | undefined, limit?: number | undefined, remaining?: number | undefined, resetAt?: Date | undefined, response?: unknown);
+}
 /**
  * Error thrown when maximum token limit is exceeded
  */
 export declare class MaxTokensExceededError extends AgentError {
-    tokenLimit: number;
-    constructor(message: string, tokenLimit: number);
+    tokenLimit?: number | undefined;
+    /**
+     * @param message    Error message
+     * @param tokenLimit The configured `maxTokens` that was hit. Undefined when
+     *                   no limit was configured and the model's own output cap
+     *                   is what ended the response — reporting a number the
+     *                   caller never set would just be misleading.
+     */
+    constructor(message: string, tokenLimit?: number | undefined);
 }
 /**
  * Error thrown when maximum retries are exceeded
@@ -36,6 +68,22 @@ export declare class MaxRetriesExceededError extends AgentError {
     maxRetries: number;
     constructor(message: string, maxRetries: number);
 }
+/**
+ * Error thrown when an execution is cancelled through the `AbortSignal` passed
+ * to `execute()` / `executeStream()`.
+ *
+ * `name` is `"AbortError"`, matching the platform convention, so callers that
+ * already check `err.name === "AbortError"` keep working.
+ */
+export declare class AbortError extends AgentError {
+    reason?: unknown | undefined;
+    /**
+     * @param message Error message
+     * @param reason The signal's `reason`, or the underlying provider error when
+     *               the signal did not carry one.
+     */
+    constructor(message: string, reason?: unknown | undefined);
+}
 /**
  * Error thrown when tool execution fails
  */

package/dist/agents/errors/AgentError.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ToolExecutionError = exports.MaxRetriesExceededError = exports.MaxTokensExceededError = exports.ApiError = exports.ExecutionError = exports.AgentError = void 0;
+exports.ToolExecutionError = exports.AbortError = exports.MaxRetriesExceededError = exports.MaxTokensExceededError = exports.RateLimitError = exports.ApiError = exports.ExecutionError = exports.AgentError = void 0;
 /**
  * Base error class for all agent-related errors
  */
@@ -37,10 +37,46 @@ class ApiError extends AgentError {
     }
 }
 exports.ApiError = ApiError;
+/**
+ * Error thrown when the provider rate limits a request and the agent's retry
+ * policy did not manage to get past it.
+ *
+ * Extends {@link ApiError}, so existing `catch (e) { if (e instanceof ApiError) }`
+ * handling keeps working; the extra fields carry what the provider said about
+ * when to come back.
+ */
+class RateLimitError extends ApiError {
+    /**
+     * @param message      Error message
+     * @param retryAfterMs How long the provider asked you to wait, in
+     *                     milliseconds, from its `Retry-After` header. Undefined
+     *                     when it sent no hint.
+     * @param limit        Requests permitted in the window (`X-RateLimit-Limit`).
+     * @param remaining    Requests left in the window (`X-RateLimit-Remaining`).
+     * @param resetAt      When the window resets (`X-RateLimit-Reset`).
+     * @param response     The underlying provider error.
+     */
+    constructor(message, retryAfterMs, limit, remaining, resetAt, response) {
+        super(message, 429, response);
+        this.retryAfterMs = retryAfterMs;
+        this.limit = limit;
+        this.remaining = remaining;
+        this.resetAt = resetAt;
+        this.name = "RateLimitError";
+    }
+}
+exports.RateLimitError = RateLimitError;
 /**
  * Error thrown when maximum token limit is exceeded
  */
 class MaxTokensExceededError extends AgentError {
+    /**
+     * @param message    Error message
+     * @param tokenLimit The configured `maxTokens` that was hit. Undefined when
+     *                   no limit was configured and the model's own output cap
+     *                   is what ended the response — reporting a number the
+     *                   caller never set would just be misleading.
+     */
     constructor(message, tokenLimit) {
         super(message);
         this.tokenLimit = tokenLimit;
@@ -59,6 +95,26 @@ class MaxRetriesExceededError extends AgentError {
     }
 }
 exports.MaxRetriesExceededError = MaxRetriesExceededError;
+/**
+ * Error thrown when an execution is cancelled through the `AbortSignal` passed
+ * to `execute()` / `executeStream()`.
+ *
+ * `name` is `"AbortError"`, matching the platform convention, so callers that
+ * already check `err.name === "AbortError"` keep working.
+ */
+class AbortError extends AgentError {
+    /**
+     * @param message Error message
+     * @param reason The signal's `reason`, or the underlying provider error when
+     *               the signal did not carry one.
+     */
+    constructor(message, reason) {
+        super(message);
+        this.reason = reason;
+        this.name = "AbortError";
+    }
+}
+exports.AbortError = AbortError;
 /**
  * Error thrown when tool execution fails
  */

package/dist/agents/google/GeminiAgent.d.ts

@@ -1,5 +1,6 @@
 import { FunctionDeclarationsTool, GenerateContentResult, Schema } from "@google/generative-ai";
 import { BaseAgent, BaseAgentConfig, ModelInfo, TokenUsage } from "../BaseAgent";
+import { ExecuteOptions } from "../cancellation";
 import { History, MessageContent } from "../../history/History";
 import { GeminiModel } from "../model-types";
 /**
@@ -123,8 +124,8 @@ export declare class GeminiAgent extends BaseAgent {
      */
     private mapJsonSchemaTypeToGemini;
     protected process(_input: string): Promise<string>;
-    execute(input: string | MessageContent[]): Promise<string>;
-    protected handleResponse(response: GenerateContentResult): Promise<string>;
+    execute(input: string | MessageContent[], options?: ExecuteOptions): Promise<string>;
+    protected handleResponse(response: GenerateContentResult, options?: ExecuteOptions): Promise<string>;
     private handleFunctionCalls;
     protected parseUsage(input: {
         promptTokenCount?: number;

package/dist/agents/google/GeminiAgent.js

@@ -4,6 +4,7 @@ exports.GeminiAgent = exports.GEMINI_RETIRED_MODELS = void 0;
 const generative_ai_1 = require("@google/generative-ai");
 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");
@@ -66,7 +67,12 @@ class GeminiAgent extends BaseAgent_1.BaseAgent {
         const responseSchema = config.responseSchema ?? vendorConfig.responseSchema;
         this.config = {
             model: config.model || "gemini-flash-latest",
-            maxTokens: config.maxTokens || 1024,
+            // No default: `maxOutputTokens` is optional on Gemini, and omitting it
+            // lets the model use its full output budget. A default here silently
+            // truncated every response — and on thinking models it was worse, since
+            // thoughts count against the same budget and a small cap could be spent
+            // entirely on them.
+            maxTokens: config.maxTokens,
             apiKey: config.apiKey,
             temperature: config.temperature,
             topP: config.topP,
@@ -251,7 +257,7 @@ class GeminiAgent 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();
@@ -297,11 +303,23 @@ class GeminiAgent extends BaseAgent_1.BaseAgent {
                     responseMimeType: this.config.responseMimeType,
                     responseSchema: this.config.responseSchema,
                 },
-            });
+            }, 
+            // Note: an abort only stops the client from waiting — Google still
+            // runs and bills the request. Merged over the model's own request
+            // options, so `customHeaders` set at construction survive.
+            { 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(`Gemini API error: ${err.message || "Unknown error"}`, err.status, error);
@@ -328,7 +346,7 @@ class GeminiAgent extends BaseAgent_1.BaseAgent {
             this.history.endExecution();
         }
     }
-    async handleResponse(response) {
+    async handleResponse(response, options) {
         const result = response.response;
         // Parse and track usage
         if (result.usageMetadata) {
@@ -342,7 +360,7 @@ class GeminiAgent extends BaseAgent_1.BaseAgent {
             throw error;
         }
         if (candidate.finishReason === "MAX_TOKENS") {
-            const error = new AgentError_1.MaxTokensExceededError("Response exceeded maximum token limit", this.config.maxTokens || 1024);
+            const error = new AgentError_1.MaxTokensExceededError("Response exceeded maximum token limit", this.config.maxTokens);
             this.emit(AgentEvent_1.AgentEvent.MAX_TOKENS_EXCEEDED, error);
             this.emit(AgentEvent_1.AgentEvent.ERROR, error);
             // Report error to viz
@@ -377,11 +395,16 @@ class GeminiAgent extends BaseAgent_1.BaseAgent {
         }
         // Handle function calls
         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 functionCall in
+            // history with no functionResponse to answer it.
+            (0, cancellation_1.throwIfAborted)(options?.signal, `Execution of agent ${this.getName()}`);
             this.emit(AgentEvent_1.AgentEvent.TOOL_USE, functionCalls);
             // Add assistant response with function calls to history (normalized)
             const assistantEntry = transformers_1.geminiTransformer.fromProviderContent("assistant", parts);
             this.addToHistory(assistantEntry);
-            const toolResults = await this.handleFunctionCalls(functionCalls);
+            const toolResults = await this.handleFunctionCalls(functionCalls, options);
             // Add tool results to history (normalized)
             for (const tr of toolResults) {
                 const resultEntry = transformers_1.geminiTransformer.toolResultEntry(tr.name, tr.response);
@@ -407,9 +430,9 @@ class GeminiAgent extends BaseAgent_1.BaseAgent {
                         responseMimeType: this.config.responseMimeType,
                         responseSchema: this.config.responseSchema,
                     },
-                });
+                }, { 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;
@@ -438,7 +461,7 @@ class GeminiAgent extends BaseAgent_1.BaseAgent {
             throw toolError;
         }
     }
-    async handleFunctionCalls(functionCalls) {
+    async handleFunctionCalls(functionCalls, options) {
         if (!functionCalls.length) {
             throw new AgentError_1.ExecutionError("No function calls found in response");
         }
@@ -462,7 +485,7 @@ class GeminiAgent extends BaseAgent_1.BaseAgent {
             try {
                 const args = (fc.args || {});
                 const result = await tool.execute(this.getId(), this.getName(), args, toolName, // Gemini uses function name as ID
-                this.config.model, "gemini");
+                this.config.model, "gemini", { signal: options?.signal });
                 return {
                     name: toolName,
                     response: JSON.stringify(result),

package/dist/agents/mistral/MistralAgent.d.ts

@@ -1,4 +1,5 @@
 import { BaseAgent, BaseAgentConfig, ModelInfo, TokenUsage } from "../BaseAgent";
+import { ExecuteOptions } from "../cancellation";
 import { History, MessageContent } from "../../history/History";
 import { ChatCompletionResponse, ModelList, Tool, UsageInfo } from "@mistralai/mistralai/models/components";
 import { MistralModel } from "../model-types";
@@ -66,8 +67,8 @@ export declare class MistralAgent extends BaseAgent {
     listModels(): Promise<ModelInfo<MistralModelCard>[]>;
     protected getToolDefinitions(): Tool[];
     protected process(_input: string): Promise<string>;
-    execute(input: string | MessageContent[]): Promise<string>;
-    protected handleResponse(response: ChatCompletionResponse): Promise<string>;
+    execute(input: string | MessageContent[], options?: ExecuteOptions): Promise<string>;
+    protected handleResponse(response: ChatCompletionResponse, options?: ExecuteOptions): Promise<string>;
     private handleToolCalls;
     protected parseUsage(input: UsageInfo): TokenUsage;
 }

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");
@@ -67,7 +68,10 @@ class MistralAgent extends BaseAgent_1.BaseAgent {
         const rateLimitDelay = config.rateLimitDelay ?? vendorConfig.rateLimitDelay ?? 1500;
         this.config = {
             model: config.model || "mistral-small-latest",
-            maxTokens: config.maxTokens || 1024,
+            // No default: `maxTokens` is optional on Mistral's API, and omitting it
+            // lets the model use its full output budget. A default here silently
+            // truncated every response.
+            maxTokens: config.maxTokens,
             disableParallelToolUse,
             safePrompt,
             randomSeed,
@@ -129,7 +133,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 +173,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 +212,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);
@@ -210,7 +222,7 @@ class MistralAgent extends BaseAgent_1.BaseAgent {
         // Track token usage
         const usage = this.accumulateUsage(this.parseUsage(response.usage));
         if (choice.finishReason === "length") {
-            const error = new AgentError_1.MaxTokensExceededError("Response exceeded maximum token limit", this.config.maxTokens || 1024);
+            const error = new AgentError_1.MaxTokensExceededError("Response exceeded maximum token limit", this.config.maxTokens);
             this.emit(AgentEvent_1.AgentEvent.MAX_TOKENS_EXCEEDED, error);
             this.emit(AgentEvent_1.AgentEvent.ERROR, error);
             // Report error to viz
@@ -255,18 +267,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 +301,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 +336,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 +366,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