@agentionai/agents 1.0.2 → 1.2.0

package/dist/agents/Agent.d.ts

@@ -35,7 +35,7 @@ type LlamaCppAgentConfig = Omit<BaseAgentConfig, "vendor" | "model"> & {
 };
 type AgentConfig = ClaudeAgentConfig | OpenAIAgentConfig | GeminiAgentConfig | MistralAgentConfig | OllamaAgentConfig | LlamaCppAgentConfig;
 export declare class Agent {
-    static create(config: AgentConfig, history?: History): ClaudeAgent | GeminiAgent | OpenAiAgent | MistralAgent | OllamaAgent | LlamaCppAgent;
+    static create(config: AgentConfig, history?: History): ClaudeAgent | GeminiAgent | MistralAgent | OllamaAgent | LlamaCppAgent | OpenAiAgent<(string & {}) | "gpt-5-pro" | "gpt-5.2-pro" | "gpt-5.4-pro" | "gpt-5.5-pro" | "o1" | "o1-pro" | "o3" | "o3-mini" | "o4-mini" | "gpt-5" | "gpt-5-mini" | "gpt-5-nano" | "gpt-5.1" | "gpt-5.2" | "gpt-5.4" | "gpt-5.4-mini" | "gpt-5.4-nano" | "gpt-5.5" | "gpt-5.6" | "gpt-5.6-sol" | "gpt-5.6-terra" | "gpt-5.6-luna" | "gpt-4.1" | "gpt-4.1-mini" | "gpt-4.1-nano" | "gpt-4o" | "gpt-4o-mini" | "gpt-4o-2024-11-20" | "gpt-4o-2024-08-06" | "gpt-4o-2024-05-13" | "gpt-4o-mini-2024-07-18" | "gpt-4-turbo" | "gpt-4-turbo-2024-04-09" | "gpt-4-turbo-preview" | "gpt-4-0125-preview" | "gpt-4-1106-preview" | "gpt-4" | "gpt-4-0613" | "gpt-3.5-turbo" | "gpt-3.5-turbo-0125" | "gpt-3.5-turbo-1106" | "o1-preview" | "o1-mini">;
 }
 export {};
 //# sourceMappingURL=Agent.d.ts.map

package/dist/agents/AgentConfig.d.ts

@@ -1,6 +1,7 @@
 import { Tool } from "../tools/Tool";
 import { BuiltInTool } from "../tools/BuiltInTool";
 import { BaseAgent } from "./BaseAgent";
+import type { ReasoningEffort } from "./model-types";
 /** Supported LLM vendors */
 export type AgentVendor = "openai" | "anthropic" | "mistral" | "gemini" | "ollama" | "llamacpp";
 /**
@@ -84,13 +85,28 @@ export interface ClaudeSpecificConfig {
      */
     thinkingBudgetTokens?: number;
 }
+/**
+ * How much the model should think before answering, for OpenAI reasoning models.
+ *
+ * Which values a given model accepts is **model-dependent**; see
+ * {@link ReasoningEffortFor} for the per-model set and
+ * {@link OPENAI_REASONING_SUPPORT} for the verified matrix.
+ */
+export type { ReasoningEffort, ReasoningEffortFor } from "./model-types";
 /**
  * Vendor-specific configuration for OpenAI
  */
 export interface OpenAISpecificConfig {
     disableParallelToolUse?: boolean;
+    /**
+     * Ask for the least reasoning the configured model supports.
+     *
+     * Resolved per model family — there is no single "off" value. Has no effect on
+     * models that do not support `reasoning.effort` at all. Takes precedence over
+     * {@link OpenAISpecificConfig.reasoningEffort}.
+     */
     disableReasoning?: boolean;
-    reasoningEffort?: "low" | "medium" | "high";
+    reasoningEffort?: ReasoningEffort;
     seed?: number;
     user?: string;
 }

package/dist/agents/BaseAgent.d.ts

@@ -12,10 +12,52 @@ export interface BaseAgentConfig extends CommonAgentConfig {
     vendor: AgentVendor;
     vendorConfig?: VendorSpecificConfig;
 }
+/**
+ * Token counts and timing for one or more provider API calls.
+ *
+ * Counts are always present. Timing fields are optional because their
+ * availability depends on the provider and on whether the call was streamed:
+ *
+ * - `totalMs` is always measured (wall clock around the API call).
+ * - `timeToFirstTokenMs` / `generationMs` require either a streamed response
+ *   (measured locally) or a provider that reports its own timings
+ *   (Ollama, llama.cpp).
+ *
+ * When usage from several calls is folded together (a tool-use loop, for
+ * example) the counts and durations are summed and the rates recomputed from
+ * those totals.
+ */
 export type TokenUsage = {
     input_tokens: number;
     output_tokens: number;
     total_tokens: number;
+    /**
+     * Reasoning/thinking tokens, where the provider reports them separately
+     * (OpenAI, Gemini). These are a subset of `output_tokens`, not an addition
+     * to them. Undefined when the provider does not break them out — Anthropic,
+     * for instance, folds thinking tokens into `output_tokens`.
+     */
+    reasoning_tokens?: number;
+    /**
+     * Milliseconds from sending the request to the first token of the response —
+     * prompt upload plus prompt processing.
+     */
+    timeToFirstTokenMs?: number;
+    /** Milliseconds spent generating the response after the first token. */
+    generationMs?: number;
+    /** Total wall-clock milliseconds spent in provider API calls. */
+    totalMs?: number;
+    /**
+     * Prompt processing throughput: `input_tokens` over `timeToFirstTokenMs`.
+     * Undefined when the time to first token is unknown.
+     */
+    inputTokensPerSecond?: number;
+    /**
+     * Generation throughput: `output_tokens` over `generationMs`. Falls back to
+     * `totalMs` when the first-token time is unknown (an unstreamed call), in
+     * which case it is an end-to-end rate rather than a pure generation rate.
+     */
+    outputTokensPerSecond?: number;
 };
 /**
  * The base agent is what the other agents are inheriting from
@@ -33,6 +75,16 @@ export declare abstract class BaseAgent<TInput = unknown, TOutput = unknown> ext
     protected vendor: AgentVendor;
     /** The model identifier for this agent */
     protected model: string;
+    /**
+     * Token counts and timings for the most recent `execute()` call, summed
+     * across every provider API call it made (including tool-use follow-ups).
+     * Reset at the start of each execution.
+     */
+    lastTokenUsage?: TokenUsage;
+    /** Start of the API call currently in flight, set by `startTurnTimer()`. */
+    private turnStartedAt?;
+    /** First-token timestamp of the call in flight, set by `markFirstToken()`. */
+    private turnFirstTokenAt?;
     /**
      * An Agent is the primary LLM entity.
      *
@@ -78,5 +130,35 @@ export declare abstract class BaseAgent<TInput = unknown, TOutput = unknown> ext
     getTools(): Tool<unknown>[];
     clearHistory(): void;
     protected abstract parseUsage(input: unknown): TokenUsage;
+    /**
+     * Clear accumulated usage. Called at the start of every `execute()` /
+     * `executeStream()` so `lastTokenUsage` describes a single execution.
+     */
+    protected resetTokenUsage(): void;
+    /**
+     * Mark the moment a provider API call is sent. Call this immediately before
+     * every request so the usage folded in afterwards can be timed.
+     */
+    protected startTurnTimer(): void;
+    /**
+     * Mark the arrival of the first token of a streamed response. Subsequent
+     * calls within the same turn are ignored, so it is safe to call on every
+     * chunk.
+     */
+    protected markFirstToken(): void;
+    /**
+     * Fold one API call's usage into `lastTokenUsage`, filling in any timings
+     * the provider did not report from the local turn timer.
+     *
+     * @returns the usage for this single call, with timings and rates filled in —
+     *          `lastTokenUsage` holds the running total across calls.
+     */
+    protected accumulateUsage(usage: TokenUsage): TokenUsage;
+    /**
+     * Add locally measured timings to a provider-parsed usage object. Timings the
+     * provider reported itself (Ollama, llama.cpp) are kept as-is — they exclude
+     * network overhead and are more accurate than anything measured here.
+     */
+    private applyTurnTiming;
 }
 //# sourceMappingURL=BaseAgent.d.ts.map

package/dist/agents/BaseAgent.js

@@ -120,6 +120,113 @@ class BaseAgent extends events_1.default {
     clearHistory() {
         this.history.clear();
     }
+    /**
+     * Clear accumulated usage. Called at the start of every `execute()` /
+     * `executeStream()` so `lastTokenUsage` describes a single execution.
+     */
+    resetTokenUsage() {
+        this.lastTokenUsage = undefined;
+        this.turnStartedAt = undefined;
+        this.turnFirstTokenAt = undefined;
+    }
+    /**
+     * Mark the moment a provider API call is sent. Call this immediately before
+     * every request so the usage folded in afterwards can be timed.
+     */
+    startTurnTimer() {
+        this.turnStartedAt = Date.now();
+        this.turnFirstTokenAt = undefined;
+    }
+    /**
+     * Mark the arrival of the first token of a streamed response. Subsequent
+     * calls within the same turn are ignored, so it is safe to call on every
+     * chunk.
+     */
+    markFirstToken() {
+        if (this.turnStartedAt !== undefined &&
+            this.turnFirstTokenAt === undefined) {
+            this.turnFirstTokenAt = Date.now();
+        }
+    }
+    /**
+     * Fold one API call's usage into `lastTokenUsage`, filling in any timings
+     * the provider did not report from the local turn timer.
+     *
+     * @returns the usage for this single call, with timings and rates filled in —
+     *          `lastTokenUsage` holds the running total across calls.
+     */
+    accumulateUsage(usage) {
+        const timed = this.applyTurnTiming(usage);
+        const previous = this.lastTokenUsage;
+        const merged = previous
+            ? {
+                input_tokens: previous.input_tokens + timed.input_tokens,
+                output_tokens: previous.output_tokens + timed.output_tokens,
+                total_tokens: previous.total_tokens + timed.total_tokens,
+                reasoning_tokens: sumOptional(previous.reasoning_tokens, timed.reasoning_tokens),
+                timeToFirstTokenMs: sumOptional(previous.timeToFirstTokenMs, timed.timeToFirstTokenMs),
+                generationMs: sumOptional(previous.generationMs, timed.generationMs),
+                totalMs: sumOptional(previous.totalMs, timed.totalMs),
+            }
+            : { ...timed };
+        this.lastTokenUsage = withThroughput(merged);
+        this.turnStartedAt = undefined;
+        this.turnFirstTokenAt = undefined;
+        return withThroughput(timed);
+    }
+    /**
+     * Add locally measured timings to a provider-parsed usage object. Timings the
+     * provider reported itself (Ollama, llama.cpp) are kept as-is — they exclude
+     * network overhead and are more accurate than anything measured here.
+     */
+    applyTurnTiming(usage) {
+        if (this.turnStartedAt === undefined)
+            return usage;
+        const now = Date.now();
+        const timed = { ...usage };
+        timed.totalMs ?? (timed.totalMs = now - this.turnStartedAt);
+        if (this.turnFirstTokenAt !== undefined) {
+            timed.timeToFirstTokenMs ?? (timed.timeToFirstTokenMs = this.turnFirstTokenAt - this.turnStartedAt);
+            timed.generationMs ?? (timed.generationMs = now - this.turnFirstTokenAt);
+        }
+        return timed;
+    }
 }
 exports.BaseAgent = BaseAgent;
+/**
+ * Add two values that may each be undefined, returning undefined only when
+ * neither side has a value (so "not reported" never reads as zero).
+ */
+function sumOptional(a, b) {
+    if (a === undefined)
+        return b;
+    if (b === undefined)
+        return a;
+    return a + b;
+}
+/**
+ * Derive tokens-per-second rates from the counts and durations on a usage
+ * object. Recomputed from totals rather than averaged, so folding several calls
+ * together stays correct.
+ *
+ * Fields that stayed unknown are dropped rather than left as explicit
+ * `undefined`, keeping serialized usage free of empty keys.
+ */
+function withThroughput(usage) {
+    const result = { ...usage };
+    if (result.timeToFirstTokenMs) {
+        result.inputTokensPerSecond =
+            result.input_tokens / (result.timeToFirstTokenMs / 1000);
+    }
+    const outputWindowMs = result.generationMs || result.totalMs;
+    if (outputWindowMs) {
+        result.outputTokensPerSecond =
+            result.output_tokens / (outputWindowMs / 1000);
+    }
+    for (const key of Object.keys(result)) {
+        if (result[key] === undefined)
+            delete result[key];
+    }
+    return result;
+}
 //# sourceMappingURL=BaseAgent.js.map

package/dist/agents/anthropic/ClaudeAgent.d.ts

@@ -49,8 +49,6 @@ type AgentConfig = BaseAgentConfig & {
 export declare class ClaudeAgent extends BaseAgent {
     private client;
     protected config: Partial<AgentConfig>;
-    /** Token usage from the last execution (for metrics tracking) */
-    lastTokenUsage?: TokenUsage;
     /** Current visualization event ID for tracking */
     private vizEventId?;
     /** Count of tool calls in current execution */

package/dist/agents/anthropic/ClaudeAgent.js

@@ -109,7 +109,7 @@ class ClaudeAgent extends BaseAgent_1.BaseAgent {
     async execute(input) {
         this.emit(AgentEvent_1.AgentEvent.BEFORE_EXECUTE, input);
         // Reset token usage for this execution
-        this.lastTokenUsage = undefined;
+        this.resetTokenUsage();
         this.currentToolCallCount = 0;
         // Normalise input to a display string for viz reporting
         const inputPreview = typeof input === "string" ? input : JSON.stringify(input);
@@ -135,6 +135,7 @@ class ClaudeAgent extends BaseAgent_1.BaseAgent {
         // mid-loop. endExecution() in the finally block enforces limits once.
         this.history.beginExecution();
         try {
+            this.startTurnTimer();
             const response = (await this.client.messages.create(this.buildMessageParams()));
             this.emit(AgentEvent_1.AgentEvent.AFTER_EXECUTE, response);
             return await this.handleResponse(response);
@@ -167,16 +168,8 @@ class ClaudeAgent extends BaseAgent_1.BaseAgent {
         }
     }
     async handleResponse(response) {
-        const usage = this.parseUsage(response.usage);
         // Store token usage for metrics tracking
-        if (this.lastTokenUsage) {
-            this.lastTokenUsage.input_tokens += usage.input_tokens;
-            this.lastTokenUsage.output_tokens += usage.output_tokens;
-            this.lastTokenUsage.total_tokens += usage.total_tokens;
-        }
-        else {
-            this.lastTokenUsage = { ...usage };
-        }
+        const usage = this.accumulateUsage(this.parseUsage(response.usage));
         if (response.stop_reason === "max_tokens") {
             const error = new AgentError_1.MaxTokensExceededError("Response exceeded maximum token limit", this.config.maxTokens || 1024);
             this.emit(AgentEvent_1.AgentEvent.MAX_TOKENS_EXCEEDED, error);
@@ -232,6 +225,7 @@ class ClaudeAgent extends BaseAgent_1.BaseAgent {
                 this.addMessageToHistory("user", toolResults);
                 // Continue conversation with tool results
                 try {
+                    this.startTurnTimer();
                     const newResponse = (await this.client.messages.create(this.buildMessageParams()));
                     this.emit(AgentEvent_1.AgentEvent.AFTER_EXECUTE, newResponse);
                     return this.handleResponse(newResponse);
@@ -329,7 +323,7 @@ class ClaudeAgent extends BaseAgent_1.BaseAgent {
      */
     async *executeStream(input) {
         this.emit(AgentEvent_1.AgentEvent.BEFORE_EXECUTE, input);
-        this.lastTokenUsage = undefined;
+        this.resetTokenUsage();
         this.currentToolCallCount = 0;
         const inputPreview = typeof input === "string" ? input : JSON.stringify(input);
         if (VizConfig_1.vizConfig.isEnabled()) {
@@ -379,6 +373,7 @@ class ClaudeAgent extends BaseAgent_1.BaseAgent {
         }
     }
     async *streamTurn() {
+        this.startTurnTimer();
         const stream = await this.client.messages.create({
             ...this.buildMessageParams(),
             stream: true,
@@ -416,6 +411,9 @@ class ClaudeAgent extends BaseAgent_1.BaseAgent {
                 }
             }
             if (event.type === "content_block_delta") {
+                // First generated content of the turn — thinking counts, since it is
+                // generation time either way.
+                this.markFirstToken();
                 const e = event;
                 const delta = e.delta;
                 const acc = blocks.get(e.index);
@@ -442,19 +440,11 @@ class ClaudeAgent extends BaseAgent_1.BaseAgent {
                 }
             }
         }
-        const usage = {
+        this.accumulateUsage({
             input_tokens: inputTokens,
             output_tokens: outputTokens,
             total_tokens: inputTokens + outputTokens,
-        };
-        if (this.lastTokenUsage) {
-            this.lastTokenUsage.input_tokens += usage.input_tokens;
-            this.lastTokenUsage.output_tokens += usage.output_tokens;
-            this.lastTokenUsage.total_tokens += usage.total_tokens;
-        }
-        else {
-            this.lastTokenUsage = { ...usage };
-        }
+        });
         if (stopReason === "max_tokens") {
             const error = new AgentError_1.MaxTokensExceededError("Response exceeded maximum token limit", this.config.maxTokens || 1024);
             this.emit(AgentEvent_1.AgentEvent.MAX_TOKENS_EXCEEDED, error);

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

@@ -29,8 +29,6 @@ export declare class GeminiAgent extends BaseAgent {
     private client;
     private generativeModel;
     protected config: Partial<AgentConfig>;
-    /** Token usage from the last execution (for metrics tracking) */
-    lastTokenUsage?: TokenUsage;
     /** Current visualization event ID for tracking */
     private vizEventId?;
     /** Count of tool calls in current execution */
@@ -57,6 +55,7 @@ export declare class GeminiAgent extends BaseAgent {
         promptTokenCount?: number;
         candidatesTokenCount?: number;
         totalTokenCount?: number;
+        thoughtsTokenCount?: number;
     }): TokenUsage;
 }
 export {};

package/dist/agents/google/GeminiAgent.js

@@ -164,7 +164,7 @@ class GeminiAgent extends BaseAgent_1.BaseAgent {
     async execute(input) {
         this.emit(AgentEvent_1.AgentEvent.BEFORE_EXECUTE, input);
         // Reset token usage for this execution
-        this.lastTokenUsage = undefined;
+        this.resetTokenUsage();
         this.currentToolCallCount = 0;
         const inputPreview = typeof input === "string" ? input : JSON.stringify(input);
         // Start visualization reporting
@@ -192,6 +192,7 @@ class GeminiAgent extends BaseAgent_1.BaseAgent {
             const contents = transformers_1.geminiTransformer.toProvider(this.history.getEntries());
             const systemMessage = this.history.getSystemMessage();
             const tools = this.getToolDefinitionsForGemini();
+            this.startTurnTimer();
             const response = await this.generativeModel.generateContent({
                 contents,
                 systemInstruction: systemMessage,
@@ -241,15 +242,7 @@ class GeminiAgent extends BaseAgent_1.BaseAgent {
         const result = response.response;
         // Parse and track usage
         if (result.usageMetadata) {
-            const usage = this.parseUsage(result.usageMetadata);
-            if (this.lastTokenUsage) {
-                this.lastTokenUsage.input_tokens += usage.input_tokens;
-                this.lastTokenUsage.output_tokens += usage.output_tokens;
-                this.lastTokenUsage.total_tokens += usage.total_tokens;
-            }
-            else {
-                this.lastTokenUsage = { ...usage };
-            }
+            this.accumulateUsage(this.parseUsage(result.usageMetadata));
         }
         // Check for finish reason
         const candidate = result.candidates?.[0];
@@ -309,6 +302,7 @@ class GeminiAgent extends BaseAgent_1.BaseAgent {
                 const newContents = transformers_1.geminiTransformer.toProvider(this.history.getEntries());
                 const systemMessage = this.history.getSystemMessage();
                 const tools = this.getToolDefinitionsForGemini();
+                this.startTurnTimer();
                 const newResponse = await this.generativeModel.generateContent({
                     contents: newContents,
                     systemInstruction: systemMessage,
@@ -400,10 +394,17 @@ class GeminiAgent extends BaseAgent_1.BaseAgent {
         return results;
     }
     parseUsage(input) {
+        // Gemini excludes thought tokens from `candidatesTokenCount` but includes
+        // them in `totalTokenCount`. Fold them into `output_tokens` so
+        // input + output === total holds, matching how other providers report.
+        // `thoughtsTokenCount` is sent by thinking models but is not declared on
+        // the legacy SDK's `UsageMetadata`, hence the widened parameter type.
+        const thoughts = input.thoughtsTokenCount;
         return {
             input_tokens: input.promptTokenCount || 0,
-            output_tokens: input.candidatesTokenCount || 0,
+            output_tokens: (input.candidatesTokenCount || 0) + (thoughts || 0),
             total_tokens: input.totalTokenCount || 0,
+            reasoning_tokens: thoughts,
         };
     }
 }

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

@@ -29,8 +29,6 @@ type AgentConfig = BaseAgentConfig & {
 export declare class MistralAgent extends BaseAgent {
     private client;
     protected config: Partial<AgentConfig>;
-    /** Token usage from the last execution (for metrics tracking) */
-    lastTokenUsage?: TokenUsage;
     /** Current visualization event ID for tracking */
     private vizEventId?;
     /** Count of tool calls in current execution */

package/dist/agents/mistral/MistralAgent.js

@@ -73,7 +73,7 @@ class MistralAgent extends BaseAgent_1.BaseAgent {
     async execute(input) {
         this.emit(AgentEvent_1.AgentEvent.BEFORE_EXECUTE, input);
         // Reset token usage for this execution
-        this.lastTokenUsage = undefined;
+        this.resetTokenUsage();
         this.currentToolCallCount = 0;
         const inputPreview = typeof input === "string" ? input : JSON.stringify(input);
         // Start visualization reporting
@@ -99,6 +99,7 @@ class MistralAgent extends BaseAgent_1.BaseAgent {
         this.history.beginExecution();
         try {
             const messages = transformers_1.mistralTransformer.toProvider(this.history.getEntries());
+            this.startTurnTimer();
             const response = await this.client.chat.complete({
                 model: this.config.model,
                 messages: messages,
@@ -147,16 +148,8 @@ class MistralAgent extends BaseAgent_1.BaseAgent {
             throw error;
         }
         const choice = response.choices[0];
-        const usage = this.parseUsage(response.usage);
         // Track token usage
-        if (this.lastTokenUsage) {
-            this.lastTokenUsage.input_tokens += usage.input_tokens;
-            this.lastTokenUsage.output_tokens += usage.output_tokens;
-            this.lastTokenUsage.total_tokens += usage.total_tokens;
-        }
-        else {
-            this.lastTokenUsage = { ...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);
             this.emit(AgentEvent_1.AgentEvent.MAX_TOKENS_EXCEEDED, error);
@@ -218,6 +211,7 @@ class MistralAgent extends BaseAgent_1.BaseAgent {
                 // Continue conversation
                 try {
                     const messages = transformers_1.mistralTransformer.toProvider(this.history.getEntries());
+                    this.startTurnTimer();
                     const newResponse = await this.client.chat.complete({
                         model: this.config.model,
                         messages: messages,

package/dist/agents/model-types.d.ts

@@ -39,5 +39,81 @@ export type LlamaCppModel = "default" | "gpt-oss-20b" | "gpt-oss-120b" | "llama-
  * You can also provide any custom string for newer models not yet listed.
  * @see https://platform.openai.com/docs/models
  */
-export type OpenAIModel = "gpt-5.2" | "gpt-5" | "gpt-4.1" | "gpt-5-mini" | "gpt-5-nano" | "gpt-4o" | "gpt-4o-mini" | "gpt-4o-2024-11-20" | "gpt-4o-2024-08-06" | "gpt-4o-2024-05-13" | "gpt-4o-mini-2024-07-18" | "gpt-4-turbo" | "gpt-4-turbo-2024-04-09" | "gpt-4-turbo-preview" | "gpt-4-0125-preview" | "gpt-4-1106-preview" | "gpt-4" | "gpt-4-0613" | "gpt-3.5-turbo" | "gpt-3.5-turbo-0125" | "gpt-3.5-turbo-1106" | "o1" | "o1-preview" | "o1-mini" | "o3-mini" | (string & {});
+export type OpenAIModel = OpenAIReasoningModel | "gpt-4.1" | "gpt-4.1-mini" | "gpt-4.1-nano" | "gpt-4o" | "gpt-4o-mini" | "gpt-4o-2024-11-20" | "gpt-4o-2024-08-06" | "gpt-4o-2024-05-13" | "gpt-4o-mini-2024-07-18" | "gpt-4-turbo" | "gpt-4-turbo-2024-04-09" | "gpt-4-turbo-preview" | "gpt-4-0125-preview" | "gpt-4-1106-preview" | "gpt-4" | "gpt-4-0613" | "gpt-3.5-turbo" | "gpt-3.5-turbo-0125" | "gpt-3.5-turbo-1106" | "o1-preview" | "o1-mini" | (string & {});
+/**
+ * Every value the Responses API's `reasoning.effort` parameter defines.
+ *
+ * Which subset a given model accepts is model-dependent — see
+ * {@link OPENAI_REASONING_SUPPORT} and {@link ReasoningEffortFor}.
+ */
+export type ReasoningEffort = "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+/**
+ * Which reasoning efforts each OpenAI model accepts.
+ *
+ * There is no universal set and no universal "off" value: the families reject
+ * each other's minimum (`none` is rejected before `gpt-5.1`, `minimal` is
+ * rejected from `gpt-5.1` on, o-series takes neither), and `pro` variants drop
+ * the lower end. `effort: null` is not an off switch either — it means *unset*,
+ * so the model applies its own default.
+ *
+ * Each group's `efforts` are ordered lowest-first, so `efforts[0]` is the least
+ * reasoning that family will do.
+ *
+ * Every row was verified against the live Responses API on 2026-08-05. Models not
+ * listed here — non-reasoning models, and families released after this table was
+ * written — accept no `reasoning.effort` guess, so callers fall back to the full
+ * {@link ReasoningEffort} union and the runtime helper omits the parameter.
+ */
+export declare const OPENAI_REASONING_SUPPORT: readonly [{
+    readonly models: readonly ["gpt-5-pro"];
+    readonly efforts: readonly ["high"];
+}, {
+    readonly models: readonly ["gpt-5.2-pro", "gpt-5.4-pro", "gpt-5.5-pro"];
+    readonly efforts: readonly ["medium", "high", "xhigh"];
+}, {
+    readonly models: readonly ["o1", "o1-pro", "o3", "o3-mini", "o4-mini"];
+    readonly efforts: readonly ["low", "medium", "high"];
+}, {
+    readonly models: readonly ["gpt-5", "gpt-5-mini", "gpt-5-nano"];
+    readonly efforts: readonly ["minimal", "low", "medium", "high"];
+}, {
+    readonly models: readonly ["gpt-5.1"];
+    readonly efforts: readonly ["none", "low", "medium", "high"];
+}, {
+    readonly models: readonly ["gpt-5.2", "gpt-5.4", "gpt-5.4-mini", "gpt-5.4-nano", "gpt-5.5"];
+    readonly efforts: readonly ["none", "low", "medium", "high", "xhigh"];
+}, {
+    readonly models: readonly ["gpt-5.6", "gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna"];
+    readonly efforts: readonly ["none", "low", "medium", "high", "xhigh", "max"];
+}];
+type ReasoningGroup = (typeof OPENAI_REASONING_SUPPORT)[number];
+/** Every OpenAI model known to accept `reasoning.effort`. */
+export type OpenAIReasoningModel = ReasoningGroup["models"][number];
+/**
+ * Strip a dated snapshot suffix (`gpt-5-nano-2025-08-07` → `gpt-5-nano`) so
+ * pinned model ids resolve to the same support set as their alias. Snapshots
+ * always start `-20`, which keeps `gpt-5-mini` from looking like a snapshot of
+ * `gpt-5`.
+ */
+type BaseModel<M extends string> = M extends `${infer Base}-20${string}` ? Base : M;
+type EffortsOf<M extends string, G = ReasoningGroup> = G extends {
+    models: readonly (infer Models)[];
+    efforts: readonly (infer Efforts)[];
+} ? BaseModel<M> extends Models ? Efforts : never : never;
+/**
+ * The reasoning efforts a given model accepts.
+ *
+ * Resolves to the exact set for every model in {@link OPENAI_REASONING_SUPPORT},
+ * and to the full {@link ReasoningEffort} union for anything else — an unknown or
+ * newer model should not be blocked by a table that has gone stale.
+ *
+ * @example
+ * ```typescript
+ * type A = ReasoningEffortFor<"gpt-5-nano">;  // "minimal" | "low" | "medium" | "high"
+ * type B = ReasoningEffortFor<"gpt-5.6-sol">; // adds "none", "xhigh", "max"; no "minimal"
+ * type C = ReasoningEffortFor<"gpt-5-pro">;   // "high"
+ * ```
+ */
+export type ReasoningEffortFor<M extends string> = [EffortsOf<M>] extends [never] ? ReasoningEffort : EffortsOf<M>;
+export {};
 //# sourceMappingURL=model-types.d.ts.map

package/dist/agents/model-types.js

@@ -5,4 +5,37 @@
  * All types also accept custom string values for new/unlisted models.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.OPENAI_REASONING_SUPPORT = void 0;
+/**
+ * Which reasoning efforts each OpenAI model accepts.
+ *
+ * There is no universal set and no universal "off" value: the families reject
+ * each other's minimum (`none` is rejected before `gpt-5.1`, `minimal` is
+ * rejected from `gpt-5.1` on, o-series takes neither), and `pro` variants drop
+ * the lower end. `effort: null` is not an off switch either — it means *unset*,
+ * so the model applies its own default.
+ *
+ * Each group's `efforts` are ordered lowest-first, so `efforts[0]` is the least
+ * reasoning that family will do.
+ *
+ * Every row was verified against the live Responses API on 2026-08-05. Models not
+ * listed here — non-reasoning models, and families released after this table was
+ * written — accept no `reasoning.effort` guess, so callers fall back to the full
+ * {@link ReasoningEffort} union and the runtime helper omits the parameter.
+ */
+exports.OPENAI_REASONING_SUPPORT = [
+    { models: ["gpt-5-pro"], efforts: ["high"] },
+    { models: ["gpt-5.2-pro", "gpt-5.4-pro", "gpt-5.5-pro"], efforts: ["medium", "high", "xhigh"] },
+    { models: ["o1", "o1-pro", "o3", "o3-mini", "o4-mini"], efforts: ["low", "medium", "high"] },
+    { models: ["gpt-5", "gpt-5-mini", "gpt-5-nano"], efforts: ["minimal", "low", "medium", "high"] },
+    { models: ["gpt-5.1"], efforts: ["none", "low", "medium", "high"] },
+    {
+        models: ["gpt-5.2", "gpt-5.4", "gpt-5.4-mini", "gpt-5.4-nano", "gpt-5.5"],
+        efforts: ["none", "low", "medium", "high", "xhigh"],
+    },
+    {
+        models: ["gpt-5.6", "gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna"],
+        efforts: ["none", "low", "medium", "high", "xhigh", "max"],
+    },
+];
 //# sourceMappingURL=model-types.js.map

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

@@ -46,8 +46,6 @@ type OllamaToolDefinition = {
  */
 export declare class OllamaAgent extends BaseAgent {
     protected config: Partial<AgentConfig>;
-    /** Token usage from the last execution (for metrics tracking) */
-    lastTokenUsage?: TokenUsage;
     /** Current visualization event ID */
     private vizEventId?;
     /** Count of tool calls in current execution */