@agentionai/agents 0.13.0 → 1.0.0

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

@@ -0,0 +1,440 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAICompatibleAgent = void 0;
+const openai_1 = __importDefault(require("openai"));
+const BaseAgent_1 = require("../BaseAgent");
+const AgentEvent_1 = require("../AgentEvent");
+const AgentError_1 = require("../errors/AgentError");
+const transformers_1 = require("../../history/transformers");
+const VizReporter_1 = require("../../viz/VizReporter");
+const VizConfig_1 = require("../../viz/VizConfig");
+/**
+ * Abstract base class for agents that talk to any OpenAI-compatible
+ * `/v1/chat/completions` endpoint (llama.cpp, vLLM, LM Studio, etc.).
+ *
+ * Subclasses must implement:
+ * - `getVendorName()` — human-readable name used in error messages (e.g. `"llama.cpp"`)
+ *
+ * Subclasses may override:
+ * - `buildExtraRequestParams()` — extra fields merged into the completions request
+ */
+class OpenAICompatibleAgent extends BaseAgent_1.BaseAgent {
+    constructor(config, history) {
+        super(config, history);
+        this.currentToolCallCount = 0;
+        this.client = new openai_1.default({
+            apiKey: config.apiKey || "not-needed",
+            baseURL: config.baseURL,
+        });
+        this.config = {
+            model: config.model,
+            baseURL: config.baseURL,
+            maxTokens: config.maxTokens,
+            temperature: config.temperature,
+            topP: config.topP,
+            stopSequences: config.stopSequences,
+            seed: config.seed,
+            presencePenalty: config.presencePenalty,
+            frequencyPenalty: config.frequencyPenalty,
+            apiKey: config.apiKey,
+        };
+        this.addSystemMessage(this.getSystemMessage());
+    }
+    /** Extra fields to merge into the chat completions request. Override for vendor-specific params. */
+    buildExtraRequestParams() {
+        return {};
+    }
+    /**
+     * List the models available on the server via the `/v1/models` endpoint.
+     */
+    async listModels() {
+        try {
+            const page = await this.client.models.list();
+            return page.data;
+        }
+        catch (error) {
+            throw new AgentError_1.ExecutionError(`Failed to list ${this.getVendorName()} models: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+    }
+    getToolDefinitions() {
+        return Array.from(this.tools.values()).map((tool) => {
+            const prompt = tool.getPrompt();
+            return {
+                type: "function",
+                function: {
+                    name: prompt.name,
+                    description: prompt.description,
+                    parameters: prompt.input_schema,
+                },
+            };
+        });
+    }
+    async process(_input) {
+        return "";
+    }
+    async execute(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 {
+            const response = await this.callProvider();
+            this.emit(AgentEvent_1.AgentEvent.AFTER_EXECUTE, response);
+            return await this.handleResponse(response);
+        }
+        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 callProvider() {
+        const messages = transformers_1.chatCompletionsTransformer.toProvider(this.history.getEntries());
+        const tools = this.tools.size > 0 ? this.getToolDefinitions() : undefined;
+        return this.client.chat.completions.create({
+            model: this.config.model,
+            messages,
+            tools,
+            stream: false,
+            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(),
+        });
+    }
+    async handleResponse(response) {
+        const usage = this.parseUsage(response);
+        if (this.lastTokenUsage) {
+            this.lastTokenUsage.input_tokens += usage.input_tokens;
+            this.lastTokenUsage.output_tokens += usage.output_tokens;
+            this.lastTokenUsage.total_tokens += usage.total_tokens;
+        }
+        else {
+            this.lastTokenUsage = { ...usage };
+        }
+        const choice = response.choices[0];
+        const message = choice.message;
+        if (choice.finish_reason === "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;
+        }
+        const hasToolCalls = message.tool_calls && message.tool_calls.length > 0;
+        if (!hasToolCalls) {
+            const textContent = message.content || "";
+            const entry = transformers_1.chatCompletionsTransformer.fromProviderMessage(message);
+            this.addToHistory(entry);
+            this.emit(AgentEvent_1.AgentEvent.DONE, message, usage);
+            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;
+            }
+            return textContent;
+        }
+        const toolCalls = message.tool_calls;
+        this.emit(AgentEvent_1.AgentEvent.TOOL_USE, toolCalls);
+        this.currentToolCallCount += toolCalls.length;
+        const assistantEntry = transformers_1.chatCompletionsTransformer.fromProviderMessage(message);
+        this.addToHistory(assistantEntry);
+        const toolResults = await this.handleToolCalls(toolCalls);
+        for (const result of toolResults) {
+            const resultEntry = transformers_1.chatCompletionsTransformer.toolResultEntry(result.toolCallId, result.content);
+            this.addToHistory(resultEntry);
+        }
+        try {
+            const newResponse = await this.callProvider();
+            this.emit(AgentEvent_1.AgentEvent.AFTER_EXECUTE, newResponse);
+            return this.handleResponse(newResponse);
+        }
+        catch (error) {
+            const executionError = new AgentError_1.ExecutionError(`${this.getVendorName()} error during tool response: ${error instanceof Error ? error.message : "Unknown error"}`);
+            this.emit(AgentEvent_1.AgentEvent.ERROR, executionError);
+            throw executionError;
+        }
+    }
+    async handleToolCalls(toolCalls) {
+        return Promise.all(toolCalls.map(async (toolCall) => {
+            const toolName = toolCall.type === "function" ? toolCall.function.name : "";
+            const tool = this.tools.get(toolName);
+            const toolCallId = toolCall.id;
+            if (toolCall.type !== "function" || !tool) {
+                const errorMessage = `Tool '${toolName}' not found`;
+                const error = new AgentError_1.ToolExecutionError(errorMessage, toolName, toolCall.type === "function"
+                    ? toolCall.function.arguments
+                    : undefined);
+                this.emit(AgentEvent_1.AgentEvent.TOOL_ERROR, error);
+                return { toolCallId, content: errorMessage };
+            }
+            try {
+                const args = JSON.parse(toolCall.function.arguments || "{}");
+                const result = await tool.execute(this.getId(), this.getName(), args, toolCallId, this.config.model, this.vendor);
+                return { toolCallId, content: JSON.stringify(result) };
+            }
+            catch (error) {
+                const errorMessage = `Error executing tool '${toolName}': ${error instanceof Error ? error.message : "Unknown error"}`;
+                if (this.debug) {
+                    console.error(errorMessage);
+                }
+                const toolError = new AgentError_1.ToolExecutionError(errorMessage, toolName, toolCall.function.arguments);
+                this.emit(AgentEvent_1.AgentEvent.TOOL_ERROR, toolError);
+                return { toolCallId, content: errorMessage };
+            }
+        }));
+    }
+    /**
+     * 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 {
+            input_tokens: usage?.prompt_tokens ?? 0,
+            output_tokens: usage?.completion_tokens ?? 0,
+            total_tokens: usage?.total_tokens ?? 0,
+        };
+    }
+}
+exports.OpenAICompatibleAgent = OpenAICompatibleAgent;
+//# sourceMappingURL=OpenAICompatibleAgent.js.map

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

@@ -5,6 +5,8 @@ export { MistralAgent } from "./agents/mistral/MistralAgent";
 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, StreamChunk } from "./agents/openai-compatible/OpenAICompatibleAgent";
 export * from "./agents/model-types";
 export * from "./agents/AgentConfig";
 export * from "./agents/AgentEvent";

package/dist/index.js

@@ -22,7 +22,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.chatCompletionsTransformer = exports.ollamaTransformer = exports.geminiTransformer = exports.mistralTransformer = exports.openAiTransformer = exports.anthropicTransformer = exports.LlamaCppAgent = exports.OllamaAgent = exports.GeminiAgent = exports.MistralAgent = exports.OpenAiAgent = void 0;
+exports.chatCompletionsTransformer = exports.ollamaTransformer = exports.geminiTransformer = exports.mistralTransformer = exports.openAiTransformer = exports.anthropicTransformer = exports.OpenAICompatibleAgent = exports.LlamaCppAgent = exports.OllamaAgent = exports.GeminiAgent = exports.MistralAgent = exports.OpenAiAgent = void 0;
 // Agents
 __exportStar(require("./agents/BaseAgent"), exports);
 __exportStar(require("./agents/anthropic/ClaudeAgent"), exports);
@@ -36,6 +36,8 @@ var OllamaAgent_1 = require("./agents/ollama/OllamaAgent");
 Object.defineProperty(exports, "OllamaAgent", { enumerable: true, get: function () { return OllamaAgent_1.OllamaAgent; } });
 var LlamaCppAgent_1 = require("./agents/llamacpp/LlamaCppAgent");
 Object.defineProperty(exports, "LlamaCppAgent", { enumerable: true, get: function () { return LlamaCppAgent_1.LlamaCppAgent; } });
+var OpenAICompatibleAgent_1 = require("./agents/openai-compatible/OpenAICompatibleAgent");
+Object.defineProperty(exports, "OpenAICompatibleAgent", { enumerable: true, get: function () { return OpenAICompatibleAgent_1.OpenAICompatibleAgent; } });
 __exportStar(require("./agents/model-types"), exports);
 __exportStar(require("./agents/AgentConfig"), exports);
 __exportStar(require("./agents/AgentEvent"), exports);

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 {