@agentionai/agents 0.14.0 → 1.0.1

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 (`reasoning` on OpenRouter, `reasoning_content` on DeepSeek/llama.cpp)
+ */
+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,201 @@ 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 };
+            }
+            // Reasoning tokens (not in OpenAI SDK types — cast required). Servers
+            // disagree on the field name: OpenRouter sends `delta.reasoning`, while
+            // DeepSeek/llama.cpp send `delta.reasoning_content`. Prefer `reasoning`;
+            // never concatenate — that would duplicate the text if both were sent.
+            const deltaExtras = delta;
+            const reasoningDelta = (deltaExtras.reasoning ?? deltaExtras.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.
  *