@agentionai/agents 0.4.2 → 0.6.1

package/README.md

@@ -86,14 +86,14 @@ import { GeminiAgent, Tool } from '@agentionai/agents/gemini';
 const weatherTool = new Tool({
   name: 'get_weather',
   description: 'Get the current weather for a location',
-  input_schema: {
+  inputSchema: {
     type: 'object',
     properties: {
       location: { type: 'string', description: 'City name' },
     },
     required: ['location'],
   },
-  handler: async ({ location }) => {
+  execute: async ({ location }) => {
     // In production, call a weather API
     return JSON.stringify({
       location,

package/dist/agents/AgentConfig.d.ts

@@ -6,24 +6,43 @@ export type AgentVendor = "openai" | "anthropic" | "mistral" | "gemini";
  * Common configuration shared by all agents
  */
 export interface CommonAgentConfig {
+    /** Unique identifier for the agent instance */
     id: string;
+    /** Human-readable name for the agent */
     name: string;
+    /** Description of the agent's purpose and capabilities */
     description: string;
+    /** API key for authenticating with the LLM provider */
     apiKey: string;
+    /** Enable debug logging for troubleshooting (default: false) */
     debug?: boolean;
+    /** Maximum number of messages to retain in conversation history */
     maxHistoryLength?: number;
+    /** Model identifier (e.g., "claude-3-5-sonnet-20241022", "gpt-4") */
     model?: string;
+    /** Array of tools the agent can use during execution */
     tools?: Tool<unknown>[];
+    /** Array of sub-agents this agent can delegate tasks to */
     agents?: BaseAgent[];
+    /** Maximum number of tokens to generate in the response */
     maxTokens?: number;
+    /** Sampling temperature (0.0-1.0). Higher values increase randomness */
     temperature?: number;
+    /** Nucleus sampling threshold (0.0-1.0). Considers tokens with top cumulative probability */
     topP?: number;
+    /** Top-K sampling. Only considers the K most likely tokens (Anthropic, Gemini) */
     topK?: number;
+    /** Sequences that will stop generation when encountered */
     stopSequences?: string[];
+    /** Request timeout in milliseconds */
     timeout?: number;
+    /** Maximum number of retry attempts on API failures */
     maxRetries?: number;
+    /** Random seed for deterministic outputs (when supported by vendor) */
     seed?: number;
+    /** Penalty for using tokens that already appear in the text (-2.0 to 2.0) */
     presencePenalty?: number;
+    /** Penalty based on token frequency in the text (-2.0 to 2.0) */
     frequencyPenalty?: number;
 }
 /**

package/dist/agents/BaseAgent.d.ts

@@ -4,6 +4,11 @@ import { History, HistoryEntry, MessageRole, MessageContent } from "../history/H
 import { AgentVendor, CommonAgentConfig, VendorSpecificConfig } from "./AgentConfig";
 export type { HistoryEntry, MessageRole, MessageContent };
 export type { AgentVendor };
+/**
+ * Parses a `retry-after` header value (seconds as string) into milliseconds.
+ */
+declare function parseRetryAfterHeader(header: string | undefined): number | undefined;
+export { parseRetryAfterHeader };
 /**
  * Agent config as used across all agents
  * @deprecated Use CommonAgentConfig with vendorConfig instead
@@ -33,6 +38,16 @@ export declare abstract class BaseAgent<TInput = unknown, TOutput = unknown> ext
     protected vendor: AgentVendor;
     /** The model identifier for this agent */
     protected model: string;
+    /** Token usage from the last execution (for metrics tracking) */
+    lastTokenUsage?: TokenUsage;
+    /** Maximum number of retry attempts (0 = disabled) */
+    protected maxRetries: number;
+    /** Initial backoff delay in ms */
+    private retryDelayMs;
+    /** Multiplier applied to delay after each attempt */
+    private retryBackoffFactor;
+    /** Maximum backoff delay cap in ms */
+    private retryMaxDelayMs;
     /**
      * An Agent is the primary LLM entity.
      *
@@ -68,6 +83,30 @@ export declare abstract class BaseAgent<TInput = unknown, TOutput = unknown> ext
      * Add a message with content blocks to history
      */
     protected addMessageToHistory(role: MessageRole, content: MessageContent[]): void;
+    /**
+     * Enable retry with exponential backoff for this agent.
+     * @param options.maxRetries - Number of retry attempts (default: 3)
+     * @param options.initialDelay - Initial backoff delay in ms (default: 1000)
+     * @param options.backoffFactor - Multiplier per attempt (default: 2)
+     * @param options.maxDelay - Maximum delay cap in ms (default: 30000)
+     */
+    withRetry(options?: {
+        maxRetries?: number;
+        initialDelay?: number;
+        backoffFactor?: number;
+        maxDelay?: number;
+    }): this;
+    /**
+     * Executes a function with retry and exponential backoff.
+     *
+     * Retries on 429 (rate limit) and 5xx (server error) responses.
+     * Never retries on MaxTokensExceededError or 4xx client errors.
+     * Throws MaxRetriesExceededError when all attempts are exhausted.
+     *
+     * @param fn - The async function to execute
+     * @param getRetryAfterMs - Optional extractor for retry-after header (returns ms to wait)
+     */
+    protected executeWithRetry<T>(fn: () => Promise<T>, getRetryAfterMs?: (error: unknown) => number | undefined): Promise<T>;
     addTools(tools: Tool<unknown>[]): void;
     getId(): string;
     getName(): string;

package/dist/agents/BaseAgent.js

@@ -4,9 +4,30 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseAgent = void 0;
+exports.parseRetryAfterHeader = parseRetryAfterHeader;
 const events_1 = __importDefault(require("events"));
 const Tool_1 = require("../tools/Tool");
 const History_1 = require("../history/History");
+const AgentEvent_1 = require("./AgentEvent");
+const AgentError_1 = require("./errors/AgentError");
+/**
+ * Extracts an HTTP status code from a raw SDK error of any vendor shape.
+ */
+function extractStatusCode(error) {
+    if (error instanceof AgentError_1.ApiError)
+        return error.statusCode;
+    const e = error;
+    return typeof e.status === "number" ? e.status : undefined;
+}
+/**
+ * Parses a `retry-after` header value (seconds as string) into milliseconds.
+ */
+function parseRetryAfterHeader(header) {
+    if (!header)
+        return undefined;
+    const seconds = parseFloat(header);
+    return isNaN(seconds) ? undefined : Math.ceil(seconds * 1000);
+}
 /**
  * The base agent is what the other agents are inheriting from
  * Handles the BaseConfig
@@ -24,7 +45,15 @@ class BaseAgent extends events_1.default {
     constructor(config, history = new History_1.History([], { transient: true })) {
         super();
         this.history = history;
-        this.debug = true;
+        this.debug = false;
+        /** Maximum number of retry attempts (0 = disabled) */
+        this.maxRetries = 0;
+        /** Initial backoff delay in ms */
+        this.retryDelayMs = 1000;
+        /** Multiplier applied to delay after each attempt */
+        this.retryBackoffFactor = 2;
+        /** Maximum backoff delay cap in ms */
+        this.retryMaxDelayMs = 30000;
         this.id = config.id;
         this.debug = config.debug || false;
         this.name = config.name;
@@ -41,6 +70,7 @@ class BaseAgent extends events_1.default {
         }
         this.tools = new Map((config.tools || []).map((tool) => [tool.name, tool]));
         this.maxHistoryLength = config.maxHistoryLength || 100;
+        this.maxRetries = config.maxRetries ?? 0;
     }
     getToolDefinitions() {
         return Array.from(this.tools.values()).map((tool) => tool.getPrompt());
@@ -81,6 +111,75 @@ class BaseAgent extends events_1.default {
     addMessageToHistory(role, content) {
         this.history.addMessage(role, content);
     }
+    /**
+     * Enable retry with exponential backoff for this agent.
+     * @param options.maxRetries - Number of retry attempts (default: 3)
+     * @param options.initialDelay - Initial backoff delay in ms (default: 1000)
+     * @param options.backoffFactor - Multiplier per attempt (default: 2)
+     * @param options.maxDelay - Maximum delay cap in ms (default: 30000)
+     */
+    withRetry(options) {
+        this.maxRetries = options?.maxRetries ?? 3;
+        if (options?.initialDelay !== undefined)
+            this.retryDelayMs = options.initialDelay;
+        if (options?.backoffFactor !== undefined)
+            this.retryBackoffFactor = options.backoffFactor;
+        if (options?.maxDelay !== undefined)
+            this.retryMaxDelayMs = options.maxDelay;
+        return this;
+    }
+    /**
+     * Executes a function with retry and exponential backoff.
+     *
+     * Retries on 429 (rate limit) and 5xx (server error) responses.
+     * Never retries on MaxTokensExceededError or 4xx client errors.
+     * Throws MaxRetriesExceededError when all attempts are exhausted.
+     *
+     * @param fn - The async function to execute
+     * @param getRetryAfterMs - Optional extractor for retry-after header (returns ms to wait)
+     */
+    async executeWithRetry(fn, getRetryAfterMs) {
+        let attempt = 0;
+        let delayMs = this.retryDelayMs;
+        while (true) {
+            try {
+                return await fn();
+            }
+            catch (error) {
+                // MaxTokensExceededError is never retryable
+                if (error instanceof AgentError_1.MaxTokensExceededError)
+                    throw error;
+                const statusCode = extractStatusCode(error);
+                const isRetryable = statusCode === 429 ||
+                    (statusCode !== undefined && statusCode >= 500);
+                if (!isRetryable || attempt >= this.maxRetries) {
+                    if (attempt > 0) {
+                        this.emit(AgentEvent_1.AgentEvent.MAX_RETRIES_EXCEEDED, {
+                            maxRetries: this.maxRetries,
+                            error,
+                        });
+                        throw new AgentError_1.MaxRetriesExceededError(`Max retries (${this.maxRetries}) exceeded`, this.maxRetries);
+                    }
+                    throw error;
+                }
+                attempt++;
+                // Respect retry-after header if the SDK provides it
+                const retryAfter = getRetryAfterMs?.(error);
+                // Add ±10% jitter to avoid thundering herd
+                const jitter = delayMs * 0.1 * (Math.random() * 2 - 1);
+                const waitMs = Math.min(retryAfter ?? delayMs + jitter, this.retryMaxDelayMs);
+                this.emit(AgentEvent_1.AgentEvent.RETRY, {
+                    attempt,
+                    maxRetries: this.maxRetries,
+                    delayMs: waitMs,
+                    statusCode,
+                    error,
+                });
+                await new Promise((resolve) => setTimeout(resolve, waitMs));
+                delayMs = Math.min(delayMs * this.retryBackoffFactor, this.retryMaxDelayMs);
+            }
+        }
+    }
     addTools(tools) {
         tools.forEach((tool) => {
             if (!this.tools.has(tool.name)) {

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

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

package/dist/agents/anthropic/ClaudeAgent.js

@@ -77,7 +77,7 @@ class ClaudeAgent extends BaseAgent_1.BaseAgent {
         try {
             const messages = transformers_1.anthropicTransformer.toProvider(this.history.entries);
             const systemMessage = this.history.getSystemMessage();
-            const response = await this.client.messages.create({
+            const response = await this.executeWithRetry(() => this.client.messages.create({
                 model: this.config.model,
                 system: systemMessage,
                 max_tokens: this.config.maxTokens,
@@ -88,7 +88,9 @@ class ClaudeAgent extends BaseAgent_1.BaseAgent {
                 top_k: this.config.topK,
                 stop_sequences: this.config.stopSequences,
                 metadata: this.config.metadata,
-            });
+            }), (err) => err instanceof sdk_1.APIError
+                ? (0, BaseAgent_1.parseRetryAfterHeader)(err.headers?.["retry-after"])
+                : undefined);
             this.emit(AgentEvent_1.AgentEvent.AFTER_EXECUTE, response);
             return await this.handleResponse(response);
         }
@@ -178,7 +180,7 @@ class ClaudeAgent extends BaseAgent_1.BaseAgent {
                 // Continue conversation with tool results
                 try {
                     const messages = transformers_1.anthropicTransformer.toProvider(this.history.entries);
-                    const newResponse = await this.client.messages.create({
+                    const newResponse = await this.executeWithRetry(() => this.client.messages.create({
                         model: this.config.model,
                         max_tokens: this.config.maxTokens,
                         messages,
@@ -188,7 +190,9 @@ class ClaudeAgent extends BaseAgent_1.BaseAgent {
                         top_k: this.config.topK,
                         stop_sequences: this.config.stopSequences,
                         metadata: this.config.metadata,
-                    });
+                    }), (err) => err instanceof sdk_1.APIError
+                        ? (0, BaseAgent_1.parseRetryAfterHeader)(err.headers?.["retry-after"])
+                        : undefined);
                     this.emit(AgentEvent_1.AgentEvent.AFTER_EXECUTE, newResponse);
                     return this.handleResponse(newResponse);
                 }

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

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

package/dist/agents/google/GeminiAgent.js

@@ -179,7 +179,7 @@ class GeminiAgent extends BaseAgent_1.BaseAgent {
             const contents = transformers_1.geminiTransformer.toProvider(this.history.entries);
             const systemMessage = this.history.getSystemMessage();
             const tools = this.getToolDefinitionsForGemini();
-            const response = await this.generativeModel.generateContent({
+            const response = await this.executeWithRetry(() => this.generativeModel.generateContent({
                 contents,
                 systemInstruction: systemMessage,
                 tools: tools ? [tools] : undefined,
@@ -193,7 +193,7 @@ class GeminiAgent extends BaseAgent_1.BaseAgent {
                     responseMimeType: this.config.responseMimeType,
                     responseSchema: this.config.responseSchema,
                 },
-            });
+            }));
             this.emit(AgentEvent_1.AgentEvent.AFTER_EXECUTE, response);
             return await this.handleResponse(response);
         }
@@ -293,7 +293,7 @@ class GeminiAgent extends BaseAgent_1.BaseAgent {
                 const newContents = transformers_1.geminiTransformer.toProvider(this.history.entries);
                 const systemMessage = this.history.getSystemMessage();
                 const tools = this.getToolDefinitionsForGemini();
-                const newResponse = await this.generativeModel.generateContent({
+                const newResponse = await this.executeWithRetry(() => this.generativeModel.generateContent({
                     contents: newContents,
                     systemInstruction: systemMessage,
                     tools: tools ? [tools] : undefined,
@@ -307,7 +307,7 @@ class GeminiAgent extends BaseAgent_1.BaseAgent {
                         responseMimeType: this.config.responseMimeType,
                         responseSchema: this.config.responseSchema,
                     },
-                });
+                }));
                 this.emit(AgentEvent_1.AgentEvent.AFTER_EXECUTE, newResponse);
                 return this.handleResponse(newResponse);
             }

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

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

package/dist/agents/mistral/MistralAgent.js

@@ -87,7 +87,7 @@ class MistralAgent extends BaseAgent_1.BaseAgent {
         this.addTextToHistory("user", input);
         try {
             const messages = transformers_1.mistralTransformer.toProvider(this.history.entries);
-            const response = await this.client.chat.complete({
+            const response = await this.executeWithRetry(() => this.client.chat.complete({
                 model: this.config.model,
                 messages: messages,
                 tools: this.getToolDefinitions(),
@@ -97,7 +97,7 @@ class MistralAgent extends BaseAgent_1.BaseAgent {
                 randomSeed: this.config.randomSeed,
                 safePrompt: this.config.safePrompt,
                 stop: this.config.stopSequences,
-            });
+            }));
             this.emit(AgentEvent_1.AgentEvent.AFTER_EXECUTE, response);
             return await this.handleResponse(response);
         }
@@ -203,7 +203,7 @@ class MistralAgent extends BaseAgent_1.BaseAgent {
                 // Continue conversation
                 try {
                     const messages = transformers_1.mistralTransformer.toProvider(this.history.entries);
-                    const newResponse = await this.client.chat.complete({
+                    const newResponse = await this.executeWithRetry(() => this.client.chat.complete({
                         model: this.config.model,
                         messages: messages,
                         tools: this.getToolDefinitions(),
@@ -213,7 +213,7 @@ class MistralAgent extends BaseAgent_1.BaseAgent {
                         randomSeed: this.config.randomSeed,
                         safePrompt: this.config.safePrompt,
                         stop: this.config.stopSequences,
-                    });
+                    }));
                     this.emit(AgentEvent_1.AgentEvent.AFTER_EXECUTE, newResponse);
                     return this.handleResponse(newResponse);
                 }

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

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

package/dist/agents/openai/OpenAiAgent.js

@@ -98,7 +98,7 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
         this.addTextToHistory("user", input);
         try {
             const inputMessages = transformers_1.openAiTransformer.toProvider(this.history.entries);
-            const response = await this.client.responses.create({
+            const response = await this.executeWithRetry(() => this.client.responses.create({
                 model: this.config.model,
                 max_output_tokens: this.config.maxTokens,
                 input: inputMessages,
@@ -110,7 +110,7 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
                 user: this.config.user,
                 ...(this.config.disableReasoning && { reasoning: { effort: null } }),
                 reasoning: { effort: this.config.reasoningEffort },
-            });
+            }));
             this.emit(AgentEvent_1.AgentEvent.AFTER_EXECUTE, response);
             return await this.handleResponse(response);
         }
@@ -217,7 +217,7 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
                 // Continue conversation
                 try {
                     const inputMessages = transformers_1.openAiTransformer.toProvider(this.history.entries);
-                    const newResponse = await this.client.responses.create({
+                    const newResponse = await this.executeWithRetry(() => this.client.responses.create({
                         model: this.config.model,
                         max_output_tokens: this.config.maxTokens,
                         input: inputMessages,
@@ -234,7 +234,7 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
                             !this.config.disableReasoning && {
                             reasoning: { effort: this.config.reasoningEffort },
                         }),
-                    });
+                    }));
                     this.emit(AgentEvent_1.AgentEvent.AFTER_EXECUTE, newResponse);
                     return this.handleResponse(newResponse);
                 }

package/dist/{vectorstore → embeddings}/OpenAIEmbeddings.d.ts

@@ -1,9 +1,13 @@
 /**
  * OpenAI embeddings implementation.
  *
- * @requires openai - Uses the OpenAI SDK (already a peer dependency)
+ * @requires openai - Uses the OpenAI SDK (peer dependency, dynamically imported)
  */
 import { Embeddings } from "./Embeddings";
+/**
+ * Available OpenAI embedding models with their dimensions.
+ */
+export type OpenAIEmbeddingModel = "text-embedding-3-small" | "text-embedding-3-large" | "text-embedding-ada-002";
 /**
  * Configuration for OpenAI embeddings.
  */
@@ -11,7 +15,7 @@ export interface OpenAIEmbeddingsConfig {
     /** OpenAI API key (defaults to OPENAI_API_KEY env var) */
     apiKey?: string;
     /** Model to use for embeddings */
-    model?: "text-embedding-3-small" | "text-embedding-3-large" | "text-embedding-ada-002" | string;
+    model?: OpenAIEmbeddingModel | string;
     /** Number of dimensions (only for text-embedding-3-* models) */
     dimensions?: number;
     /** Base URL for API (for proxies or compatible APIs) */
@@ -20,10 +24,14 @@ export interface OpenAIEmbeddingsConfig {
 /**
  * OpenAI embeddings provider.
  *
+ * Supports all OpenAI embedding models including text-embedding-3-small,
+ * text-embedding-3-large, and text-embedding-ada-002.
+ *
  * @example
  * ```typescript
  * const embeddings = new OpenAIEmbeddings({
  *   model: 'text-embedding-3-small',
+ *   dimensions: 512, // Optional: reduce dimensions for faster search
  * });
  *
  * const vectors = await embeddings.embed(['Hello world', 'Goodbye world']);

package/dist/{vectorstore → embeddings}/OpenAIEmbeddings.js

@@ -2,7 +2,7 @@
 /**
  * OpenAI embeddings implementation.
  *
- * @requires openai - Uses the OpenAI SDK (already a peer dependency)
+ * @requires openai - Uses the OpenAI SDK (peer dependency, dynamically imported)
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -49,10 +49,14 @@ const MODEL_DIMENSIONS = {
 /**
  * OpenAI embeddings provider.
  *
+ * Supports all OpenAI embedding models including text-embedding-3-small,
+ * text-embedding-3-large, and text-embedding-ada-002.
+ *
  * @example
  * ```typescript
  * const embeddings = new OpenAIEmbeddings({
  *   model: 'text-embedding-3-small',
+ *   dimensions: 512, // Optional: reduce dimensions for faster search
  * });
  *
  * const vectors = await embeddings.embed(['Hello world', 'Goodbye world']);

package/dist/embeddings/VoyageAIEmbeddings.d.ts

@@ -0,0 +1,80 @@
+/**
+ * VoyageAI embeddings implementation.
+ *
+ * @requires voyageai - Uses the VoyageAI SDK (peer dependency, dynamically imported)
+ */
+import { Embeddings } from "./Embeddings";
+/**
+ * Available VoyageAI embedding models with their dimensions and rate limits.
+ */
+export type VoyageAIEmbeddingModel = "voyage-4-large" | "voyage-3-large" | "voyage-context-3" | "voyage-code-3" | "voyage-4" | "voyage-3.5" | "voyage-4-lite" | "voyage-3.5-lite";
+/**
+ * Available VoyageAI multimodal models.
+ */
+export type VoyageAIMultimodalModel = "voyage-multimodal-3.5" | "voyage-multimodal-3";
+/**
+ * Configuration for VoyageAI embeddings.
+ */
+export interface VoyageAIEmbeddingsConfig {
+    /** VoyageAI API key (defaults to VOYAGE_API_KEY env var) */
+    apiKey?: string;
+    /** Model to use for embeddings */
+    model?: VoyageAIEmbeddingModel | VoyageAIMultimodalModel | string;
+    /** Input type for optimization (default: "document") */
+    inputType?: "query" | "document";
+    /** Optional truncation mode */
+    truncation?: boolean;
+    /** Base URL for API (for proxies or compatible APIs) */
+    baseURL?: string;
+    /** Maximum number of retries (default: 2) */
+    maxRetries?: number;
+    /** Timeout in seconds (default: 60) */
+    timeoutInSeconds?: number;
+}
+/**
+ * VoyageAI embeddings provider.
+ *
+ * Supports VoyageAI's embedding models including voyage-4, voyage-3.5, voyage-code-3,
+ * and multimodal models. Features automatic retries with exponential backoff.
+ *
+ * @example
+ * ```typescript
+ * const embeddings = new VoyageAIEmbeddings({
+ *   model: 'voyage-4',
+ *   inputType: 'document', // or 'query' for search queries
+ * });
+ *
+ * const vectors = await embeddings.embed(['Hello world', 'Goodbye world']);
+ * ```
+ *
+ * @example With custom configuration
+ * ```typescript
+ * const embeddings = new VoyageAIEmbeddings({
+ *   model: 'voyage-code-3',
+ *   maxRetries: 3,
+ *   timeoutInSeconds: 30,
+ * });
+ * ```
+ */
+export declare class VoyageAIEmbeddings extends Embeddings {
+    readonly name = "voyageai";
+    readonly model: string;
+    readonly dimensions: number;
+    private apiKey;
+    private inputType;
+    private truncation?;
+    private baseURL?;
+    private maxRetries;
+    private timeoutInSeconds;
+    constructor(config?: VoyageAIEmbeddingsConfig);
+    /**
+     * Generate embeddings for multiple texts using VoyageAI API.
+     */
+    embed(texts: string[]): Promise<number[][]>;
+    /**
+     * Generate embedding for a search query.
+     * Overrides the default to use inputType: "query" for better search results.
+     */
+    embedQuery(query: string): Promise<number[]>;
+}
+//# sourceMappingURL=VoyageAIEmbeddings.d.ts.map