jina-ai-provider/dist/index.cjs

Jina AI Provider for running Jina AI models with Vercel AI SDK

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/index.ts
var index_exports = {};
__export(index_exports, {
  createJina: () => createJina,
  jina: () => jina
});
module.exports = __toCommonJS(index_exports);

// src/jina-provider.ts
var import_provider_utils3 = require("@ai-sdk/provider-utils");

// src/jina-embedding-model.ts
var import_provider = require("@ai-sdk/provider");
var import_provider_utils2 = require("@ai-sdk/provider-utils");
var import_zod2 = require("zod");

// src/jina-error.ts
var import_provider_utils = require("@ai-sdk/provider-utils");
var import_zod = require("zod");
var voyageErrorDataSchema = import_zod.z.object({
  error: import_zod.z.object({
    code: import_zod.z.string().nullable(),
    message: import_zod.z.string(),
    param: import_zod.z.any().nullable(),
    type: import_zod.z.string()
  })
});
var voyageFailedResponseHandler = (0, import_provider_utils.createJsonErrorResponseHandler)({
  errorSchema: voyageErrorDataSchema,
  errorToMessage: (data) => data.error.message
});

// src/jina-embedding-model.ts
var JinaEmbeddingModel = class {
  specificationVersion = "v1";
  modelId;
  config;
  settings;
  get provider() {
    return this.config.provider;
  }
  get maxEmbeddingsPerCall() {
    return 2048;
  }
  get supportsParallelCalls() {
    return false;
  }
  constructor(modelId, settings, config) {
    this.modelId = modelId;
    this.settings = settings;
    this.config = config;
  }
  async doEmbed({
    values,
    headers,
    abortSignal
  }) {
    if (values.length > this.maxEmbeddingsPerCall) {
      throw new import_provider.TooManyEmbeddingValuesForCallError({
        maxEmbeddingsPerCall: this.maxEmbeddingsPerCall,
        modelId: this.modelId,
        provider: this.provider,
        values
      });
    }
    const { responseHeaders, value: response } = await (0, import_provider_utils2.postJsonToApi)({
      abortSignal,
      body: {
        model: this.modelId,
        input: values,
        task: this.settings.inputType,
        embedding_type: this.settings.embeddingType,
        dimensions: this.settings.outputDimension,
        normalized: this.settings.normalized ?? true,
        late_chunking: this.settings.lateChunking,
        truncate: this.settings.truncate ?? false
      },
      failedResponseHandler: voyageFailedResponseHandler,
      fetch: this.config.fetch,
      headers: (0, import_provider_utils2.combineHeaders)(this.config.headers(), headers),
      successfulResponseHandler: (0, import_provider_utils2.createJsonResponseHandler)(
        jinaEmbeddingResponseSchema
      ),
      url: `${this.config.baseURL}/embeddings`
    });
    return {
      embeddings: response.data.map((item) => item.embedding),
      usage: response.usage ? { tokens: response.usage.total_tokens } : void 0,
      rawResponse: { headers: responseHeaders }
    };
  }
};
var jinaEmbeddingResponseSchema = import_zod2.z.object({
  data: import_zod2.z.array(
    import_zod2.z.object({
      object: import_zod2.z.literal("embedding"),
      embedding: import_zod2.z.array(import_zod2.z.number()),
      index: import_zod2.z.number().optional()
    })
  ),
  usage: import_zod2.z.object({
    total_tokens: import_zod2.z.number(),
    prompt_tokens: import_zod2.z.number().optional()
  }).nullish(),
  model: import_zod2.z.string().optional()
});

// src/jina-provider.ts
function createJina(options = {}) {
  const baseURL = (0, import_provider_utils3.withoutTrailingSlash)(options.baseURL) ?? "https://api.jina.ai/v1";
  const getHeaders = () => ({
    Authorization: `Bearer ${(0, import_provider_utils3.loadApiKey)({
      apiKey: options.apiKey,
      environmentVariableName: "JINA_API_KEY",
      description: "Jina"
    })}`,
    ...options.headers
  });
  const createTextEmbeddingModel = (modelId, settings = {}) => new JinaEmbeddingModel(modelId, settings, {
    provider: "jina.text.embedding",
    baseURL,
    headers: getHeaders,
    fetch: options.fetch
  });
  const createMultiModalEmbeddingModel = (modelId, settings = {}) => new JinaEmbeddingModel(modelId, settings, {
    provider: "jina.multimodal.embedding",
    baseURL,
    headers: getHeaders,
    fetch: options.fetch
  });
  const provider = function(modelId, settings) {
    if (new.target) {
      throw new Error(
        "The Jina model function cannot be called with the new keyword."
      );
    }
    return createTextEmbeddingModel(modelId, settings);
  };
  provider.textEmbeddingModel = createTextEmbeddingModel;
  provider.multiModalEmbeddingModel = createMultiModalEmbeddingModel;
  provider.languageModel = (modelId) => {
    throw new Error(
      `Language model '${modelId}' is not supported by Jina provider.`
    );
  };
  return provider;
}
var jina = createJina();
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  createJina,
  jina
});
//# sourceMappingURL=index.cjs.map