@tradejs/infra 1.0.5 → 1.0.8

package/dist/ai.mjs

@@ -0,0 +1,386 @@
+import {
+  mergeJsonlFiles,
+  toFileToken
+} from "./chunk-KVEZORMS.mjs";
+
+// src/aiDatasetFile.ts
+import { once } from "events";
+import { createWriteStream } from "fs";
+import fs from "fs/promises";
+import path from "path";
+import { createReadStream } from "fs";
+import readline from "readline";
+var DEFAULT_DIR = "data/ai/export";
+var AI_DATASET_WRITE_BATCH_SIZE = 100;
+var AI_MERGE_SORT_RUN_MAX_ROWS = 2e3;
+var AI_MERGE_SORT_RUN_MAX_BYTES = 16 * 1024 * 1024;
+var AI_CHUNK_FILE_RE = /^ai-dataset-(.+)-chunk-[^.]+\.jsonl$/;
+var writerByPath = /* @__PURE__ */ new Map();
+var getAiChunkFilePath = (strategyName, chunkId, outDir = DEFAULT_DIR) => path.join(
+  outDir,
+  `ai-dataset-${toFileToken(strategyName)}-chunk-${toFileToken(chunkId)}.jsonl`
+);
+var appendAiDatasetRow = async (params) => {
+  const { strategyName, chunkId, row, outDir = DEFAULT_DIR } = params;
+  const filePath = getAiChunkFilePath(strategyName, chunkId, outDir);
+  let state = writerByPath.get(filePath);
+  if (!state) {
+    await fs.mkdir(outDir, { recursive: true });
+    const stream = createWriteStream(filePath, {
+      encoding: "utf8",
+      flags: "a"
+    });
+    state = {
+      filePath,
+      stream,
+      buffer: [],
+      writeQueue: Promise.resolve(),
+      closed: false
+    };
+    writerByPath.set(filePath, state);
+  }
+  if (state.closed) {
+    throw new Error(`AI dataset writer is closed: ${filePath}`);
+  }
+  state.buffer.push(`${JSON.stringify(row)}
+`);
+  if (state.buffer.length >= AI_DATASET_WRITE_BATCH_SIZE) {
+    await flushAiDatasetWriter(filePath);
+  }
+  return filePath;
+};
+var flushState = async (state) => {
+  if (state.closed || state.buffer.length === 0) {
+    return;
+  }
+  const chunk = state.buffer.join("");
+  state.buffer = [];
+  if (!state.stream.write(chunk)) {
+    await once(state.stream, "drain");
+  }
+};
+var flushAiDatasetWriter = async (filePath) => {
+  const state = writerByPath.get(filePath);
+  if (!state || state.closed) {
+    return;
+  }
+  state.writeQueue = state.writeQueue.then(() => flushState(state));
+  await state.writeQueue;
+};
+var closeState = async (state) => {
+  if (state.closed) {
+    return;
+  }
+  await flushState(state);
+  state.closed = true;
+  state.stream.end();
+  await Promise.all([
+    once(state.stream, "finish"),
+    once(state.stream, "close")
+  ]);
+};
+var closeAiDatasetWriter = async (filePath) => {
+  const state = writerByPath.get(filePath);
+  if (!state) {
+    return;
+  }
+  state.writeQueue = state.writeQueue.then(() => closeState(state));
+  await state.writeQueue;
+  writerByPath.delete(filePath);
+};
+var closeAllAiDatasetWriters = async () => {
+  const filePaths = [...writerByPath.keys()];
+  for (const filePath of filePaths) {
+    await closeAiDatasetWriter(filePath);
+  }
+};
+var listAiChunkFiles = async (params) => {
+  const { strategyName, outDir = DEFAULT_DIR } = params;
+  const prefix = `ai-dataset-${toFileToken(strategyName)}-chunk-`;
+  let entries = [];
+  try {
+    entries = await fs.readdir(outDir);
+  } catch {
+    return [];
+  }
+  return entries.filter((name) => name.startsWith(prefix) && name.endsWith(".jsonl")).map((name) => path.join(outDir, name)).sort();
+};
+var listAiChunkStrategies = async (params) => {
+  const outDir = params?.outDir ?? DEFAULT_DIR;
+  let entries = [];
+  try {
+    entries = await fs.readdir(outDir);
+  } catch {
+    return [];
+  }
+  return [
+    ...new Set(
+      entries.map((name) => name.match(AI_CHUNK_FILE_RE)?.[1] || "").filter(Boolean)
+    )
+  ].sort();
+};
+var parseAiDatasetLine = (line, filePath) => {
+  try {
+    return JSON.parse(line);
+  } catch (error) {
+    const message = error?.message || String(error);
+    throw new Error(
+      `Failed to parse AI dataset row from ${filePath}: ${message}`
+    );
+  }
+};
+var getAiDatasetSortKey = (row) => {
+  const timestamp = Number(row.timestamp);
+  return {
+    timestamp: Number.isFinite(timestamp) ? timestamp : Number.MAX_SAFE_INTEGER,
+    symbol: String(row.symbol || ""),
+    signalId: String(row.signalId || "")
+  };
+};
+var compareAiDatasetSortKeys = (left, right) => {
+  if (left.timestamp !== right.timestamp) {
+    return left.timestamp - right.timestamp;
+  }
+  const symbolCompare = left.symbol.localeCompare(right.symbol);
+  if (symbolCompare !== 0) {
+    return symbolCompare;
+  }
+  return left.signalId.localeCompare(right.signalId);
+};
+var compareSortableAiDatasetLines = (left, right) => {
+  const keyCompare = compareAiDatasetSortKeys(left.sortKey, right.sortKey);
+  if (keyCompare !== 0) {
+    return keyCompare;
+  }
+  return left.sourceIndex - right.sourceIndex;
+};
+var compareSortedRunHeads = (left, right) => {
+  const keyCompare = compareAiDatasetSortKeys(left.sortKey, right.sortKey);
+  if (keyCompare !== 0) {
+    return keyCompare;
+  }
+  return left.runIndex - right.runIndex;
+};
+var writeJsonlLines = async (params) => {
+  const { filePath, lines } = params;
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  const stream = createWriteStream(filePath, { encoding: "utf8" });
+  const done = Promise.all([once(stream, "finish"), once(stream, "close")]);
+  try {
+    for (const line of lines) {
+      if (!stream.write(`${line}
+`)) {
+        await once(stream, "drain");
+      }
+    }
+  } finally {
+    stream.end();
+    await done;
+  }
+};
+var flushSortedRun = async (params) => {
+  const { tempDir, runIndex, entries } = params;
+  entries.sort(compareSortableAiDatasetLines);
+  const filePath = path.join(
+    tempDir,
+    `run-${String(runIndex).padStart(6, "0")}.jsonl`
+  );
+  await writeJsonlLines({
+    filePath,
+    lines: entries.map(({ line }) => line)
+  });
+  return filePath;
+};
+var readNextNonEmptyLine = async (iterator) => {
+  while (true) {
+    const next = await iterator.next();
+    if (next.done) {
+      return null;
+    }
+    const trimmed = String(next.value || "").trim();
+    if (trimmed) {
+      return trimmed;
+    }
+  }
+};
+var mergeSortedRuns = async (params) => {
+  const { runPaths, outPath } = params;
+  await fs.mkdir(path.dirname(outPath), { recursive: true });
+  const output = createWriteStream(outPath, { encoding: "utf8" });
+  const outputDone = Promise.all([
+    once(output, "finish"),
+    once(output, "close")
+  ]);
+  const heads = [];
+  try {
+    for (let runIndex = 0; runIndex < runPaths.length; runIndex += 1) {
+      const runPath = runPaths[runIndex];
+      const reader = readline.createInterface({
+        input: createReadStream(runPath, { encoding: "utf8" }),
+        crlfDelay: Infinity
+      });
+      const iterator = reader[Symbol.asyncIterator]();
+      const line = await readNextNonEmptyLine(iterator);
+      if (!line) {
+        reader.close();
+        continue;
+      }
+      heads.push({
+        runIndex,
+        line,
+        sortKey: getAiDatasetSortKey(parseAiDatasetLine(line, runPath)),
+        iterator,
+        reader
+      });
+    }
+    while (heads.length > 0) {
+      let bestIndex = 0;
+      for (let index = 1; index < heads.length; index += 1) {
+        if (compareSortedRunHeads(heads[index], heads[bestIndex]) < 0) {
+          bestIndex = index;
+        }
+      }
+      const best = heads[bestIndex];
+      if (!output.write(`${best.line}
+`)) {
+        await once(output, "drain");
+      }
+      const nextLine = await readNextNonEmptyLine(best.iterator);
+      if (!nextLine) {
+        best.reader.close();
+        heads.splice(bestIndex, 1);
+        continue;
+      }
+      best.line = nextLine;
+      best.sortKey = getAiDatasetSortKey(
+        parseAiDatasetLine(nextLine, runPaths[best.runIndex])
+      );
+    }
+  } finally {
+    for (const head of heads) {
+      head.reader.close();
+    }
+    output.end();
+    await outputDone;
+  }
+};
+var mergeAiJsonlFiles = async (params) => {
+  const {
+    filePaths,
+    outPath,
+    maxRowsInMemory = AI_MERGE_SORT_RUN_MAX_ROWS,
+    maxBytesInMemory = AI_MERGE_SORT_RUN_MAX_BYTES
+  } = params;
+  const tempDir = path.join(
+    path.dirname(outPath),
+    `.ai-merge-${path.basename(outPath)}-${Date.now()}-${process.pid}`
+  );
+  let batch = [];
+  let batchBytes = 0;
+  let sourceIndex = 0;
+  let runIndex = 0;
+  const runPaths = [];
+  const flushBatch = async () => {
+    if (!batch.length) {
+      return;
+    }
+    runPaths.push(
+      await flushSortedRun({
+        tempDir,
+        runIndex,
+        entries: batch
+      })
+    );
+    runIndex += 1;
+    batch = [];
+    batchBytes = 0;
+  };
+  try {
+    await fs.mkdir(tempDir, { recursive: true });
+    for (const filePath of filePaths) {
+      const reader = readline.createInterface({
+        input: createReadStream(filePath, { encoding: "utf8" }),
+        crlfDelay: Infinity
+      });
+      try {
+        for await (const line of reader) {
+          const trimmed = line.trim();
+          if (!trimmed) {
+            continue;
+          }
+          batch.push({
+            line: trimmed,
+            sortKey: getAiDatasetSortKey(parseAiDatasetLine(trimmed, filePath)),
+            sourceIndex
+          });
+          sourceIndex += 1;
+          batchBytes += Buffer.byteLength(trimmed, "utf8") + 1;
+          if (batch.length >= maxRowsInMemory || batchBytes >= maxBytesInMemory) {
+            await flushBatch();
+          }
+        }
+      } finally {
+        reader.close();
+      }
+    }
+    await flushBatch();
+    if (!runPaths.length) {
+      await fs.mkdir(path.dirname(outPath), { recursive: true });
+      await fs.writeFile(outPath, "", "utf8");
+      return;
+    }
+    await mergeSortedRuns({
+      runPaths,
+      outPath
+    });
+  } finally {
+    await fs.rm(tempDir, { recursive: true, force: true });
+  }
+};
+var readAiDatasetRows = async (params) => {
+  const { filePath, limitFromEnd = 0, skipFromEnd = 0 } = params;
+  const rows = [];
+  const recentLines = [];
+  let totalRows = 0;
+  const recentWindowLimit = limitFromEnd > 0 ? limitFromEnd + Math.max(0, skipFromEnd) : 0;
+  const reader = readline.createInterface({
+    input: createReadStream(filePath, { encoding: "utf8" }),
+    crlfDelay: Infinity
+  });
+  for await (const line of reader) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      continue;
+    }
+    totalRows += 1;
+    if (limitFromEnd > 0) {
+      if (recentLines.length === recentWindowLimit) {
+        recentLines.shift();
+      }
+      recentLines.push(trimmed);
+    } else {
+      const row = JSON.parse(trimmed);
+      rows.push(row);
+    }
+  }
+  const effectiveSkip = Math.max(0, skipFromEnd);
+  const selectedRecentLines = effectiveSkip > 0 ? recentLines.slice(0, Math.max(0, recentLines.length - effectiveSkip)) : recentLines;
+  const selectedRows = limitFromEnd > 0 ? selectedRecentLines.map((line) => JSON.parse(line)) : effectiveSkip > 0 ? rows.slice(0, Math.max(0, rows.length - effectiveSkip)) : rows;
+  return {
+    rows: selectedRows,
+    totalRows
+  };
+};
+export {
+  appendAiDatasetRow,
+  closeAiDatasetWriter,
+  closeAllAiDatasetWriters,
+  flushAiDatasetWriter,
+  getAiChunkFilePath,
+  listAiChunkFiles,
+  listAiChunkStrategies,
+  mergeAiJsonlFiles,
+  mergeJsonlFiles,
+  readAiDatasetRows,
+  toFileToken
+};

package/dist/aiEndpoints.d.mts

@@ -0,0 +1,10 @@
+type AiEndpointOption = {
+    label: string;
+    value: string;
+};
+declare const AI_CUSTOM_ENDPOINT_VALUE = "__custom__";
+declare const AI_ENDPOINT_OPTIONS: AiEndpointOption[];
+declare const normalizeAiEndpoint: (value: unknown) => string;
+declare const isKnownAiEndpoint: (value: unknown) => value is string;
+
+export { AI_CUSTOM_ENDPOINT_VALUE, AI_ENDPOINT_OPTIONS, type AiEndpointOption, isKnownAiEndpoint, normalizeAiEndpoint };

package/dist/aiEndpoints.d.ts

@@ -0,0 +1,10 @@
+type AiEndpointOption = {
+    label: string;
+    value: string;
+};
+declare const AI_CUSTOM_ENDPOINT_VALUE = "__custom__";
+declare const AI_ENDPOINT_OPTIONS: AiEndpointOption[];
+declare const normalizeAiEndpoint: (value: unknown) => string;
+declare const isKnownAiEndpoint: (value: unknown) => value is string;
+
+export { AI_CUSTOM_ENDPOINT_VALUE, AI_ENDPOINT_OPTIONS, type AiEndpointOption, isKnownAiEndpoint, normalizeAiEndpoint };

package/dist/aiEndpoints.js

@@ -0,0 +1,159 @@
+"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/aiEndpoints.ts
+var aiEndpoints_exports = {};
+__export(aiEndpoints_exports, {
+  AI_CUSTOM_ENDPOINT_VALUE: () => AI_CUSTOM_ENDPOINT_VALUE,
+  AI_ENDPOINT_OPTIONS: () => AI_ENDPOINT_OPTIONS,
+  isKnownAiEndpoint: () => isKnownAiEndpoint,
+  normalizeAiEndpoint: () => normalizeAiEndpoint
+});
+module.exports = __toCommonJS(aiEndpoints_exports);
+var AI_CUSTOM_ENDPOINT_VALUE = "__custom__";
+var AI_ENDPOINT_OPTIONS = [
+  {
+    label: "OpenAI",
+    value: "https://api.openai.com/v1"
+  },
+  {
+    label: "Claude",
+    value: "https://api.anthropic.com/v1"
+  },
+  {
+    label: "OpenRouter",
+    value: "https://openrouter.ai/api/v1"
+  },
+  {
+    label: "Gemini",
+    value: "https://generativelanguage.googleapis.com/v1beta/openai"
+  },
+  {
+    label: "Together AI",
+    value: "https://api.together.xyz/v1"
+  },
+  {
+    label: "Groq",
+    value: "https://api.groq.com/openai/v1"
+  },
+  {
+    label: "DeepInfra",
+    value: "https://api.deepinfra.com/v1/openai"
+  },
+  {
+    label: "xAI",
+    value: "https://api.x.ai/v1"
+  },
+  {
+    label: "Qwen (DashScope Intl)",
+    value: "https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
+  },
+  {
+    label: "Qwen (DashScope CN)",
+    value: "https://dashscope.aliyuncs.com/compatible-mode/v1"
+  },
+  {
+    label: "Qwen (DashScope US)",
+    value: "https://dashscope-us.aliyuncs.com/compatible-mode/v1"
+  },
+  {
+    label: "Perplexity",
+    value: "https://api.perplexity.ai"
+  },
+  {
+    label: "Fireworks",
+    value: "https://api.fireworks.ai/inference/v1"
+  },
+  {
+    label: "SambaNova",
+    value: "https://api.sambanova.ai/v1"
+  },
+  {
+    label: "Hyperbolic",
+    value: "https://api.hyperbolic.xyz/v1"
+  },
+  {
+    label: "Kimi",
+    value: "https://api.moonshot.ai/v1"
+  },
+  {
+    label: "ProxyAPI",
+    value: "https://openai.api.proxyapi.ru/v1"
+  },
+  {
+    label: "Custom",
+    value: AI_CUSTOM_ENDPOINT_VALUE
+  }
+];
+var KNOWN_AI_ENDPOINTS = new Set(
+  AI_ENDPOINT_OPTIONS.map((option) => option.value).filter(
+    (value) => value !== AI_CUSTOM_ENDPOINT_VALUE
+  )
+);
+var normalizeUrl = (value) => value.replace(/\/+$/, "");
+var isIpv4Address = (value) => /^(?:\d{1,3}\.){3}\d{1,3}$/.test(value.trim());
+var parseIpv4Address = (value) => value.trim().split(".").map((part) => Number(part));
+var isPrivateIpv4Address = (value) => {
+  if (!isIpv4Address(value)) {
+    return false;
+  }
+  const [a, b, c, d] = parseIpv4Address(value);
+  if ([a, b, c, d].some(
+    (part) => !Number.isInteger(part) || part < 0 || part > 255
+  )) {
+    return false;
+  }
+  return a === 10 || a === 127 || a === 0 || a === 169 && b === 254 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 168;
+};
+var isPrivateHostname = (hostname) => {
+  const normalized = hostname.trim().toLowerCase();
+  if (!normalized) {
+    return true;
+  }
+  return normalized === "localhost" || normalized.endsWith(".localhost") || normalized.endsWith(".local") || normalized.endsWith(".internal") || normalized.endsWith(".lan") || normalized === "::1" || normalized === "[::1]" || isPrivateIpv4Address(normalized);
+};
+var isValidAiEndpointUrl = (value) => {
+  try {
+    const url = new URL(value);
+    return url.protocol === "https:" && !isPrivateHostname(url.hostname);
+  } catch {
+    return false;
+  }
+};
+var normalizeAiEndpoint = (value) => {
+  if (typeof value !== "string") {
+    return "";
+  }
+  const trimmed = normalizeUrl(value.trim());
+  if (!trimmed) {
+    return "";
+  }
+  if (KNOWN_AI_ENDPOINTS.has(trimmed)) {
+    return trimmed;
+  }
+  return isValidAiEndpointUrl(trimmed) ? trimmed : "";
+};
+var isKnownAiEndpoint = (value) => KNOWN_AI_ENDPOINTS.has(normalizeAiEndpoint(value));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AI_CUSTOM_ENDPOINT_VALUE,
+  AI_ENDPOINT_OPTIONS,
+  isKnownAiEndpoint,
+  normalizeAiEndpoint
+});

package/dist/aiEndpoints.mjs

@@ -0,0 +1,12 @@
+import {
+  AI_CUSTOM_ENDPOINT_VALUE,
+  AI_ENDPOINT_OPTIONS,
+  isKnownAiEndpoint,
+  normalizeAiEndpoint
+} from "./chunk-XQ3YBULV.mjs";
+export {
+  AI_CUSTOM_ENDPOINT_VALUE,
+  AI_ENDPOINT_OPTIONS,
+  isKnownAiEndpoint,
+  normalizeAiEndpoint
+};

package/dist/aiLanguages.d.mts

@@ -0,0 +1,11 @@
+type AiResponseLanguageOption = {
+    label: string;
+    value: string;
+    promptName: string;
+};
+declare const AI_RESPONSE_LANGUAGE_OPTIONS: AiResponseLanguageOption[];
+declare const DEFAULT_AI_RESPONSE_LANGUAGE: string;
+declare const normalizeAiResponseLanguage: (value: unknown) => string;
+declare const getAiResponseLanguagePromptName: (value: unknown) => string;
+
+export { AI_RESPONSE_LANGUAGE_OPTIONS, type AiResponseLanguageOption, DEFAULT_AI_RESPONSE_LANGUAGE, getAiResponseLanguagePromptName, normalizeAiResponseLanguage };

package/dist/aiLanguages.d.ts

@@ -0,0 +1,11 @@
+type AiResponseLanguageOption = {
+    label: string;
+    value: string;
+    promptName: string;
+};
+declare const AI_RESPONSE_LANGUAGE_OPTIONS: AiResponseLanguageOption[];
+declare const DEFAULT_AI_RESPONSE_LANGUAGE: string;
+declare const normalizeAiResponseLanguage: (value: unknown) => string;
+declare const getAiResponseLanguagePromptName: (value: unknown) => string;
+
+export { AI_RESPONSE_LANGUAGE_OPTIONS, type AiResponseLanguageOption, DEFAULT_AI_RESPONSE_LANGUAGE, getAiResponseLanguagePromptName, normalizeAiResponseLanguage };

package/dist/aiLanguages.js

@@ -0,0 +1,71 @@
+"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/aiLanguages.ts
+var aiLanguages_exports = {};
+__export(aiLanguages_exports, {
+  AI_RESPONSE_LANGUAGE_OPTIONS: () => AI_RESPONSE_LANGUAGE_OPTIONS,
+  DEFAULT_AI_RESPONSE_LANGUAGE: () => DEFAULT_AI_RESPONSE_LANGUAGE,
+  getAiResponseLanguagePromptName: () => getAiResponseLanguagePromptName,
+  normalizeAiResponseLanguage: () => normalizeAiResponseLanguage
+});
+module.exports = __toCommonJS(aiLanguages_exports);
+var AI_RESPONSE_LANGUAGE_OPTIONS = [
+  { label: "English", value: "en", promptName: "English" },
+  { label: "Chinese", value: "zh", promptName: "Chinese" },
+  { label: "Hindi", value: "hi", promptName: "Hindi" },
+  { label: "Spanish", value: "es", promptName: "Spanish" },
+  { label: "French", value: "fr", promptName: "French" },
+  { label: "Arabic", value: "ar", promptName: "Arabic" },
+  { label: "Bengali", value: "bn", promptName: "Bengali" },
+  { label: "Portuguese", value: "pt", promptName: "Portuguese" },
+  { label: "Russian", value: "ru", promptName: "Russian" },
+  { label: "Urdu", value: "ur", promptName: "Urdu" },
+  { label: "Indonesian", value: "id", promptName: "Indonesian" },
+  { label: "German", value: "de", promptName: "German" },
+  { label: "Japanese", value: "ja", promptName: "Japanese" },
+  { label: "Swahili", value: "sw", promptName: "Swahili" },
+  { label: "Marathi", value: "mr", promptName: "Marathi" },
+  { label: "Telugu", value: "te", promptName: "Telugu" },
+  { label: "Turkish", value: "tr", promptName: "Turkish" },
+  { label: "Tamil", value: "ta", promptName: "Tamil" },
+  { label: "Vietnamese", value: "vi", promptName: "Vietnamese" },
+  { label: "Korean", value: "ko", promptName: "Korean" }
+];
+var KNOWN_AI_RESPONSE_LANGUAGES = new Set(
+  AI_RESPONSE_LANGUAGE_OPTIONS.map((option) => option.value)
+);
+var DEFAULT_AI_RESPONSE_LANGUAGE = AI_RESPONSE_LANGUAGE_OPTIONS[0].value;
+var normalizeAiResponseLanguage = (value) => {
+  if (typeof value !== "string") {
+    return DEFAULT_AI_RESPONSE_LANGUAGE;
+  }
+  const trimmed = value.trim().toLowerCase();
+  return KNOWN_AI_RESPONSE_LANGUAGES.has(trimmed) ? trimmed : DEFAULT_AI_RESPONSE_LANGUAGE;
+};
+var getAiResponseLanguagePromptName = (value) => AI_RESPONSE_LANGUAGE_OPTIONS.find(
+  (option) => option.value === normalizeAiResponseLanguage(value)
+)?.promptName ?? AI_RESPONSE_LANGUAGE_OPTIONS[0].promptName;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AI_RESPONSE_LANGUAGE_OPTIONS,
+  DEFAULT_AI_RESPONSE_LANGUAGE,
+  getAiResponseLanguagePromptName,
+  normalizeAiResponseLanguage
+});

package/dist/aiLanguages.mjs

@@ -0,0 +1,12 @@
+import {
+  AI_RESPONSE_LANGUAGE_OPTIONS,
+  DEFAULT_AI_RESPONSE_LANGUAGE,
+  getAiResponseLanguagePromptName,
+  normalizeAiResponseLanguage
+} from "./chunk-CCC7DX2T.mjs";
+export {
+  AI_RESPONSE_LANGUAGE_OPTIONS,
+  DEFAULT_AI_RESPONSE_LANGUAGE,
+  getAiResponseLanguagePromptName,
+  normalizeAiResponseLanguage
+};