sarvam-ai-provider/dist/index.mjs

The **Sarvam AI SDK Provider** is a library developed to integrate with the Vercel AI SDK. This library brings Speech to Text (STT) capabilities to your applications, allowing for seamless interaction with audio and text data.

// src/sarvam-transcription-model.ts
import {
  combineHeaders,
  createJsonResponseHandler,
  parseProviderOptions,
  postFormDataToApi
} from "@ai-sdk/provider-utils";
import { z as z2 } from "zod";

// src/sarvam-error.ts
import { z } from "zod";
import { createJsonErrorResponseHandler } from "@ai-sdk/provider-utils";
var SarvamErrorDataSchema = z.object({
  error: z.object({
    message: z.string(),
    code: z.number()
  })
});
var sarvamFailedResponseHandler = createJsonErrorResponseHandler({
  errorSchema: SarvamErrorDataSchema,
  errorToMessage: (data) => data.error.message
});

// src/sarvam-transcription-model.ts
var sarvamProviderOptionsSchema = z2.object({
  language_code: z2.string(),
  with_timestamps: z2.boolean().nullish().default(false),
  /**
   * Enables speaker diarization, which identifies and separates different speakers in the audio.
   * When set to true, the API will provide speaker-specific segments in the response.
   * Note: This parameter is currently in Beta mode.
   */
  with_diarization: z2.boolean().nullish().default(false),
  /**
   * Number of speakers to be detected in the audio.
   * This is used when with_diarization is set to true.
   * Can be null.
   */
  num_speakers: z2.number().int().nullish()
});
var SarvamTranscriptionModel = class {
  constructor(modelId, config) {
    this.modelId = modelId;
    this.config = config;
    this.specificationVersion = "v1";
  }
  get provider() {
    return this.config.provider;
  }
  getArgs({
    audio,
    mediaType,
    providerOptions
  }) {
    const warnings = [];
    const sarvamOptions = parseProviderOptions({
      provider: "sarvam",
      providerOptions,
      schema: sarvamProviderOptionsSchema
    });
    const formData = new FormData();
    const blob = audio instanceof Blob ? audio : new Blob([audio], { type: mediaType });
    formData.append("file", blob);
    formData.append("model", this.modelId);
    if (sarvamOptions) {
      formData.append("language_code", sarvamOptions.language_code);
      formData.append(
        "with_timestamps",
        sarvamOptions.with_timestamps ? "true" : "false"
      );
      formData.append(
        "with_diarization",
        sarvamOptions.with_diarization ? "true" : "false"
      );
      if (sarvamOptions.num_speakers !== null && sarvamOptions.num_speakers !== void 0) {
        formData.append("num_speakers", sarvamOptions.num_speakers.toString());
      }
    }
    return {
      formData,
      warnings
    };
  }
  async doGenerate(options) {
    var _a, _b, _c, _d, _e;
    const currentDate = (_c = (_b = (_a = this.config._internal) == null ? void 0 : _a.currentDate) == null ? void 0 : _b.call(_a)) != null ? _c : /* @__PURE__ */ new Date();
    const { formData, warnings } = this.getArgs(options);
    const {
      value: response,
      responseHeaders,
      rawValue: rawResponse
    } = await postFormDataToApi({
      url: this.config.url({
        path: "/speech-to-text",
        modelId: this.modelId
      }),
      headers: combineHeaders(this.config.headers(), options.headers),
      formData,
      failedResponseHandler: sarvamFailedResponseHandler,
      successfulResponseHandler: createJsonResponseHandler(
        sarvamTranscriptionResponseSchema
      ),
      abortSignal: options.abortSignal,
      fetch: this.config.fetch
    });
    return {
      text: response.transcript,
      segments: response.timestamps ? response.timestamps.words.map((word, index) => ({
        text: word,
        startSecond: response.timestamps.start_time_seconds[index],
        endSecond: response.timestamps.end_time_seconds[index]
      })) : [],
      language: response.language_code ? response.language_code : void 0,
      durationInSeconds: (_e = (_d = response.timestamps) == null ? void 0 : _d.end_time_seconds[response.timestamps.end_time_seconds.length - 1]) != null ? _e : void 0,
      warnings,
      response: {
        timestamp: currentDate,
        modelId: this.modelId,
        headers: responseHeaders,
        body: rawResponse
      }
    };
  }
};
var sarvamTranscriptionResponseSchema = z2.object({
  request_id: z2.string().nullable(),
  transcript: z2.string(),
  language_code: z2.string().nullable(),
  timestamps: z2.object({
    end_time_seconds: z2.array(z2.number()),
    start_time_seconds: z2.array(z2.number()),
    words: z2.array(z2.string())
  }).optional(),
  diarized_transcript: z2.object({
    entries: z2.array(
      z2.object({
        end_time_seconds: z2.array(z2.number()),
        start_time_seconds: z2.array(z2.number()),
        transcript: z2.string(),
        speaker_id: z2.string()
      })
    )
  }).optional()
});

// src/sarvam-provider.ts
function createSarvam(options = {}) {
  const getHeaders = () => ({
    ...options.headers
  });
  const createTranscriptionModel = (modelId) => new SarvamTranscriptionModel(modelId, {
    provider: `sarvam.transcription`,
    url: ({ path }) => `https://api.sarvam.ai${path}`,
    headers: getHeaders,
    fetch: options.fetch
  });
  const provider = function(modelId) {
    return {
      transcription: createTranscriptionModel(modelId)
    };
  };
  provider.transcription = createTranscriptionModel;
  provider.transcriptionModel = createTranscriptionModel;
  return provider;
}
var sarvam = createSarvam();
export {
  createSarvam,
  sarvam
};
//# sourceMappingURL=index.mjs.map