@agentionai/agents 0.3.0-beta

package/dist/history/transformers.js

@@ -0,0 +1,415 @@
+"use strict";
+/**
+ * Provider Transformers
+ *
+ * Transform between normalized HistoryEntry format and provider-specific formats.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.geminiTransformer = exports.mistralTransformer = exports.openAiTransformer = exports.anthropicTransformer = void 0;
+const types_1 = require("./types");
+// =============================================================================
+// Anthropic Transformer
+// =============================================================================
+exports.anthropicTransformer = {
+    /**
+     * Convert normalized entries to Anthropic MessageParam format
+     */
+    toProvider(entries) {
+        return entries
+            .filter((entry) => entry.role !== "system") // Anthropic handles system separately
+            .map((entry) => {
+            const role = entry.role === "assistant" ? "assistant" : "user";
+            // Convert content blocks to Anthropic's ContentBlockParam
+            const content = entry.content.map((block) => {
+                if ((0, types_1.isTextContent)(block)) {
+                    return { type: "text", text: block.text };
+                }
+                if ((0, types_1.isToolUseContent)(block)) {
+                    return {
+                        type: "tool_use",
+                        id: block.id,
+                        name: block.name,
+                        input: block.input,
+                    };
+                }
+                if ((0, types_1.isToolResultContent)(block)) {
+                    return {
+                        type: "tool_result",
+                        tool_use_id: block.tool_use_id,
+                        content: block.content,
+                        is_error: block.is_error,
+                    };
+                }
+                throw new Error(`Unknown content type: ${block.type}`);
+            });
+            return { role, content };
+        });
+    },
+    /**
+     * Convert Anthropic response content to normalized HistoryEntry
+     */
+    fromProviderContent(role, content) {
+        const normalizedContent = content.map((block) => {
+            if (block.type === "text") {
+                return (0, types_1.text)(block.text);
+            }
+            if (block.type === "tool_use") {
+                return (0, types_1.toolUse)(block.id, block.name, block.input);
+            }
+            // Handle thinking blocks or other types as text
+            return (0, types_1.text)(JSON.stringify(block));
+        });
+        return {
+            role,
+            content: normalizedContent,
+            meta: { provider: "anthropic" },
+        };
+    },
+    /**
+     * Extract system message from entries
+     */
+    getSystemMessage(entries) {
+        const systemEntry = entries.find((e) => e.role === "system");
+        if (!systemEntry)
+            return undefined;
+        return systemEntry.content
+            .filter(types_1.isTextContent)
+            .map((c) => c.text)
+            .join("\n");
+    },
+};
+// =============================================================================
+// OpenAI Transformer
+// =============================================================================
+/**
+ * Map to track ID conversions from other providers to OpenAI format.
+ * OpenAI requires IDs to start with 'fc_' for function calls.
+ */
+const idMappingToOpenAi = new Map();
+/**
+ * Convert a tool call ID to OpenAI format.
+ * OpenAI expects IDs starting with 'fc_'.
+ */
+function toOpenAiId(originalId) {
+    // Already an OpenAI ID
+    if (originalId.startsWith("fc_")) {
+        return originalId;
+    }
+    // Check if we've already mapped this ID
+    if (idMappingToOpenAi.has(originalId)) {
+        return idMappingToOpenAi.get(originalId);
+    }
+    // Generate a new OpenAI-compatible ID and store the mapping
+    const newId = `fc_${originalId.replace(/[^a-zA-Z0-9]/g, "").slice(0, 24)}`;
+    idMappingToOpenAi.set(originalId, newId);
+    return newId;
+}
+exports.openAiTransformer = {
+    /**
+     * Convert normalized entries to OpenAI ResponseInputItem format
+     */
+    toProvider(entries) {
+        const items = [];
+        for (const entry of entries) {
+            if (entry.role === "system") {
+                items.push({
+                    type: "message",
+                    role: "system",
+                    content: entry.content
+                        .filter(types_1.isTextContent)
+                        .map((c) => c.text)
+                        .join("\n"),
+                });
+                continue;
+            }
+            // Separate tool_use from other content for OpenAI format
+            const textBlocks = entry.content.filter(types_1.isTextContent);
+            const toolUseBlocks = entry.content.filter(types_1.isToolUseContent);
+            const toolResultBlocks = entry.content.filter(types_1.isToolResultContent);
+            // Add text message if present
+            if (textBlocks.length > 0 && entry.role !== "user") {
+                items.push({
+                    type: "message",
+                    role: entry.role,
+                    content: textBlocks.map((c) => c.text).join("\n"),
+                });
+            }
+            else if (entry.role === "user" &&
+                textBlocks.length > 0 &&
+                toolResultBlocks.length === 0) {
+                items.push({
+                    type: "message",
+                    role: "user",
+                    content: textBlocks.map((c) => c.text).join("\n"),
+                });
+            }
+            // Add tool calls as separate function_call items (OpenAI format)
+            // Convert IDs to OpenAI format if they came from another provider
+            for (const toolBlock of toolUseBlocks) {
+                const openAiId = toOpenAiId(toolBlock.id);
+                items.push({
+                    type: "function_call",
+                    id: openAiId,
+                    call_id: openAiId,
+                    name: toolBlock.name,
+                    arguments: JSON.stringify(toolBlock.input),
+                });
+            }
+            // Add tool results as function_call_output items
+            // Use the same ID mapping to match results with their calls
+            for (const resultBlock of toolResultBlocks) {
+                const openAiId = toOpenAiId(resultBlock.tool_use_id);
+                items.push({
+                    type: "function_call_output",
+                    call_id: openAiId,
+                    output: resultBlock.content,
+                });
+            }
+        }
+        return items;
+    },
+    /**
+     * Convert OpenAI response to normalized HistoryEntry
+     */
+    fromProviderMessage(role, outputText, functionCalls) {
+        const content = [];
+        if (outputText) {
+            content.push((0, types_1.text)(outputText));
+        }
+        if (functionCalls) {
+            for (const call of functionCalls) {
+                let input = {};
+                try {
+                    input = JSON.parse(call.arguments);
+                }
+                catch {
+                    input = { raw: call.arguments };
+                }
+                content.push((0, types_1.toolUse)(call.call_id, call.name, input));
+            }
+        }
+        return {
+            role,
+            content,
+            meta: { provider: "openai" },
+        };
+    },
+    /**
+     * Create a tool result entry from OpenAI function call output
+     */
+    toolResultEntry(call_id, output, is_error) {
+        return {
+            role: "user",
+            content: [(0, types_1.toolResult)(call_id, output, is_error)],
+            meta: { provider: "openai", call_id },
+        };
+    },
+};
+exports.mistralTransformer = {
+    /**
+     * Convert normalized entries to Mistral message format
+     */
+    toProvider(entries) {
+        const messages = [];
+        for (const entry of entries) {
+            const textBlocks = entry.content.filter(types_1.isTextContent);
+            const toolUseBlocks = entry.content.filter(types_1.isToolUseContent);
+            const toolResultBlocks = entry.content.filter(types_1.isToolResultContent);
+            if (entry.role === "system") {
+                messages.push({
+                    role: "system",
+                    content: textBlocks.map((c) => c.text).join("\n"),
+                });
+                continue;
+            }
+            if (entry.role === "assistant") {
+                const contentText = textBlocks.map((c) => c.text).join("\n");
+                // When there are tool calls but no text content, content should be null or empty string
+                // Some APIs are picky about this
+                const content = contentText || (toolUseBlocks.length > 0 ? null : "");
+                const msg = {
+                    role: "assistant",
+                    content: content,
+                };
+                if (toolUseBlocks.length > 0) {
+                    msg.toolCalls = toolUseBlocks.map((block) => ({
+                        id: block.id,
+                        function: {
+                            name: block.name,
+                            arguments: JSON.stringify(block.input),
+                        },
+                    }));
+                }
+                messages.push(msg);
+                continue;
+            }
+            // User role - could be text or tool results
+            if (toolResultBlocks.length > 0) {
+                // Mistral uses separate "tool" role messages for each result
+                // We need to find the corresponding tool name from the assistant's tool_calls
+                for (const result of toolResultBlocks) {
+                    // Find the tool name from meta if available
+                    const toolName = entry.meta?.tool_name || "";
+                    messages.push({
+                        role: "tool",
+                        content: result.content,
+                        toolCallId: result.tool_use_id,
+                        name: toolName,
+                    });
+                }
+            }
+            else if (textBlocks.length > 0) {
+                messages.push({
+                    role: "user",
+                    content: textBlocks.map((c) => c.text).join("\n"),
+                });
+            }
+        }
+        return messages;
+    },
+    /**
+     * Convert Mistral response to normalized HistoryEntry
+     */
+    fromProviderMessage(message) {
+        const content = [];
+        // Handle content
+        if (typeof message.content === "string" && message.content) {
+            content.push((0, types_1.text)(message.content));
+        }
+        else if (Array.isArray(message.content)) {
+            for (const chunk of message.content) {
+                if (typeof chunk === "string") {
+                    content.push((0, types_1.text)(chunk));
+                }
+                else if (chunk.type === "text" && chunk.text) {
+                    content.push((0, types_1.text)(chunk.text));
+                }
+            }
+        }
+        // Handle tool calls
+        if (message.toolCalls) {
+            for (const call of message.toolCalls) {
+                const args = typeof call.function.arguments === "string"
+                    ? JSON.parse(call.function.arguments)
+                    : call.function.arguments;
+                content.push((0, types_1.toolUse)(call.id || "", call.function.name, args));
+            }
+        }
+        return {
+            role: "assistant",
+            content,
+            meta: { provider: "mistral" },
+        };
+    },
+    /**
+     * Create a tool result entry for Mistral
+     */
+    toolResultEntry(tool_call_id, name, output) {
+        return {
+            role: "user",
+            content: [(0, types_1.toolResult)(tool_call_id, output)],
+            meta: { provider: "mistral", tool_call_id, tool_name: name },
+        };
+    },
+};
+// =============================================================================
+// Gemini Transformer
+// =============================================================================
+exports.geminiTransformer = {
+    /**
+     * Convert normalized entries to Gemini Content format
+     */
+    toProvider(entries) {
+        const contents = [];
+        for (const entry of entries) {
+            // Skip system messages - Gemini handles these separately via systemInstruction
+            if (entry.role === "system") {
+                continue;
+            }
+            const textBlocks = entry.content.filter(types_1.isTextContent);
+            const toolUseBlocks = entry.content.filter(types_1.isToolUseContent);
+            const toolResultBlocks = entry.content.filter(types_1.isToolResultContent);
+            // Gemini uses "user" and "model" roles
+            const role = entry.role === "assistant" ? "model" : "user";
+            const parts = [];
+            // Add text parts
+            for (const block of textBlocks) {
+                parts.push({ text: block.text });
+            }
+            // Add function call parts (for assistant/model messages)
+            for (const block of toolUseBlocks) {
+                parts.push({
+                    functionCall: {
+                        name: block.name,
+                        args: block.input,
+                    },
+                });
+            }
+            // Add function response parts (for user messages with tool results)
+            for (const block of toolResultBlocks) {
+                // Parse content if it's JSON, otherwise wrap in response object
+                let responseData;
+                try {
+                    responseData = JSON.parse(block.content);
+                }
+                catch {
+                    responseData = { result: block.content };
+                }
+                parts.push({
+                    functionResponse: {
+                        name: block.tool_use_id, // Gemini uses the function name, but we store tool_use_id
+                        response: responseData,
+                    },
+                });
+            }
+            if (parts.length > 0) {
+                contents.push({ role, parts });
+            }
+        }
+        return contents;
+    },
+    /**
+     * Convert Gemini response parts to normalized HistoryEntry
+     */
+    fromProviderContent(role, parts) {
+        const normalizedContent = [];
+        for (const part of parts) {
+            if ("text" in part && part.text) {
+                normalizedContent.push((0, types_1.text)(part.text));
+            }
+            if ("functionCall" in part && part.functionCall) {
+                const fc = part.functionCall;
+                normalizedContent.push((0, types_1.toolUse)(fc.name, // Gemini doesn't have separate IDs, use function name
+                fc.name, (fc.args || {})));
+            }
+        }
+        return {
+            role,
+            content: normalizedContent,
+            meta: { provider: "gemini" },
+        };
+    },
+    /**
+     * Create a tool result entry for Gemini
+     */
+    toolResultEntry(functionName, output, is_error) {
+        return {
+            role: "user",
+            content: [(0, types_1.toolResult)(functionName, output, is_error)],
+            meta: { provider: "gemini" },
+        };
+    },
+    /**
+     * Extract system message from entries
+     */
+    getSystemMessage(entries) {
+        const systemEntry = entries.find((e) => e.role === "system");
+        if (!systemEntry)
+            return undefined;
+        return systemEntry.content
+            .filter(types_1.isTextContent)
+            .map((c) => c.text)
+            .join("\n");
+    },
+};
+//# sourceMappingURL=transformers.js.map

package/dist/history/types.d.ts

@@ -0,0 +1,130 @@
+/**
+ * Shared History Types
+ *
+ * These types define a provider-agnostic message format that can be
+ * transformed to/from any LLM provider's native format.
+ */
+/**
+ * Plain text content
+ */
+export type TextContent = {
+    type: "text";
+    text: string;
+};
+/**
+ * Tool/function call made by the assistant
+ */
+export type ToolUseContent = {
+    type: "tool_use";
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+};
+/**
+ * Result of a tool execution
+ */
+export type ToolResultContent = {
+    type: "tool_result";
+    tool_use_id: string;
+    content: string;
+    is_error?: boolean;
+};
+/**
+ * Union of all content types
+ */
+export type MessageContent = TextContent | ToolUseContent | ToolResultContent;
+/**
+ * Anthropic-specific metadata
+ */
+export type AnthropicMeta = {
+    provider: "anthropic";
+    cache_control?: {
+        type: "ephemeral";
+    };
+};
+/**
+ * OpenAI-specific metadata
+ */
+export type OpenAiMeta = {
+    provider: "openai";
+    call_id?: string;
+};
+/**
+ * Mistral-specific metadata
+ */
+export type MistralMeta = {
+    provider: "mistral";
+    tool_call_id?: string;
+    tool_name?: string;
+};
+/**
+ * Gemini-specific metadata
+ */
+export type GeminiMeta = {
+    provider: "gemini";
+};
+/**
+ * Union of all provider metadata types
+ */
+export type ProviderMeta = AnthropicMeta | OpenAiMeta | MistralMeta | GeminiMeta;
+/**
+ * Valid roles for history entries
+ */
+export type MessageRole = "user" | "assistant" | "system";
+/**
+ * A single entry in the conversation history.
+ *
+ * This is the normalized format that all providers transform to/from.
+ *
+ * @example Text message
+ * ```typescript
+ * const entry: HistoryEntry = {
+ *   role: "user",
+ *   content: [{ type: "text", text: "Hello" }]
+ * };
+ * ```
+ *
+ * @example Assistant with tool use
+ * ```typescript
+ * const entry: HistoryEntry = {
+ *   role: "assistant",
+ *   content: [
+ *     { type: "text", text: "I'll help you with that." },
+ *     { type: "tool_use", id: "call_123", name: "get_weather", input: { city: "Paris" } }
+ *   ]
+ * };
+ * ```
+ *
+ * @example Tool result
+ * ```typescript
+ * const entry: HistoryEntry = {
+ *   role: "user",
+ *   content: [{ type: "tool_result", tool_use_id: "call_123", content: "22°C, sunny" }]
+ * };
+ * ```
+ */
+export type HistoryEntry = {
+    role: MessageRole;
+    content: MessageContent[];
+    meta?: ProviderMeta;
+};
+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;
+/**
+ * Create a text content block
+ */
+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 tool result content block
+ */
+export declare function toolResult(tool_use_id: string, content: string, is_error?: boolean): ToolResultContent;
+/**
+ * Create a simple text message entry
+ */
+export declare function textMessage(role: MessageRole, value: string): HistoryEntry;
+//# sourceMappingURL=types.d.ts.map

package/dist/history/types.js

@@ -0,0 +1,55 @@
+"use strict";
+/**
+ * Shared History Types
+ *
+ * These types define a provider-agnostic message format that can be
+ * transformed to/from any LLM provider's native format.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTextContent = isTextContent;
+exports.isToolUseContent = isToolUseContent;
+exports.isToolResultContent = isToolResultContent;
+exports.text = text;
+exports.toolUse = toolUse;
+exports.toolResult = toolResult;
+exports.textMessage = textMessage;
+// =============================================================================
+// Helper Type Guards
+// =============================================================================
+function isTextContent(content) {
+    return content.type === "text";
+}
+function isToolUseContent(content) {
+    return content.type === "tool_use";
+}
+function isToolResultContent(content) {
+    return content.type === "tool_result";
+}
+// =============================================================================
+// Utility Functions
+// =============================================================================
+/**
+ * Create a text content block
+ */
+function text(value) {
+    return { type: "text", text: value };
+}
+/**
+ * Create a tool use content block
+ */
+function toolUse(id, name, input) {
+    return { type: "tool_use", id, name, input };
+}
+/**
+ * Create a tool result content block
+ */
+function toolResult(tool_use_id, content, is_error) {
+    return { type: "tool_result", tool_use_id, content, is_error };
+}
+/**
+ * Create a simple text message entry
+ */
+function textMessage(role, value) {
+    return { role, content: [text(value)] };
+}
+//# sourceMappingURL=types.js.map

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+export * from "./agents/BaseAgent";
+export * from "./agents/anthropic/ClaudeAgent";
+export { OpenAiAgent } from "./agents/openai/OpenAiAgent";
+export { MistralAgent } from "./agents/mistral/MistralAgent";
+export { GeminiAgent } from "./agents/google/GeminiAgent";
+export * from "./agents/model-types";
+export * from "./history/History";
+export * from "./history/types";
+export { anthropicTransformer, openAiTransformer, mistralTransformer, geminiTransformer, } from "./history/transformers";
+export * from "./graph/AgentGraph";
+export * from "./tools/Tool";
+export * from "./viz";
+export * from "./vectorstore";
+export * from "./chunkers";
+export * from "./ingestion";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,48 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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.geminiTransformer = exports.mistralTransformer = exports.openAiTransformer = exports.anthropicTransformer = exports.GeminiAgent = exports.MistralAgent = exports.OpenAiAgent = void 0;
+// Agents
+__exportStar(require("./agents/BaseAgent"), exports);
+__exportStar(require("./agents/anthropic/ClaudeAgent"), exports);
+var OpenAiAgent_1 = require("./agents/openai/OpenAiAgent");
+Object.defineProperty(exports, "OpenAiAgent", { enumerable: true, get: function () { return OpenAiAgent_1.OpenAiAgent; } });
+var MistralAgent_1 = require("./agents/mistral/MistralAgent");
+Object.defineProperty(exports, "MistralAgent", { enumerable: true, get: function () { return MistralAgent_1.MistralAgent; } });
+var GeminiAgent_1 = require("./agents/google/GeminiAgent");
+Object.defineProperty(exports, "GeminiAgent", { enumerable: true, get: function () { return GeminiAgent_1.GeminiAgent; } });
+__exportStar(require("./agents/model-types"), exports);
+// History
+__exportStar(require("./history/History"), exports);
+__exportStar(require("./history/types"), exports);
+var transformers_1 = require("./history/transformers");
+Object.defineProperty(exports, "anthropicTransformer", { enumerable: true, get: function () { return transformers_1.anthropicTransformer; } });
+Object.defineProperty(exports, "openAiTransformer", { enumerable: true, get: function () { return transformers_1.openAiTransformer; } });
+Object.defineProperty(exports, "mistralTransformer", { enumerable: true, get: function () { return transformers_1.mistralTransformer; } });
+Object.defineProperty(exports, "geminiTransformer", { enumerable: true, get: function () { return transformers_1.geminiTransformer; } });
+// Graph
+__exportStar(require("./graph/AgentGraph"), exports);
+// Tools
+__exportStar(require("./tools/Tool"), exports);
+// Visualization
+__exportStar(require("./viz"), exports);
+// Vector Store
+__exportStar(require("./vectorstore"), exports);
+// Chunkers
+__exportStar(require("./chunkers"), exports);
+// Ingestion
+__exportStar(require("./ingestion"), exports);
+//# sourceMappingURL=index.js.map