@mastra/voyageai 0.0.0

package/dist/index.cjs

@@ -0,0 +1,579 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var voyageai = require('voyageai');
+
+// src/types.ts
+var TEXT_MODEL_INFO = {
+  "voyage-4-large": {
+    maxInputTokens: 12e4,
+    defaultDimension: 1024,
+    supportedDimensions: [256, 512, 1024, 2048],
+    isMultimodal: false,
+    isContextualized: false
+  },
+  "voyage-4": {
+    maxInputTokens: 32e4,
+    defaultDimension: 1024,
+    supportedDimensions: [256, 512, 1024, 2048],
+    isMultimodal: false,
+    isContextualized: false
+  },
+  "voyage-4-lite": {
+    maxInputTokens: 1e6,
+    defaultDimension: 1024,
+    supportedDimensions: [256, 512, 1024, 2048],
+    isMultimodal: false,
+    isContextualized: false
+  },
+  "voyage-3-large": {
+    maxInputTokens: 12e4,
+    defaultDimension: 1024,
+    supportedDimensions: [256, 512, 1024, 2048],
+    isMultimodal: false,
+    isContextualized: false
+  },
+  "voyage-3.5": {
+    maxInputTokens: 32e4,
+    defaultDimension: 1024,
+    supportedDimensions: [256, 512, 1024, 2048],
+    isMultimodal: false,
+    isContextualized: false
+  },
+  "voyage-3.5-lite": {
+    maxInputTokens: 1e6,
+    defaultDimension: 1024,
+    supportedDimensions: [256, 512, 1024, 2048],
+    isMultimodal: false,
+    isContextualized: false
+  },
+  "voyage-code-3": {
+    maxInputTokens: 32e3,
+    defaultDimension: 1024,
+    supportedDimensions: [256, 512, 1024, 2048],
+    isMultimodal: false,
+    isContextualized: false
+  },
+  "voyage-finance-2": {
+    maxInputTokens: 32e3,
+    defaultDimension: 1024,
+    isMultimodal: false,
+    isContextualized: false
+  },
+  "voyage-law-2": {
+    maxInputTokens: 32e3,
+    defaultDimension: 1024,
+    isMultimodal: false,
+    isContextualized: false
+  }
+};
+var MULTIMODAL_MODEL_INFO = {
+  "voyage-multimodal-3": {
+    maxInputTokens: 32e3,
+    defaultDimension: 1024,
+    isMultimodal: true,
+    isContextualized: false
+  },
+  "voyage-multimodal-3.5": {
+    maxInputTokens: 32e3,
+    defaultDimension: 1024,
+    isMultimodal: true,
+    isContextualized: false
+  }
+};
+var CONTEXTUALIZED_MODEL_INFO = {
+  "voyage-context-3": {
+    maxInputTokens: 32e3,
+    defaultDimension: 1024,
+    supportedDimensions: [256, 512, 1024, 2048],
+    isMultimodal: false,
+    isContextualized: true
+  }
+};
+var RERANKER_MODEL_INFO = {
+  "rerank-2.5": {
+    contextLength: 32e3,
+    description: "Best quality with instruction-following support"
+  },
+  "rerank-2.5-lite": {
+    contextLength: 32e3,
+    description: "Optimized for latency and quality"
+  },
+  "rerank-2": {
+    contextLength: 16e3,
+    description: "Second-generation with multilingual support"
+  },
+  "rerank-2-lite": {
+    contextLength: 8e3,
+    description: "Second-generation, latency-optimized"
+  },
+  "rerank-1": {
+    contextLength: 8e3,
+    description: "First-generation, quality-focused"
+  },
+  "rerank-lite-1": {
+    contextLength: 4e3,
+    description: "First-generation, latency-optimized"
+  }
+};
+function toSdkInputType(inputType) {
+  if (inputType === null) return void 0;
+  return inputType;
+}
+async function createTokenAwareBatches(client, model, texts, maxTokens, maxInputsPerBatch) {
+  const tokenResults = await client.tokenize(texts, model);
+  const batches = [];
+  let currentBatch = [];
+  let currentTokens = 0;
+  for (let i = 0; i < texts.length; i++) {
+    const tokenCount = tokenResults[i]?.ids.length ?? 0;
+    if (currentBatch.length > 0 && (currentTokens + tokenCount > maxTokens || currentBatch.length >= maxInputsPerBatch)) {
+      batches.push(currentBatch);
+      currentBatch = [];
+      currentTokens = 0;
+    }
+    currentBatch.push(texts[i]);
+    currentTokens += tokenCount;
+  }
+  if (currentBatch.length > 0) {
+    batches.push(currentBatch);
+  }
+  return batches;
+}
+var VoyageTextEmbeddingModelV2 = class {
+  constructor(config) {
+    this.specificationVersion = "v2";
+    this.provider = "voyage";
+    this.maxEmbeddingsPerCall = 1e3;
+    // VoyageAI supports up to 1000 inputs per API call
+    this.supportsParallelCalls = true;
+    this.modelId = config.model;
+    this.config = config;
+    this.maxInputTokens = TEXT_MODEL_INFO[config.model]?.maxInputTokens ?? 32e3;
+    const apiKey = config.apiKey || process.env.VOYAGE_API_KEY;
+    if (!apiKey) {
+      throw new Error(
+        "VoyageAI API key is required. Set VOYAGE_API_KEY environment variable or pass apiKey in config."
+      );
+    }
+    this.client = new voyageai.VoyageAIClient({ apiKey });
+  }
+  /**
+   * Generate embeddings for the provided text values.
+   * Automatically splits inputs into token-aware batches when total tokens
+   * would exceed the model's limit.
+   */
+  async doEmbed(args) {
+    const { values, providerOptions } = args;
+    const inputType = providerOptions?.voyage?.inputType ?? this.config.inputType;
+    const outputDimension = providerOptions?.voyage?.outputDimension ?? this.config.outputDimension;
+    const outputDtype = providerOptions?.voyage?.outputDtype ?? this.config.outputDtype;
+    const truncation = providerOptions?.voyage?.truncation ?? this.config.truncation ?? true;
+    const batches = await createTokenAwareBatches(
+      this.client,
+      this.modelId,
+      values,
+      this.maxInputTokens,
+      this.maxEmbeddingsPerCall
+    );
+    const allEmbeddings = [];
+    for (const batch of batches) {
+      const response = await this.client.embed({
+        input: batch,
+        model: this.modelId,
+        inputType: toSdkInputType(inputType),
+        outputDimension,
+        outputDtype,
+        truncation
+      });
+      const embeddings = response.data?.sort((a, b) => (a.index ?? 0) - (b.index ?? 0)).map((item) => item.embedding ?? []) ?? [];
+      allEmbeddings.push(...embeddings);
+    }
+    return { embeddings: allEmbeddings };
+  }
+};
+var VoyageTextEmbeddingModelV3 = class {
+  constructor(config) {
+    this.specificationVersion = "v3";
+    this.provider = "voyage";
+    this.maxEmbeddingsPerCall = 1e3;
+    // VoyageAI supports up to 1000 inputs per API call
+    this.supportsParallelCalls = true;
+    this.modelId = config.model;
+    this.v2Model = new VoyageTextEmbeddingModelV2(config);
+  }
+  /**
+   * Generate embeddings for the provided text values
+   */
+  async doEmbed(args) {
+    const result = await this.v2Model.doEmbed(args);
+    return { ...result, warnings: [] };
+  }
+};
+function createVoyageTextEmbedding(config) {
+  const normalizedConfig = typeof config === "string" ? { model: config } : config;
+  return new VoyageTextEmbeddingModelV3(normalizedConfig);
+}
+function createVoyageTextEmbeddingV2(config) {
+  const normalizedConfig = typeof config === "string" ? { model: config } : config;
+  return new VoyageTextEmbeddingModelV2(normalizedConfig);
+}
+function toSdkContent(content) {
+  switch (content.type) {
+    case "text":
+      return content.text;
+    case "image_url":
+      return { type: "image_url", image_url: content.image_url };
+    case "image_base64":
+      return { type: "image_base64", image_base64: content.image_base64 };
+    case "video_url":
+      return { type: "video_url", video_url: content.video_url };
+    default:
+      throw new Error(`Unknown content type: ${content.type}`);
+  }
+}
+function toSdkInput(input) {
+  return input.content.map(toSdkContent);
+}
+function toSdkInputType2(inputType) {
+  if (inputType === null) return void 0;
+  return inputType;
+}
+var VoyageMultimodalEmbeddingModel = class {
+  constructor(config) {
+    this.provider = "voyage";
+    this.maxEmbeddingsPerCall = 1e3;
+    this.supportsParallelCalls = true;
+    this.modelId = config.model;
+    this.config = config;
+    const apiKey = config.apiKey || process.env.VOYAGE_API_KEY;
+    if (!apiKey) {
+      throw new Error(
+        "VoyageAI API key is required. Set VOYAGE_API_KEY environment variable or pass apiKey in config."
+      );
+    }
+    this.client = new voyageai.VoyageAIClient({ apiKey });
+  }
+  /**
+   * Generate embeddings for multimodal inputs
+   *
+   * @param args.values - Array of multimodal inputs, each containing interleaved content
+   * @param args.providerOptions - Runtime options to override config
+   * @returns Object containing embeddings array
+   */
+  async doEmbed(args) {
+    const { values, providerOptions } = args;
+    const inputType = providerOptions?.voyage?.inputType ?? this.config.inputType;
+    const truncation = providerOptions?.voyage?.truncation ?? this.config.truncation ?? true;
+    const sdkInputs = values.map(toSdkInput);
+    const response = await this.client.multimodalEmbed({
+      inputs: sdkInputs,
+      model: this.modelId,
+      inputType: toSdkInputType2(inputType),
+      truncation
+    });
+    const embeddings = response.data?.sort((a, b) => (a.index ?? 0) - (b.index ?? 0)).map((item) => item.embedding ?? []) ?? [];
+    return { embeddings };
+  }
+  /**
+   * Generate a single embedding for a multimodal input
+   *
+   * @param input - Single multimodal input
+   * @returns Single embedding vector
+   */
+  async embedOne(input) {
+    const result = await this.doEmbed({ values: [input] });
+    return result.embeddings[0] ?? [];
+  }
+};
+function createVoyageMultimodalEmbedding(config) {
+  const normalizedConfig = typeof config === "string" ? { model: config } : config;
+  return new VoyageMultimodalEmbeddingModel(normalizedConfig);
+}
+function toSdkInputType3(inputType) {
+  if (inputType === null) return void 0;
+  return inputType;
+}
+var VoyageContextualizedEmbeddingModel = class {
+  constructor(config) {
+    this.provider = "voyage";
+    this.maxEmbeddingsPerCall = 1e3;
+    // Max inputs
+    this.maxTotalChunks = 16e3;
+    // Max total chunks across all inputs
+    this.supportsParallelCalls = true;
+    this.modelId = config.model;
+    this.config = config;
+    const apiKey = config.apiKey || process.env.VOYAGE_API_KEY;
+    if (!apiKey) {
+      throw new Error(
+        "VoyageAI API key is required. Set VOYAGE_API_KEY environment variable or pass apiKey in config."
+      );
+    }
+    this.client = new voyageai.VoyageAIClient({ apiKey });
+  }
+  /**
+   * Generate contextualized embeddings for grouped chunks
+   *
+   * @param args.values - Nested array where each inner array contains chunks from the same document
+   * @param args.inputType - 'query' for search queries, 'document' for content being indexed
+   * @param args.outputDimension - Output embedding dimension (256, 512, 1024, or 2048)
+   * @param args.outputDtype - Output data type
+   * @param args.providerOptions - Runtime options to override config
+   * @returns Object containing flattened embeddings array (one per chunk across all documents)
+   */
+  async doEmbed(args) {
+    const { values, providerOptions } = args;
+    const inputType = args.inputType ?? providerOptions?.voyage?.inputType ?? this.config.inputType;
+    const outputDimension = args.outputDimension ?? providerOptions?.voyage?.outputDimension ?? this.config.outputDimension;
+    const outputDtype = args.outputDtype ?? providerOptions?.voyage?.outputDtype ?? this.config.outputDtype;
+    const response = await this.client.contextualizedEmbed({
+      inputs: values,
+      model: this.modelId,
+      inputType: toSdkInputType3(inputType),
+      outputDimension,
+      outputDtype
+    });
+    const sortedData = [...response.data ?? []].sort((a, b) => (a.index ?? 0) - (b.index ?? 0));
+    const allEmbeddings = [];
+    const chunkCounts = [];
+    for (const item of sortedData) {
+      const chunkData = item.data ?? [];
+      const docEmbeddings = chunkData.map((chunk) => chunk.embedding ?? []);
+      chunkCounts.push(docEmbeddings.length);
+      allEmbeddings.push(...docEmbeddings);
+    }
+    return { embeddings: allEmbeddings, chunkCounts };
+  }
+  /**
+   * Generate contextualized embeddings and return grouped by document
+   *
+   * @param args - Same as doEmbed
+   * @returns Embeddings grouped by document
+   */
+  async doEmbedGrouped(args) {
+    const { values, providerOptions } = args;
+    const inputType = args.inputType ?? providerOptions?.voyage?.inputType ?? this.config.inputType;
+    const outputDimension = args.outputDimension ?? providerOptions?.voyage?.outputDimension ?? this.config.outputDimension;
+    const outputDtype = args.outputDtype ?? providerOptions?.voyage?.outputDtype ?? this.config.outputDtype;
+    const response = await this.client.contextualizedEmbed({
+      inputs: values,
+      model: this.modelId,
+      inputType: toSdkInputType3(inputType),
+      outputDimension,
+      outputDtype
+    });
+    const sortedData = [...response.data ?? []].sort((a, b) => (a.index ?? 0) - (b.index ?? 0));
+    const embeddingsByDocument = sortedData.map((item) => {
+      const chunkData = item.data ?? [];
+      return chunkData.map((chunk) => chunk.embedding ?? []);
+    });
+    return { embeddingsByDocument };
+  }
+  /**
+   * Generate a query embedding (contextualized with itself)
+   *
+   * @param query - The search query text
+   * @returns Single embedding vector
+   */
+  async embedQuery(query) {
+    const result = await this.doEmbed({
+      values: [[query]],
+      inputType: "query"
+    });
+    return result.embeddings[0] ?? [];
+  }
+  /**
+   * Generate document chunk embeddings with context
+   *
+   * @param chunks - Array of text chunks from the same document
+   * @returns Array of embeddings, one per chunk
+   */
+  async embedDocumentChunks(chunks) {
+    const result = await this.doEmbed({
+      values: [chunks],
+      inputType: "document"
+    });
+    return result.embeddings;
+  }
+};
+function createVoyageContextualizedEmbedding(config) {
+  const normalizedConfig = typeof config === "string" ? { model: config } : config;
+  return new VoyageContextualizedEmbeddingModel(normalizedConfig);
+}
+var VoyageRelevanceScorer = class {
+  constructor(config) {
+    this.modelId = config.model;
+    this.config = config;
+    const apiKey = config.apiKey || process.env.VOYAGE_API_KEY;
+    if (!apiKey) {
+      throw new Error(
+        "VoyageAI API key is required. Set VOYAGE_API_KEY environment variable or pass apiKey in config."
+      );
+    }
+    this.client = new voyageai.VoyageAIClient({ apiKey });
+  }
+  /**
+   * Get relevance score between a query and a document.
+   *
+   * @param query - The search query (text1)
+   * @param document - The document to score (text2)
+   * @returns Relevance score between 0 and 1
+   */
+  async getRelevanceScore(query, document) {
+    const response = await this.client.rerank({
+      query,
+      documents: [document],
+      model: this.modelId,
+      topK: 1,
+      truncation: this.config.truncation ?? true
+    });
+    const result = response.data?.[0];
+    if (!result || result.relevanceScore === void 0) {
+      throw new Error("No relevance score found in VoyageAI response");
+    }
+    return result.relevanceScore;
+  }
+  /**
+   * Rerank multiple documents against a query.
+   *
+   * This is more efficient than calling getRelevanceScore multiple times
+   * as it makes a single API call for all documents.
+   *
+   * @param query - The search query
+   * @param documents - Array of documents to rerank
+   * @param topK - Optional number of top results to return
+   * @returns Array of reranked results with scores
+   */
+  async rerankDocuments(query, documents, topK) {
+    const response = await this.client.rerank({
+      query,
+      documents,
+      model: this.modelId,
+      topK,
+      truncation: this.config.truncation ?? true
+    });
+    return response.data?.map((item) => ({
+      document: documents[item.index ?? 0] ?? "",
+      index: item.index ?? 0,
+      score: item.relevanceScore ?? 0
+    })) ?? [];
+  }
+};
+function createVoyageReranker(config) {
+  const normalizedConfig = typeof config === "string" ? { model: config } : config;
+  return new VoyageRelevanceScorer(normalizedConfig);
+}
+var voyageReranker = createVoyageReranker;
+
+// src/index.ts
+var voyageEmbedding = createVoyageTextEmbedding;
+var voyageEmbeddingV2 = createVoyageTextEmbeddingV2;
+var voyageMultimodalEmbedding = createVoyageMultimodalEmbedding;
+var voyageContextualizedEmbedding = createVoyageContextualizedEmbedding;
+var voyage = (() => {
+  const cache = /* @__PURE__ */ new Map();
+  function lazy(key, factory) {
+    let instance = cache.get(key);
+    if (!instance) {
+      instance = factory();
+      cache.set(key, instance);
+    }
+    return instance;
+  }
+  const base = {
+    get specificationVersion() {
+      return "v3";
+    },
+    get provider() {
+      return "voyage";
+    },
+    get modelId() {
+      return "voyage-3.5";
+    },
+    get maxEmbeddingsPerCall() {
+      return 1e3;
+    },
+    get supportsParallelCalls() {
+      return true;
+    },
+    doEmbed(args) {
+      return lazy("_default", () => createVoyageTextEmbedding("voyage-3.5")).doEmbed(args);
+    }
+  };
+  return Object.defineProperties(base, {
+    // Text models (V3) - voyage-4 series
+    v4large: { get: () => lazy("v4large", () => createVoyageTextEmbedding("voyage-4-large")) },
+    v4: { get: () => lazy("v4", () => createVoyageTextEmbedding("voyage-4")) },
+    v4lite: { get: () => lazy("v4lite", () => createVoyageTextEmbedding("voyage-4-lite")) },
+    // Text models (V3) - voyage-3 series
+    large: { get: () => lazy("large", () => createVoyageTextEmbedding("voyage-3-large")) },
+    v35: { get: () => lazy("v35", () => createVoyageTextEmbedding("voyage-3.5")) },
+    v35lite: { get: () => lazy("v35lite", () => createVoyageTextEmbedding("voyage-3.5-lite")) },
+    code: { get: () => lazy("code", () => createVoyageTextEmbedding("voyage-code-3")) },
+    finance: { get: () => lazy("finance", () => createVoyageTextEmbedding("voyage-finance-2")) },
+    law: { get: () => lazy("law", () => createVoyageTextEmbedding("voyage-law-2")) },
+    // Text models (V2) - voyage-4 series
+    v4largeV2: { get: () => lazy("v4largeV2", () => createVoyageTextEmbeddingV2("voyage-4-large")) },
+    v4V2: { get: () => lazy("v4V2", () => createVoyageTextEmbeddingV2("voyage-4")) },
+    v4liteV2: { get: () => lazy("v4liteV2", () => createVoyageTextEmbeddingV2("voyage-4-lite")) },
+    // Text models (V2) - voyage-3 series
+    largeV2: { get: () => lazy("largeV2", () => createVoyageTextEmbeddingV2("voyage-3-large")) },
+    v35V2: { get: () => lazy("v35V2", () => createVoyageTextEmbeddingV2("voyage-3.5")) },
+    v35liteV2: { get: () => lazy("v35liteV2", () => createVoyageTextEmbeddingV2("voyage-3.5-lite")) },
+    codeV2: { get: () => lazy("codeV2", () => createVoyageTextEmbeddingV2("voyage-code-3")) },
+    financeV2: { get: () => lazy("financeV2", () => createVoyageTextEmbeddingV2("voyage-finance-2")) },
+    lawV2: { get: () => lazy("lawV2", () => createVoyageTextEmbeddingV2("voyage-law-2")) },
+    // Multimodal models
+    multimodal: { get: () => lazy("multimodal", () => createVoyageMultimodalEmbedding("voyage-multimodal-3.5")) },
+    multimodal3: { get: () => lazy("multimodal3", () => createVoyageMultimodalEmbedding("voyage-multimodal-3")) },
+    multimodal35: { get: () => lazy("multimodal35", () => createVoyageMultimodalEmbedding("voyage-multimodal-3.5")) },
+    // Contextualized model
+    contextualized: {
+      get: () => lazy("contextualized", () => createVoyageContextualizedEmbedding("voyage-context-3"))
+    },
+    context3: { get: () => lazy("context3", () => createVoyageContextualizedEmbedding("voyage-context-3")) },
+    // Reranker models
+    reranker: { get: () => lazy("reranker", () => createVoyageReranker("rerank-2.5")) },
+    reranker25: { get: () => lazy("reranker25", () => createVoyageReranker("rerank-2.5")) },
+    reranker25lite: { get: () => lazy("reranker25lite", () => createVoyageReranker("rerank-2.5-lite")) },
+    reranker2: { get: () => lazy("reranker2", () => createVoyageReranker("rerank-2")) },
+    reranker2lite: { get: () => lazy("reranker2lite", () => createVoyageReranker("rerank-2-lite")) },
+    // Factory functions (no lazy needed - they are factories themselves)
+    embedding: { value: createVoyageTextEmbedding },
+    embeddingV2: { value: createVoyageTextEmbeddingV2 },
+    multimodalEmbedding: { value: createVoyageMultimodalEmbedding },
+    contextualizedEmbedding: { value: createVoyageContextualizedEmbedding },
+    createReranker: { value: createVoyageReranker }
+  });
+})();
+var index_default = voyage;
+
+Object.defineProperty(exports, "VoyageAIClient", {
+  enumerable: true,
+  get: function () { return voyageai.VoyageAIClient; }
+});
+exports.CONTEXTUALIZED_MODEL_INFO = CONTEXTUALIZED_MODEL_INFO;
+exports.MULTIMODAL_MODEL_INFO = MULTIMODAL_MODEL_INFO;
+exports.RERANKER_MODEL_INFO = RERANKER_MODEL_INFO;
+exports.TEXT_MODEL_INFO = TEXT_MODEL_INFO;
+exports.VoyageContextualizedEmbeddingModel = VoyageContextualizedEmbeddingModel;
+exports.VoyageMultimodalEmbeddingModel = VoyageMultimodalEmbeddingModel;
+exports.VoyageRelevanceScorer = VoyageRelevanceScorer;
+exports.VoyageTextEmbeddingModelV2 = VoyageTextEmbeddingModelV2;
+exports.VoyageTextEmbeddingModelV3 = VoyageTextEmbeddingModelV3;
+exports.createVoyageContextualizedEmbedding = createVoyageContextualizedEmbedding;
+exports.createVoyageMultimodalEmbedding = createVoyageMultimodalEmbedding;
+exports.createVoyageReranker = createVoyageReranker;
+exports.createVoyageTextEmbedding = createVoyageTextEmbedding;
+exports.createVoyageTextEmbeddingV2 = createVoyageTextEmbeddingV2;
+exports.default = index_default;
+exports.voyage = voyage;
+exports.voyageContextualizedEmbedding = voyageContextualizedEmbedding;
+exports.voyageEmbedding = voyageEmbedding;
+exports.voyageEmbeddingV2 = voyageEmbeddingV2;
+exports.voyageMultimodalEmbedding = voyageMultimodalEmbedding;
+exports.voyageReranker = voyageReranker;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map