@agentionai/agents 0.14.0 → 1.0.0

package/README.md

@@ -75,6 +75,7 @@ import { ClaudeAgent, OpenAiAgent } from '@agentionai/agents';
 ## Features
 
 - **Multi-Provider, No Lock-in** - Claude, OpenAI, Gemini, Mistral, plus local models via Ollama and llama.cpp—same interface. Switch models with one line.
+- **Streaming** - `executeStream()` on Claude, OpenAI, and all OpenAI-compatible agents. Yields `{ type: "text" | "reasoning" }` chunks; tool calls handled transparently.
 - **Built-In Tools** - Use provider-defined server-side tools (e.g. Anthropic's web search, bash, text editor) alongside your own.
 - **Composable, Not Magical** - Agents are objects. Pipelines are arrays. No hidden state, no surprises.
 - **Multimodal / Vision** - Send images alongside text with a unified `MessageContent[]` API across all providers.
@@ -186,6 +187,27 @@ const agent = new ClaudeAgent({
 const response = await agent.execute('What happened in the news today?');
 ```
 
+### Streaming
+
+All three major providers support streaming via `executeStream()`, which returns an `AsyncGenerator<StreamChunk>`. Each chunk is `{ type: "text" | "reasoning"; content: string }` — text for visible output, reasoning for internal thinking tokens (DeepSeek R1, Claude extended thinking, OpenAI o-series).
+
+```typescript
+import { ClaudeAgent } from '@agentionai/agents/claude';
+
+const agent = new ClaudeAgent({
+  apiKey: process.env.ANTHROPIC_API_KEY,
+  id: 'assistant',
+  name: 'Assistant',
+  description: 'You are a helpful assistant.',
+});
+
+for await (const chunk of agent.executeStream('Tell me a story')) {
+  if (chunk.type === 'text') process.stdout.write(chunk.content);
+}
+```
+
+Tool calls are handled transparently — the generator continues streaming after each round-trip. The same API works across `ClaudeAgent`, `OpenAiAgent`, and `LlamaCppAgent` / any `OpenAICompatibleAgent` subclass.
+
 ### Multi-Agent Pipeline
 
 Chain agents together with different providers and models:

package/dist/agents/AgentConfig.d.ts

@@ -73,6 +73,16 @@ export interface ClaudeSpecificConfig {
      * implementation detail that can change.
      */
     authType?: "apiKey" | "oauth";
+    /**
+     * Enable extended thinking by setting a thinking token budget. When set (> 0), the
+     * agent requests `thinking: { type: "enabled", budget_tokens }` and surfaces thinking
+     * tokens as `"reasoning"` chunks from `executeStream()`.
+     *
+     * Constraints (enforced by Anthropic): `budget_tokens` must be ≥ 1024 and strictly less
+     * than `maxTokens`. When enabled, `temperature`/`topP`/`topK` are not sent (the API
+     * requires default sampling with thinking).
+     */
+    thinkingBudgetTokens?: number;
 }
 /**
  * Vendor-specific configuration for OpenAI

package/dist/agents/AgentEvent.d.ts

@@ -10,6 +10,8 @@ export declare class AgentEvent {
     static MAX_RETRIES_EXCEEDED: string;
     static MAX_TOKENS_EXCEEDED: string;
     static TOOL_ERROR: string;
+    static CHUNK: string;
+    static REASONING_CHUNK: string;
     private defaultPrevented;
     constructor(target: BaseAgent<any>);
     preventDefault(): void;

package/dist/agents/AgentEvent.js

@@ -23,4 +23,6 @@ AgentEvent.RETRY = "retry";
 AgentEvent.MAX_RETRIES_EXCEEDED = "max_retries_exceeded";
 AgentEvent.MAX_TOKENS_EXCEEDED = "max_tokens_exceeded";
 AgentEvent.TOOL_ERROR = "tool_error";
+AgentEvent.CHUNK = "chunk";
+AgentEvent.REASONING_CHUNK = "reasoning_chunk";
 //# sourceMappingURL=AgentEvent.js.map

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

@@ -1,8 +1,10 @@
+import { Anthropic } from "@anthropic-ai/sdk";
 import { Message, ToolUnion, Usage } from "@anthropic-ai/sdk/resources";
 import { type ToolDefinition } from "../../tools/Tool";
 import { type BuiltInTool } from "../../tools/BuiltInTool";
 import { BaseAgent, BaseAgentConfig, TokenUsage } from "../BaseAgent";
 import { History, MessageContent } from "../../history/History";
+import { StreamChunk } from "../openai-compatible/OpenAICompatibleAgent";
 import { ClaudeModel } from "../model-types";
 type AgentConfig = BaseAgentConfig & {
     apiKey: string;
@@ -22,6 +24,12 @@ type AgentConfig = BaseAgentConfig & {
      * @see lib/tools/BuiltInTool.ts
      */
     builtInTools?: BuiltInTool[];
+    /**
+     * Enable extended thinking with this token budget (≥ 1024, and strictly less than
+     * `maxTokens`). When set, thinking tokens are streamed as `"reasoning"` chunks and
+     * `temperature`/`topP`/`topK` are omitted (required by the API when thinking is on).
+     */
+    thinkingBudgetTokens?: number;
 };
 /**
  * Agent for Anthropic models.
@@ -54,10 +62,56 @@ export declare class ClaudeAgent extends BaseAgent {
      * (server-side) built-in tools, in the shape Anthropic's API expects.
      */
     protected getAllToolDefinitions(): ToolUnion[];
+    /**
+     * Build the common `messages.create` params (shared by `execute()` and
+     * `executeStream()`), excluding `stream`. When extended thinking is enabled
+     * (`thinkingBudgetTokens > 0`) the API requires default sampling, so
+     * `temperature`/`top_p`/`top_k` are omitted in favour of the `thinking` block.
+     */
+    protected buildMessageParams(): {
+        thinking: {
+            type: "enabled";
+            budget_tokens: number;
+        };
+        model: string & ClaudeModel;
+        system: string | undefined;
+        max_tokens: number;
+        messages: Anthropic.Messages.MessageParam[];
+        tools: Anthropic.Messages.ToolUnion[];
+        stop_sequences: string[] | undefined;
+        metadata: Record<string, string> | undefined;
+    } | {
+        temperature: number | undefined;
+        top_p: number | undefined;
+        top_k: number | undefined;
+        model: string & ClaudeModel;
+        system: string | undefined;
+        max_tokens: number;
+        messages: Anthropic.Messages.MessageParam[];
+        tools: Anthropic.Messages.ToolUnion[];
+        stop_sequences: string[] | undefined;
+        metadata: Record<string, string> | undefined;
+    };
     protected process(_input: string): Promise<string>;
     execute(input: string | MessageContent[]): Promise<string>;
     protected handleResponse(response: Message): Promise<string>;
     private handleToolUse;
+    /**
+     * Stream a response as an async generator of `StreamChunk` objects.
+     * Yields `{ type: "text" }` for visible output and `{ type: "reasoning" }` for
+     * extended thinking tokens (models with thinking enabled). Tool calls are handled
+     * transparently — the generator continues streaming after each round-trip.
+     *
+     * @example
+     * ```typescript
+     * for await (const chunk of agent.executeStream("Explain recursion")) {
+     *   if (chunk.type === "text") process.stdout.write(chunk.content);
+     *   else process.stderr.write(`[thinking] ${chunk.content}`);
+     * }
+     * ```
+     */
+    executeStream(input: string | MessageContent[]): AsyncGenerator<StreamChunk>;
+    private streamTurn;
     protected parseUsage(input: Usage): TokenUsage;
 }
 export {};

package/dist/agents/anthropic/ClaudeAgent.js

@@ -38,6 +38,7 @@ class ClaudeAgent extends BaseAgent_1.BaseAgent {
         const metadata = config.metadata ?? vendorConfig.metadata;
         const builtInTools = config.builtInTools ?? vendorConfig.builtInTools;
         const authType = config.authType ?? vendorConfig.authType ?? "apiKey";
+        const thinkingBudgetTokens = config.thinkingBudgetTokens ?? vendorConfig.thinkingBudgetTokens;
         this.client = new sdk_1.Anthropic(authType === "oauth"
             ? { authToken: config.apiKey }
             : { apiKey: config.apiKey });
@@ -48,6 +49,7 @@ class ClaudeAgent extends BaseAgent_1.BaseAgent {
             metadata,
             builtInTools,
             authType,
+            thinkingBudgetTokens,
             apiKey: config.apiKey,
             temperature: config.temperature,
             topP: config.topP,
@@ -70,6 +72,37 @@ class ClaudeAgent extends BaseAgent_1.BaseAgent {
             ...(this.config.builtInTools ?? []),
         ];
     }
+    /**
+     * Build the common `messages.create` params (shared by `execute()` and
+     * `executeStream()`), excluding `stream`. When extended thinking is enabled
+     * (`thinkingBudgetTokens > 0`) the API requires default sampling, so
+     * `temperature`/`top_p`/`top_k` are omitted in favour of the `thinking` block.
+     */
+    buildMessageParams() {
+        const messages = transformers_1.anthropicTransformer.toProvider(this.history.getEntries());
+        const thinkingEnabled = (this.config.thinkingBudgetTokens ?? 0) > 0;
+        return {
+            model: this.config.model,
+            system: this.history.getSystemMessage(),
+            max_tokens: this.config.maxTokens,
+            messages,
+            tools: this.getAllToolDefinitions(),
+            stop_sequences: this.config.stopSequences,
+            metadata: this.config.metadata,
+            ...(thinkingEnabled
+                ? {
+                    thinking: {
+                        type: "enabled",
+                        budget_tokens: this.config.thinkingBudgetTokens,
+                    },
+                }
+                : {
+                    temperature: this.config.temperature,
+                    top_p: this.config.topP,
+                    top_k: this.config.topK,
+                }),
+        };
+    }
     async process(_input) {
         return "";
     }
@@ -102,20 +135,7 @@ class ClaudeAgent extends BaseAgent_1.BaseAgent {
         // mid-loop. endExecution() in the finally block enforces limits once.
         this.history.beginExecution();
         try {
-            const messages = transformers_1.anthropicTransformer.toProvider(this.history.getEntries());
-            const systemMessage = this.history.getSystemMessage();
-            const response = await this.client.messages.create({
-                model: this.config.model,
-                system: systemMessage,
-                max_tokens: this.config.maxTokens,
-                messages,
-                tools: this.getAllToolDefinitions(),
-                temperature: this.config.temperature,
-                top_p: this.config.topP,
-                top_k: this.config.topK,
-                stop_sequences: this.config.stopSequences,
-                metadata: this.config.metadata,
-            });
+            const response = (await this.client.messages.create(this.buildMessageParams()));
             this.emit(AgentEvent_1.AgentEvent.AFTER_EXECUTE, response);
             return await this.handleResponse(response);
         }
@@ -212,19 +232,7 @@ class ClaudeAgent extends BaseAgent_1.BaseAgent {
                 this.addMessageToHistory("user", toolResults);
                 // Continue conversation with tool results
                 try {
-                    const messages = transformers_1.anthropicTransformer.toProvider(this.history.getEntries());
-                    const newResponse = await this.client.messages.create({
-                        model: this.config.model,
-                        system: this.history.getSystemMessage(),
-                        max_tokens: this.config.maxTokens,
-                        messages,
-                        tools: this.getAllToolDefinitions(),
-                        temperature: this.config.temperature,
-                        top_p: this.config.topP,
-                        top_k: this.config.topK,
-                        stop_sequences: this.config.stopSequences,
-                        metadata: this.config.metadata,
-                    });
+                    const newResponse = (await this.client.messages.create(this.buildMessageParams()));
                     this.emit(AgentEvent_1.AgentEvent.AFTER_EXECUTE, newResponse);
                     return this.handleResponse(newResponse);
                 }
@@ -305,6 +313,206 @@ class ClaudeAgent extends BaseAgent_1.BaseAgent {
         }));
         return results;
     }
+    /**
+     * Stream a response as an async generator of `StreamChunk` objects.
+     * Yields `{ type: "text" }` for visible output and `{ type: "reasoning" }` for
+     * extended thinking tokens (models with thinking enabled). Tool calls are handled
+     * transparently — the generator continues streaming after each round-trip.
+     *
+     * @example
+     * ```typescript
+     * for await (const chunk of agent.executeStream("Explain recursion")) {
+     *   if (chunk.type === "text") process.stdout.write(chunk.content);
+     *   else process.stderr.write(`[thinking] ${chunk.content}`);
+     * }
+     * ```
+     */
+    async *executeStream(input) {
+        this.emit(AgentEvent_1.AgentEvent.BEFORE_EXECUTE, input);
+        this.lastTokenUsage = undefined;
+        this.currentToolCallCount = 0;
+        const inputPreview = typeof input === "string" ? input : JSON.stringify(input);
+        if (VizConfig_1.vizConfig.isEnabled()) {
+            this.vizEventId = VizReporter_1.vizReporter.agentStart(this.id, this.name, this.config.model, "anthropic", inputPreview);
+        }
+        if (this.history.transient) {
+            this.history.clear();
+            this.addSystemMessage(this.getSystemMessage());
+        }
+        if (typeof input === "string") {
+            this.addTextToHistory("user", input);
+        }
+        else {
+            this.addMessageToHistory("user", input);
+        }
+        this.history.setSessionAnchor();
+        this.history.beginExecution();
+        try {
+            yield* this.streamTurn();
+        }
+        catch (error) {
+            if (error instanceof sdk_1.APIError) {
+                const apiError = new AgentError_1.ApiError(`Anthropic API error: ${error.message}`, error.status, error);
+                this.emit(AgentEvent_1.AgentEvent.ERROR, apiError);
+                if (this.vizEventId) {
+                    VizReporter_1.vizReporter.agentError(this.vizEventId, "ApiError", apiError.message, error.status === 429);
+                    this.vizEventId = undefined;
+                }
+                throw apiError;
+            }
+            // Errors raised inside streamTurn() (e.g. MaxTokensExceededError) are
+            // already emitted and viz-reported at the throw site — preserve their
+            // type rather than re-wrapping them in a generic ExecutionError.
+            if (error instanceof AgentError_1.AgentError) {
+                throw error;
+            }
+            const executionError = new AgentError_1.ExecutionError(`Anthropic error: ${error instanceof Error ? error.message : "Unknown error"}`);
+            this.emit(AgentEvent_1.AgentEvent.ERROR, executionError);
+            if (this.vizEventId) {
+                VizReporter_1.vizReporter.agentError(this.vizEventId, "ExecutionError", executionError.message, false);
+                this.vizEventId = undefined;
+            }
+            throw executionError;
+        }
+        finally {
+            this.history.endExecution();
+        }
+    }
+    async *streamTurn() {
+        const stream = await this.client.messages.create({
+            ...this.buildMessageParams(),
+            stream: true,
+        });
+        const blocks = new Map();
+        let textContent = "";
+        let stopReason = null;
+        let inputTokens = 0;
+        let outputTokens = 0;
+        for await (const event of stream) {
+            if (event.type === "message_start") {
+                const e = event;
+                inputTokens = e.message.usage.input_tokens;
+                outputTokens = e.message.usage.output_tokens;
+            }
+            if (event.type === "message_delta") {
+                const e = event;
+                stopReason = e.delta.stop_reason ?? stopReason;
+                outputTokens += e.usage?.output_tokens ?? 0;
+            }
+            if (event.type === "content_block_start") {
+                const e = event;
+                const block = e.content_block;
+                if (block.type === "tool_use") {
+                    blocks.set(e.index, { kind: "tool_use", id: block.id, name: block.name, inputJson: "" });
+                }
+                else if (block.type === "text") {
+                    blocks.set(e.index, { kind: "text", text: "" });
+                }
+                else if (block.type === "thinking") {
+                    blocks.set(e.index, { kind: "thinking", thinking: "", signature: "" });
+                }
+                else if (block.type === "redacted_thinking") {
+                    blocks.set(e.index, { kind: "redacted_thinking", data: block.data });
+                }
+            }
+            if (event.type === "content_block_delta") {
+                const e = event;
+                const delta = e.delta;
+                const acc = blocks.get(e.index);
+                if (delta.type === "text_delta") {
+                    textContent += delta.text;
+                    if (acc?.kind === "text")
+                        acc.text += delta.text;
+                    this.emit(AgentEvent_1.AgentEvent.CHUNK, delta.text);
+                    yield { type: "text", content: delta.text };
+                }
+                else if (delta.type === "thinking_delta") {
+                    if (acc?.kind === "thinking")
+                        acc.thinking += delta.thinking;
+                    this.emit(AgentEvent_1.AgentEvent.REASONING_CHUNK, delta.thinking);
+                    yield { type: "reasoning", content: delta.thinking };
+                }
+                else if (delta.type === "signature_delta") {
+                    if (acc?.kind === "thinking")
+                        acc.signature += delta.signature;
+                }
+                else if (delta.type === "input_json_delta") {
+                    if (acc?.kind === "tool_use")
+                        acc.inputJson += delta.partial_json;
+                }
+            }
+        }
+        const usage = {
+            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);
+            this.emit(AgentEvent_1.AgentEvent.ERROR, error);
+            if (this.vizEventId) {
+                VizReporter_1.vizReporter.agentError(this.vizEventId, "MaxTokensExceededError", error.message, false);
+                this.vizEventId = undefined;
+            }
+            throw error;
+        }
+        // Rebuild the assistant turn in stream order (thinking → text → tool_use).
+        const orderedBlocks = Array.from(blocks.entries())
+            .sort(([a], [b]) => a - b)
+            .map(([, b]) => {
+            switch (b.kind) {
+                case "thinking":
+                    return { type: "thinking", thinking: b.thinking, signature: b.signature };
+                case "redacted_thinking":
+                    return { type: "redacted_thinking", data: b.data };
+                case "tool_use":
+                    return {
+                        type: "tool_use",
+                        id: b.id,
+                        name: b.name,
+                        input: JSON.parse(b.inputJson || "{}"),
+                    };
+                case "text":
+                    return { type: "text", text: b.text, citations: [] };
+            }
+        });
+        // Fallback: preserve streamed text even if no text block start was observed.
+        if (textContent && !orderedBlocks.some((b) => b.type === "text")) {
+            orderedBlocks.push({ type: "text", text: textContent, citations: [] });
+        }
+        const toolUseBlocks = orderedBlocks.filter((b) => b.type === "tool_use");
+        if (stopReason === "tool_use" && toolUseBlocks.length > 0) {
+            this.emit(AgentEvent_1.AgentEvent.TOOL_USE, orderedBlocks);
+            this.currentToolCallCount += toolUseBlocks.length;
+            const assistantEntry = transformers_1.anthropicTransformer.fromProviderContent("assistant", orderedBlocks);
+            this.addToHistory(assistantEntry);
+            const toolResults = await this.handleToolUse(orderedBlocks);
+            this.addMessageToHistory("user", toolResults);
+            yield* this.streamTurn();
+        }
+        else {
+            const assistantEntry = transformers_1.anthropicTransformer.fromProviderContent("assistant", orderedBlocks);
+            this.addToHistory(assistantEntry);
+            this.emit(AgentEvent_1.AgentEvent.DONE, { content: textContent }, this.lastTokenUsage);
+            if (this.vizEventId) {
+                VizReporter_1.vizReporter.agentComplete(this.vizEventId, {
+                    input: this.lastTokenUsage?.input_tokens || 0,
+                    output: this.lastTokenUsage?.output_tokens || 0,
+                    total: this.lastTokenUsage?.total_tokens || 0,
+                }, "end_turn", this.currentToolCallCount > 0, this.currentToolCallCount, textContent);
+                this.vizEventId = undefined;
+            }
+        }
+    }
     parseUsage(input) {
         return {
             input_tokens: input.input_tokens,

package/dist/agents/google/GeminiAgent.js

@@ -118,7 +118,7 @@ class GeminiAgent extends BaseAgent_1.BaseAgent {
                     items: this.convertPropertyToSchema(prop.items),
                     description,
                 };
-            case "object":
+            case "object": {
                 const objProps = {};
                 if (prop.properties) {
                     const subProps = prop.properties;
@@ -132,6 +132,7 @@ class GeminiAgent extends BaseAgent_1.BaseAgent {
                     description,
                     required: prop.required,
                 };
+            }
             default:
                 return { type: generative_ai_1.SchemaType.STRING, description };
         }

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

@@ -2,6 +2,7 @@ import { BaseAgent, BaseAgentConfig, TokenUsage } from "../BaseAgent";
 import { History, MessageContent } from "../../history/History";
 import { Tool, Response, ResponseUsage } from "openai/resources/responses/responses";
 import { OpenAIModel } from "../model-types";
+import { StreamChunk } from "../openai-compatible/OpenAICompatibleAgent";
 type AgentConfig = BaseAgentConfig & {
     apiKey: string;
     model?: OpenAIModel;
@@ -42,6 +43,20 @@ export declare class OpenAiAgent extends BaseAgent {
     execute(input: string | MessageContent[]): Promise<string>;
     protected handleResponse(response: Response): Promise<string>;
     private handleToolUse;
+    /**
+     * Stream a response as an async generator of `StreamChunk` objects.
+     * Yields `{ type: "text" }` for visible output and `{ type: "reasoning" }` for
+     * reasoning summary tokens (o-series models). Tool calls are handled transparently.
+     *
+     * @example
+     * ```typescript
+     * for await (const chunk of agent.executeStream("Explain recursion")) {
+     *   if (chunk.type === "text") process.stdout.write(chunk.content);
+     * }
+     * ```
+     */
+    executeStream(input: string | MessageContent[]): AsyncGenerator<StreamChunk>;
+    private streamTurn;
     protected parseUsage(input: ResponseUsage): TokenUsage;
 }
 export {};

package/dist/agents/openai/OpenAiAgent.js

@@ -341,6 +341,156 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
         }));
         return toolResults;
     }
+    /**
+     * Stream a response as an async generator of `StreamChunk` objects.
+     * Yields `{ type: "text" }` for visible output and `{ type: "reasoning" }` for
+     * reasoning summary tokens (o-series models). Tool calls are handled transparently.
+     *
+     * @example
+     * ```typescript
+     * for await (const chunk of agent.executeStream("Explain recursion")) {
+     *   if (chunk.type === "text") process.stdout.write(chunk.content);
+     * }
+     * ```
+     */
+    async *executeStream(input) {
+        this.emit(AgentEvent_1.AgentEvent.BEFORE_EXECUTE, input);
+        this.lastTokenUsage = undefined;
+        this.currentToolCallCount = 0;
+        const inputPreview = typeof input === "string" ? input : JSON.stringify(input);
+        if (VizConfig_1.vizConfig.isEnabled()) {
+            this.vizEventId = VizReporter_1.vizReporter.agentStart(this.id, this.name, this.config.model, "openai", inputPreview);
+        }
+        if (this.history.transient) {
+            this.history.clear();
+            this.addSystemMessage(this.getSystemMessage());
+        }
+        if (typeof input === "string") {
+            this.addTextToHistory("user", input);
+        }
+        else {
+            this.addMessageToHistory("user", input);
+        }
+        this.history.setSessionAnchor();
+        this.history.beginExecution();
+        try {
+            yield* this.streamTurn();
+        }
+        catch (error) {
+            if (error instanceof AgentError_1.AgentError) {
+                this.emit(AgentEvent_1.AgentEvent.ERROR, error);
+                if (this.vizEventId) {
+                    VizReporter_1.vizReporter.agentError(this.vizEventId, error.constructor.name, error.message, false);
+                    this.vizEventId = undefined;
+                }
+                throw error;
+            }
+            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);
+                this.emit(AgentEvent_1.AgentEvent.ERROR, apiError);
+                if (this.vizEventId) {
+                    VizReporter_1.vizReporter.agentError(this.vizEventId, "ApiError", apiError.message, openAIError.error.code === "rate_limit_exceeded");
+                    this.vizEventId = undefined;
+                }
+                throw apiError;
+            }
+            const executionError = new AgentError_1.ExecutionError(`OpenAI error: ${error instanceof Error ? error.message : "Unknown error"}`);
+            this.emit(AgentEvent_1.AgentEvent.ERROR, executionError);
+            if (this.vizEventId) {
+                VizReporter_1.vizReporter.agentError(this.vizEventId, "ExecutionError", executionError.message, false);
+                this.vizEventId = undefined;
+            }
+            throw executionError;
+        }
+        finally {
+            this.history.endExecution();
+        }
+    }
+    async *streamTurn() {
+        const inputMessages = transformers_1.openAiTransformer.toProvider(this.history.getEntries());
+        const stream = await this.client.responses.create({
+            model: this.config.model,
+            max_output_tokens: this.config.maxTokens,
+            input: inputMessages,
+            tools: this.getToolDefinitions(),
+            store: false,
+            stream: true,
+            temperature: this.config.temperature,
+            top_p: this.config.topP,
+            user: this.config.user,
+            ...(this.config.disableReasoning && { reasoning: { effort: null } }),
+            ...(this.config.reasoningEffort && !this.config.disableReasoning && {
+                // `summary: "auto"` is required for the Responses API to stream
+                // `response.reasoning_summary_text.delta` events.
+                reasoning: { effort: this.config.reasoningEffort, summary: "auto" },
+            }),
+        });
+        let completedEvent = null;
+        for await (const event of stream) {
+            if (event.type === "response.output_text.delta") {
+                this.emit(AgentEvent_1.AgentEvent.CHUNK, event.delta);
+                yield { type: "text", content: event.delta };
+            }
+            if (event.type === "response.reasoning_summary_text.delta") {
+                this.emit(AgentEvent_1.AgentEvent.REASONING_CHUNK, event.delta);
+                yield { type: "reasoning", content: event.delta };
+            }
+            if (event.type === "response.completed") {
+                completedEvent = event;
+                if (event.response.usage) {
+                    const usage = this.parseUsage(event.response.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 };
+                    }
+                }
+            }
+            if (event.type === "response.incomplete") {
+                throw new AgentError_1.MaxTokensExceededError("Response incomplete: max tokens reached", this.config.maxTokens || 1024);
+            }
+        }
+        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) {
+            this.emit(AgentEvent_1.AgentEvent.TOOL_USE, toolCalls);
+            this.currentToolCallCount += toolCalls.length;
+            const functionCalls = toolCalls.map((tc) => ({
+                id: tc.id || tc.call_id,
+                call_id: tc.call_id,
+                name: tc.name,
+                arguments: tc.arguments,
+            }));
+            const assistantEntry = transformers_1.openAiTransformer.fromProviderMessage("assistant", response.output_text || "", functionCalls);
+            this.addToHistory(assistantEntry);
+            const toolResults = await this.handleToolUse(toolCalls);
+            for (const result of toolResults) {
+                this.addToHistory(transformers_1.openAiTransformer.toolResultEntry(result.call_id, result.output, false));
+            }
+            yield* this.streamTurn();
+        }
+        else {
+            const textContent = response.output_text || "";
+            const entry = transformers_1.openAiTransformer.fromProviderMessage("assistant", textContent);
+            this.addToHistory(entry);
+            this.emit(AgentEvent_1.AgentEvent.DONE, response, this.lastTokenUsage);
+            if (this.vizEventId) {
+                VizReporter_1.vizReporter.agentComplete(this.vizEventId, {
+                    input: this.lastTokenUsage?.input_tokens || 0,
+                    output: this.lastTokenUsage?.output_tokens || 0,
+                    total: this.lastTokenUsage?.total_tokens || 0,
+                }, "end_turn", this.currentToolCallCount > 0, this.currentToolCallCount, textContent);
+                this.vizEventId = undefined;
+            }
+        }
+    }
     parseUsage(input) {
         return {
             input_tokens: input.input_tokens,

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

@@ -4,6 +4,15 @@ import { Model } from "openai/resources/models";
 import { BaseAgent, BaseAgentConfig, TokenUsage } from "../BaseAgent";
 import { AgentVendor } from "../AgentConfig";
 import { History, MessageContent } from "../../history/History";
+/**
+ * A single chunk yielded by `executeStream()`.
+ * - `"text"` — visible output token
+ * - `"reasoning"` — internal reasoning token (DeepSeek-style `reasoning_content`)
+ */
+export type StreamChunk = {
+    type: "text" | "reasoning";
+    content: string;
+};
 export type OpenAICompatibleConfig = BaseAgentConfig & {
     /** Base URL of the OpenAI-compatible `/v1` endpoint (required) */
     baseURL: string;
@@ -43,6 +52,24 @@ export declare abstract class OpenAICompatibleAgent extends BaseAgent {
     private callProvider;
     protected handleResponse(response: ChatCompletion): Promise<string>;
     private handleToolCalls;
+    /**
+     * Stream a response as an async generator of `StreamChunk` objects.
+     *
+     * Yields `{ type: "text" }` for visible output and `{ type: "reasoning" }` for
+     * internal reasoning tokens (models that expose `reasoning_content`, e.g. DeepSeek R1).
+     * Tool calls are executed transparently — the generator continues streaming after
+     * each tool-call round-trip.
+     *
+     * @example
+     * ```typescript
+     * for await (const chunk of agent.executeStream("Explain recursion")) {
+     *   if (chunk.type === "text") process.stdout.write(chunk.content);
+     * }
+     * ```
+     */
+    executeStream(input: string | MessageContent[]): AsyncGenerator<StreamChunk>;
+    private streamTurn;
+    private accumulateStreamUsage;
     protected parseUsage(response: ChatCompletion): TokenUsage;
 }
 //# sourceMappingURL=OpenAICompatibleAgent.d.ts.map

package/dist/agents/openai-compatible/OpenAICompatibleAgent.js

@@ -236,6 +236,197 @@ class OpenAICompatibleAgent extends BaseAgent_1.BaseAgent {
             }
         }));
     }
+    /**
+     * Stream a response as an async generator of `StreamChunk` objects.
+     *
+     * Yields `{ type: "text" }` for visible output and `{ type: "reasoning" }` for
+     * internal reasoning tokens (models that expose `reasoning_content`, e.g. DeepSeek R1).
+     * Tool calls are executed transparently — the generator continues streaming after
+     * each tool-call round-trip.
+     *
+     * @example
+     * ```typescript
+     * for await (const chunk of agent.executeStream("Explain recursion")) {
+     *   if (chunk.type === "text") process.stdout.write(chunk.content);
+     * }
+     * ```
+     */
+    async *executeStream(input) {
+        this.emit(AgentEvent_1.AgentEvent.BEFORE_EXECUTE, input);
+        this.lastTokenUsage = undefined;
+        this.currentToolCallCount = 0;
+        const inputPreview = typeof input === "string" ? input : JSON.stringify(input);
+        if (VizConfig_1.vizConfig.isEnabled()) {
+            this.vizEventId = VizReporter_1.vizReporter.agentStart(this.id, this.name, this.config.model, this.vendor, inputPreview);
+        }
+        if (this.history.transient) {
+            this.history.clear();
+            this.addSystemMessage(this.getSystemMessage());
+        }
+        if (typeof input === "string") {
+            this.addTextToHistory("user", input);
+        }
+        else {
+            this.addMessageToHistory("user", input);
+        }
+        this.history.setSessionAnchor();
+        this.history.beginExecution();
+        try {
+            yield* this.streamTurn();
+        }
+        catch (error) {
+            if (error instanceof openai_1.default.APIError) {
+                const apiError = new AgentError_1.ApiError(`${this.getVendorName()} API error: ${error.message}`, error.status, error);
+                this.emit(AgentEvent_1.AgentEvent.ERROR, apiError);
+                if (this.vizEventId) {
+                    VizReporter_1.vizReporter.agentError(this.vizEventId, "ApiError", apiError.message, error.status === 429);
+                    this.vizEventId = undefined;
+                }
+                throw apiError;
+            }
+            if (error instanceof AgentError_1.AgentError) {
+                this.emit(AgentEvent_1.AgentEvent.ERROR, error);
+                if (this.vizEventId) {
+                    VizReporter_1.vizReporter.agentError(this.vizEventId, error.constructor.name, error.message, false);
+                    this.vizEventId = undefined;
+                }
+                throw error;
+            }
+            const executionError = new AgentError_1.ExecutionError(`${this.getVendorName()} error: ${error instanceof Error ? error.message : "Unknown error"}`);
+            this.emit(AgentEvent_1.AgentEvent.ERROR, executionError);
+            if (this.vizEventId) {
+                VizReporter_1.vizReporter.agentError(this.vizEventId, "ExecutionError", executionError.message, false);
+                this.vizEventId = undefined;
+            }
+            throw executionError;
+        }
+        finally {
+            this.history.endExecution();
+        }
+    }
+    async *streamTurn() {
+        const messages = transformers_1.chatCompletionsTransformer.toProvider(this.history.getEntries());
+        const tools = this.tools.size > 0 ? this.getToolDefinitions() : undefined;
+        const stream = await this.client.chat.completions.create({
+            model: this.config.model,
+            messages,
+            tools,
+            stream: true,
+            stream_options: { include_usage: true },
+            max_tokens: this.config.maxTokens,
+            temperature: this.config.temperature,
+            top_p: this.config.topP,
+            stop: this.config.stopSequences,
+            seed: this.config.seed,
+            presence_penalty: this.config.presencePenalty,
+            frequency_penalty: this.config.frequencyPenalty,
+            ...this.buildExtraRequestParams(),
+        });
+        let textContent = "";
+        const toolCallAcc = new Map();
+        let finishReason = null;
+        for await (const chunk of stream) {
+            // Final chunk carrying usage (choices is empty)
+            if (chunk.choices.length === 0) {
+                if (chunk.usage)
+                    this.accumulateStreamUsage(chunk.usage);
+                continue;
+            }
+            const choice = chunk.choices[0];
+            finishReason = choice.finish_reason ?? finishReason;
+            const delta = choice.delta;
+            if (delta.content) {
+                textContent += delta.content;
+                this.emit(AgentEvent_1.AgentEvent.CHUNK, delta.content);
+                yield { type: "text", content: delta.content };
+            }
+            // DeepSeek-style reasoning tokens (not in OpenAI SDK types — cast required)
+            const reasoningDelta = delta.reasoning_content;
+            if (reasoningDelta) {
+                this.emit(AgentEvent_1.AgentEvent.REASONING_CHUNK, reasoningDelta);
+                yield { type: "reasoning", content: reasoningDelta };
+            }
+            if (delta.tool_calls) {
+                for (const tc of delta.tool_calls) {
+                    if (!toolCallAcc.has(tc.index)) {
+                        toolCallAcc.set(tc.index, { id: "", name: "", arguments: "" });
+                    }
+                    const acc = toolCallAcc.get(tc.index);
+                    if (tc.id)
+                        acc.id = tc.id;
+                    if (tc.function?.name)
+                        acc.name += tc.function.name;
+                    if (tc.function?.arguments)
+                        acc.arguments += tc.function.arguments;
+                }
+            }
+        }
+        if (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);
+            this.emit(AgentEvent_1.AgentEvent.ERROR, error);
+            if (this.vizEventId) {
+                VizReporter_1.vizReporter.agentError(this.vizEventId, "MaxTokensExceededError", error.message, false);
+                this.vizEventId = undefined;
+            }
+            throw error;
+        }
+        if (finishReason === "tool_calls" && toolCallAcc.size > 0) {
+            const toolCalls = Array.from(toolCallAcc.entries())
+                .sort(([a], [b]) => a - b)
+                .map(([, tc]) => ({
+                id: tc.id,
+                type: "function",
+                function: { name: tc.name, arguments: tc.arguments },
+            }));
+            this.emit(AgentEvent_1.AgentEvent.TOOL_USE, toolCalls);
+            this.currentToolCallCount += toolCalls.length;
+            const assistantEntry = transformers_1.chatCompletionsTransformer.fromProviderMessage({
+                role: "assistant",
+                content: textContent || null,
+                tool_calls: toolCalls,
+            });
+            this.addToHistory(assistantEntry);
+            const toolResults = await this.handleToolCalls(toolCalls);
+            for (const result of toolResults) {
+                this.addToHistory(transformers_1.chatCompletionsTransformer.toolResultEntry(result.toolCallId, result.content));
+            }
+            yield* this.streamTurn();
+        }
+        else {
+            const assistantEntry = transformers_1.chatCompletionsTransformer.fromProviderMessage({
+                role: "assistant",
+                content: textContent || null,
+            });
+            this.addToHistory(assistantEntry);
+            this.emit(AgentEvent_1.AgentEvent.DONE, { content: textContent }, this.lastTokenUsage);
+            if (this.vizEventId) {
+                VizReporter_1.vizReporter.agentComplete(this.vizEventId, {
+                    input: this.lastTokenUsage?.input_tokens || 0,
+                    output: this.lastTokenUsage?.output_tokens || 0,
+                    total: this.lastTokenUsage?.total_tokens || 0,
+                }, "end_turn", this.currentToolCallCount > 0, this.currentToolCallCount, textContent);
+                this.vizEventId = undefined;
+            }
+        }
+    }
+    accumulateStreamUsage(usage) {
+        if (!usage)
+            return;
+        const u = {
+            input_tokens: usage.prompt_tokens ?? 0,
+            output_tokens: usage.completion_tokens ?? 0,
+            total_tokens: usage.total_tokens ?? 0,
+        };
+        if (this.lastTokenUsage) {
+            this.lastTokenUsage.input_tokens += u.input_tokens;
+            this.lastTokenUsage.output_tokens += u.output_tokens;
+            this.lastTokenUsage.total_tokens += u.total_tokens;
+        }
+        else {
+            this.lastTokenUsage = u;
+        }
+    }
     parseUsage(response) {
         const usage = response.usage;
         return {

package/dist/history/History.d.ts

@@ -3,8 +3,8 @@ import { HistoryEntry, MessageRole, MessageContent } from "./types";
 import type { ReduceOptions } from "./types";
 /** @internal — exposed for test teardown only */
 export declare function resetTokenxCache(): void;
-export type { HistoryEntry, MessageRole, MessageContent, ReduceOptions, ImageMimeType, ImageUrlContent, ImageBase64Content, } from "./types";
-export { text, toolUse, toolResult, textMessage, imageUrl, imageBase64, isTextContent, isToolUseContent, isToolResultContent, isImageUrlContent, isImageBase64Content, isImageContent, } from "./types";
+export type { HistoryEntry, MessageRole, MessageContent, ReduceOptions, ImageMimeType, ImageUrlContent, ImageBase64Content, ThinkingContent, } from "./types";
+export { text, toolUse, toolResult, thinking, textMessage, imageUrl, imageBase64, isTextContent, isToolUseContent, isToolResultContent, isThinkingContent, isImageUrlContent, isImageBase64Content, isImageContent, } from "./types";
 /**
  * Metadata stored alongside each history entry.
  * Extended with summary tracking fields for the compression plugin.

package/dist/history/History.js

@@ -36,7 +36,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.History = exports.isImageContent = exports.isImageBase64Content = exports.isImageUrlContent = exports.isToolResultContent = exports.isToolUseContent = exports.isTextContent = exports.imageBase64 = exports.imageUrl = exports.textMessage = exports.toolResult = exports.toolUse = exports.text = void 0;
+exports.History = exports.isImageContent = exports.isImageBase64Content = exports.isImageUrlContent = exports.isThinkingContent = exports.isToolResultContent = exports.isToolUseContent = exports.isTextContent = exports.imageBase64 = exports.imageUrl = exports.textMessage = exports.thinking = exports.toolResult = exports.toolUse = exports.text = void 0;
 exports.resetTokenxCache = resetTokenxCache;
 const events_1 = __importDefault(require("events"));
 const types_1 = require("./types");
@@ -70,12 +70,14 @@ var types_2 = require("./types");
 Object.defineProperty(exports, "text", { enumerable: true, get: function () { return types_2.text; } });
 Object.defineProperty(exports, "toolUse", { enumerable: true, get: function () { return types_2.toolUse; } });
 Object.defineProperty(exports, "toolResult", { enumerable: true, get: function () { return types_2.toolResult; } });
+Object.defineProperty(exports, "thinking", { enumerable: true, get: function () { return types_2.thinking; } });
 Object.defineProperty(exports, "textMessage", { enumerable: true, get: function () { return types_2.textMessage; } });
 Object.defineProperty(exports, "imageUrl", { enumerable: true, get: function () { return types_2.imageUrl; } });
 Object.defineProperty(exports, "imageBase64", { enumerable: true, get: function () { return types_2.imageBase64; } });
 Object.defineProperty(exports, "isTextContent", { enumerable: true, get: function () { return types_2.isTextContent; } });
 Object.defineProperty(exports, "isToolUseContent", { enumerable: true, get: function () { return types_2.isToolUseContent; } });
 Object.defineProperty(exports, "isToolResultContent", { enumerable: true, get: function () { return types_2.isToolResultContent; } });
+Object.defineProperty(exports, "isThinkingContent", { enumerable: true, get: function () { return types_2.isThinkingContent; } });
 Object.defineProperty(exports, "isImageUrlContent", { enumerable: true, get: function () { return types_2.isImageUrlContent; } });
 Object.defineProperty(exports, "isImageBase64Content", { enumerable: true, get: function () { return types_2.isImageBase64Content; } });
 Object.defineProperty(exports, "isImageContent", { enumerable: true, get: function () { return types_2.isImageContent; } });

package/dist/history/index.d.ts

@@ -1,5 +1,5 @@
 export { History, resetTokenxCache, type EntryMetadata, type ReducibleEntry, type HistoryPlugin, } from "./History";
 export { RedisHistory } from "./RedisHistory";
-export type { HistoryEntry, MessageRole, MessageContent, TextContent, ToolUseContent, ToolResultContent, ProviderMeta, ReduceOptions, } from "./types";
-export { text, toolUse, toolResult, textMessage, isTextContent, isToolUseContent, isToolResultContent, } from "./types";
+export type { HistoryEntry, MessageRole, MessageContent, TextContent, ToolUseContent, ToolResultContent, ThinkingContent, ProviderMeta, ReduceOptions, } from "./types";
+export { text, toolUse, toolResult, thinking, textMessage, isTextContent, isToolUseContent, isToolResultContent, isThinkingContent, } from "./types";
 //# sourceMappingURL=index.d.ts.map

package/dist/history/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isToolResultContent = exports.isToolUseContent = exports.isTextContent = exports.textMessage = exports.toolResult = exports.toolUse = exports.text = exports.RedisHistory = exports.resetTokenxCache = exports.History = void 0;
+exports.isThinkingContent = exports.isToolResultContent = exports.isToolUseContent = exports.isTextContent = exports.textMessage = exports.thinking = exports.toolResult = exports.toolUse = exports.text = exports.RedisHistory = exports.resetTokenxCache = exports.History = void 0;
 var History_1 = require("./History");
 Object.defineProperty(exports, "History", { enumerable: true, get: function () { return History_1.History; } });
 Object.defineProperty(exports, "resetTokenxCache", { enumerable: true, get: function () { return History_1.resetTokenxCache; } });
@@ -10,8 +10,10 @@ var types_1 = require("./types");
 Object.defineProperty(exports, "text", { enumerable: true, get: function () { return types_1.text; } });
 Object.defineProperty(exports, "toolUse", { enumerable: true, get: function () { return types_1.toolUse; } });
 Object.defineProperty(exports, "toolResult", { enumerable: true, get: function () { return types_1.toolResult; } });
+Object.defineProperty(exports, "thinking", { enumerable: true, get: function () { return types_1.thinking; } });
 Object.defineProperty(exports, "textMessage", { enumerable: true, get: function () { return types_1.textMessage; } });
 Object.defineProperty(exports, "isTextContent", { enumerable: true, get: function () { return types_1.isTextContent; } });
 Object.defineProperty(exports, "isToolUseContent", { enumerable: true, get: function () { return types_1.isToolUseContent; } });
 Object.defineProperty(exports, "isToolResultContent", { enumerable: true, get: function () { return types_1.isToolResultContent; } });
+Object.defineProperty(exports, "isThinkingContent", { enumerable: true, get: function () { return types_1.isThinkingContent; } });
 //# sourceMappingURL=index.js.map

package/dist/history/transformers.js

@@ -40,6 +40,19 @@ exports.anthropicTransformer = {
                         is_error: block.is_error,
                     };
                 }
+                if ((0, types_1.isThinkingContent)(block)) {
+                    if (block.redactedData !== undefined) {
+                        return {
+                            type: "redacted_thinking",
+                            data: block.redactedData,
+                        };
+                    }
+                    return {
+                        type: "thinking",
+                        thinking: block.thinking,
+                        signature: block.signature ?? "",
+                    };
+                }
                 if ((0, types_1.isImageUrlContent)(block)) {
                     return {
                         type: "image",
@@ -72,7 +85,13 @@ exports.anthropicTransformer = {
             if (block.type === "tool_use") {
                 return (0, types_1.toolUse)(block.id, block.name, block.input);
             }
-            // Handle thinking blocks or other types as text
+            if (block.type === "thinking") {
+                return (0, types_1.thinking)(block.thinking, block.signature);
+            }
+            if (block.type === "redacted_thinking") {
+                return (0, types_1.thinking)("", undefined, block.data);
+            }
+            // Unknown / unsupported block — preserve a textual representation
             return (0, types_1.text)(JSON.stringify(block));
         });
         return {

package/dist/history/types.d.ts

@@ -29,6 +29,20 @@ export type ToolResultContent = {
     content: string;
     is_error?: boolean;
 };
+/**
+ * Extended-thinking / reasoning block produced by the assistant (Anthropic).
+ *
+ * These must be preserved verbatim — including `signature` — and echoed back on
+ * the following request when the assistant used a tool, or the provider rejects
+ * the turn. `redactedData` is set instead of `thinking` for redacted blocks,
+ * whose payload is opaque and must be returned unchanged.
+ */
+export type ThinkingContent = {
+    type: "thinking";
+    thinking: string;
+    signature?: string;
+    redactedData?: string;
+};
 /**
  * Supported image MIME types across all providers
  */
@@ -56,7 +70,7 @@ export type ImageBase64Content = {
 /**
  * Union of all content types
  */
-export type MessageContent = TextContent | ToolUseContent | ToolResultContent | ImageUrlContent | ImageBase64Content;
+export type MessageContent = TextContent | ToolUseContent | ToolResultContent | ThinkingContent | ImageUrlContent | ImageBase64Content;
 /**
  * Anthropic-specific metadata
  */
@@ -149,6 +163,7 @@ export type HistoryEntry = {
 export declare function isTextContent(content: MessageContent): content is TextContent;
 export declare function isToolUseContent(content: MessageContent): content is ToolUseContent;
 export declare function isToolResultContent(content: MessageContent): content is ToolResultContent;
+export declare function isThinkingContent(content: MessageContent): content is ThinkingContent;
 export declare function isImageUrlContent(content: MessageContent): content is ImageUrlContent;
 export declare function isImageBase64Content(content: MessageContent): content is ImageBase64Content;
 export declare function isImageContent(content: MessageContent): content is ImageUrlContent | ImageBase64Content;
@@ -160,6 +175,10 @@ export declare function text(value: string): TextContent;
  * Create a tool use content block
  */
 export declare function toolUse(id: string, name: string, input: Record<string, unknown>): ToolUseContent;
+/**
+ * Create a thinking content block. Pass `redactedData` for redacted thinking.
+ */
+export declare function thinking(thinkingText: string, signature?: string, redactedData?: string): ThinkingContent;
 /**
  * Create a tool result content block
  */

package/dist/history/types.js

@@ -9,11 +9,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isTextContent = isTextContent;
 exports.isToolUseContent = isToolUseContent;
 exports.isToolResultContent = isToolResultContent;
+exports.isThinkingContent = isThinkingContent;
 exports.isImageUrlContent = isImageUrlContent;
 exports.isImageBase64Content = isImageBase64Content;
 exports.isImageContent = isImageContent;
 exports.text = text;
 exports.toolUse = toolUse;
+exports.thinking = thinking;
 exports.toolResult = toolResult;
 exports.textMessage = textMessage;
 exports.imageUrl = imageUrl;
@@ -30,6 +32,9 @@ function isToolUseContent(content) {
 function isToolResultContent(content) {
     return content.type === "tool_result";
 }
+function isThinkingContent(content) {
+    return content.type === "thinking";
+}
 function isImageUrlContent(content) {
     return content.type === "image_url";
 }
@@ -54,6 +59,12 @@ function text(value) {
 function toolUse(id, name, input) {
     return { type: "tool_use", id, name, input };
 }
+/**
+ * Create a thinking content block. Pass `redactedData` for redacted thinking.
+ */
+function thinking(thinkingText, signature, redactedData) {
+    return { type: "thinking", thinking: thinkingText, signature, redactedData };
+}
 /**
  * Create a tool result content block
  */

package/dist/index.d.ts

@@ -6,7 +6,7 @@ export { GeminiAgent } from "./agents/google/GeminiAgent";
 export { OllamaAgent } from "./agents/ollama/OllamaAgent";
 export { LlamaCppAgent } from "./agents/llamacpp/LlamaCppAgent";
 export { OpenAICompatibleAgent } from "./agents/openai-compatible/OpenAICompatibleAgent";
-export type { OpenAICompatibleConfig } from "./agents/openai-compatible/OpenAICompatibleAgent";
+export type { OpenAICompatibleConfig, StreamChunk } from "./agents/openai-compatible/OpenAICompatibleAgent";
 export * from "./agents/model-types";
 export * from "./agents/AgentConfig";
 export * from "./agents/AgentEvent";

package/dist/ingestion/IngestionPipeline.js

@@ -187,7 +187,7 @@ class IngestionPipeline {
                 await this.store.addEmbeddedDocuments(embeddedDocs);
                 result.chunksStored += embeddedDocs.length;
             }
-            catch (error) {
+            catch {
                 // Try storing one by one to identify problematic chunks
                 for (let i = 0; i < embeddedDocs.length; i++) {
                     try {

package/dist/llamacpp.d.ts

@@ -1,6 +1,6 @@
 export * from "./core";
 export { LlamaCppAgent } from "./agents/llamacpp/LlamaCppAgent";
 export { OpenAICompatibleAgent } from "./agents/openai-compatible/OpenAICompatibleAgent";
-export type { OpenAICompatibleConfig } from "./agents/openai-compatible/OpenAICompatibleAgent";
+export type { OpenAICompatibleConfig, StreamChunk } from "./agents/openai-compatible/OpenAICompatibleAgent";
 export { chatCompletionsTransformer } from "./history/transformers";
 //# sourceMappingURL=llamacpp.d.ts.map

package/dist/team/Team.js

@@ -71,16 +71,7 @@ class Team extends node_events_1.default {
      * @returns The result from the lead agent
      */
     async execute(input) {
-        // this.emit("teamTaskStarted", { input, teamName: this.name });
-        try {
-            const result = await this.leadAgent.execute(input);
-            // this.emit("teamTaskCompleted", { input, result, teamName: this.name });
-            return result;
-        }
-        catch (error) {
-            // this.emit("teamTaskError", { input, error, teamName: this.name });
-            throw error;
-        }
+        return this.leadAgent.execute(input);
     }
     /**
      * Get the lead agent

package/dist/vectorstore/LanceDBVectorStore.js

@@ -53,7 +53,6 @@ const CHUNK_METADATA_KEYS = [
     "start", "end", "source_id", "source_path",
     "char_count", "token_count", "hash", "section", "page",
 ];
-const CHUNK_METADATA_KEY_SET = new Set(CHUNK_METADATA_KEYS);
 /**
  * LanceDB implementation of the VectorStore interface.
  *

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@agentionai/agents",
   "author": "Laurent Zuijdwijk",
-  "version": "0.14.0",
+  "version": "1.0.0",
   "description": "Agent Library",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -87,8 +87,8 @@
     "test": "jest",
     "test:watch": "jest --watch",
     "lint": "eslint 'lib/**/*.{js,ts}'",
-    "lint:fix": "eslint 'src/**/*.{js,ts}' --fix",
-    "format": "prettier --write 'src/**/*.{js,ts,json,md}'",
+    "lint:fix": "eslint 'lib/**/*.{js,ts}' --fix",
+    "format": "prettier --write 'lib/**/*.{js,ts,json,md}'",
     "prepare": "npm run build",
     "example": "tsx",
     "example:watch": "nodemon --watch examples --watch src --ext ts --exec 'ts-node --project tsconfig.esm.json' examples/index.ts",
@@ -102,7 +102,6 @@
     "publish:all": "npm run publish:npm && npm run publish:github"
   },
   "overrides": {
-    "ajv": "^8.17.1",
     "whatwg-url": "^14.0.0"
   },
   "devDependencies": {
@@ -116,12 +115,10 @@
     "@mistralai/mistralai": "^1.13.0",
     "@types/jest": "^29.5.0",
     "@types/node": "^18.15.11",
-    "@typescript-eslint/eslint-plugin": "^5.57.1",
-    "@typescript-eslint/parser": "^5.57.1",
     "apache-arrow": "^18.1.0",
     "babel-jest": "^29.7.0",
     "docdash": "^2.0.2",
-    "eslint": "^8.57.1",
+    "eslint": "^9.23.0",
     "eslint-config-prettier": "^8.8.0",
     "eslint-plugin-prettier": "^4.2.1",
     "globals": "^16.0.0",