krutrim-ai-sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1594 @@
+'use strict';
+
+var providerUtils = require('@ai-sdk/provider-utils');
+var zod = require('zod');
+var provider = require('@ai-sdk/provider');
+
+// src/provider.ts
+var krutrimErrorDataSchema = zod.z.object({
+  error: zod.z.union([
+    zod.z.string(),
+    zod.z.object({
+      message: zod.z.string().optional(),
+      type: zod.z.string().optional(),
+      code: zod.z.union([zod.z.string(), zod.z.number()]).optional(),
+      param: zod.z.string().nullable().optional()
+    })
+  ]).optional(),
+  message: zod.z.string().optional(),
+  status: zod.z.union([zod.z.string(), zod.z.number()]).optional(),
+  detail: zod.z.object({
+    info: zod.z.string().optional()
+  }).passthrough().optional(),
+  // OpenAI-compatible sometimes nests differently
+  code: zod.z.union([zod.z.string(), zod.z.number()]).optional()
+});
+function extractRawMessage(data) {
+  if (typeof data.error === "string" && data.error.length > 0) {
+    return data.error;
+  }
+  if (data.error && typeof data.error === "object" && typeof data.error.message === "string" && data.error.message.length > 0) {
+    return data.error.message;
+  }
+  if (typeof data.message === "string" && data.message.length > 0) {
+    return data.message;
+  }
+  if (data.detail?.info) {
+    return data.detail.info;
+  }
+  return "Unknown Krutrim API error";
+}
+function enhanceKrutrimErrorMessage(rawMessage, statusCode) {
+  const lower = rawMessage.toLowerCase();
+  const tips = [];
+  if (statusCode === 401 || lower.includes("unauthorized") || lower.includes("invalid api key") || lower.includes("authentication") || lower.includes("api key")) {
+    tips.push(
+      "Check KRUTRIM_API_KEY or KRUTRIM_CLOUD_API_KEY (console: https://cloud.olakrutrim.com).",
+      "Keys can be regenerated under Key Management \u2192 Model API Keys."
+    );
+  }
+  if (statusCode === 403 || lower.includes("forbidden") || lower.includes("region")) {
+    tips.push(
+      "This model or endpoint may be restricted to supported regions / account tiers.",
+      "Confirm your Krutrim Cloud account has access in the console."
+    );
+  }
+  if (statusCode === 429 || lower.includes("rate limit") || lower.includes("too many requests") || lower.includes("quota")) {
+    tips.push(
+      "Rate limit or quota exceeded. Back off and retry with exponential delay.",
+      "Billing is typically INR-based on Krutrim Cloud \u2014 top up credits under Usage & Transactions if balance is low."
+    );
+  }
+  if (lower.includes("insufficient") || lower.includes("credit") || lower.includes("balance") || lower.includes("payment") || lower.includes("billing")) {
+    tips.push(
+      "Krutrim Cloud usage is billed in INR. Add credits at https://cloud.olakrutrim.com (Usage & Transactions)."
+    );
+  }
+  if (lower.includes("model") && (lower.includes("not found") || lower.includes("invalid") || lower.includes("does not exist") || lower.includes("unknown"))) {
+    tips.push(
+      "Copy the exact model string from the Model Catalogue (case-sensitive).",
+      'Try aliases like "krutrim-2" \u2192 "Krutrim-2", or pass the catalogue ID directly.'
+    );
+  }
+  if (statusCode === 404) {
+    tips.push(
+      "Verify baseURL is https://cloud.olakrutrim.com/v1 for chat/embeddings.",
+      "Language Labs (Bhashik) uses https://cloud.olakrutrim.com/api/v1/..."
+    );
+  }
+  if (statusCode != null && statusCode >= 500) {
+    tips.push(
+      "Krutrim API returned a server error. Retry shortly; check status in the console if it persists."
+    );
+  }
+  if (tips.length === 0) {
+    return rawMessage;
+  }
+  return `${rawMessage}
+
+\u{1F4A1} Krutrim tips:
+${tips.map((t) => `  \u2022 ${t}`).join("\n")}`;
+}
+var krutrimFailedResponseHandler = providerUtils.createJsonErrorResponseHandler({
+  errorSchema: krutrimErrorDataSchema,
+  errorToMessage: (data) => enhanceKrutrimErrorMessage(extractRawMessage(data))
+});
+
+// src/bhashik/language-detection.ts
+var lidResponseSchema = zod.z.object({
+  status: zod.z.string().nullish(),
+  data: zod.z.array(
+    zod.z.object({
+      label: zod.z.string().nullish(),
+      value: zod.z.string().nullish()
+    })
+  ).nullish()
+});
+function extractUserText(options) {
+  const prompt = options.prompt;
+  if (typeof prompt === "string") {
+    return prompt;
+  }
+  if (!Array.isArray(prompt)) {
+    return "";
+  }
+  const parts = [];
+  for (const message of prompt) {
+    if (message.role === "user") {
+      for (const part of message.content) {
+        if (part.type === "text") {
+          parts.push(part.text);
+        }
+      }
+    }
+  }
+  return parts.join("\n");
+}
+var KrutrimLanguageDetectionModel = class {
+  constructor(config) {
+    this.specificationVersion = "v3";
+    this.modelId = "bhashik-language-detection";
+    this.config = config;
+    this.provider = config.provider;
+  }
+  get supportedUrls() {
+    return {};
+  }
+  async doGenerate(options) {
+    const query = extractUserText(options);
+    if (!query.trim()) {
+      throw new Error(
+        "Language detection requires a non-empty user prompt or message."
+      );
+    }
+    const {
+      responseHeaders,
+      value: response,
+      rawValue
+    } = await providerUtils.postJsonToApi({
+      url: this.config.languageLabsUrl("/languagelabs/language-detection"),
+      headers: providerUtils.combineHeaders(this.config.headers(), options.headers),
+      body: { query },
+      failedResponseHandler: krutrimFailedResponseHandler,
+      successfulResponseHandler: providerUtils.createJsonResponseHandler(lidResponseSchema),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    const primary = response.data?.[0];
+    const text = primary?.value ?? primary?.label ?? response.data?.map((d) => d.value ?? d.label).filter(Boolean).join(", ") ?? "unknown";
+    const content = [{ type: "text", text }];
+    return {
+      content,
+      finishReason: { unified: "stop", raw: "stop" },
+      usage: {
+        inputTokens: {
+          total: void 0,
+          noCache: void 0,
+          cacheRead: void 0,
+          cacheWrite: void 0
+        },
+        outputTokens: {
+          total: void 0,
+          text: void 0,
+          reasoning: void 0
+        }
+      },
+      providerMetadata: {
+        krutrim: {
+          detections: response.data ?? []
+        }
+      },
+      warnings: [
+        {
+          type: "other",
+          message: "languageDetection only analyzes prompt / user messages (not system or assistant)."
+        }
+      ],
+      request: { body: { query } },
+      response: {
+        headers: responseHeaders,
+        body: rawValue,
+        modelId: this.modelId,
+        timestamp: /* @__PURE__ */ new Date()
+      }
+    };
+  }
+  async doStream(options) {
+    const result = await this.doGenerate(options);
+    const text = result.content.find((c) => c.type === "text")?.type === "text" ? result.content.find((c) => c.type === "text").text : "";
+    const stream = new ReadableStream({
+      start(controller) {
+        controller.enqueue({ type: "stream-start", warnings: result.warnings });
+        controller.enqueue({ type: "text-start", id: "text-0" });
+        controller.enqueue({ type: "text-delta", id: "text-0", delta: text });
+        controller.enqueue({ type: "text-end", id: "text-0" });
+        controller.enqueue({
+          type: "finish",
+          finishReason: result.finishReason,
+          usage: result.usage,
+          providerMetadata: result.providerMetadata
+        });
+        controller.close();
+      }
+    });
+    return {
+      stream,
+      request: result.request,
+      response: result.response
+    };
+  }
+};
+
+// src/indic/languages.ts
+var INDIC_LANGUAGES = [
+  {
+    code: "hi-IN",
+    bhashik: "hin",
+    name: "Hindi",
+    nativeName: "\u0939\u093F\u0928\u094D\u0926\u0940",
+    script: "Deva"
+  },
+  {
+    code: "bn-IN",
+    bhashik: "ben",
+    name: "Bengali",
+    nativeName: "\u09AC\u09BE\u0982\u09B2\u09BE",
+    script: "Beng"
+  },
+  {
+    code: "ta-IN",
+    bhashik: "tam",
+    name: "Tamil",
+    nativeName: "\u0BA4\u0BAE\u0BBF\u0BB4\u0BCD",
+    script: "Taml"
+  },
+  {
+    code: "te-IN",
+    bhashik: "tel",
+    name: "Telugu",
+    nativeName: "\u0C24\u0C46\u0C32\u0C41\u0C17\u0C41",
+    script: "Telu"
+  },
+  {
+    code: "mr-IN",
+    bhashik: "mar",
+    name: "Marathi",
+    nativeName: "\u092E\u0930\u093E\u0920\u0940",
+    script: "Deva"
+  },
+  {
+    code: "gu-IN",
+    bhashik: "guj",
+    name: "Gujarati",
+    nativeName: "\u0A97\u0AC1\u0A9C\u0AB0\u0ABE\u0AA4\u0AC0",
+    script: "Gujr"
+  },
+  {
+    code: "kn-IN",
+    bhashik: "kan",
+    name: "Kannada",
+    nativeName: "\u0C95\u0CA8\u0CCD\u0CA8\u0CA1",
+    script: "Knda"
+  },
+  {
+    code: "ml-IN",
+    bhashik: "mal",
+    name: "Malayalam",
+    nativeName: "\u0D2E\u0D32\u0D2F\u0D3E\u0D33\u0D02",
+    script: "Mlym"
+  },
+  {
+    code: "pa-IN",
+    bhashik: "pan",
+    name: "Punjabi",
+    nativeName: "\u0A2A\u0A70\u0A1C\u0A3E\u0A2C\u0A40",
+    script: "Guru"
+  },
+  {
+    code: "or-IN",
+    bhashik: null,
+    name: "Odia",
+    nativeName: "\u0B13\u0B21\u0B3C\u0B3F\u0B06",
+    script: "Orya",
+    notes: "Not all Bhashik endpoints list Odia yet."
+  },
+  {
+    code: "as-IN",
+    bhashik: null,
+    name: "Assamese",
+    nativeName: "\u0985\u09B8\u09AE\u09C0\u09AF\u09BC\u09BE",
+    script: "Beng"
+  },
+  {
+    code: "ur-IN",
+    bhashik: null,
+    name: "Urdu",
+    nativeName: "\u0627\u0631\u062F\u0648",
+    script: "Arab"
+  },
+  {
+    code: "en-IN",
+    bhashik: "eng",
+    name: "English (India)",
+    nativeName: "English",
+    script: "Latn"
+  },
+  {
+    code: "sa-IN",
+    bhashik: null,
+    name: "Sanskrit",
+    nativeName: "\u0938\u0902\u0938\u094D\u0915\u0943\u0924\u092E\u094D",
+    script: "Deva"
+  },
+  {
+    code: "ne-IN",
+    bhashik: null,
+    name: "Nepali",
+    nativeName: "\u0928\u0947\u092A\u093E\u0932\u0940",
+    script: "Deva"
+  }
+];
+function toBhashikLanguageCode(code) {
+  const entry = INDIC_LANGUAGES.find(
+    (l) => l.code === code || l.bhashik === code
+  );
+  return entry?.bhashik ?? null;
+}
+function toTranslationLanguageCode(code) {
+  const entry = INDIC_LANGUAGES.find(
+    (l) => l.code === code || l.bhashik === code
+  );
+  if (!entry?.bhashik) {
+    if (code.includes("_")) return code;
+    throw new Error(
+      `No Bhashik/translation mapping for language "${code}". Use a supported code or pass an explicit tag like "hin_Deva".`
+    );
+  }
+  return `${entry.bhashik}_${entry.script}`;
+}
+
+// src/bhashik/speech-model.ts
+var ttsResponseSchema = zod.z.object({
+  status: zod.z.string().nullish(),
+  data: zod.z.object({
+    audio_file: zod.z.string().nullish(),
+    // Some deployments may return base64 directly
+    audio: zod.z.string().nullish(),
+    audio_base64: zod.z.string().nullish()
+  }).nullish()
+});
+var KrutrimSpeechModel = class {
+  constructor(language, settings = {}, config) {
+    this.specificationVersion = "v3";
+    this.modelId = "Krutrim-TTS";
+    const mapped = toBhashikLanguageCode(language);
+    if (!mapped) {
+      if (["eng", "guj", "ben", "hin", "kan", "mal", "mar", "tam", "tel"].includes(
+        language
+      )) {
+        this.languageCode = language;
+      } else {
+        throw new Error(
+          `Unsupported TTS language "${language}". Use hi-IN, ta-IN, eng, hin, etc.`
+        );
+      }
+    } else {
+      this.languageCode = mapped;
+    }
+    this.settings = settings;
+    this.config = config;
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  async doGenerate({
+    text,
+    headers,
+    abortSignal
+  }) {
+    const {
+      responseHeaders,
+      value: response,
+      rawValue
+    } = await providerUtils.postJsonToApi({
+      url: this.config.languageLabsUrl("/languagelabs/tts"),
+      headers: providerUtils.combineHeaders(this.config.headers(), headers),
+      body: {
+        input_text: text,
+        input_language: this.languageCode,
+        input_speaker: this.settings.speaker ?? "female"
+      },
+      failedResponseHandler: krutrimFailedResponseHandler,
+      successfulResponseHandler: providerUtils.createJsonResponseHandler(ttsResponseSchema),
+      abortSignal,
+      fetch: this.config.fetch
+    });
+    let audioData = response.data?.audio_base64 ?? response.data?.audio ?? void 0;
+    const audioUrl = response.data?.audio_file;
+    if (!audioData && audioUrl) {
+      const fetchFn = this.config.fetch ?? globalThis.fetch;
+      const audioResponse = await fetchFn(audioUrl, {
+        headers: this.config.headers(),
+        signal: abortSignal
+      });
+      if (!audioResponse.ok) {
+        throw new Error(
+          `Failed to download TTS audio from ${audioUrl}: ${audioResponse.status}`
+        );
+      }
+      const buffer = new Uint8Array(await audioResponse.arrayBuffer());
+      audioData = buffer;
+    }
+    if (!audioData) {
+      throw new Error(
+        "Krutrim TTS response did not include audio data or a downloadable audio_file URL."
+      );
+    }
+    return {
+      audio: audioData,
+      warnings: [],
+      response: {
+        headers: responseHeaders,
+        body: rawValue,
+        timestamp: /* @__PURE__ */ new Date(),
+        modelId: this.modelId
+      }
+    };
+  }
+};
+var sttResponseSchema = zod.z.object({
+  status: zod.z.string().nullish(),
+  data: zod.z.object({
+    text: zod.z.union([zod.z.array(zod.z.string()), zod.z.string()]).nullish()
+  }).nullish()
+});
+var KrutrimTranscriptionModel = class {
+  constructor(language, config) {
+    this.specificationVersion = "v3";
+    this.modelId = "Krutrim-Dhwani";
+    const mapped = toBhashikLanguageCode(language);
+    if (!mapped) {
+      if (["eng", "guj", "ben", "hin", "kan", "mal", "mar", "tam", "tel"].includes(
+        language
+      )) {
+        this.languageCode = language;
+      } else {
+        throw new Error(
+          `Unsupported STT language "${language}". Use hi-IN, ta-IN, eng, hin, etc.`
+        );
+      }
+    } else {
+      this.languageCode = mapped;
+    }
+    this.config = config;
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  async doGenerate({
+    audio,
+    mediaType,
+    headers,
+    abortSignal
+  }) {
+    const formData = new FormData();
+    let blob;
+    if (typeof audio === "string") {
+      const binary = Buffer.from(audio, "base64");
+      blob = new Blob([binary], { type: mediaType ?? "audio/wav" });
+    } else {
+      blob = new Blob([audio], {
+        type: mediaType ?? "audio/wav"
+      });
+    }
+    formData.append("file", blob, "audio.wav");
+    formData.append("lang_code", this.languageCode);
+    const baseHeaders = { ...this.config.headers(), ...headers };
+    delete baseHeaders["Content-Type"];
+    delete baseHeaders["content-type"];
+    const {
+      responseHeaders,
+      value: response,
+      rawValue
+    } = await providerUtils.postToApi({
+      url: this.config.languageLabsUrl("/languagelabs/transcribe/upload"),
+      headers: providerUtils.combineHeaders(baseHeaders, void 0),
+      body: {
+        content: formData,
+        values: formData
+      },
+      failedResponseHandler: krutrimFailedResponseHandler,
+      successfulResponseHandler: providerUtils.createJsonResponseHandler(sttResponseSchema),
+      abortSignal,
+      fetch: this.config.fetch
+    });
+    const textField = response.data?.text;
+    const text = Array.isArray(textField) ? textField.join(" ") : textField ?? "";
+    return {
+      text,
+      segments: [],
+      language: this.languageCode,
+      durationInSeconds: void 0,
+      warnings: [],
+      response: {
+        headers: responseHeaders,
+        body: rawValue,
+        timestamp: /* @__PURE__ */ new Date(),
+        modelId: this.modelId
+      }
+    };
+  }
+};
+var translationResponseSchema = zod.z.object({
+  status: zod.z.string().nullish(),
+  data: zod.z.object({
+    translated_text: zod.z.string().nullish()
+  }).nullish()
+});
+function extractUserText2(options) {
+  const prompt = options.prompt;
+  if (!Array.isArray(prompt)) {
+    return "";
+  }
+  const parts = [];
+  for (const message of prompt) {
+    if (message.role === "user") {
+      for (const part of message.content) {
+        if (part.type === "text") {
+          parts.push(part.text);
+        }
+      }
+    }
+  }
+  return parts.join("\n");
+}
+var KrutrimTranslationModel = class {
+  constructor(settings, config) {
+    this.specificationVersion = "v3";
+    this.settings = settings;
+    this.config = config;
+    this.provider = config.provider;
+    this.modelId = settings.model ?? "krutrim-translate-v1.0";
+  }
+  get supportedUrls() {
+    return {};
+  }
+  async doGenerate(options) {
+    const text = extractUserText2(options);
+    if (!text.trim()) {
+      throw new Error("Translation requires a non-empty user prompt or message.");
+    }
+    const src = toTranslationLanguageCode(this.settings.from);
+    const tgt = toTranslationLanguageCode(this.settings.to);
+    const body = {
+      text,
+      src_language: src,
+      tgt_language: tgt,
+      model: this.modelId
+    };
+    const {
+      responseHeaders,
+      value: response,
+      rawValue
+    } = await providerUtils.postJsonToApi({
+      url: this.config.languageLabsUrl("/languagelabs/translation"),
+      headers: providerUtils.combineHeaders(this.config.headers(), options.headers),
+      body,
+      failedResponseHandler: krutrimFailedResponseHandler,
+      successfulResponseHandler: providerUtils.createJsonResponseHandler(
+        translationResponseSchema
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    const translated = response.data?.translated_text ?? "";
+    const content = [
+      { type: "text", text: translated }
+    ];
+    return {
+      content,
+      finishReason: { unified: "stop", raw: "stop" },
+      usage: {
+        inputTokens: {
+          total: void 0,
+          noCache: void 0,
+          cacheRead: void 0,
+          cacheWrite: void 0
+        },
+        outputTokens: {
+          total: void 0,
+          text: void 0,
+          reasoning: void 0
+        }
+      },
+      providerMetadata: {
+        krutrim: {
+          src_language: src,
+          tgt_language: tgt,
+          model: this.modelId
+        }
+      },
+      warnings: [
+        {
+          type: "other",
+          message: "translation only processes prompt / user messages (not system or assistant)."
+        }
+      ],
+      request: { body },
+      response: {
+        headers: responseHeaders,
+        body: rawValue,
+        modelId: this.modelId,
+        timestamp: /* @__PURE__ */ new Date()
+      }
+    };
+  }
+  async doStream(options) {
+    const result = await this.doGenerate(options);
+    const textPart = result.content.find((c) => c.type === "text");
+    const text = textPart && textPart.type === "text" ? textPart.text : "";
+    const stream = new ReadableStream({
+      start(controller) {
+        controller.enqueue({ type: "stream-start", warnings: result.warnings });
+        controller.enqueue({ type: "text-start", id: "text-0" });
+        controller.enqueue({ type: "text-delta", id: "text-0", delta: text });
+        controller.enqueue({ type: "text-end", id: "text-0" });
+        controller.enqueue({
+          type: "finish",
+          finishReason: result.finishReason,
+          usage: result.usage,
+          providerMetadata: result.providerMetadata
+        });
+        controller.close();
+      }
+    });
+    return {
+      stream,
+      request: result.request,
+      response: result.response
+    };
+  }
+};
+
+// src/models.ts
+var KRUTRIM_CHAT_MODELS = {
+  /** Krutrim's flagship Indic-capable model (v1). */
+  krutrim1: "Krutrim-1",
+  /** Krutrim's next-generation text model. */
+  krutrim2: "Krutrim-2",
+  /** Lowercase alias accepted by many OpenAI-compatible samples. */
+  krutrim1Lower: "krutrim-1",
+  krutrim2Lower: "krutrim-2",
+  // Open models commonly hosted on Krutrim Cloud
+  llama33_70b: "Llama-3.3-70B-Instruct",
+  llama32_11b_vision: "Llama-3.2-11B-Vision-Instruct",
+  llama4_maverick: "Llama-4-Maverick-17B-128E-Instruct",
+  llama3_8b: "Meta-Llama-3-8B-Instruct",
+  mistral7b: "Mistral-7B-v0.2",
+  mistral7bInstruct: "Mistral-7B-Instruct",
+  qwen3_32b: "Qwen3-32B",
+  qwen3_30b: "Qwen3-30B-A3B",
+  phi4_reasoning: "Phi-4-reasoning-plus",
+  deepseekR1: "DeepSeek-R1",
+  deepseekR1_70b: "DeepSeek-R1-Distill-Llama-70B",
+  deepseekR1_8b: "DeepSeek-R1-Distill-Llama-8B",
+  gemma3_27b: "gemma-3-27b-it",
+  spectreV2: "Krutrim-spectre-v2"
+};
+var KRUTRIM_EMBEDDING_MODELS = {
+  /** Krutrim embedding model. */
+  vyakyarth: "Vyakyarth",
+  /** Alternative Krutrim embedding model. */
+  bhasantarit: "Bhasantarit"
+};
+var KRUTRIM_SPEECH_MODELS = {
+  /** Krutrim Speech-to-Text. */
+  dhwani: "Krutrim-Dhwani",
+  /** Krutrim Text-to-Speech. */
+  tts: "Krutrim-TTS"
+};
+var KRUTRIM_VISION_MODELS = {
+  chitrapathak: "chitrapathak",
+  llama32_11b_vision: "Llama-3.2-11B-Vision-Instruct",
+  llama4_maverick: "Llama-4-Maverick-17B-128E-Instruct",
+  gemma3_27b: "gemma-3-27b-it"
+};
+var MODEL_ALIASES = {
+  // Native Krutrim
+  krutrim: "Krutrim-2",
+  "krutrim-1": "Krutrim-1",
+  "krutrim-2": "Krutrim-2",
+  krutrim1: "Krutrim-1",
+  krutrim2: "Krutrim-2",
+  "Krutrim-1": "Krutrim-1",
+  "Krutrim-2": "Krutrim-2",
+  // Speech
+  dhwani: "Krutrim-Dhwani",
+  "krutrim-dhwani": "Krutrim-Dhwani",
+  "Krutrim-Dhwani": "Krutrim-Dhwani",
+  tts: "Krutrim-TTS",
+  "krutrim-tts": "Krutrim-TTS",
+  "Krutrim-TTS": "Krutrim-TTS",
+  // Embeddings
+  vyakyarth: "Vyakyarth",
+  Vyakyarth: "Vyakyarth",
+  bhasantarit: "Bhasantarit",
+  Bhasantarit: "Bhasantarit",
+  // Common open-model shortcuts
+  "llama-3.3-70b": "Llama-3.3-70B-Instruct",
+  "llama3.3-70b": "Llama-3.3-70B-Instruct",
+  "llama-3.2-11b-vision": "Llama-3.2-11B-Vision-Instruct",
+  "mistral-7b": "Mistral-7B-v0.2",
+  "deepseek-r1": "DeepSeek-R1",
+  "qwen3-32b": "Qwen3-32B",
+  "phi-4": "Phi-4-reasoning-plus"
+};
+function resolveModelId(modelId) {
+  return MODEL_ALIASES[modelId] ?? MODEL_ALIASES[modelId.toLowerCase()] ?? modelId;
+}
+function convertToChatMessages(prompt) {
+  const messages = [];
+  for (const message of prompt) {
+    switch (message.role) {
+      case "system": {
+        messages.push({ role: "system", content: message.content });
+        break;
+      }
+      case "user": {
+        if (message.content.length === 1 && message.content[0].type === "text") {
+          messages.push({
+            role: "user",
+            content: message.content[0].text
+          });
+          break;
+        }
+        messages.push({
+          role: "user",
+          content: message.content.map((part) => {
+            switch (part.type) {
+              case "text": {
+                return { type: "text", text: part.text };
+              }
+              case "file": {
+                let imageData;
+                if (typeof part.data === "string") {
+                  if (part.data.startsWith("http://") || part.data.startsWith("https://") || part.data.startsWith("data:")) {
+                    imageData = part.data;
+                  } else {
+                    imageData = `data:${part.mediaType};base64,${part.data}`;
+                  }
+                } else if (part.data instanceof URL) {
+                  imageData = part.data.toString();
+                } else {
+                  imageData = `data:${part.mediaType};base64,${providerUtils.convertUint8ArrayToBase64(part.data)}`;
+                }
+                return {
+                  type: "image_url",
+                  image_url: { url: imageData }
+                };
+              }
+              default: {
+                const _exhaustive = part;
+                throw new provider.UnsupportedFunctionalityError({
+                  functionality: `Unsupported content part type: ${JSON.stringify(_exhaustive)}`
+                });
+              }
+            }
+          })
+        });
+        break;
+      }
+      case "assistant": {
+        let text = "";
+        const toolCalls = [];
+        for (const part of message.content) {
+          switch (part.type) {
+            case "text": {
+              text += part.text;
+              break;
+            }
+            case "tool-call": {
+              toolCalls.push({
+                id: part.toolCallId,
+                type: "function",
+                function: {
+                  name: part.toolName,
+                  arguments: typeof part.input === "string" ? part.input : JSON.stringify(part.input)
+                }
+              });
+              break;
+            }
+          }
+        }
+        messages.push({
+          role: "assistant",
+          content: text || null,
+          tool_calls: toolCalls.length > 0 ? toolCalls : void 0
+        });
+        break;
+      }
+      case "tool": {
+        for (const part of message.content) {
+          if (part.type === "tool-result") {
+            messages.push({
+              role: "tool",
+              tool_call_id: part.toolCallId,
+              content: JSON.stringify(part.output)
+            });
+          }
+        }
+        break;
+      }
+      default: {
+        const _exhaustive = message;
+        throw new Error(`Unsupported role: ${JSON.stringify(_exhaustive)}`);
+      }
+    }
+  }
+  return messages;
+}
+function prepareTools({
+  tools,
+  toolChoice
+}) {
+  const finalTools = tools?.length ? tools : void 0;
+  const toolWarnings = [];
+  if (finalTools == null) {
+    return { tools: void 0, tool_choice: void 0, toolWarnings };
+  }
+  const krutrimTools = [];
+  for (const tool of finalTools) {
+    if (tool.type === "provider") {
+      toolWarnings.push({ type: "unsupported", feature: tool.name });
+    } else {
+      krutrimTools.push({
+        type: "function",
+        function: {
+          name: tool.name,
+          description: tool.description,
+          parameters: tool.inputSchema
+        }
+      });
+    }
+  }
+  if (toolChoice == null) {
+    return { tools: krutrimTools, tool_choice: void 0, toolWarnings };
+  }
+  const type = toolChoice.type;
+  switch (type) {
+    case "auto":
+    case "none":
+    case "required":
+      return { tools: krutrimTools, tool_choice: type, toolWarnings };
+    case "tool":
+      return {
+        tools: krutrimTools,
+        tool_choice: {
+          type: "function",
+          function: { name: toolChoice.toolName }
+        },
+        toolWarnings
+      };
+    default: {
+      const _exhaustive = type;
+      throw new provider.UnsupportedFunctionalityError({
+        functionality: `Unsupported tool choice type: ${_exhaustive}`
+      });
+    }
+  }
+}
+var chatSettingsSchema = zod.z.object({
+  n: zod.z.number().min(1).max(128).nullish(),
+  user: zod.z.string().nullish(),
+  reasoningEffort: zod.z.enum(["low", "medium", "high"]).nullish(),
+  // snake_case passthrough for raw API fields if set via providerOptions
+  reasoning_effort: zod.z.enum(["low", "medium", "high"]).nullish()
+});
+var chatResponseSchema = zod.z.object({
+  id: zod.z.string().nullish(),
+  created: zod.z.number().nullish(),
+  model: zod.z.string().nullish(),
+  object: zod.z.string().nullish(),
+  system_fingerprint: zod.z.string().nullish(),
+  choices: zod.z.array(
+    zod.z.object({
+      index: zod.z.number(),
+      finish_reason: zod.z.string().nullish(),
+      logprobs: zod.z.object({}).nullish(),
+      message: zod.z.object({
+        content: zod.z.string().nullish(),
+        reasoning_content: zod.z.string().nullish(),
+        refusal: zod.z.string().nullish(),
+        role: zod.z.string().nullish(),
+        tool_calls: zod.z.array(
+          zod.z.object({
+            id: zod.z.string().nullish(),
+            type: zod.z.literal("function"),
+            function: zod.z.object({
+              name: zod.z.string(),
+              arguments: zod.z.string()
+            })
+          })
+        ).nullish()
+      })
+    })
+  ),
+  usage: zod.z.object({
+    completion_tokens: zod.z.number().nullish(),
+    prompt_tokens: zod.z.number().nullish(),
+    total_tokens: zod.z.number().nullish()
+  }).nullish()
+});
+var chatChunkSchema = zod.z.union([
+  zod.z.object({
+    id: zod.z.string().nullish(),
+    created: zod.z.number().nullish(),
+    model: zod.z.string().nullish(),
+    choices: zod.z.array(
+      zod.z.object({
+        delta: zod.z.object({
+          content: zod.z.string().nullish(),
+          reasoning: zod.z.string().nullish(),
+          reasoning_content: zod.z.string().nullish(),
+          role: zod.z.string().nullish(),
+          tool_calls: zod.z.array(
+            zod.z.object({
+              index: zod.z.number(),
+              id: zod.z.string().nullish(),
+              type: zod.z.literal("function").optional(),
+              function: zod.z.object({
+                name: zod.z.string().nullish(),
+                arguments: zod.z.string().nullish()
+              })
+            })
+          ).nullish()
+        }).nullish(),
+        finish_reason: zod.z.string().nullable().optional(),
+        index: zod.z.number()
+      })
+    ),
+    usage: zod.z.object({
+      prompt_tokens: zod.z.number().nullish(),
+      completion_tokens: zod.z.number().nullish(),
+      total_tokens: zod.z.number().nullish()
+    }).nullish()
+  }),
+  krutrimErrorDataSchema
+]);
+
+// src/chat/utils.ts
+function mapFinishReason(finishReason) {
+  switch (finishReason) {
+    case "stop":
+      return "stop";
+    case "length":
+      return "length";
+    case "content_filter":
+      return "content-filter";
+    case "function_call":
+    case "tool_calls":
+      return "tool-calls";
+    default:
+      return "other";
+  }
+}
+function getResponseMetadata({
+  id,
+  model,
+  created
+}) {
+  return {
+    id: id ?? void 0,
+    modelId: model ?? void 0,
+    timestamp: created != null ? new Date(created * 1e3) : void 0
+  };
+}
+
+// src/chat/language-model.ts
+var KrutrimChatLanguageModel = class {
+  constructor(modelId, settings, config) {
+    this.specificationVersion = "v3";
+    this.modelId = modelId;
+    this.resolvedModelId = resolveModelId(String(modelId));
+    this.settings = settings;
+    this.config = config;
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  get supportedUrls() {
+    return {
+      "image/*": [/^https?:\/\/.+/i]
+    };
+  }
+  async getArgs(options) {
+    const {
+      prompt,
+      maxOutputTokens,
+      temperature,
+      topP,
+      topK,
+      frequencyPenalty,
+      presencePenalty,
+      stopSequences,
+      responseFormat,
+      seed,
+      tools,
+      toolChoice,
+      providerOptions,
+      stream
+    } = options;
+    const warnings = [];
+    if (topK != null) {
+      warnings.push({ type: "unsupported", feature: "topK" });
+    }
+    const krutrimOptions = await providerUtils.parseProviderOptions({
+      provider: "krutrim",
+      providerOptions: {
+        krutrim: {
+          ...providerOptions?.krutrim,
+          ...this.settings
+        }
+      },
+      schema: chatSettingsSchema
+    });
+    const reasoningEffort = krutrimOptions?.reasoningEffort ?? krutrimOptions?.reasoning_effort;
+    const baseArgs = {
+      model: this.resolvedModelId,
+      messages: convertToChatMessages(prompt),
+      max_tokens: maxOutputTokens,
+      temperature,
+      top_p: topP,
+      frequency_penalty: frequencyPenalty,
+      presence_penalty: presencePenalty,
+      stop: stopSequences,
+      seed,
+      n: krutrimOptions?.n ?? void 0,
+      user: krutrimOptions?.user ?? void 0,
+      response_format: stream === false && responseFormat?.type === "json" ? responseFormat.schema ? {
+        type: "json_schema",
+        json_schema: {
+          name: responseFormat.name ?? "response",
+          description: responseFormat.description,
+          schema: responseFormat.schema,
+          strict: true
+        }
+      } : { type: "json_object" } : void 0
+    };
+    if (reasoningEffort) {
+      baseArgs.reasoning_effort = reasoningEffort;
+    }
+    let toolsArg = null;
+    if (tools && tools.length > 0) {
+      toolsArg = prepareTools({ tools, toolChoice });
+    }
+    if (responseFormat?.type === "json" && responseFormat.schema) ;
+    return {
+      args: {
+        ...baseArgs,
+        ...toolsArg ? {
+          tools: toolsArg.tools,
+          tool_choice: toolsArg.tool_choice
+        } : {}
+      },
+      warnings: [...warnings, ...toolsArg?.toolWarnings ?? []]
+    };
+  }
+  async doGenerate(options) {
+    const { args, warnings } = await this.getArgs({
+      ...options,
+      stream: false
+    });
+    const {
+      responseHeaders,
+      value: response,
+      rawValue: rawResponse
+    } = await providerUtils.postJsonToApi({
+      url: this.config.url({
+        path: "/chat/completions",
+        modelId: this.resolvedModelId
+      }),
+      headers: providerUtils.combineHeaders(this.config.headers(), options.headers),
+      body: args,
+      failedResponseHandler: krutrimFailedResponseHandler,
+      successfulResponseHandler: providerUtils.createJsonResponseHandler(chatResponseSchema),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    const choice = response.choices[0];
+    if (!choice) {
+      throw new provider.InvalidResponseDataError({
+        data: response,
+        message: "No choices returned in Krutrim chat completion response"
+      });
+    }
+    const content = [];
+    if (choice.message.content) {
+      content.push({ type: "text", text: choice.message.content });
+    }
+    if (choice.message.reasoning_content) {
+      content.push({ type: "reasoning", text: choice.message.reasoning_content });
+    }
+    if (choice.message.tool_calls?.length) {
+      for (const toolCall of choice.message.tool_calls) {
+        content.push({
+          type: "tool-call",
+          toolCallId: toolCall.id ?? (this.config.generateId ?? providerUtils.generateId)(),
+          toolName: toolCall.function.name,
+          input: toolCall.function.arguments
+        });
+      }
+    }
+    return {
+      content,
+      finishReason: {
+        unified: mapFinishReason(choice.finish_reason),
+        raw: choice.finish_reason ?? void 0
+      },
+      usage: {
+        inputTokens: {
+          total: response.usage?.prompt_tokens ?? void 0,
+          noCache: void 0,
+          cacheRead: void 0,
+          cacheWrite: void 0
+        },
+        outputTokens: {
+          total: response.usage?.completion_tokens ?? void 0,
+          text: void 0,
+          reasoning: void 0
+        }
+      },
+      providerMetadata: {
+        krutrim: {
+          system_fingerprint: response.system_fingerprint,
+          resolvedModelId: this.resolvedModelId
+        }
+      },
+      warnings,
+      request: { body: args },
+      response: {
+        headers: responseHeaders,
+        body: rawResponse,
+        id: response.id ?? void 0,
+        modelId: response.model ?? void 0,
+        timestamp: response.created ? new Date(response.created * 1e3) : void 0
+      }
+    };
+  }
+  async doStream(options) {
+    const { args, warnings } = await this.getArgs({ ...options, stream: true });
+    const { responseHeaders, value: response } = await providerUtils.postJsonToApi({
+      url: this.config.url({
+        path: "/chat/completions",
+        modelId: this.resolvedModelId
+      }),
+      headers: providerUtils.combineHeaders(this.config.headers(), options.headers),
+      body: { ...args, stream: true },
+      failedResponseHandler: krutrimFailedResponseHandler,
+      successfulResponseHandler: providerUtils.createEventSourceResponseHandler(chatChunkSchema),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    const toolCalls = [];
+    let finishReason = {
+      unified: "other",
+      raw: void 0
+    };
+    let usage = {
+      inputTokens: {
+        total: void 0,
+        noCache: void 0,
+        cacheRead: void 0,
+        cacheWrite: void 0
+      },
+      outputTokens: {
+        total: void 0,
+        text: void 0,
+        reasoning: void 0
+      }
+    };
+    let isFirstChunk = true;
+    let textStarted = false;
+    let reasoningStarted = false;
+    const self = this;
+    return {
+      stream: response.pipeThrough(
+        new TransformStream({
+          start(controller) {
+            controller.enqueue({ type: "stream-start", warnings });
+          },
+          transform(chunk, controller) {
+            if (!chunk.success) {
+              finishReason = { unified: "error", raw: void 0 };
+              controller.enqueue({ type: "error", error: chunk.error });
+              return;
+            }
+            const value = chunk.value;
+            if ("error" in value && value.error != null && !("choices" in value)) {
+              finishReason = { unified: "error", raw: void 0 };
+              controller.enqueue({ type: "error", error: value.error });
+              return;
+            }
+            if (!("choices" in value)) {
+              return;
+            }
+            if (isFirstChunk) {
+              isFirstChunk = false;
+              const metadata = getResponseMetadata(value);
+              if (metadata.id || metadata.timestamp || metadata.modelId) {
+                controller.enqueue({ type: "response-metadata", ...metadata });
+              }
+            }
+            if (value.usage != null) {
+              usage = {
+                inputTokens: {
+                  total: value.usage.prompt_tokens ?? void 0,
+                  noCache: void 0,
+                  cacheRead: void 0,
+                  cacheWrite: void 0
+                },
+                outputTokens: {
+                  total: value.usage.completion_tokens ?? void 0,
+                  text: void 0,
+                  reasoning: void 0
+                }
+              };
+            }
+            const choice = value.choices[0];
+            if (choice?.finish_reason != null) {
+              finishReason = {
+                unified: mapFinishReason(choice.finish_reason),
+                raw: choice.finish_reason
+              };
+            }
+            if (choice?.delta == null) {
+              return;
+            }
+            const delta = choice.delta;
+            const reasoningText = delta.reasoning ?? delta.reasoning_content;
+            if (reasoningText != null && reasoningText.length > 0) {
+              if (!reasoningStarted) {
+                reasoningStarted = true;
+                controller.enqueue({
+                  type: "reasoning-start",
+                  id: "reasoning-0"
+                });
+              }
+              controller.enqueue({
+                type: "reasoning-delta",
+                id: "reasoning-0",
+                delta: reasoningText
+              });
+            }
+            if (delta.content != null && delta.content.length > 0) {
+              if (!textStarted) {
+                textStarted = true;
+                controller.enqueue({ type: "text-start", id: "text-0" });
+              }
+              controller.enqueue({
+                type: "text-delta",
+                id: "text-0",
+                delta: delta.content
+              });
+            }
+            if (delta.tool_calls != null) {
+              for (const toolCallDelta of delta.tool_calls) {
+                const index = toolCallDelta.index;
+                if (toolCalls[index] == null) {
+                  if (toolCallDelta.id == null) {
+                    throw new provider.InvalidResponseDataError({
+                      data: toolCallDelta,
+                      message: `Expected tool call 'id' to be a string.`
+                    });
+                  }
+                  if (toolCallDelta.function?.name == null) {
+                    throw new provider.InvalidResponseDataError({
+                      data: toolCallDelta,
+                      message: `Expected tool call 'function.name' to be a string.`
+                    });
+                  }
+                  toolCalls[index] = {
+                    id: toolCallDelta.id,
+                    name: toolCallDelta.function.name,
+                    arguments: toolCallDelta.function.arguments ?? "",
+                    hasFinished: false
+                  };
+                  const toolCall2 = toolCalls[index];
+                  controller.enqueue({
+                    type: "tool-input-start",
+                    id: toolCall2.id,
+                    toolName: toolCall2.name
+                  });
+                  if (toolCall2.arguments.length > 0) {
+                    controller.enqueue({
+                      type: "tool-input-delta",
+                      id: toolCall2.id,
+                      delta: toolCall2.arguments
+                    });
+                  }
+                  if (providerUtils.isParsableJson(toolCall2.arguments)) {
+                    controller.enqueue({
+                      type: "tool-input-end",
+                      id: toolCall2.id
+                    });
+                    controller.enqueue({
+                      type: "tool-call",
+                      toolCallId: toolCall2.id,
+                      toolName: toolCall2.name,
+                      input: toolCall2.arguments
+                    });
+                    toolCall2.hasFinished = true;
+                  }
+                  continue;
+                }
+                const toolCall = toolCalls[index];
+                if (toolCall.hasFinished) continue;
+                if (toolCallDelta.function?.arguments != null) {
+                  toolCall.arguments += toolCallDelta.function.arguments;
+                  controller.enqueue({
+                    type: "tool-input-delta",
+                    id: toolCall.id,
+                    delta: toolCallDelta.function.arguments
+                  });
+                }
+                if (toolCall.name != null && toolCall.arguments != null && providerUtils.isParsableJson(toolCall.arguments)) {
+                  controller.enqueue({
+                    type: "tool-input-end",
+                    id: toolCall.id
+                  });
+                  controller.enqueue({
+                    type: "tool-call",
+                    toolCallId: toolCall.id,
+                    toolName: toolCall.name,
+                    input: toolCall.arguments
+                  });
+                  toolCall.hasFinished = true;
+                }
+              }
+            }
+          },
+          flush(controller) {
+            if (reasoningStarted) {
+              controller.enqueue({ type: "reasoning-end", id: "reasoning-0" });
+            }
+            if (textStarted) {
+              controller.enqueue({ type: "text-end", id: "text-0" });
+            }
+            controller.enqueue({
+              type: "finish",
+              finishReason,
+              usage,
+              providerMetadata: {
+                krutrim: {
+                  resolvedModelId: self.resolvedModelId
+                }
+              }
+            });
+          }
+        })
+      ),
+      request: { body: args },
+      response: { headers: responseHeaders }
+    };
+  }
+};
+
+// src/config.ts
+var KRUTRIM_DEFAULT_BASE_URL = "https://cloud.olakrutrim.com/v1";
+var KRUTRIM_DEFAULT_API_HOST = "https://cloud.olakrutrim.com";
+function resolveKrutrimApiKey(apiKey) {
+  if (apiKey && apiKey.trim().length > 0) {
+    return apiKey;
+  }
+  if (typeof process === "undefined" || !process.env) {
+    return void 0;
+  }
+  return process.env.KRUTRIM_API_KEY?.trim() || process.env.KRUTRIM_CLOUD_API_KEY?.trim() || void 0;
+}
+var embeddingResponseSchema = zod.z.object({
+  object: zod.z.string().nullish(),
+  data: zod.z.array(
+    zod.z.object({
+      object: zod.z.string().nullish(),
+      embedding: zod.z.array(zod.z.number()),
+      index: zod.z.number()
+    })
+  ),
+  model: zod.z.string().nullish(),
+  usage: zod.z.object({
+    prompt_tokens: zod.z.number().nullish(),
+    total_tokens: zod.z.number().nullish()
+  }).nullish()
+});
+var KrutrimEmbeddingModel = class {
+  constructor(modelId, config) {
+    this.specificationVersion = "v3";
+    this.maxEmbeddingsPerCall = 32;
+    this.supportsParallelCalls = true;
+    this.modelId = modelId;
+    this.resolvedModelId = resolveModelId(modelId);
+    this.config = config;
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  async doEmbed({
+    values,
+    headers,
+    abortSignal,
+    providerOptions
+  }) {
+    const krutrimOptions = providerOptions?.krutrim;
+    const {
+      responseHeaders,
+      value: response,
+      rawValue
+    } = await providerUtils.postJsonToApi({
+      url: this.config.url({
+        path: "/embeddings",
+        modelId: this.resolvedModelId
+      }),
+      headers: providerUtils.combineHeaders(this.config.headers(), headers),
+      body: {
+        model: this.resolvedModelId,
+        input: values,
+        dimensions: krutrimOptions?.dimensions,
+        user: krutrimOptions?.user
+      },
+      failedResponseHandler: krutrimFailedResponseHandler,
+      successfulResponseHandler: providerUtils.createJsonResponseHandler(embeddingResponseSchema),
+      abortSignal,
+      fetch: this.config.fetch
+    });
+    return {
+      embeddings: response.data.slice().sort((a, b) => a.index - b.index).map((item) => item.embedding),
+      usage: response.usage?.total_tokens ? { tokens: response.usage.total_tokens } : void 0,
+      warnings: [],
+      response: { headers: responseHeaders, body: rawValue }
+    };
+  }
+};
+
+// src/provider.ts
+function createKrutrim(options = {}) {
+  const baseURL = providerUtils.withoutTrailingSlash(options.baseURL) ?? KRUTRIM_DEFAULT_BASE_URL;
+  const apiHost = providerUtils.withoutTrailingSlash(options.apiHost) ?? KRUTRIM_DEFAULT_API_HOST;
+  const getApiKey = () => {
+    const resolved = resolveKrutrimApiKey(options.apiKey);
+    return providerUtils.loadApiKey({
+      apiKey: resolved,
+      environmentVariableName: "KRUTRIM_API_KEY",
+      description: "Krutrim Cloud"
+    });
+  };
+  const getHeaders = () => {
+    const apiKey = getApiKey();
+    return {
+      Authorization: `Bearer ${apiKey}`,
+      "User-Agent": "krutrim-ai-sdk",
+      ...options.headers
+    };
+  };
+  const sharedConfig = {
+    headers: getHeaders,
+    fetch: options.fetch,
+    generateId: options.generateId ?? providerUtils.generateId,
+    url: ({ path }) => `${baseURL}${path}`,
+    languageLabsUrl: (path) => {
+      const normalized = path.startsWith("/") ? path : `/${path}`;
+      return `${apiHost}/api/v1${normalized}`;
+    }
+  };
+  const createChatModel = (modelId, settings = {}) => new KrutrimChatLanguageModel(modelId, settings, {
+    ...sharedConfig,
+    provider: "krutrim.chat"
+  });
+  const createLanguageModel = (modelId, settings) => {
+    if (new.target) {
+      throw new Error(
+        "The Krutrim model function cannot be called with the new keyword."
+      );
+    }
+    return createChatModel(modelId, settings);
+  };
+  const createEmbeddingModel = (modelId) => new KrutrimEmbeddingModel(modelId, {
+    ...sharedConfig,
+    provider: "krutrim.embedding"
+  });
+  const provider = ((modelId, settings) => createLanguageModel(modelId, settings));
+  provider.languageModel = createLanguageModel;
+  provider.chat = createChatModel;
+  provider.embedding = createEmbeddingModel;
+  provider.embeddingModel = createEmbeddingModel;
+  provider.textEmbeddingModel = createEmbeddingModel;
+  provider.speech = (language, settings) => new KrutrimSpeechModel(language, settings ?? {}, {
+    ...sharedConfig,
+    provider: "krutrim.speech"
+  });
+  provider.transcription = (language) => new KrutrimTranscriptionModel(language, {
+    ...sharedConfig,
+    provider: "krutrim.transcription"
+  });
+  provider.languageDetection = () => new KrutrimLanguageDetectionModel({
+    ...sharedConfig,
+    provider: "krutrim.language-detection"
+  });
+  provider.translation = (settings) => new KrutrimTranslationModel(settings, {
+    ...sharedConfig,
+    provider: "krutrim.translation"
+  });
+  return provider;
+}
+var krutrim = createKrutrim();
+
+// src/indic/prompts.ts
+function languageLabel(code) {
+  const entry = INDIC_LANGUAGES.find((l) => l.code === code);
+  if (entry) {
+    return `${entry.name} (${entry.nativeName})`;
+  }
+  return code;
+}
+function indicResponsePrompt(language, options) {
+  const nativeScript = options?.nativeScript ?? true;
+  const allowCodeMix = options?.allowCodeMix ?? false;
+  const label = languageLabel(language);
+  return [
+    `You are a helpful assistant optimized for Indian languages and culture.`,
+    `Respond primarily in ${label}.`,
+    nativeScript ? `Prefer the language's native script over Latin transliteration unless the user writes in Latin script and clearly wants Romanized output.` : `Latin / Romanized script is acceptable when natural for the user.`,
+    allowCodeMix ? `Light code-mixing with English is fine when it matches how speakers actually talk.` : `Avoid unnecessary English code-mixing unless the user does so first.`,
+    `Be culturally aware of Indian context (festivals, geography, INR, regional nuance) without stereotyping.`
+  ].join(" ");
+}
+function languageDetectionPrompt() {
+  return [
+    "Identify the primary language of the user message.",
+    "Reply with ONLY a BCP-47 language tag such as hi-IN, ta-IN, en-IN, bn-IN, ml-IN.",
+    "If mixed, pick the dominant language. No explanation."
+  ].join(" ");
+}
+function transliterationNotes(targetLanguage) {
+  const target = targetLanguage ? ` When responding, prefer native script for ${languageLabel(targetLanguage)} unless asked otherwise.` : "";
+  return [
+    'Users may type Indian languages in Latin script (e.g. Hinglish: "aap kaise ho", Tanglish, etc.).',
+    "Interpret Romanized Indic phonetically; do not treat it as English only.",
+    "When the meaning is clear, reply in the same language; offer native script when helpful.",
+    target
+  ].join(" ").trim();
+}
+function indicSupportAgentPrompt(options) {
+  const brand = options?.brandName ?? "our service";
+  const langs = options?.languages?.map(languageLabel).join(", ") ?? "Hindi, English (India), and other major Indian languages";
+  return [
+    `You are a polite, efficient customer support agent for ${brand}.`,
+    `You can assist in: ${langs}.`,
+    `Mirror the customer's language and script when possible.`,
+    `Keep answers clear, short, and actionable. Amounts should use \u20B9 / INR when relevant.`,
+    `If you are unsure, ask a clarifying question instead of guessing personal data.`
+  ].join(" ");
+}
+
+exports.INDIC_LANGUAGES = INDIC_LANGUAGES;
+exports.KRUTRIM_CHAT_MODELS = KRUTRIM_CHAT_MODELS;
+exports.KRUTRIM_DEFAULT_API_HOST = KRUTRIM_DEFAULT_API_HOST;
+exports.KRUTRIM_DEFAULT_BASE_URL = KRUTRIM_DEFAULT_BASE_URL;
+exports.KRUTRIM_EMBEDDING_MODELS = KRUTRIM_EMBEDDING_MODELS;
+exports.KRUTRIM_SPEECH_MODELS = KRUTRIM_SPEECH_MODELS;
+exports.KRUTRIM_VISION_MODELS = KRUTRIM_VISION_MODELS;
+exports.MODEL_ALIASES = MODEL_ALIASES;
+exports.createKrutrim = createKrutrim;
+exports.enhanceKrutrimErrorMessage = enhanceKrutrimErrorMessage;
+exports.indicResponsePrompt = indicResponsePrompt;
+exports.indicSupportAgentPrompt = indicSupportAgentPrompt;
+exports.krutrim = krutrim;
+exports.krutrimErrorDataSchema = krutrimErrorDataSchema;
+exports.krutrimFailedResponseHandler = krutrimFailedResponseHandler;
+exports.languageDetectionPrompt = languageDetectionPrompt;
+exports.resolveKrutrimApiKey = resolveKrutrimApiKey;
+exports.resolveModelId = resolveModelId;
+exports.toBhashikLanguageCode = toBhashikLanguageCode;
+exports.toTranslationLanguageCode = toTranslationLanguageCode;
+exports.transliterationNotes = transliterationNotes;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map