@strapi-ai/translator 0.0.1

package/dist/server/index.mjs

@@ -0,0 +1,1217 @@
+import { createHash, createDecipheriv, randomBytes, createCipheriv } from "node:crypto";
+import { errors } from "@strapi/utils";
+import { OpenAI } from "openai";
+const DEFAULT_TRANSLATION_SYSTEM_PROMPT = "You are a CMS content translator. Output only the translated text, with no explanations, no quotes, and no metadata. Preserve formatting and markup exactly: Markdown, HTML, custom tags, links, images. Leave code blocks, URLs, query parameters, variables, and placeholders unchanged. Keep brand names, product names, and currency values in their original form. Translate meaning by meaning, using natural, concise wording and the standard terminology of the target locale.";
+const DEFAULT_TRANSLATION_CONFIG = {
+  apiKey: "",
+  baseUrl: "",
+  model: "",
+  fallbackModel: "",
+  systemPrompt: DEFAULT_TRANSLATION_SYSTEM_PROMPT,
+  temperature: 0.3,
+  maxTokens: 0,
+  concurrency: 3,
+  maxRetries: 3,
+  retryBaseDelayMs: 1e3,
+  retryMaxDelayMs: 3e4
+};
+const CONFIG_LIMITS = {
+  temperature: { min: 0, max: 2 },
+  maxTokens: { min: 0, max: 2e5 },
+  concurrency: { min: 1, max: 8 },
+  maxRetries: { min: 1, max: 10 },
+  retryBaseDelayMs: { min: 100, max: 6e4 },
+  retryMaxDelayMs: { min: 100, max: 3e5 }
+};
+const editableKeys = [
+  "baseUrl",
+  "model",
+  "fallbackModel",
+  "systemPrompt",
+  "temperature",
+  "maxTokens",
+  "concurrency",
+  "maxRetries",
+  "retryBaseDelayMs",
+  "retryMaxDelayMs"
+];
+const normalizeString = (value, fallback) => {
+  if (typeof value !== "string") {
+    return fallback;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : fallback;
+};
+const normalizeOptionalString = (value) => {
+  if (typeof value !== "string") {
+    return "";
+  }
+  return value.trim();
+};
+const toNumber = (value, fallback) => {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "string" && value.trim() !== "") {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : fallback;
+  }
+  return fallback;
+};
+const clamp = (value, min, max) => Math.min(Math.max(value, min), max);
+const normalizeNumber = (value, fallback, min, max) => clamp(toNumber(value, fallback), min, max);
+const normalizeInteger = (value, fallback, min, max) => Math.floor(normalizeNumber(value, fallback, min, max));
+const pickEditableTranslationConfig = (input) => {
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    return {};
+  }
+  return editableKeys.reduce((result, key) => {
+    if (Object.prototype.hasOwnProperty.call(input, key)) {
+      result[key] = input[key];
+    }
+    return result;
+  }, {});
+};
+const normalizeTranslationConfig = (input = {}) => {
+  const retryBaseDelayMs = normalizeInteger(
+    input.retryBaseDelayMs,
+    DEFAULT_TRANSLATION_CONFIG.retryBaseDelayMs,
+    CONFIG_LIMITS.retryBaseDelayMs.min,
+    CONFIG_LIMITS.retryBaseDelayMs.max
+  );
+  const retryMaxDelayMs = Math.max(
+    retryBaseDelayMs,
+    normalizeInteger(
+      input.retryMaxDelayMs,
+      DEFAULT_TRANSLATION_CONFIG.retryMaxDelayMs,
+      CONFIG_LIMITS.retryMaxDelayMs.min,
+      CONFIG_LIMITS.retryMaxDelayMs.max
+    )
+  );
+  return {
+    apiKey: normalizeOptionalString(input.apiKey),
+    baseUrl: normalizeString(input.baseUrl, DEFAULT_TRANSLATION_CONFIG.baseUrl),
+    model: normalizeString(input.model, DEFAULT_TRANSLATION_CONFIG.model),
+    fallbackModel: normalizeOptionalString(input.fallbackModel),
+    systemPrompt: normalizeString(input.systemPrompt, DEFAULT_TRANSLATION_CONFIG.systemPrompt),
+    temperature: normalizeNumber(
+      input.temperature,
+      DEFAULT_TRANSLATION_CONFIG.temperature,
+      CONFIG_LIMITS.temperature.min,
+      CONFIG_LIMITS.temperature.max
+    ),
+    maxTokens: normalizeInteger(
+      input.maxTokens,
+      DEFAULT_TRANSLATION_CONFIG.maxTokens,
+      CONFIG_LIMITS.maxTokens.min,
+      CONFIG_LIMITS.maxTokens.max
+    ),
+    concurrency: normalizeInteger(
+      input.concurrency,
+      DEFAULT_TRANSLATION_CONFIG.concurrency,
+      CONFIG_LIMITS.concurrency.min,
+      CONFIG_LIMITS.concurrency.max
+    ),
+    maxRetries: normalizeInteger(
+      input.maxRetries,
+      DEFAULT_TRANSLATION_CONFIG.maxRetries,
+      CONFIG_LIMITS.maxRetries.min,
+      CONFIG_LIMITS.maxRetries.max
+    ),
+    retryBaseDelayMs,
+    retryMaxDelayMs
+  };
+};
+const selectEditableTranslationConfig = (config2) => ({
+  baseUrl: config2.baseUrl,
+  model: config2.model,
+  fallbackModel: config2.fallbackModel,
+  systemPrompt: config2.systemPrompt,
+  temperature: config2.temperature,
+  maxTokens: config2.maxTokens,
+  concurrency: config2.concurrency,
+  maxRetries: config2.maxRetries,
+  retryBaseDelayMs: config2.retryBaseDelayMs,
+  retryMaxDelayMs: config2.retryMaxDelayMs
+});
+const normalizeEditableTranslationConfig = (input = {}) => selectEditableTranslationConfig(normalizeTranslationConfig(input));
+const maskSecret = (value) => {
+  if (!value) {
+    return "";
+  }
+  if (value.length <= 8) {
+    return "****";
+  }
+  return `********${value.slice(-4)}`;
+};
+const toPublicTranslationConfig = (config2) => ({
+  ...selectEditableTranslationConfig(config2),
+  apiKeyConfigured: config2.apiKey.length > 0,
+  apiKeyPreview: maskSecret(config2.apiKey)
+});
+const ALGORITHM = "aes-256-gcm";
+const IV_LENGTH = 12;
+const AUTH_TAG_LENGTH = 16;
+const VERSION_TAG = "v1";
+const deriveKey = (key) => {
+  if (!key || key.trim() === "") {
+    throw new Error("A non-empty secret key is required for the API key cipher.");
+  }
+  return createHash("sha256").update(key).digest();
+};
+const createSecretCipher = (config2) => {
+  const key = deriveKey(config2.key);
+  const encrypt = (plain) => {
+    if (!plain) return "";
+    const iv = randomBytes(IV_LENGTH);
+    const cipher = createCipheriv(ALGORITHM, key, iv);
+    const encrypted = Buffer.concat([cipher.update(plain, "utf8"), cipher.final()]);
+    const authTag = cipher.getAuthTag();
+    return [
+      VERSION_TAG,
+      iv.toString("base64"),
+      authTag.toString("base64"),
+      encrypted.toString("base64")
+    ].join(":");
+  };
+  const decrypt = (payload) => {
+    if (!payload) return "";
+    const parts = payload.split(":");
+    if (parts.length !== 4 || parts[0] !== VERSION_TAG) {
+      throw new Error("Cannot decrypt API key: unrecognized cipher payload format.");
+    }
+    const iv = Buffer.from(parts[1], "base64");
+    const authTag = Buffer.from(parts[2], "base64");
+    const encrypted = Buffer.from(parts[3], "base64");
+    if (iv.length !== IV_LENGTH || authTag.length !== AUTH_TAG_LENGTH) {
+      throw new Error("Cannot decrypt API key: cipher payload has wrong length.");
+    }
+    const decipher = createDecipheriv(ALGORITHM, key, iv);
+    decipher.setAuthTag(authTag);
+    const decrypted = Buffer.concat([decipher.update(encrypted), decipher.final()]);
+    return decrypted.toString("utf8");
+  };
+  return { encrypt, decrypt };
+};
+const PLUGIN_ID$1 = "ai-translator";
+const TRANSLATION_SETTINGS_STORE_KEY = "translation-settings";
+const resolveCipherKey = (strapi) => {
+  const strapiConfigGet = strapi.config?.get;
+  if (typeof strapiConfigGet === "function") {
+    const encryptionKey = strapiConfigGet.call(strapi.config, "admin.secrets.encryptionKey");
+    if (typeof encryptionKey === "string" && encryptionKey.trim() !== "") {
+      return encryptionKey;
+    }
+  }
+  if (typeof strapiConfigGet === "function") {
+    const appKeys = strapiConfigGet.call(strapi.config, "server.app.keys");
+    if (Array.isArray(appKeys) && typeof appKeys[0] === "string" && appKeys[0].trim() !== "") {
+      return appKeys[0];
+    }
+  }
+  throw new Error(
+    "AI Translator cannot persist API keys: configure ENCRYPTION_KEY or APP_KEYS in your Strapi environment."
+  );
+};
+const readNonSecretPluginConfig = (strapi, pluginId) => {
+  const pluginGetter = strapi.plugin;
+  const plugin = typeof pluginGetter === "function" ? pluginGetter.call(strapi, pluginId) : void 0;
+  const configGetter = plugin?.config;
+  const fromPluginConfig = {};
+  for (const key of Object.keys(DEFAULT_TRANSLATION_CONFIG)) {
+    if (key === "apiKey") {
+      continue;
+    }
+    if (typeof configGetter === "function") {
+      const value = configGetter.call(plugin, key);
+      if (value !== void 0) {
+        fromPluginConfig[key] = value;
+      }
+    }
+  }
+  if (Object.keys(fromPluginConfig).length > 0) {
+    return pickEditableTranslationConfig(fromPluginConfig);
+  }
+  const strapiConfigGetter = strapi.config?.get;
+  if (typeof strapiConfigGetter !== "function") {
+    return {};
+  }
+  const config2 = strapiConfigGetter.call(strapi.config, `plugin::${pluginId}`);
+  return pickEditableTranslationConfig(config2);
+};
+const readEncryptedStoredApiKey = (input) => {
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    return "";
+  }
+  const value = input.apiKey;
+  return typeof value === "string" ? value : "";
+};
+const readPlainApiKeyUpdate = (input) => {
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    return "";
+  }
+  const value = input.apiKey;
+  return typeof value === "string" ? value.trim() : "";
+};
+const createTranslationConfigRepository = (strapi, options = {}) => {
+  const pluginId = options.pluginId ?? PLUGIN_ID$1;
+  const storeKey = options.storeKey ?? TRANSLATION_SETTINGS_STORE_KEY;
+  const cipher = options.cipher ?? createSecretCipher({ key: resolveCipherKey(strapi) });
+  const getStore = () => strapi.store({
+    environment: strapi.config.environment,
+    type: "plugin",
+    name: pluginId
+  });
+  const getStoredConfig = async () => getStore().get({ key: storeKey });
+  const decryptStoredApiKey = (storedConfig) => {
+    const encrypted = readEncryptedStoredApiKey(storedConfig);
+    if (!encrypted) return "";
+    try {
+      return cipher.decrypt(encrypted);
+    } catch {
+      strapi.log?.warn?.(
+        "[ai-translator] Stored API key could not be decrypted (was ENCRYPTION_KEY or APP_KEYS rotated?). Re-save the API key in the plugin settings."
+      );
+      return "";
+    }
+  };
+  const getConfig = async () => {
+    const pluginConfig = readNonSecretPluginConfig(strapi, pluginId);
+    const storedConfig = await getStoredConfig();
+    const storedEditableConfig = pickEditableTranslationConfig(
+      storedConfig
+    );
+    return normalizeTranslationConfig({
+      ...DEFAULT_TRANSLATION_CONFIG,
+      ...pluginConfig,
+      ...storedEditableConfig,
+      apiKey: decryptStoredApiKey(storedConfig)
+    });
+  };
+  const getPublicConfig = async () => toPublicTranslationConfig(await getConfig());
+  const setEditableConfig = async (input) => {
+    const store = getStore();
+    const existingStoredConfig = await store.get({ key: storeKey });
+    const existing = pickEditableTranslationConfig(existingStoredConfig);
+    const updates = pickEditableTranslationConfig(input);
+    const existingEncryptedApiKey = readEncryptedStoredApiKey(existingStoredConfig);
+    const updatedPlainApiKey = readPlainApiKeyUpdate(input);
+    const clearApiKey = input?.apiKey === null;
+    const apiKeyCiphertext = clearApiKey ? "" : updatedPlainApiKey ? cipher.encrypt(updatedPlainApiKey) : existingEncryptedApiKey;
+    const value = normalizeEditableTranslationConfig({
+      ...existing,
+      ...updates
+    });
+    await store.set({
+      key: storeKey,
+      value: apiKeyCiphertext ? { ...value, apiKey: apiKeyCiphertext } : value
+    });
+    return getPublicConfig();
+  };
+  return {
+    getConfig,
+    getPublicConfig,
+    setEditableConfig
+  };
+};
+const SETTINGS_MANAGE_ACTION = {
+  section: "plugins",
+  displayName: "Manage settings",
+  uid: "settings.manage",
+  pluginName: PLUGIN_ID$1
+};
+const bootstrap = ({ strapi }) => {
+  const actionProvider = strapi.admin?.services?.permission?.actionProvider;
+  if (actionProvider && typeof actionProvider.registerMany === "function") {
+    actionProvider.registerMany([SETTINGS_MANAGE_ACTION]);
+  }
+};
+const NUMERIC_CONFIG_KEYS = [
+  "temperature",
+  "maxTokens",
+  "concurrency",
+  "maxRetries",
+  "retryBaseDelayMs",
+  "retryMaxDelayMs"
+];
+const config = {
+  default: () => selectEditableTranslationConfig(DEFAULT_TRANSLATION_CONFIG),
+  validator(config2) {
+    const normalized = normalizeEditableTranslationConfig(config2);
+    const invalidKeys = NUMERIC_CONFIG_KEYS.filter(
+      (key) => key in config2 && normalized[key] !== config2[key]
+    );
+    if (invalidKeys.length > 0) {
+      throw new Error(
+        `ai-translator plugin config has an invalid value for: ${invalidKeys.join(", ")}. Check config/plugins.(js|ts) for this plugin.`
+      );
+    }
+  }
+};
+const { ApplicationError } = errors;
+const PLUGIN_ID = "ai-translator";
+const writeSSE = (ctx, event) => {
+  ctx.res.write(`event: ${event.type}
+data: ${JSON.stringify(event)}
+
+`);
+};
+const getErrorMessage$1 = (error) => error instanceof Error ? error.message : String(error);
+const controllers$1 = ({ strapi }) => ({
+  async getConfig(ctx) {
+    const translationService = strapi.plugin(PLUGIN_ID).service("translation-session-service");
+    ctx.body = await translationService.getConfig();
+  },
+  async setConfig(ctx) {
+    const translationService = strapi.plugin(PLUGIN_ID).service("translation-session-service");
+    ctx.body = await translationService.updateConfig(ctx.request.body);
+  },
+  async listModels(ctx) {
+    const body = ctx.request.body || {};
+    const draft = {
+      apiKey: typeof body.apiKey === "string" ? body.apiKey : void 0,
+      baseUrl: typeof body.baseUrl === "string" ? body.baseUrl : void 0
+    };
+    try {
+      const translationService = strapi.plugin(PLUGIN_ID).service("translation-session-service");
+      ctx.body = {
+        models: await translationService.listModels(draft)
+      };
+    } catch (error) {
+      throw new ApplicationError(getErrorMessage$1(error));
+    }
+  },
+  async translate(ctx) {
+    const { contentType, entry, components, sourceLocale, targetLocale, include } = ctx.request.body ?? {};
+    if (!contentType || !entry || !targetLocale) {
+      throw new ApplicationError("Missing required parameters: contentType, entry, targetLocale");
+    }
+    ctx.res.writeHead(200, {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive"
+    });
+    const abortController = new AbortController();
+    ctx.req.on("close", () => abortController.abort());
+    const keepalive = setInterval(() => {
+      if (abortController.signal.aborted) return;
+      try {
+        ctx.res.write(": keepalive\n\n");
+      } catch {
+        abortController.abort();
+        clearInterval(keepalive);
+      }
+    }, 15e3);
+    try {
+      const translationService = strapi.plugin(PLUGIN_ID).service("translation-session-service");
+      const generator = translationService.createTranslationStream({
+        contentType,
+        entry,
+        components,
+        sourceLocale,
+        targetLocale,
+        include,
+        signal: abortController.signal
+      });
+      for await (const event of generator) {
+        if (abortController.signal.aborted) break;
+        writeSSE(ctx, event);
+      }
+    } catch (error) {
+      writeSSE(ctx, {
+        type: "session_failed",
+        error: getErrorMessage$1(error)
+      });
+    } finally {
+      clearInterval(keepalive);
+      ctx.res.end();
+    }
+  }
+});
+const controllers = {
+  translation: controllers$1
+};
+const settingsPolicies = [
+  {
+    name: "admin::hasPermissions",
+    config: { actions: ["plugin::ai-translator.settings.manage"] }
+  }
+];
+const adminRoutes = [
+  {
+    method: "POST",
+    path: "/translate",
+    handler: "translation.translate",
+    config: {
+      policies: []
+    }
+  },
+  {
+    method: "GET",
+    path: "/config",
+    handler: "translation.getConfig",
+    config: {
+      policies: []
+    }
+  },
+  {
+    method: "POST",
+    path: "/config",
+    handler: "translation.setConfig",
+    config: {
+      policies: settingsPolicies
+    }
+  },
+  {
+    method: "POST",
+    path: "/models",
+    handler: "translation.listModels",
+    config: {
+      policies: settingsPolicies
+    }
+  }
+];
+const routes = {
+  admin: {
+    type: "admin",
+    routes: adminRoutes
+  }
+};
+const escapeSegment = (segment) => segment.replace(/~/g, "~0").replace(/\./g, "~1").replace(/:/g, "~2");
+const encodeSegment = (segment) => {
+  if (typeof segment === "number") {
+    if (!Number.isInteger(segment) || segment < 0) {
+      throw new Error(`Invalid numeric path segment: ${segment}`);
+    }
+    return `n:${segment}`;
+  }
+  return `s:${escapeSegment(segment)}`;
+};
+const pathToId = (path) => path.map(encodeSegment).join(".");
+const sanitizeFieldPaths = (value) => {
+  if (!Array.isArray(value)) {
+    return void 0;
+  }
+  return value.filter(
+    (path) => Array.isArray(path) && path.length > 0 && path.every((segment) => typeof segment === "string" || typeof segment === "number")
+  );
+};
+const pathsEqual = (left, right) => left.length === right.length && left.every((segment, index2) => segment === right[index2]);
+const createEmptyTranslationPatch = () => ({
+  operations: []
+});
+const assembleTranslationPatch = (sourceUnits, translatedUnits) => {
+  const sourceById = new Map(sourceUnits.map((unit) => [unit.id, unit]));
+  return {
+    operations: translatedUnits.map((translatedUnit) => {
+      const sourceUnit = sourceById.get(translatedUnit.id);
+      if (!sourceUnit) {
+        throw new Error(`Translated unit does not match a source unit: ${translatedUnit.id}`);
+      }
+      if (!pathsEqual(sourceUnit.path, translatedUnit.path)) {
+        throw new Error(`Translated unit path mismatch: ${translatedUnit.id}`);
+      }
+      return {
+        unitId: sourceUnit.id,
+        path: sourceUnit.path,
+        value: translatedUnit.translatedText
+      };
+    })
+  };
+};
+const createTranslatableUnit = (input) => ({
+  id: pathToId(input.path),
+  path: [...input.path],
+  fieldName: input.fieldName,
+  fieldType: input.fieldType,
+  sourceValue: input.sourceValue,
+  encodedText: input.encodedText,
+  metadata: input.metadata ?? { schemaType: input.fieldType }
+});
+const createStringValueCodec = () => ({
+  fieldTypes: ["string", "text", "richtext"],
+  extract(value) {
+    if (typeof value !== "string" || value.trim().length === 0) return [];
+    return [
+      {
+        pathSuffix: [],
+        sourceValue: value,
+        encodedText: value
+      }
+    ];
+  }
+});
+const isPlainRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+const FORBIDDEN_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+const MAX_DEPTH = 64;
+const shouldTranslateStringLeaf = (fieldType, pathSuffix) => {
+  if (fieldType === "blocks") {
+    return pathSuffix[pathSuffix.length - 1] === "text";
+  }
+  return fieldType === "json";
+};
+const collectStringLeaves = (fieldType, value, pathSuffix = []) => {
+  if (pathSuffix.length > MAX_DEPTH) return [];
+  if (typeof value === "string") {
+    if (!value.trim() || !shouldTranslateStringLeaf(fieldType, pathSuffix)) return [];
+    return [
+      {
+        pathSuffix,
+        sourceValue: value,
+        encodedText: value
+      }
+    ];
+  }
+  if (Array.isArray(value)) {
+    return value.flatMap(
+      (item, index2) => collectStringLeaves(fieldType, item, [...pathSuffix, index2])
+    );
+  }
+  if (isPlainRecord(value)) {
+    return Object.entries(value).flatMap(
+      ([key, nestedValue]) => FORBIDDEN_KEYS.has(key) ? [] : collectStringLeaves(fieldType, nestedValue, [...pathSuffix, key])
+    );
+  }
+  return [];
+};
+const createStructuredValueCodec = (fieldType) => ({
+  fieldTypes: [fieldType],
+  extract(value) {
+    return collectStringLeaves(fieldType, value);
+  }
+});
+const createDefaultValueCodecs = () => [
+  createStringValueCodec(),
+  createStructuredValueCodec("blocks"),
+  createStructuredValueCodec("json")
+];
+const DEFAULT_EXCLUDE_FIELD_NAMES = [
+  "id",
+  "documentId",
+  "locale",
+  "createdAt",
+  "updatedAt",
+  "publishedAt",
+  "createdBy",
+  "updatedBy",
+  "slug",
+  "uid"
+];
+const isLocalized = (schema) => schema.pluginOptions?.i18n?.localized !== false;
+const MAX_SCHEMA_DEPTH = 32;
+const extractTranslatableUnits = (contentType, entry, components = {}, options = {}) => {
+  const units = [];
+  const excludeFieldNames = new Set(options.excludeFieldNames ?? DEFAULT_EXCLUDE_FIELD_NAMES);
+  const valueCodecs = options.valueCodecs ?? createDefaultValueCodecs();
+  const traverse = (schema, data, path = [], dynamicZoneComponent) => {
+    if (!data || path.length > MAX_SCHEMA_DEPTH) return;
+    for (const [fieldName, rawFieldSchema] of Object.entries(schema.attributes || {})) {
+      const fieldSchema = rawFieldSchema;
+      const value = data[fieldName];
+      if (value == null || excludeFieldNames.has(fieldName) || !isLocalized(fieldSchema)) continue;
+      const fieldPath = [...path, fieldName];
+      const fieldType = fieldSchema.type;
+      const valueCodec = valueCodecs.find((codec) => codec.fieldTypes.includes(fieldType));
+      if (valueCodec) {
+        const encodedUnits = valueCodec.extract(value);
+        for (const encodedUnit of encodedUnits) {
+          const unitPath = [...fieldPath, ...encodedUnit.pathSuffix];
+          const leaf = unitPath[unitPath.length - 1];
+          units.push(
+            createTranslatableUnit({
+              path: unitPath,
+              fieldName: typeof leaf === "string" ? leaf : fieldName,
+              fieldType,
+              sourceValue: encodedUnit.sourceValue,
+              encodedText: encodedUnit.encodedText,
+              metadata: {
+                schemaType: fieldSchema.type,
+                component: fieldSchema.component,
+                dynamicZoneComponent
+              }
+            })
+          );
+        }
+        if (encodedUnits.length > 0) continue;
+      }
+      if (fieldSchema.type === "component") {
+        const componentSchema = components[fieldSchema.component];
+        if (!componentSchema) continue;
+        if (fieldSchema.repeatable && Array.isArray(value)) {
+          value.forEach((item, index2) => {
+            traverse(componentSchema, item, [...fieldPath, index2]);
+          });
+        } else if (typeof value === "object") {
+          traverse(componentSchema, value, fieldPath);
+        }
+        continue;
+      }
+      if (fieldSchema.type === "dynamiczone" && Array.isArray(value)) {
+        value.forEach((item, index2) => {
+          const componentUid = item?.__component;
+          const componentSchema = componentUid ? components[componentUid] : void 0;
+          if (componentSchema) {
+            traverse(componentSchema, item, [...fieldPath, index2], componentUid);
+          }
+        });
+      }
+    }
+  };
+  traverse(contentType, entry);
+  return units;
+};
+class TranslationCredentialError extends Error {
+  constructor(message, options) {
+    super(message);
+    this.name = "TranslationCredentialError";
+    this.cause = options?.cause;
+  }
+}
+const RATE_LIMIT_STATUS = 429;
+const errorMessage = (error) => error instanceof Error ? error.message : String(error);
+const createSummary = (totalUnits, translatedUnits, failedUnitIds) => ({
+  totalUnits,
+  succeededUnits: translatedUnits.length,
+  failedUnits: failedUnitIds.length,
+  failedUnitIds
+});
+const isPathPrefix = (prefix, path) => prefix.length > 0 && prefix.length <= path.length && prefix.every((segment, index2) => segment === path[index2]);
+const filterUnits = (units, include) => include ? units.filter((unit) => include.some((prefix) => isPathPrefix(prefix, unit.path))) : units;
+async function* translateEntry(input) {
+  const units = filterUnits(
+    extractTranslatableUnits(input.contentType, input.entry, input.components ?? {}),
+    input.include
+  );
+  const translatedUnits = [];
+  const failedUnitIds = [];
+  yield {
+    type: "session_started",
+    sourceLocale: input.sourceLocale,
+    targetLocale: input.targetLocale,
+    totalUnits: units.length,
+    unitPaths: units.map((unit) => unit.path)
+  };
+  const pool = new AbortController();
+  const onAbort = () => pool.abort();
+  input.signal?.addEventListener("abort", onAbort, { once: true });
+  if (input.signal?.aborted) pool.abort();
+  const queue = [];
+  let wake;
+  const push = (event) => {
+    queue.push(event);
+    wake?.();
+    wake = void 0;
+  };
+  let credentialError;
+  let pauseUntil = 0;
+  const waitForDispatchWindow = async () => {
+    while (pauseUntil > Date.now() && !pool.signal.aborted) {
+      const delay = Math.min(500, pauseUntil - Date.now());
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+  };
+  const runUnit = async (unit) => {
+    push({ type: "unit_started", unit });
+    try {
+      let translatedText;
+      for await (const providerEvent of input.translator.translateUnit(
+        unit,
+        {
+          sourceLocale: input.sourceLocale,
+          targetLocale: input.targetLocale
+        },
+        pool.signal
+      )) {
+        if (providerEvent.type === "delta") {
+          push({
+            type: "unit_delta",
+            unitId: unit.id,
+            path: unit.path,
+            delta: providerEvent.delta,
+            content: providerEvent.content
+          });
+        } else if (providerEvent.type === "completed") {
+          translatedText = providerEvent.translatedText;
+        } else if (providerEvent.type === "retry_scheduled") {
+          if (providerEvent.status === RATE_LIMIT_STATUS) {
+            pauseUntil = Math.max(pauseUntil, Date.now() + providerEvent.delayMs);
+          }
+          push({
+            type: "unit_retry_scheduled",
+            unitId: unit.id,
+            path: unit.path,
+            attempt: providerEvent.attempt,
+            delayMs: providerEvent.delayMs,
+            reason: providerEvent.reason
+          });
+        } else {
+          push({
+            type: "unit_fallback_used",
+            unitId: unit.id,
+            path: unit.path,
+            fromModel: providerEvent.fromModel,
+            toModel: providerEvent.toModel,
+            reason: providerEvent.reason
+          });
+        }
+      }
+      if (translatedText === void 0) {
+        throw new Error(`Translator did not complete unit: ${unit.id}`);
+      }
+      translatedUnits.push({ id: unit.id, path: unit.path, translatedText });
+      push({ type: "unit_completed", unitId: unit.id, path: unit.path, translatedText });
+    } catch (error) {
+      if (pool.signal.aborted) return;
+      if (error instanceof TranslationCredentialError) {
+        credentialError ??= error;
+        pool.abort();
+        return;
+      }
+      failedUnitIds.push(unit.id);
+      push({ type: "unit_failed", unitId: unit.id, path: unit.path, error: errorMessage(error) });
+    }
+  };
+  let cursor = 0;
+  const worker = async () => {
+    while (!pool.signal.aborted) {
+      await waitForDispatchWindow();
+      if (pool.signal.aborted) return;
+      const unit = units[cursor++];
+      if (!unit) return;
+      await runUnit(unit);
+    }
+  };
+  const concurrency = Math.min(
+    Math.max(1, Math.floor(input.concurrency ?? 1)),
+    Math.max(1, units.length)
+  );
+  let settled = false;
+  const workers = Promise.all(Array.from({ length: concurrency }, () => worker())).finally(() => {
+    settled = true;
+    wake?.();
+    wake = void 0;
+  });
+  try {
+    while (!settled || queue.length > 0) {
+      const event = queue.shift();
+      if (event) {
+        yield event;
+      } else {
+        await new Promise((resolve) => {
+          wake = resolve;
+        });
+      }
+    }
+    await workers;
+  } finally {
+    input.signal?.removeEventListener("abort", onAbort);
+    pool.abort();
+  }
+  if (input.signal?.aborted) {
+    yield {
+      type: "session_aborted",
+      summary: createSummary(units.length, translatedUnits, failedUnitIds)
+    };
+    return;
+  }
+  if (credentialError) {
+    yield { type: "session_failed", error: errorMessage(credentialError) };
+    return;
+  }
+  const patch = translatedUnits.length > 0 ? assembleTranslationPatch(units, translatedUnits) : createEmptyTranslationPatch();
+  yield { type: "session_completed", patch, summary: createSummary(units.length, translatedUnits, failedUnitIds) };
+}
+const DEFAULT_RETRY_BASE_DELAY_MS = 1e3;
+const DEFAULT_RETRY_MAX_DELAY_MS = 3e4;
+const defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const abortableSleep = async (sleep, ms, signal) => {
+  if (!signal) {
+    return sleep(ms);
+  }
+  let onAbort;
+  try {
+    await Promise.race([
+      sleep(ms),
+      new Promise((resolve) => {
+        onAbort = () => resolve();
+        signal.addEventListener("abort", onAbort, { once: true });
+      })
+    ]);
+  } finally {
+    if (onAbort) {
+      signal.removeEventListener("abort", onAbort);
+    }
+  }
+};
+const getErrorMessage = (error) => error instanceof Error ? error.message : String(error);
+const retryDelay = (attempt, baseDelayMs, maxDelayMs) => Math.min(baseDelayMs * Math.pow(2, attempt - 1), maxDelayMs);
+const getStatusCode = (error) => {
+  if (!error || typeof error !== "object") return void 0;
+  const candidate = error;
+  const status = candidate.status ?? candidate.statusCode;
+  return typeof status === "number" ? status : void 0;
+};
+const classifyError = (error) => {
+  const status = getStatusCode(error);
+  if (status === 401 || status === 403) return "credential";
+  if (status === 400 || status === 404 || status === 422) return "request";
+  return "transient";
+};
+const buildMessages = (unit, context, systemPrompt) => [
+  {
+    role: "system",
+    content: [
+      systemPrompt,
+      `Target locale: ${context.targetLocale}.`,
+      context.sourceLocale ? `Source locale: ${context.sourceLocale}.` : "",
+      "Translate only the user-provided content.",
+      "Return only the translated content with no labels, wrappers, or explanation."
+    ].filter(Boolean).join(" ")
+  },
+  {
+    role: "user",
+    content: unit.encodedText
+  }
+];
+const createLLMTranslationProvider = (config2) => {
+  const sleep = config2.sleep ?? defaultSleep;
+  const retryBaseDelayMs = config2.retryBaseDelayMs ?? DEFAULT_RETRY_BASE_DELAY_MS;
+  const retryMaxDelayMs = config2.retryMaxDelayMs ?? DEFAULT_RETRY_MAX_DELAY_MS;
+  const maxRetries = Number.isFinite(config2.maxRetries) ? Math.max(1, config2.maxRetries) : 1;
+  async function* translateWithModel(unit, context, model, signal) {
+    let accumulated = "";
+    let finishReason = "unknown";
+    for await (const chunk of config2.client.streamCompletion({
+      model,
+      messages: buildMessages(unit, context, config2.systemPrompt),
+      temperature: config2.temperature,
+      maxTokens: config2.maxTokens && config2.maxTokens > 0 ? config2.maxTokens : void 0,
+      signal
+    })) {
+      if (chunk.delta) {
+        accumulated += chunk.delta;
+        yield {
+          type: "delta",
+          delta: chunk.delta,
+          content: accumulated
+        };
+      }
+      if (chunk.finishReason) {
+        finishReason = chunk.finishReason;
+      }
+    }
+    if (!accumulated.trim()) {
+      throw new Error("LLM returned empty translation");
+    }
+    if (finishReason === "length") {
+      throw new Error("LLM translation was truncated");
+    }
+    yield {
+      type: "completed",
+      translatedText: accumulated.trim()
+    };
+  }
+  async function* translateWithRetries(unit, context, model, signal) {
+    let lastError;
+    for (let attempt = 1; attempt <= maxRetries; attempt += 1) {
+      try {
+        yield* translateWithModel(unit, context, model, signal);
+        return;
+      } catch (error) {
+        lastError = error;
+        if (signal?.aborted) {
+          throw error;
+        }
+        if (classifyError(error) !== "transient") {
+          throw error;
+        }
+        if (attempt < maxRetries) {
+          const delayMs = retryDelay(attempt, retryBaseDelayMs, retryMaxDelayMs);
+          yield {
+            type: "retry_scheduled",
+            attempt,
+            delayMs,
+            reason: getErrorMessage(error),
+            status: getStatusCode(error)
+          };
+          await abortableSleep(sleep, delayMs, signal);
+          if (signal?.aborted) {
+            throw error;
+          }
+        }
+      }
+    }
+    throw lastError instanceof Error ? lastError : new Error(getErrorMessage(lastError));
+  }
+  async function* translateWithFallback(unit, context, signal) {
+    try {
+      yield* translateWithRetries(unit, context, config2.model, signal);
+    } catch (primaryError) {
+      if (!config2.fallbackModel || signal?.aborted || classifyError(primaryError) === "credential") {
+        throw primaryError;
+      }
+      yield {
+        type: "fallback_used",
+        fromModel: config2.model,
+        toModel: config2.fallbackModel,
+        reason: getErrorMessage(primaryError)
+      };
+      yield* translateWithRetries(unit, context, config2.fallbackModel, signal);
+    }
+  }
+  return {
+    async *translateUnit(unit, context, signal) {
+      try {
+        yield* translateWithFallback(unit, context, signal);
+      } catch (error) {
+        if (!signal?.aborted && classifyError(error) === "credential") {
+          throw new TranslationCredentialError(getErrorMessage(error), { cause: error });
+        }
+        throw error;
+      }
+    }
+  };
+};
+const SDK_MAX_RETRIES = 0;
+const REQUEST_TIMEOUT_MS$1 = 12e4;
+const createClient = (config2) => new OpenAI({
+  apiKey: config2.apiKey,
+  baseURL: config2.baseUrl,
+  maxRetries: SDK_MAX_RETRIES,
+  timeout: REQUEST_TIMEOUT_MS$1
+});
+const buildParams = (request) => {
+  const params = {
+    model: request.model,
+    messages: request.messages,
+    temperature: request.temperature,
+    stream: true
+  };
+  if (request.maxTokens && request.maxTokens > 0) {
+    params.max_tokens = request.maxTokens;
+  }
+  return params;
+};
+const createOpenAIChatCompletionClient = (config2) => {
+  const client = createClient(config2);
+  return {
+    async *streamCompletion(request) {
+      if (request.signal?.aborted) {
+        throw new Error("Chat completion aborted");
+      }
+      const params = buildParams(request);
+      const options = request.signal ? { signal: request.signal } : void 0;
+      const stream = options ? await client.chat.completions.create(params, options) : await client.chat.completions.create(params);
+      for await (const chunk of stream) {
+        if (request.signal?.aborted) {
+          throw new Error("Chat completion aborted");
+        }
+        const delta = chunk.choices?.[0]?.delta?.content || "";
+        const finishReason = chunk.choices?.[0]?.finish_reason || void 0;
+        if (delta || finishReason) {
+          yield { delta, finishReason };
+        }
+      }
+    }
+  };
+};
+const REQUEST_TIMEOUT_MS = 1e4;
+const normalizeBaseUrl = (baseUrl) => baseUrl.trim().replace(/\/+$/, "");
+const buildModelsUrl = (baseUrl) => `${normalizeBaseUrl(baseUrl)}/models`;
+const hasVersionSuffix = (baseUrl) => /\/v\d+$/.test(normalizeBaseUrl(baseUrl));
+const parseModels = (payload) => {
+  const items = payload && typeof payload === "object" && Array.isArray(payload.data) ? payload.data : [];
+  const seen = /* @__PURE__ */ new Set();
+  const models = [];
+  for (const item of items) {
+    if (!item || typeof item !== "object") {
+      continue;
+    }
+    const id = item.id;
+    if (typeof id !== "string" || id.trim() === "" || seen.has(id)) {
+      continue;
+    }
+    seen.add(id);
+    models.push({ id, label: id });
+  }
+  return models;
+};
+const listOpenAICompatibleModels = async (config2) => {
+  const fetchImpl = config2.fetch ?? globalThis.fetch;
+  if (!fetchImpl) {
+    throw new Error("Runtime fetch API is not available for loading provider models.");
+  }
+  let response;
+  try {
+    response = await fetchImpl(buildModelsUrl(config2.baseUrl), {
+      headers: {
+        Accept: "application/json",
+        Authorization: `Bearer ${config2.apiKey}`
+      },
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+    });
+  } catch (error) {
+    if (error instanceof Error && error.name === "TimeoutError") {
+      throw new Error(
+        `Provider did not respond within ${REQUEST_TIMEOUT_MS / 1e3}s. Check the base URL.`
+      );
+    }
+    throw error;
+  }
+  if (!response.ok) {
+    const base = `Failed to load provider models: ${response.status} ${response.statusText}`.trim();
+    const hint = response.status === 404 && !hasVersionSuffix(config2.baseUrl) ? ". Try appending /v1 to the base URL (most OpenAI-compatible APIs need a version segment)." : "";
+    throw new Error(`${base}${hint}`);
+  }
+  const models = parseModels(await response.json());
+  if (models.length === 0) {
+    throw new Error("Provider did not return any usable models.");
+  }
+  return models;
+};
+const getRegisteredSchema = (strapi, uid) => {
+  if (typeof uid !== "string" || uid.trim() === "") return void 0;
+  try {
+    const getModel = strapi.getModel;
+    const model = typeof getModel === "function" ? getModel.call(strapi, uid) : void 0;
+    return model && typeof model === "object" ? model : void 0;
+  } catch {
+    return void 0;
+  }
+};
+const reconcileAttributes = (clientSchema, registeredSchema) => {
+  const registeredAttributes = registeredSchema?.attributes;
+  if (!registeredAttributes || typeof clientSchema?.attributes !== "object") {
+    return clientSchema;
+  }
+  const attributes = {};
+  for (const [fieldName, clientField] of Object.entries(
+    clientSchema.attributes
+  )) {
+    const registeredField = registeredAttributes[fieldName];
+    attributes[fieldName] = registeredField && typeof registeredField === "object" ? { ...clientField, pluginOptions: registeredField.pluginOptions } : clientField;
+  }
+  return { ...clientSchema, attributes };
+};
+const reconcileContentTypeSchema = (strapi, contentType, components = {}) => {
+  const reconciledContentType = reconcileAttributes(
+    contentType,
+    getRegisteredSchema(strapi, contentType?.uid)
+  );
+  const reconciledComponents = {};
+  for (const [componentUid, componentSchema] of Object.entries(components)) {
+    reconciledComponents[componentUid] = reconcileAttributes(
+      componentSchema,
+      getRegisteredSchema(strapi, componentUid)
+    );
+  }
+  return { contentType: reconciledContentType, components: reconciledComponents };
+};
+const assertApiKeyConfigured = (config2) => {
+  if (!config2.apiKey) {
+    throw new Error(
+      "Translator API key is not configured. Configure an API key in the plugin settings."
+    );
+  }
+  if (!config2.baseUrl) {
+    throw new Error(
+      "Provider base URL is not configured. Set a base URL in the plugin settings."
+    );
+  }
+  if (!config2.model) {
+    throw new Error("Translation model is not configured. Select a model in the plugin settings.");
+  }
+};
+const createProvider = (config2, createChatClient, createTranslationProvider) => {
+  assertApiKeyConfigured(config2);
+  const client = createChatClient({
+    apiKey: config2.apiKey,
+    baseUrl: config2.baseUrl
+  });
+  return createTranslationProvider({
+    client,
+    model: config2.model,
+    fallbackModel: config2.fallbackModel || void 0,
+    systemPrompt: config2.systemPrompt,
+    temperature: config2.temperature,
+    maxTokens: config2.maxTokens,
+    maxRetries: config2.maxRetries,
+    retryBaseDelayMs: config2.retryBaseDelayMs,
+    retryMaxDelayMs: config2.retryMaxDelayMs
+  });
+};
+const createTranslationSessionService = (strapi, dependencies = {}) => {
+  const configRepository = dependencies.configRepository ?? createTranslationConfigRepository(strapi);
+  const createChatClient = dependencies.createChatClient ?? createOpenAIChatCompletionClient;
+  const createTranslationProvider = dependencies.createTranslationProvider ?? createLLMTranslationProvider;
+  const loadModels = dependencies.listModels ?? listOpenAICompatibleModels;
+  const listModels = async (draft) => {
+    const config2 = await configRepository.getConfig();
+    const draftApiKey = typeof draft?.apiKey === "string" ? draft.apiKey.trim() : "";
+    const draftBaseUrl = typeof draft?.baseUrl === "string" ? draft.baseUrl.trim() : "";
+    const effectiveBaseUrl = draftBaseUrl || config2.baseUrl;
+    const isSavedBaseUrl = draftBaseUrl.length === 0 || draftBaseUrl === config2.baseUrl;
+    const effectiveApiKey = draftApiKey || (isSavedBaseUrl ? config2.apiKey : "");
+    if (!effectiveBaseUrl) {
+      throw new Error("Provider base URL is not configured. Set a base URL in the plugin settings.");
+    }
+    if (!effectiveApiKey) {
+      throw new Error(
+        isSavedBaseUrl ? "Translator API key is not configured. Configure an API key in the plugin settings." : "An API key is required to list models for a base URL that differs from the saved configuration."
+      );
+    }
+    return loadModels({
+      apiKey: effectiveApiKey,
+      baseUrl: effectiveBaseUrl
+    });
+  };
+  const createTranslationStream = async function* (input) {
+    const config2 = await configRepository.getConfig();
+    const translator = createProvider(config2, createChatClient, createTranslationProvider);
+    const { contentType, components } = reconcileContentTypeSchema(
+      strapi,
+      input.contentType,
+      input.components
+    );
+    yield* translateEntry({
+      contentType,
+      entry: input.entry,
+      components,
+      sourceLocale: input.sourceLocale,
+      targetLocale: input.targetLocale,
+      translator,
+      signal: input.signal,
+      include: sanitizeFieldPaths(input.include),
+      concurrency: config2.concurrency
+    });
+  };
+  return {
+    getConfig: configRepository.getPublicConfig,
+    updateConfig: configRepository.setEditableConfig,
+    listModels,
+    createTranslationStream
+  };
+};
+const translationSessionService = ({ strapi }) => {
+  return createTranslationSessionService(strapi);
+};
+const services = {
+  "translation-session-service": translationSessionService
+};
+const index = {
+  register() {
+  },
+  bootstrap,
+  destroy() {
+  },
+  config,
+  controllers,
+  routes,
+  services,
+  contentTypes: {},
+  policies: {},
+  middlewares: {}
+};
+export {
+  index as default
+};