@braze/sanity-plugin-ai-translation 0.2.22 → 0.2.24

package/dist/index.js

@@ -1,4 +1,4 @@
-import { useClient, defineType, defineField, pathToString, definePlugin } from "sanity";
+import { useClient, defineType, defineField, getPublishedId, pathToString, definePlugin } from "sanity";
 import { jsx, jsxs } from "react/jsx-runtime";
 import { ErrorOutlineIcon, CheckmarkCircleIcon, EmptyIcon, AddIcon, TrashIcon, WarningOutlineIcon, InfoOutlineIcon, ArrowLeftIcon, EditIcon, TranslateIcon, CheckmarkIcon, CircleIcon, ArrowRightIcon, PanelRightIcon } from "@sanity/icons";
 import { createContext, useContext, useEffect, useState, useReducer, useCallback, useMemo } from "react";
@@ -6,6 +6,7 @@ import { Card, Flex, Stack, Text, Spinner, Button, Box, Tooltip, Checkbox, Selec
 import { useListeningQuery, useOpenInNewPane } from "sanity-plugin-utils";
 import defaults from "lodash.defaults";
 import { toPlainText } from "@portabletext/react";
+import { uuid } from "@sanity/uuid";
 import cloneDeep from "lodash.clonedeep";
 import get from "lodash.get";
 import set from "lodash.set";
@@ -31,7 +32,7 @@ const TranslationContext = createContext({
       "useTranslationContext must be used within a TranslationContextProvider with document and config props"
     );
   return context;
-}, TRANSLATION_METADATA_TYPE = "translation.metadata", undraftId = (id) => id.replace(/^drafts\./, ""), draftId = (id) => `drafts.${undraftId(id)}`, TRANSLATION_METADATA_QUERY = "*[_type == $translationMetadataType && references($documentId)][0]", useTranslationMetadata = ({ documentId }) => {
+}, TRANSLATION_METADATA_TYPE = "translation.metadata", undraftId = (id) => id.replace(/^drafts\./, ""), TRANSLATION_METADATA_QUERY = "*[_type == $translationMetadataType && references($documentId)][0]", useTranslationMetadata = ({ documentId }) => {
   const { dispatch } = useTranslationContext(), { data, loading, error } = useListeningQuery(TRANSLATION_METADATA_QUERY, {
     params: {
       documentId: undraftId(documentId),
@@ -191,12 +192,7 @@ async function analyzeFeedback({
   currentDocument,
   onProgress
 }) {
-  devLog.info("Starting feedback analysis", {
-    sourceLanguage,
-    targetLanguage,
-    hasUserFeedback: !!userFeedback,
-    shouldIncludeEdits
-  }), onProgress?.({ stage: "analyzing", message: "Analyzing feedback and edits..." });
+  onProgress?.({ stage: "analyzing", message: "Analyzing feedback and edits..." });
   const analysisPrompt = buildAnalysisPrompt({
     sourceLanguage,
     targetLanguage,
@@ -205,10 +201,8 @@ async function analyzeFeedback({
     sourceSnapshot,
     targetSnapshot,
     currentDocument
-  }), analysis = await analyzeWithAI(client, analysisPrompt);
-  devLog.info("AI analysis complete", { analysis });
-  const suggestions = convertAnalysisToSuggestions(analysis, sourceLanguage, targetLanguage);
-  devLog.info("Generated suggestions", { count: suggestions.length }), onProgress?.({ stage: "analyzing", message: "Validating suggestions..." });
+  }), analysis = await analyzeWithAI(client, analysisPrompt), suggestions = convertAnalysisToSuggestions(analysis, sourceLanguage, targetLanguage);
+  onProgress?.({ stage: "analyzing", message: "Validating suggestions..." });
   const validatedSuggestions = await Promise.all(
     suggestions.map(async (suggestion) => {
       const validation = await validateSuggestion(client, suggestion);
@@ -221,7 +215,10 @@ async function analyzeFeedback({
       };
     })
   );
-  return devLog.info("Suggestions validated", {
+  return devLog.info("Feedback analysis complete", {
+    sourceLanguage,
+    targetLanguage,
+    total: validatedSuggestions.length,
     valid: validatedSuggestions.filter((s) => s.validationStatus === "valid").length,
     warnings: validatedSuggestions.filter((s) => s.validationStatus === "warning").length,
     invalid: validatedSuggestions.filter((s) => s.validationStatus === "invalid").length
@@ -235,24 +232,18 @@ async function applySuggestions({
   suggestions,
   onProgress
 }) {
-  if (devLog.info("Applying suggestions", {
-    sourceLanguage,
-    targetLanguage,
-    targetLanguageType: typeof targetLanguage,
-    targetLanguageValue: targetLanguage,
-    count: suggestions.filter((s) => s.approved).length
-  }), !targetLanguage)
+  if (!targetLanguage)
     throw devLog.error("targetLanguage is undefined in applySuggestions!", {
       sourceLanguage,
       targetLanguage,
       suggestionsCount: suggestions.length
     }), new Error("targetLanguage is required but was undefined");
   const approvedSuggestions = suggestions.filter((s) => s.approved);
-  if (approvedSuggestions.length === 0) {
-    devLog.info("No approved suggestions to apply");
-    return;
-  }
-  onProgress?.({ stage: "applying", message: "Applying updates to translation settings..." }), await applyImprovementsFromSuggestions(client, schemaId, targetLanguage, approvedSuggestions, onProgress), devLog.info("Suggestions applied successfully");
+  approvedSuggestions.length !== 0 && (onProgress?.({ stage: "applying", message: "Applying updates to translation settings..." }), await applyImprovementsFromSuggestions(client, schemaId, targetLanguage, approvedSuggestions, onProgress), devLog.info("Suggestions applied successfully", {
+    sourceLanguage,
+    targetLanguage,
+    count: approvedSuggestions.length
+  }));
 }
 function buildAnalysisPrompt({
   sourceLanguage,
@@ -470,49 +461,21 @@ function parseAIResponse(responseText) {
   }
 }
 async function applyImprovementsFromSuggestions(client, schemaId, targetLanguage, suggestions, onProgress) {
-  devLog.info("Applying improvements from suggestions", {
-    count: suggestions.length,
-    targetLanguage,
-    suggestions: suggestions.map((s) => ({
-      type: s.type,
-      approved: s.approved,
-      sourceLocale: s.sourceLocale,
-      targetLocale: s.targetLocale,
-      sourceValue: s.sourceValue,
-      targetValue: s.targetValue
-    }))
-  });
   const settingsId = "translation-settings";
   await client.fetch("*[_id == $id][0]", { id: settingsId }) || await client.createIfNotExists({
     _id: settingsId,
     _type: "translationSettings"
   });
-  const updates = [], globalPrompts = suggestions.filter((s) => s.type === "globalPrompt" && s.description.trim()), localePrompts = suggestions.filter((s) => s.type === "localePrompt" && s.description.trim()), protectedPhrases = suggestions.filter((s) => s.type === "protectedPhrase" && s.description.trim()), glossaryTermsBeforeFilter = suggestions.filter((s) => s.type === "glossaryTerm");
-  devLog.info("Glossary terms before filtering", {
-    count: glossaryTermsBeforeFilter.length,
-    terms: glossaryTermsBeforeFilter.map((s) => ({
-      sourceLocale: s.sourceLocale,
-      sourceValue: s.sourceValue,
-      targetLocale: s.targetLocale,
-      targetValue: s.targetValue,
-      approved: s.approved
-    }))
-  });
-  const glossaryTerms = suggestions.filter(
+  const updates = [], globalPrompts = suggestions.filter((s) => s.type === "globalPrompt" && s.description.trim()), localePrompts = suggestions.filter((s) => s.type === "localePrompt" && s.description.trim()), protectedPhrases = suggestions.filter((s) => s.type === "protectedPhrase" && s.description.trim()), glossaryTerms = suggestions.filter(
     (s) => s.type === "glossaryTerm" && s.sourceLocale?.trim() && s.sourceValue?.trim() && s.targetLocale?.trim() && s.targetValue?.trim()
   );
-  if (devLog.info("Filtered suggestions by type", {
-    globalPrompts: globalPrompts.length,
-    localePrompts: localePrompts.length,
-    protectedPhrases: protectedPhrases.length,
-    glossaryTerms: glossaryTerms.length
-  }), (globalPrompts.length > 0 || localePrompts.length > 0) && (onProgress?.({
+  if ((globalPrompts.length > 0 || localePrompts.length > 0) && (onProgress?.({
     stage: "applying",
     message: globalPrompts.length > 0 && localePrompts.length > 0 ? "Updating global and locale translation prompts..." : globalPrompts.length > 0 ? "Updating global translation prompt..." : `Updating ${targetLanguage} translation prompt...`
   }), updates.push(updatePromptsWithTemplate(client, schemaId, settingsId, targetLanguage, globalPrompts, localePrompts))), protectedPhrases.length > 0) {
     onProgress?.({ stage: "applying", message: "Adding protected phrases..." });
     const phrases = protectedPhrases.map((s) => s.description);
-    devLog.debug("Applying protected phrases", { phrases }), updates.push(addProtectedPhrases(client, settingsId, phrases));
+    updates.push(addProtectedPhrases(client, settingsId, phrases));
   }
   if (glossaryTerms.length > 0) {
     onProgress?.({ stage: "applying", message: "Adding glossary terms..." });
@@ -524,22 +487,17 @@ async function applyImprovementsFromSuggestions(client, schemaId, targetLanguage
       targetValue: s.targetValue
       // biome-ignore-end lint/style/noNonNullAssertion: safely handled
     }));
-    devLog.debug("Applying glossary terms", { terms }), updates.push(addGlossaryTerms(client, terms));
+    updates.push(addGlossaryTerms(client, terms));
   }
   updates.length === 0 && devLog.warn("No valid updates to apply - all suggestions may have been empty"), await Promise.all(updates), onProgress?.({ stage: "applying", message: "Recording changes..." }), await recordChangeHistory(
     client,
     settingsId,
     targetLanguage,
     suggestions.filter((s) => s.approved)
-  ), devLog.info("All improvements applied successfully");
+  );
 }
 async function updatePromptsWithTemplate(client, _schemaId, settingsId, targetLanguage, globalPrompts, localePrompts) {
-  if (devLog.info("Updating prompts with deterministic template", {
-    settingsId,
-    targetLanguage,
-    hasGlobalUpdates: globalPrompts.length > 0,
-    hasLocaleUpdates: localePrompts.length > 0
-  }), !targetLanguage)
+  if (!targetLanguage)
     throw devLog.error("targetLanguage is undefined or empty!", {
       targetLanguage,
       globalPrompts: globalPrompts.length,
@@ -555,11 +513,7 @@ async function updatePromptsWithTemplate(client, _schemaId, settingsId, targetLa
       ...updates.map((update) => `- ${update}`)
     ].filter(Boolean).join(`
 `);
-    await client.patch(settingsId).set({ globalPrompt: newGlobalPrompt }).commit(), devLog.info("Global prompt updated", {
-      previousLength: currentGlobalPrompt.length,
-      newLength: newGlobalPrompt.length,
-      addedUpdates: updates.length
-    });
+    await client.patch(settingsId).set({ globalPrompt: newGlobalPrompt }).commit();
   }
   if (localePrompts.length > 0) {
     const updates = localePrompts.map((s) => s.description.trim()).filter(Boolean), existingLocalePrompts = currentSettings?.localePrompts || [], existingLocalePrompt = existingLocalePrompts.find((lp) => lp._key === targetLanguage);
@@ -572,12 +526,7 @@ async function updatePromptsWithTemplate(client, _schemaId, settingsId, targetLa
         ...updates.map((update) => `- ${update}`)
       ].filter(Boolean).join(`
 `), localeIndex = existingLocalePrompts.findIndex((lp) => lp._key === targetLanguage);
-      await client.patch(settingsId).set({ [`localePrompts[${localeIndex}].value`]: newValue }).commit(), devLog.info("Locale prompt updated", {
-        targetLanguage,
-        previousLength: currentValue.length,
-        newLength: newValue.length,
-        addedUpdates: updates.length
-      });
+      await client.patch(settingsId).set({ [`localePrompts[${localeIndex}].value`]: newValue }).commit();
     } else {
       const newValue = [`## User Feedback (${timestamp})`, ...updates.map((update) => `- ${update}`)].filter(Boolean).join(`
 `);
@@ -587,22 +536,17 @@ async function updatePromptsWithTemplate(client, _schemaId, settingsId, targetLa
           _key: targetLanguage,
           value: newValue
         }
-      ]).commit(), devLog.info("Locale prompt created", {
-        targetLanguage,
-        length: newValue.length,
-        addedUpdates: updates.length
-      });
+      ]).commit();
     }
   }
   devLog.info("Prompts updated successfully", {
+    targetLanguage,
     globalUpdated: globalPrompts.length > 0,
     localeUpdated: localePrompts.length > 0
   });
 }
 async function addProtectedPhrases(client, settingsId, phrases) {
-  devLog.info("Adding protected phrases", { settingsId, phrasesCount: phrases.length, phrases });
   const currentPhrases = await client.fetch("*[_id == $settingsId][0].protectedPhrases", { settingsId });
-  devLog.debug("Fetched current protected phrases", { currentCount: currentPhrases?.length });
   let newPhrases = phrases.filter((phrase) => !currentPhrases?.includes(phrase));
   const conflictingPhrases = [];
   for (const phrase of newPhrases)
@@ -610,12 +554,7 @@ async function addProtectedPhrases(client, settingsId, phrases) {
       'count(*[_type == "translationGlossaryTerm" && count(translations[value == $phrase]) > 0]) > 0',
       { phrase }
     ) && (conflictingPhrases.push(phrase), devLog.warn("Skipping protected phrase due to glossary conflict", { phrase }));
-  if (newPhrases = newPhrases.filter((phrase) => !conflictingPhrases.includes(phrase)), newPhrases.length === 0) {
-    devLog.info("No new protected phrases to add (all already exist)");
-    return;
-  }
-  const result = await client.patch(settingsId).setIfMissing({ protectedPhrases: [] }).append("protectedPhrases", newPhrases).commit();
-  devLog.info("Protected phrases added", { count: newPhrases.length, phrases: newPhrases, resultId: result._id });
+  newPhrases = newPhrases.filter((phrase) => !conflictingPhrases.includes(phrase)), newPhrases.length !== 0 && (await client.patch(settingsId).setIfMissing({ protectedPhrases: [] }).append("protectedPhrases", newPhrases).commit(), devLog.info("Protected phrases added", { count: newPhrases.length }));
 }
 async function addGlossaryTerms(client, terms) {
   const protectedPhrasesLower = (await client.fetch('*[_id == "translation-settings"][0].protectedPhrases'))?.map((p) => p.toLowerCase()) || [], validTerms = terms.filter(({ sourceValue, targetValue }) => sourceValue === targetValue ? (devLog.warn("Skipping glossary term where source === target (should be a protected phrase)", {
@@ -643,29 +582,13 @@ async function addGlossaryTerms(client, terms) {
     );
     if (existingTerm) {
       const existingTargetIndex = existingTerm.translations.findIndex((t) => t._key === targetLocale), existingTargetValue = existingTargetIndex >= 0 ? existingTerm.translations[existingTargetIndex].value : null;
-      existingTargetIndex === -1 ? (await client.patch(existingTerm._id).append("translations", [
+      existingTargetIndex === -1 ? await client.patch(existingTerm._id).append("translations", [
         {
           _type: "internationalizedArrayStringValue",
           _key: targetLocale,
           value: targetValue
         }
-      ]).commit(), devLog.info("Added target language to existing glossary term", {
-        sourceLocale,
-        sourceValue,
-        targetLocale,
-        targetValue
-      })) : existingTargetValue !== targetValue ? (await client.patch(existingTerm._id).set({ [`translations[${existingTargetIndex}].value`]: targetValue }).commit(), devLog.info("Updated existing glossary term translation", {
-        sourceLocale,
-        sourceValue,
-        targetLocale,
-        oldValue: existingTargetValue,
-        newValue: targetValue
-      })) : devLog.info("Glossary term already has this exact translation", {
-        sourceLocale,
-        sourceValue,
-        targetLocale,
-        targetValue
-      });
+      ]).commit() : existingTargetValue !== targetValue && await client.patch(existingTerm._id).set({ [`translations[${existingTargetIndex}].value`]: targetValue }).commit();
     } else
       await client.create({
         _type: "translationGlossaryTerm",
@@ -681,11 +604,10 @@ async function addGlossaryTerms(client, terms) {
             value: targetValue
           }
         ]
-      }), devLog.info("Created new glossary term", { sourceLocale, sourceValue, targetLocale, targetValue });
+      });
   }
   devLog.info("Glossary terms processed", {
-    totalRequested: terms.length,
-    validAdded: validTerms.length,
+    processed: validTerms.length,
     skipped: terms.length - validTerms.length
   });
 }
@@ -698,10 +620,7 @@ async function recordChangeHistory(client, settingsId, targetLanguage, suggestio
     description: suggestion.description,
     locale: suggestion.type === "localePrompt" ? targetLanguage : void 0
   }));
-  historyEntries.length !== 0 && (await client.patch(settingsId).setIfMissing({ changeHistory: [] }).append("changeHistory", historyEntries).commit(), devLog.info("Change history recorded", {
-    count: historyEntries.length,
-    timestamp
-  }));
+  historyEntries.length !== 0 && await client.patch(settingsId).setIfMissing({ changeHistory: [] }).append("changeHistory", historyEntries).commit();
 }
 const ICON_SIZE = 64, progressIconMap = {
   in_progress: /* @__PURE__ */ jsx(Spinner, {}),
@@ -1227,8 +1146,8 @@ const ICON_SIZE = 64, progressIconMap = {
         references: action.payload
       };
     case "SET_TRANSLATION_JOB_STATUS": {
-      const jobKey = `${action.payload._id}_${action.payload.language}`, newTranslationJobs = new Map(context.translationJobs);
-      return newTranslationJobs.set(jobKey, defaults(action.payload, newTranslationJobs.get(jobKey))), {
+      const jobKey = `${action.payload._id}_${action.payload.language}`, newTranslationJobs = new Map(context.translationJobs), existingJob = newTranslationJobs.get(jobKey), mergedJob = defaults(action.payload, existingJob);
+      return newTranslationJobs.set(jobKey, mergedJob), {
         ...context,
         translationJobs: newTranslationJobs
       };
@@ -1755,7 +1674,12 @@ const fetchTranslationPrompts = async ({
     }
   };
   return recursiveSearch(obj, []), results;
-}, localizeReferences = async ({ client, documentId, languageFieldName }) => {
+}, localizeReferences = async ({
+  client,
+  documentId,
+  sourceLanguage,
+  languageFieldName
+}) => {
   try {
     const doc = await client.fetch("*[_id == $documentId][0]", { documentId });
     if (!doc) {
@@ -1777,25 +1701,25 @@ const fetchTranslationPrompts = async ({
     const refs = findKeyValues(doc, "_ref");
     if (!refs?.length)
       return;
-    await updateReferences(documentId, client, refs, targetLanguage);
+    await updateReferences(documentId, client, refs, sourceLanguage, targetLanguage);
   } catch (error) {
     devLog.error("Error localizing references", error instanceof Error ? error : new Error(String(error)), {
       documentId,
       component: "localizeReferences"
     });
   }
-}, updateReferences = async (documentId, client, refs, targetLanguage) => {
+}, updateReferences = async (documentId, client, refs, sourceLanguage, targetLanguage) => {
   if (!refs?.length)
     return [];
-  const refIds = refs.map((r) => undraftId(r.value)), translations = await client.fetch(
-    `*[_type == $translationMetadataSchemaType && count(translations[value._ref in $refIds]) > 0]
-      .translations[value._ref in $refIds]{
-        "sourceId": value._ref,
-        "targetId": ^.translations[_key == $targetLanguage][0].value._ref
-      }[defined(targetId)]`,
+  const refIds = refs.map((r) => getPublishedId(r.value)), translations = await client.fetch(
+    `*[_type == $translationMetadataSchemaType && array::intersects(translations[].value._ref, $refIds)] {
+      "sourceId": translations[_key == $sourceLanguage][0].value._ref,
+      "targetId": translations[_key == $targetLanguage][0].value._ref
+    }`,
     {
       translationMetadataSchemaType: TRANSLATION_METADATA_TYPE,
       refIds,
+      sourceLanguage,
       targetLanguage
     }
   ), translationMap = /* @__PURE__ */ new Map();
@@ -1804,13 +1728,8 @@ const fetchTranslationPrompts = async ({
   const patch = client.patch(documentId);
   let hasChanges = !1;
   for (const ref of refs) {
-    const sourceId = undraftId(ref.value), newId = translationMap.get(sourceId);
-    newId && (patch.set({ [pathToString(ref.path)]: undraftId(newId) }), patch.set({ [`${pathToString(ref.path.slice(0, -1))}._weak`]: !0 }), patch.set({
-      [`${pathToString(ref.path.slice(0, -1))}._strengthenOnPublish`]: {
-        _type: "reference",
-        _weak: !1
-      }
-    }), hasChanges = !0);
+    const sourceId = getPublishedId(ref.value), newId = translationMap.get(sourceId);
+    newId && (patch.set({ [pathToString(ref.path)]: getPublishedId(newId) }), hasChanges = !0);
   }
   hasChanges && (await patch.commit(), devLog.info("Updated references in batch", {
     documentId,
@@ -1833,7 +1752,9 @@ const fetchTranslationPrompts = async ({
         payload
       });
     }
-}, getTranslationMetadata = async ({
+}, getExistingTranslationId = (translationMetadata, targetLanguage) => translationMetadata?.translations?.length && translationMetadata.translations.find(
+  (translation) => translation._key === targetLanguage
+)?.value._ref || null, getTranslationMetadata = async ({
   client,
   sourceDocument,
   sourceLanguage
@@ -1882,7 +1803,7 @@ const fetchTranslationPrompts = async ({
       _type: "internationalizedArrayReferenceValue",
       value: {
         _type: "reference",
-        _ref: undraftId(newDocument._id),
+        _ref: getPublishedId(newDocument._id),
         _weak: !0,
         _strengthenOnPublish: {
           _type: "reference",
@@ -1892,7 +1813,7 @@ const fetchTranslationPrompts = async ({
     }, newTranslationHistory = {
       _key: targetLanguage,
       language: targetLanguage,
-      sourceId: undraftId(sourceDocument._id),
+      sourceId: getPublishedId(sourceDocument._id),
       sourceRev: sourceDocument._rev,
       sourceLanguage,
       sourceSnapshot: JSON.stringify(sourceDocument),
@@ -1922,70 +1843,51 @@ const fetchTranslationPrompts = async ({
       status
     })
   });
-}, getExistingTranslationId = (translationMetadata, targetLanguage) => translationMetadata?.translations?.length && translationMetadata.translations.find(
-  (translation) => translation._key === targetLanguage
-)?.value._ref || null, determineTranslationTarget = ({
-  translationMetadata,
-  targetLanguage
-}) => {
-  const existingTranslationId = getExistingTranslationId(translationMetadata, targetLanguage);
-  return existingTranslationId ? {
-    // Update existing translation
-    operation: "createOrReplace",
-    _id: existingTranslationId
-  } : {
-    // Create new translation
-    operation: "create"
-  };
-}, analyzeDocumentContent = (document) => {
-  let hasCodeBlocks = !1, hasInlineCode = !1, codeBlockCount = 0, inlineCodeCount = 0;
-  const hasMarkdown = !1;
-  let hasPortableText = !1, estimatedFieldCount = 0;
-  const traverse = (value, depth = 0) => {
-    value != null && (depth > 0 && typeof value == "object" && estimatedFieldCount++, Array.isArray(value) ? value.forEach((item) => {
-      item && typeof item == "object" && "_type" in item && item._type === "code" && (hasCodeBlocks = !0, codeBlockCount++, hasPortableText = !0), item && typeof item == "object" && "_type" in item && item._type === "block" && "children" in item && Array.isArray(item.children) && (hasPortableText = !0, item.children.forEach((child) => {
-        child && typeof child == "object" && "marks" in child && Array.isArray(child.marks) && child.marks.includes("code") && (hasInlineCode = !0, inlineCodeCount++);
-      })), traverse(item, depth + 1);
-    }) : typeof value == "object" && Object.values(value).forEach((val) => traverse(val, depth + 1)));
-  };
-  traverse(document);
-  let complexity = "simple";
-  return estimatedFieldCount > 50 ? complexity = "complex" : estimatedFieldCount > 20 && (complexity = "moderate"), {
-    hasCodeBlocks,
-    hasInlineCode,
-    codeBlockCount,
-    inlineCodeCount,
-    hasMarkdown,
-    hasPortableText,
-    complexity,
-    estimatedFieldCount
+}, callGPT5 = async (apiKey, request) => (request.model || "gpt-5") === "gpt-5" ? await callGPT5ResponsesAPI(apiKey, request) : await callChatCompletionsAPI(apiKey, request), callGPT5ResponsesAPI = async (apiKey, request) => {
+  const model = request.model || "gpt-5", requestBody = {
+    model,
+    input: request.messages
+    // Uses 'input' instead of 'messages'
   };
-}, assembleLanguageSpecs = ({
-  sourceDocument,
-  languageFieldName,
-  targetLanguage
-}) => {
-  const sourceLanugageId = sourceDocument[languageFieldName];
-  if (!sourceLanugageId)
-    throw new Error("[assembleLanguages] Source language ID is missing");
-  return {
-    fromLanguage: {
-      id: sourceLanugageId,
-      title: sourceLanugageId
+  request.reasoningEffort && (requestBody.reasoning = {
+    effort: request.reasoningEffort,
+    summary: "auto"
+    // Request reasoning summaries
+  });
+  const response = await fetch("https://api.openai.com/v1/responses", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`
     },
-    toLanguage: {
-      id: targetLanguage,
-      title: targetLanguage
-    }
+    body: JSON.stringify(requestBody)
+  });
+  if (!response.ok) {
+    const error = await response.json();
+    throw new Error(`GPT-5 API error: ${error.error?.message || "Unknown error"}`);
+  }
+  const result = await response.json(), tokensUsed = {
+    prompt: result.usage?.input_tokens || 0,
+    completion: result.usage?.output_tokens || 0,
+    reasoning: result.usage?.output_tokens_details?.reasoning_tokens || 0,
+    total: result.usage?.total_tokens || 0
+  }, cost = calculateCost(tokensUsed, model);
+  let content = "";
+  if (result.output && Array.isArray(result.output)) {
+    const messageItem = result.output.find((item) => item.type === "message");
+    messageItem?.content && Array.isArray(messageItem.content) && (content = messageItem.content.find((item) => item.type === "output_text")?.text || "");
+  }
+  return content || (content = result.output_text || result.text || ""), {
+    content,
+    tokensUsed,
+    cost
   };
-}, callGPT5 = async (apiKey, request) => {
-  const model = request.model || "gpt-5", isGPT5 = model === "gpt-5", useStreaming = !!request.onReasoningChunk, requestBody = {
+}, callChatCompletionsAPI = async (apiKey, request) => {
+  const model = request.model || "gpt-4o", requestBody = {
     model,
     messages: request.messages,
-    stream: useStreaming
-  };
-  isGPT5 || (requestBody.temperature = request.temperature ?? 0.3), isGPT5 && (requestBody.reasoning_effort = request.reasoningEffort || "medium", requestBody.verbosity = request.verbosity || "medium");
-  const response = await fetch("https://api.openai.com/v1/chat/completions", {
+    temperature: request.temperature ?? 0.3
+  }, response = await fetch("https://api.openai.com/v1/chat/completions", {
     method: "POST",
     headers: {
       "Content-Type": "application/json",
@@ -1995,88 +1897,30 @@ const fetchTranslationPrompts = async ({
   });
   if (!response.ok) {
     const error = await response.json();
-    throw new Error(`GPT-5 API error: ${error.error?.message || "Unknown error"}`);
+    throw new Error(`OpenAI API error: ${error.error?.message || "Unknown error"}`);
   }
-  if (useStreaming && response.body && request.onReasoningChunk)
-    return await handleStreamingResponse(response, request.onReasoningChunk, model);
   const result = await response.json(), usage = result.usage || {}, tokensUsed = {
     prompt: usage.prompt_tokens || 0,
     completion: usage.completion_tokens || 0,
     reasoning: usage.reasoning_tokens || 0,
-    // New in GPT-5
     total: usage.total_tokens || 0
-  }, cost = calculateGPT5Cost(tokensUsed, request.model || "gpt-5"), messageContent = result.choices[0].message.content;
-  let reasoningSummary, actualContent = messageContent;
-  const reasoningMatch = messageContent.match(/^<reasoning>([\s\S]*?)<\/reasoning>\n\n([\s\S]*)$/i);
-  return reasoningMatch && (reasoningSummary = reasoningMatch[1].trim(), actualContent = reasoningMatch[2]), {
-    content: actualContent,
-    tokensUsed,
-    cost,
-    reasoningSummary
-  };
-}, handleStreamingResponse = async (response, onReasoningChunk, model) => {
-  if (!response.body)
-    throw new Error("Response body is null");
-  const reader = response.body.getReader(), decoder = new TextDecoder();
-  let fullContent = "", inReasoning = !1, reasoningBuffer = "", contentBuffer = "", tokensUsed = { prompt: 0, completion: 0, reasoning: 0, total: 0 };
-  try {
-    for (; ; ) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      const lines = decoder.decode(value, { stream: !0 }).split(`
-`).filter((line) => line.trim() !== "");
-      for (const line of lines)
-        if (line.startsWith("data: ")) {
-          const data = line.slice(6);
-          if (data === "[DONE]") continue;
-          try {
-            const parsed = JSON.parse(data);
-            parsed.usage && (tokensUsed = {
-              prompt: parsed.usage.prompt_tokens || 0,
-              completion: parsed.usage.completion_tokens || 0,
-              reasoning: parsed.usage.reasoning_tokens || 0,
-              total: parsed.usage.total_tokens || 0
-            });
-            const delta = parsed.choices?.[0]?.delta?.content;
-            if (delta)
-              if (fullContent += delta, delta.includes("<reasoning>")) {
-                inReasoning = !0;
-                const parts = delta.split("<reasoning>");
-                reasoningBuffer += parts[1] || "";
-              } else if (delta.includes("</reasoning>")) {
-                inReasoning = !1;
-                const parts = delta.split("</reasoning>");
-                reasoningBuffer += parts[0] || "", contentBuffer += parts[1] || "";
-              } else inReasoning ? (reasoningBuffer += delta, onReasoningChunk(reasoningBuffer)) : contentBuffer += delta;
-          } catch {
-          }
-        }
-    }
-  } finally {
-    reader.releaseLock();
-  }
-  const cost = calculateGPT5Cost(tokensUsed, model);
+  }, cost = calculateCost(tokensUsed, model);
   return {
-    content: contentBuffer || fullContent,
+    content: result.choices[0].message.content || "",
     tokensUsed,
-    cost,
-    reasoningSummary: reasoningBuffer || void 0
+    cost
   };
-}, calculateGPT5Cost = (tokens, model) => {
+}, calculateCost = (tokens, model) => {
   const pricing = {
     "gpt-5": {
       input: 2e-6,
-      // $0.002 per 1k input tokens
       output: 1e-5,
-      // $0.010 per 1k output tokens
       reasoning: 5e-6
-      // $0.005 per 1k reasoning tokens
     },
     "gpt-4o": {
       input: 5e-6,
       output: 14999999999999999e-21,
       reasoning: 0
-      // No reasoning tokens in GPT-4
     },
     "gpt-4-turbo": {
       input: 1e-5,
@@ -2355,434 +2199,35 @@ const fetchTranslationPrompts = async ({
         type: "metadata_changed"
       }) : key !== "text" && validateStructureRecursive(origObj[key], modObj[key], [...path, key], errors));
   }
-}, assembleTranslationPrompt = (context, components) => {
-  const sections = [
-    {
-      id: "agentDirectives",
-      content: buildAgentDirectivesSection(context),
-      required: !0,
-      priority: 0
-    },
-    {
-      id: "criticalRules",
-      content: buildCriticalRulesSection(context),
-      required: !0,
-      priority: 1
-    }
-  ];
-  components.glossaryTerms?.trim() && sections.push({
-    id: "glossaryTerms",
-    content: buildGlossarySection(components.glossaryTerms),
-    required: !1,
-    priority: 3
-  });
-  const styleSection = buildStyleGuideSection(components.globalPrompt, components.localePrompt);
-  styleSection && sections.push({
-    id: "styleGuide",
-    content: styleSection,
-    required: !1,
-    priority: 4
-  }), sections.sort((a, b) => a.priority - b.priority);
-  let styleGuide = "";
-  const omittedSections = [], truncatedSections = [];
-  for (const section of sections) {
-    const prefix = styleGuide.length > 0 ? `
-
----
-
-` : "", availableCharacters = 2e3 - (styleGuide.length + prefix.length);
-    if (availableCharacters <= 0) {
-      if (section.required) {
-        const truncatedContent = truncateSection(section.content, 0);
-        truncatedContent && (styleGuide += prefix + truncatedContent, truncatedSections.push(section.id));
-      } else
-        omittedSections.push(section.id);
-      continue;
-    }
-    if (section.content.length <= availableCharacters) {
-      styleGuide += prefix + section.content;
-      continue;
-    }
-    if (section.required) {
-      const truncatedContent = truncateSection(section.content, availableCharacters);
-      styleGuide += prefix + truncatedContent, truncatedSections.push(section.id);
-    } else
-      omittedSections.push(section.id);
-  }
-  return {
-    styleGuide,
-    omittedSections,
-    truncatedSections
-  };
-}, truncateSection = (content, limit) => {
-  if (limit <= 0)
-    return "";
-  if (content.length <= limit)
-    return content;
-  if (limit <= 1)
-    return content.slice(0, limit);
-  const ellipsis = "\u2026";
-  if (limit <= ellipsis.length)
-    return content.slice(0, limit);
-  const sliceEnd = limit - ellipsis.length, sliced = content.slice(0, sliceEnd), trimmed = sliced.replace(/\s+\S*$/, "").trimEnd();
-  return `${trimmed.length >= sliceEnd / 2 ? trimmed : sliced}${ellipsis}`;
-}, buildAgentDirectivesSection = (context) => {
-  const { targetLanguage, sourceLanguage } = context;
-  return `# AGENT WORKFLOW DIRECTIVES
-
-- Use only the provided ${sourceLanguage || "the source language"} source; never fetch outside context.
-- Scan each field once, then move directly into translation work.
-- Plan updates before editing so document structure remains intact.
-- Default to medium reasoning effort and escalate only for ambiguous passages.
-- Output just the ${targetLanguage || "the target language"} translation and mirror the source formatting exactly.`;
-}, buildCriticalRulesSection = (context) => {
-  const { sourceLanguage, targetLanguage } = context, fromLanguage = sourceLanguage || "the source language", toLanguage = targetLanguage || "the target language";
-  return `# CRITICAL TRANSLATION RULES
-
-Follow these without exception:
-
-1. Translate from ${fromLanguage} into ${toLanguage}; every output token must be ${toLanguage} unless flagged as protected.
-2. Preserve meaning exactly\u2014no additions, deletions, or tone shifts.
-3. Maintain all layout, markdown, rich-text marks, and data structure.
-4. Never invent metadata or field values that are absent in the source.
-5. Leave technical tokens (code, IDs, filenames) untouched.
-6. Keep punctuation, casing, and spacing unless ${toLanguage} grammar forces a change.`;
-}, buildGlossarySection = (glossaryTerms) => `# TERMINOLOGY RULES
-
-Apply these mappings immediately after protected phrases and before style preferences.
-
-${glossaryTerms}`, buildStyleGuideSection = (globalPrompt, localePrompt) => {
-  const components = [];
-  return (globalPrompt || localePrompt) && (components.push("# TRANSLATION STYLE GUIDE (LOWEST PRIORITY)"), components.push(
-    "Apply these directions only after honoring critical rules, protected phrases, and glossary terminology."
-  ), components.push("")), globalPrompt && (components.push("## General Guidelines"), components.push(globalPrompt), components.push("")), localePrompt && (components.push("## Language-Specific Guidelines"), components.push(localePrompt)), components.length > 0 ? components.join(`
-`) : null;
-}, translateEntireDocument = async ({
+}, getOpenAITranslation = async ({
   dispatch,
-  client,
-  schemaId,
   sourceDocument,
-  targetLanguage,
   languageFieldName,
-  translationTarget,
   translationPrompts,
-  translationMode,
-  openaiConfig,
-  releaseId,
-  isNewTranslation
-}) => {
-  const logContext = {
-    documentId: sourceDocument._id,
-    targetLanguage,
-    schemaId,
-    operation: translationTarget.operation,
-    targetId: translationTarget._id,
-    translationMode,
-    releaseId,
-    isNewTranslation
-  };
-  devLog.group("translateEntireDocument", logContext), devLog.time("translateEntireDocument");
-  try {
-    let versionedDocumentId, baseDocumentId;
-    if (isNewTranslation) {
-      const { _id, _createdAt, _updatedAt, _rev, ...docWithoutMeta } = sourceDocument, newTranslationDoc = {
-        ...docWithoutMeta,
-        _type: sourceDocument._type,
-        [languageFieldName]: targetLanguage
-      };
-      devLog.info("Creating new translation document in release", logContext), baseDocumentId = translationTarget._id || `new-translation-${Date.now()}`, await client.action({
-        actionType: "sanity.action.document.version.create",
-        publishedId: baseDocumentId,
-        document: {
-          ...newTranslationDoc,
-          _type: sourceDocument._type,
-          _id: `versions.${releaseId}.${baseDocumentId}`
-        }
-      }), versionedDocumentId = `versions.${releaseId}.${baseDocumentId}`, devLog.info("New translation version created in release", {
-        ...logContext,
-        versionedDocumentId,
-        baseDocumentId
-      });
-    } else {
-      const existingTranslationId = translationTarget._id;
-      if (!existingTranslationId)
-        throw new Error("Translation target ID not found for update operation");
-      devLog.info("Creating version of existing translation in release", {
-        ...logContext,
-        existingTranslationId
-      });
-      let existingDoc = await client.getDocument(existingTranslationId), actualDocumentId = existingTranslationId;
-      if (!existingDoc) {
-        const alternateId = existingTranslationId.startsWith("drafts.") ? undraftId(existingTranslationId) : draftId(existingTranslationId);
-        devLog.info("Document not found with stored ID, trying alternate ID", {
-          ...logContext,
-          storedId: existingTranslationId,
-          alternateId
-        }), existingDoc = await client.getDocument(alternateId), existingDoc && (actualDocumentId = alternateId, devLog.info("Found document with alternate ID", {
-          ...logContext,
-          actualDocumentId
-        }));
-      }
-      if (!existingDoc)
-        throw new Error(
-          `Existing translation document not found: ${existingTranslationId} (also tried ${existingTranslationId.startsWith("drafts.") ? undraftId(existingTranslationId) : draftId(existingTranslationId)})`
-        );
-      const publishedId = undraftId(actualDocumentId);
-      await client.action({
-        actionType: "sanity.action.document.version.create",
-        publishedId,
-        document: {
-          ...existingDoc,
-          _id: `versions.${releaseId}.${publishedId}`
-        }
-      }), versionedDocumentId = `versions.${releaseId}.${publishedId}`, baseDocumentId = publishedId, devLog.info("Existing translation version created", {
-        ...logContext,
-        versionedDocumentId,
-        baseDocumentId
-      });
-      const { _id, _createdAt, _updatedAt, _rev, ...sourceContent } = sourceDocument;
-      await client.createOrReplace({
-        ...sourceContent,
-        _id: versionedDocumentId,
-        [languageFieldName]: targetLanguage
-      }), devLog.info("Source content cloned onto version", {
-        ...logContext,
-        versionedDocumentId
-      });
-    }
-    let translatedDocument;
-    switch (translationMode) {
-      case "openai-only": {
-        if (!openaiConfig?.enabled || !openaiConfig?.apiKey)
-          throw new Error("OpenAI is not configured but openai-only mode was selected");
-        devLog.info("Using OpenAI-only translation", logContext), setJobStatus(dispatch, sourceDocument._id, targetLanguage, "translating_with_openai");
-        const versionedDoc = await client.getDocument(versionedDocumentId);
-        if (!versionedDoc)
-          throw new Error(`Versioned document not found: ${versionedDocumentId}`);
-        const translatedDoc = await translateInPlaceWithOpenAI({
-          dispatch,
-          sourceDocument,
-          targetDocument: versionedDoc,
-          targetLanguage,
-          languageFieldName,
-          translationPrompts,
-          openaiConfig,
-          isReview: !1
-        });
-        translatedDoc && (translatedDocument = await client.createOrReplace({
-          ...translatedDoc,
-          _id: versionedDocumentId
-        }));
-        break;
-      }
-      case "sanity-with-review":
-        if (!openaiConfig?.enabled || !openaiConfig?.apiKey)
-          throw new Error("OpenAI is not configured but sanity-with-review mode was selected");
-        if (devLog.info("Using Sanity + OpenAI review", logContext), translatedDocument = await translateWithSanityAgent({
-          dispatch,
-          client,
-          schemaId,
-          sourceDocument,
-          targetLanguage,
-          languageFieldName,
-          versionedDocumentId,
-          translationPrompts
-        }), translatedDocument) {
-          setJobStatus(dispatch, sourceDocument._id, targetLanguage, "reviewing_with_openai");
-          const reviewedDoc = await translateInPlaceWithOpenAI({
-            dispatch,
-            sourceDocument,
-            targetDocument: translatedDocument,
-            targetLanguage,
-            languageFieldName,
-            translationPrompts,
-            openaiConfig,
-            isReview: !0
-          });
-          reviewedDoc && (translatedDocument = await client.createOrReplace({
-            ...reviewedDoc,
-            _id: versionedDocumentId
-          }));
-        }
-        break;
-      default:
-        devLog.info("Using Sanity-only translation", logContext), translatedDocument = await translateWithSanityAgent({
-          dispatch,
-          client,
-          schemaId,
-          sourceDocument,
-          targetLanguage,
-          languageFieldName,
-          versionedDocumentId,
-          translationPrompts
-        });
-        break;
-    }
-    return devLog.timeEnd("translateEntireDocument"), devLog.groupEnd(), translatedDocument ? {
-      ...translatedDocument,
-      _id: baseDocumentId
-    } : void 0;
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    devLog.error(
-      "translateEntireDocument failed",
-      error instanceof Error ? error : new Error(String(error)),
-      logContext
-    ), setJobStatus(dispatch, sourceDocument._id, targetLanguage, "error", {
-      errorMessage
-    }), devLog.timeEnd("translateEntireDocument"), devLog.groupEnd();
-    return;
-  }
-}, translateWithSanityAgent = async ({
-  dispatch,
-  client,
-  schemaId,
-  sourceDocument,
   targetLanguage,
-  languageFieldName,
-  versionedDocumentId,
-  translationPrompts
-}) => {
-  const logContext = {
-    documentId: sourceDocument._id,
-    targetLanguage,
-    versionedDocumentId
-  };
-  try {
-    const { toLanguage, fromLanguage } = assembleLanguageSpecs({
-      sourceDocument,
-      languageFieldName,
-      targetLanguage
-    });
-    devLog.debug("Language specs assembled", {
-      ...logContext,
-      toLanguage,
-      fromLanguage
-    });
-    const documentAnalysis = analyzeDocumentContent(sourceDocument);
-    devLog.debug("Document analysis completed", {
-      ...logContext,
-      analysis: documentAnalysis
-    }), devLog.info("Starting Sanity agent translation", logContext), setJobStatus(dispatch, sourceDocument._id, targetLanguage, "translating");
-    const { styleGuide, omittedSections, truncatedSections } = assembleTranslationPrompt(
-      {
-        documentAnalysis,
-        isUpdate: !1,
-        // Always fresh translation in a version
-        targetLanguage,
-        sourceLanguage: sourceDocument[languageFieldName]
-      },
-      {
-        globalPrompt: translationPrompts.globalPrompt,
-        localePrompt: translationPrompts.localeInstructions[targetLanguage]?.prompt,
-        glossaryTerms: translationPrompts.localeInstructions[targetLanguage]?.glossaryTerms,
-        protectedPhrases: translationPrompts.protectedPhrases
-      }
-    );
-    devLog.info("Structured style guide generated", {
-      ...logContext,
-      styleGuideLength: styleGuide.length,
-      omittedSections,
-      truncatedSections
-    }), (omittedSections.length > 0 || truncatedSections.length > 0) && devLog.warn("Style guide adjusted to fit character limit", {
-      ...logContext,
-      omittedSections,
-      truncatedSections
-    });
-    const newDocument = await client.agent.action.translate({
-      schemaId,
-      toLanguage,
-      fromLanguage,
-      documentId: versionedDocumentId,
-      // Use versioned document ID
-      languageFieldPath: [languageFieldName],
-      styleGuide,
-      protectedPhrases: translationPrompts.protectedPhrases || [],
-      conditionalPaths: {
-        defaultHidden: !1,
-        defaultReadOnly: !1
-      }
-    });
-    return devLog.info("Sanity agent translation completed", {
-      ...logContext,
-      newDocumentId: newDocument._id,
-      newDocumentRev: newDocument._rev
-    }), newDocument;
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    devLog.error(
-      "Sanity agent translation failed",
-      error instanceof Error ? error : new Error(String(error)),
-      logContext
-    ), setJobStatus(dispatch, sourceDocument._id, targetLanguage, "error", {
-      errorMessage
-    });
-    return;
-  }
-}, translateInPlaceWithOpenAI = async ({
-  dispatch,
-  sourceDocument,
-  targetDocument,
-  targetLanguage,
-  languageFieldName,
-  translationPrompts,
-  openaiConfig,
-  isReview
+  openaiConfig
 }) => {
   const sourceLanguage = sourceDocument[languageFieldName], logContext = {
     sourceId: sourceDocument._id,
-    targetId: targetDocument._id,
-    targetLanguage,
-    sourceLanguage,
-    isReview
+    sourceLanguage
   };
   try {
-    const sourceText = serializeDocument(sourceDocument), targetText = serializeDocument(targetDocument);
-    devLog.debug("Documents serialized for OpenAI", {
-      ...logContext,
-      sourceLength: sourceText.length,
-      targetLength: targetText.length
-    });
-    const prompt = isReview ? buildReviewPrompt({
+    const sourceText = serializeDocument(sourceDocument), prompt = buildTranslationPrompt$1({
       sourceText,
-      translatedText: targetText,
       sourceLanguage,
       targetLanguage,
       translationPrompts
-    }) : buildTranslationPrompt({
-      sourceText,
-      sourceLanguage,
-      targetLanguage,
-      translationPrompts
-    });
-    devLog.debug("Calling GPT-5", {
-      ...logContext,
-      promptLength: prompt.length
-    });
-    const response = await callGPT5(openaiConfig.apiKey, {
+    }), response = await callGPT5(openaiConfig.apiKey, {
       messages: [
         {
-          role: "system",
-          content: isReview ? "You are a translation quality reviewer. Review and refine translations while preserving structure." : "You are a professional translator. Translate documents while preserving their exact structure."
+          role: "developer",
+          content: "You are a translation quality reviewer. Review and refine translations while preserving structure."
         },
         { role: "user", content: prompt }
       ],
       model: openaiConfig.model,
-      reasoningEffort: openaiConfig.reasoningEffort,
-      verbosity: openaiConfig.verbosity,
-      onReasoningChunk: (reasoning) => {
-        const status2 = isReview ? "reviewing_with_openai" : "translating_with_openai";
-        setJobStatus(dispatch, sourceDocument._id, targetLanguage, status2, {
-          reasoningProgress: reasoning
-        });
-      }
-    });
-    devLog.info("OpenAI operation completed", {
-      ...logContext,
-      tokensUsed: response.tokensUsed.total,
-      cost: response.cost
-    });
-    const result = deserializeDocument(targetDocument, response.content), validation = validateStructureIntegrity(targetDocument, result);
+      reasoningEffort: openaiConfig.reasoningEffort
+    }), result = deserializeDocument(sourceDocument, response.content), validation = validateStructureIntegrity(sourceDocument, result);
     if (!validation.valid) {
       devLog.error("Structure validation failed", {
         ...logContext,
@@ -2796,17 +2241,14 @@ ${glossaryTerms}`, buildStyleGuideSection = (globalPrompt, localePrompt) => {
           `Structure validation failed: ${unexpectedErrors.length} errors. First: ${unexpectedErrors[0].type} at ${unexpectedErrors[0].path.join(".")}`
         );
     }
-    devLog.info("Structure validation passed", logContext);
-    const status = isReview ? "reviewing_with_openai" : "translating_with_openai";
-    return setJobStatus(dispatch, sourceDocument._id, targetLanguage, status, {
+    return setJobStatus(dispatch, sourceDocument._id, targetLanguage, "translating_with_openai", {
       tokensUsed: response.tokensUsed.total,
-      estimatedCost: response.cost,
-      reasoningSummary: response.reasoningSummary
+      estimatedCost: response.cost
     }), result;
   } catch (error) {
     throw devLog.error("OpenAI translation failed", error instanceof Error ? error : new Error(String(error)), logContext), error;
   }
-}, buildTranslationPrompt = ({
+}, buildTranslationPrompt$1 = ({
   sourceText,
   sourceLanguage,
   targetLanguage,
@@ -2853,73 +2295,175 @@ Brief summary of key translation decisions and reasoning
 </reasoning>
 
 Then return the translated document:`;
-}, buildReviewPrompt = ({
-  sourceText,
-  translatedText,
+}, assembleLanguageSpecs = ({
+  sourceDocument,
+  languageFieldName,
+  targetLanguage
+}) => {
+  const sourceLanugageId = sourceDocument[languageFieldName];
+  if (!sourceLanugageId)
+    throw new Error("[assembleLanguages] Source language ID is missing");
+  return {
+    fromLanguage: {
+      id: sourceLanugageId,
+      title: sourceLanugageId
+    },
+    toLanguage: {
+      id: targetLanguage,
+      title: targetLanguage
+    }
+  };
+}, buildTranslationPrompt = ({
   sourceLanguage,
   targetLanguage,
-  translationPrompts
+  components,
+  isUpdate = !1
 }) => {
-  const { globalPrompt, localeInstructions, protectedPhrases } = translationPrompts, localePrompt = localeInstructions[targetLanguage]?.prompt, glossaryTerms = localeInstructions[targetLanguage]?.glossaryTerms;
-  return `# TRANSLATION QUALITY REVIEW
-
-Review this ${targetLanguage} translation and return a corrected version.
+  const sections = [];
+  sections.push(buildAgentDirectivesSection(sourceLanguage, targetLanguage)), sections.push(buildCriticalRulesSection(sourceLanguage, targetLanguage)), isUpdate && sections.push(buildUpdateInstructionsSection()), components.glossaryTerms?.trim() && sections.push(buildGlossarySection(components.glossaryTerms)), components.protectedPhrases?.length && sections.push(buildProtectedPhrasesSection(components.protectedPhrases));
+  const styleSection = buildStyleGuideSection(components.globalPrompt, components.localePrompt);
+  return styleSection && sections.push(styleSection), sections.join(`
 
-## Review Criteria
+---
 
-1. **Accuracy**: Does it accurately convey the ${sourceLanguage} source meaning?
-2. **Terminology**: Are glossary terms used correctly?
-3. **Protected Phrases**: Are protected phrases preserved?
-4. **Fluency**: Is it natural and fluent in ${targetLanguage}?
-5. **Style**: Does it follow the style guide?
-6. **Completeness**: Is all content translated?
+`);
+}, buildAgentDirectivesSection = (sourceLanguage, targetLanguage) => `# AGENT WORKFLOW DIRECTIVES
 
-## Guidelines
+- Use only the provided ${sourceLanguage || "the source language"} source; never fetch outside context.
+- Scan each field once, then move directly into translation work.
+- Plan updates before editing so document structure remains intact.
+- Default to medium reasoning effort and escalate only for ambiguous passages.
+- Output just the ${targetLanguage || "the target language"} translation and mirror the source formatting exactly.`, buildCriticalRulesSection = (sourceLanguage, targetLanguage) => {
+  const fromLanguage = sourceLanguage || "the source language", toLanguage = targetLanguage || "the target language";
+  return `# CRITICAL TRANSLATION RULES
 
-${globalPrompt ? `### General Guidelines
-${globalPrompt}
-` : ""}
-${localePrompt ? `### ${targetLanguage} Guidelines
-${localePrompt}
-` : ""}
-${glossaryTerms ? `### Required Terminology
-${glossaryTerms}
-` : ""}
-${protectedPhrases?.length ? `### Protected Phrases (must preserve)
-${protectedPhrases.join(", ")}
-` : ""}
+Follow these without exception:
 
-## Source Document (${sourceLanguage})
+1. Translate from ${fromLanguage} into ${toLanguage}; every output token must be ${toLanguage} unless flagged as protected.
+2. Preserve meaning exactly\u2014no additions, deletions, or tone shifts.
+3. Maintain all layout, markdown, rich-text marks, and data structure.
+4. Never invent metadata or field values that are absent in the source.
+5. Leave technical tokens (code, IDs, filenames) untouched.
+6. Keep punctuation, casing, and spacing unless ${toLanguage} grammar forces a change.`;
+}, buildUpdateInstructionsSection = () => `# UPDATING EXISTING TRANSLATION
 
-\`\`\`
-${sourceText}
-\`\`\`
+This document already has a translation; only adjust fields that changed.
 
-## Current Translation (${targetLanguage})
+- Compare the latest source to the existing target text.
+- Keep prior terminology and style unless the source demands a change.
+- Edit minimally while guaranteeing accuracy and completeness.`, buildGlossarySection = (glossaryTerms) => `# TERMINOLOGY RULES
 
-\`\`\`
-${translatedText}
-\`\`\`
+Apply these mappings immediately after protected phrases and before style preferences.
 
-## Instructions
+${glossaryTerms}`, buildProtectedPhrasesSection = (protectedPhrases) => `# PROTECTED PHRASES
 
-1. Review the translation for quality issues
-2. Make corrections where needed to improve accuracy, fluency, or adherence to guidelines
-3. Keep good translations as-is - only fix what needs fixing
-4. Return the corrected translation in THE EXACT SAME FORMAT
-5. **CRITICAL**: Only modify text content between tags
-6. Never add, remove, or change any tags, attributes, or structure
-
-If you made corrections or have insights about the translation quality, include a brief summary:
-<reasoning>
-Brief summary of review findings and corrections made
-</reasoning>
+These phrases must NEVER be translated. Keep them exactly as they appear:
 
-Then return the corrected translation document:`;
+${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localePrompt) => {
+  const components = [];
+  return (globalPrompt || localePrompt) && (components.push("# TRANSLATION STYLE GUIDE (LOWEST PRIORITY)"), components.push(
+    "Apply these directions only after honoring critical rules, protected phrases, and glossary terminology."
+  ), components.push("")), globalPrompt && (components.push("## General Guidelines"), components.push(globalPrompt), components.push("")), localePrompt && (components.push("## Language-Specific Guidelines"), components.push(localePrompt)), components.length > 0 ? components.join(`
+`) : null;
+}, getSanityAgentTranslation = async ({
+  sourceDocument,
+  targetLanguage,
+  languageFieldName,
+  schemaId,
+  client,
+  translationPrompts
+}) => {
+  const styleGuide = buildTranslationPrompt({
+    sourceLanguage: sourceDocument[languageFieldName],
+    targetLanguage,
+    isUpdate: !1,
+    // Always fresh translation in a version
+    components: {
+      globalPrompt: translationPrompts.globalPrompt,
+      localePrompt: translationPrompts.localeInstructions[targetLanguage]?.prompt,
+      glossaryTerms: translationPrompts.localeInstructions[targetLanguage]?.glossaryTerms,
+      protectedPhrases: translationPrompts.protectedPhrases
+    }
+  }), { fromLanguage, toLanguage } = assembleLanguageSpecs({
+    sourceDocument,
+    languageFieldName,
+    targetLanguage
+  });
+  return await client.agent.action.translate({
+    schemaId,
+    toLanguage,
+    fromLanguage,
+    documentId: sourceDocument._id,
+    noWrite: !0,
+    // Do not write to the document, just return the translated content
+    languageFieldPath: [languageFieldName],
+    styleGuide,
+    protectedPhrases: translationPrompts.protectedPhrases,
+    conditionalPaths: {
+      defaultHidden: !1,
+      defaultReadOnly: !1
+    }
+  });
+}, handleTranslation = async ({
+  dispatch,
+  client,
+  schemaId,
+  sourceDocument,
+  targetLanguage,
+  existingTranslationId,
+  languageFieldName,
+  translationPrompts,
+  translationMode,
+  openaiConfig,
+  releaseId
+}) => {
+  let translatedDoc;
+  switch (translationMode) {
+    case "sanity-only": {
+      setJobStatus(dispatch, sourceDocument._id, targetLanguage, "translating"), translatedDoc = await getSanityAgentTranslation({
+        sourceDocument,
+        targetLanguage,
+        languageFieldName,
+        schemaId,
+        client,
+        translationPrompts
+      });
+      break;
+    }
+    case "openai-only": {
+      if (!openaiConfig?.enabled || !openaiConfig?.apiKey)
+        throw new Error("OpenAI is not configured but openai-only mode was selected");
+      setJobStatus(dispatch, sourceDocument._id, targetLanguage, "translating_with_openai"), translatedDoc = await getOpenAITranslation({
+        dispatch,
+        sourceDocument,
+        targetLanguage,
+        languageFieldName,
+        translationPrompts,
+        openaiConfig
+      });
+      break;
+    }
+    case "sanity-with-review":
+      throw new Error("Sanity with review translation method is not implemented");
+    default:
+      throw new Error(`Invalid translation mode: ${translationMode}`);
+  }
+  if (!translatedDoc)
+    return null;
+  const targetDocumentPublishedId = existingTranslationId || uuid(), targetDocumentVersionId = `versions.${releaseId}.${targetDocumentPublishedId}`, newDoc = {
+    ...translatedDoc,
+    _id: targetDocumentVersionId
+  };
+  return await client.action({
+    actionType: "sanity.action.document.version.create",
+    publishedId: targetDocumentPublishedId,
+    document: newDoc
+  }), newDoc;
 }, translateDocument = async ({
   dispatch,
   client,
   sourceDocument,
+  sourceLanguage,
   targetLanguage,
   languageFieldName,
   shouldOverwriteFreshTranslations,
@@ -2938,62 +2482,37 @@ Then return the corrected translation document:`;
   };
   devLog.group("translateDocument", logContext), devLog.time("translateDocument"), setJobStatus(dispatch, sourceDocument._id, targetLanguage, "preparing_translation");
   try {
-    const sourceLanguage = sourceDocument[languageFieldName];
-    if (devLog.debug("Checking source document language", {
-      ...logContext,
-      sourceLanguage,
-      languageFieldName
-    }), !sourceLanguage) {
-      const error = `Source document ${sourceDocument._id} does not have a language`;
-      throw devLog.error(error, void 0, logContext), new Error(error);
-    }
-    devLog.debug("Getting translation metadata", logContext);
     const translationMetadata = await getTranslationMetadata({
       client,
       sourceDocument,
       sourceLanguage
     }), isAlreadyFreshTranslation = translationMetadata.translationHistory?.some(
       (history) => history.language === targetLanguage && history.sourceRev === sourceDocument._rev
-    ) ?? !1;
-    if (devLog.debug("Checking if translation is already fresh", {
-      ...logContext,
-      isAlreadyFreshTranslation,
-      currentRev: sourceDocument._rev
-    }), !shouldOverwriteFreshTranslations && isAlreadyFreshTranslation) {
-      devLog.info("Skipping fresh translation", logContext), setJobStatus(dispatch, sourceDocument._id, targetLanguage, "skipped", {
+    );
+    if (!shouldOverwriteFreshTranslations && isAlreadyFreshTranslation) {
+      setJobStatus(dispatch, sourceDocument._id, targetLanguage, "skipped", {
         targetId: translationMetadata.translations.find((t) => t._key === targetLanguage)?.value._ref
-      }), devLog.timeEnd("translateDocument"), devLog.groupEnd();
+      });
       return;
     }
-    const translationTarget = determineTranslationTarget({
-      translationMetadata,
-      targetLanguage
-    }), isNewTranslation = translationTarget.operation === "create";
-    devLog.debug("Translation target determined", {
-      ...logContext,
-      operation: translationTarget.operation,
-      isNewTranslation
-    });
-    const newDocument = await translateEntireDocument({
+    const existingTranslationId = getExistingTranslationId(translationMetadata, targetLanguage), newDocument = await handleTranslation({
       dispatch,
       client,
       schemaId,
       sourceDocument,
       targetLanguage,
+      existingTranslationId,
       languageFieldName,
-      translationTarget,
       translationPrompts,
       translationMode,
       openaiConfig,
-      releaseId,
-      isNewTranslation
+      releaseId
     });
-    if (!newDocument)
-      throw devLog.error("Failed to create translation document", void 0, logContext), setJobStatus(dispatch, sourceDocument._id, targetLanguage, "error"), devLog.timeEnd("translateDocument"), devLog.groupEnd(), new Error("Failed to create translation document");
-    return devLog.debug("Translation document created", {
-      ...logContext,
-      newDocumentId: newDocument._id
-    }), devLog.debug("Updating translation metadata", logContext), setJobStatus(dispatch, sourceDocument._id, targetLanguage, "updating_metadata", {
+    if (!newDocument) {
+      setJobStatus(dispatch, sourceDocument._id, targetLanguage, "error"), devLog.timeEnd("translateDocument"), devLog.groupEnd();
+      return;
+    }
+    return setJobStatus(dispatch, sourceDocument._id, targetLanguage, "updating_metadata", {
       targetId: newDocument._id
     }), await updateTranslationMetadata({
       client,
@@ -3002,8 +2521,10 @@ Then return the corrected translation document:`;
       newDocument,
       targetLanguage,
       translationMetadata,
-      isNewTranslation
-    }), setJobStatus(dispatch, sourceDocument._id, targetLanguage, "completed"), devLog.info("Translation completed successfully", {
+      isNewTranslation: !existingTranslationId
+    }), setJobStatus(dispatch, sourceDocument._id, targetLanguage, "completed", {
+      targetId: newDocument._id
+    }), devLog.info("Translation completed successfully", {
       ...logContext,
       newDocumentId: newDocument._id
     }), devLog.timeEnd("translateDocument"), devLog.groupEnd(), newDocument._id;
@@ -3029,40 +2550,32 @@ Then return the corrected translation document:`;
 }) => {
   const logContext = {
     documentId: sourceDocument._id,
+    documentRev: sourceDocument._rev,
     targetLanguages,
     referencesCount: references.length,
     maxConcurrentJobs: maxConcurrentTranslationJobs,
     translationMode,
     shouldOverwriteFreshTranslations
   };
-  devLog.group("translateDocumentSet", logContext), devLog.time("translateDocumentSet");
   let releaseId;
   try {
     const sourceLanguage = sourceDocument[languageFieldName];
     if (!sourceLanguage)
       throw devLog.error("Source language not found"), new Error("Source language not found");
-    maxConcurrentTranslationJobs && (devLog.debug("Updating translation semaphore permits", {
-      ...logContext,
-      newPermits: maxConcurrentTranslationJobs
-    }), translationSemaphore.updatePermits(maxConcurrentTranslationJobs)), devLog.info("Starting document set translation", logContext), dispatch({
+    maxConcurrentTranslationJobs && translationSemaphore.updatePermits(maxConcurrentTranslationJobs), dispatch({
       type: "SET_OVERALL_STATUS",
       payload: "translating"
     });
-    const releaseTitle = `[AI Translation] ${sourceDocument.title || sourceDocument._id.split("-").slice(0, 2).join("-")} (${sourceDocument._type}) ${sourceLanguage} \u2192 ${targetLanguages.join(", ")}`, releaseDescription = `AI translation batch created on ${(/* @__PURE__ */ new Date()).toLocaleDateString()} at ${(/* @__PURE__ */ new Date()).toLocaleTimeString()}`;
-    devLog.info("Creating Content Release for translation batch", {
-      ...logContext,
-      releaseTitle
-    });
-    const { releaseId: newReleaseId } = await client.releases.create({
+    const releaseTitle = `[AI Translation] ${sourceDocument.title || sourceDocument._id.split("-").slice(0, 2).join("-")} (${sourceDocument._type}) ${sourceLanguage} \u2192 ${targetLanguages.join(", ")}`, releaseDescription = `AI translation batch created on ${(/* @__PURE__ */ new Date()).toLocaleDateString()} at ${(/* @__PURE__ */ new Date()).toLocaleTimeString()}`, { releaseId: releaseId2 } = await client.releases.create({
       metadata: {
         title: releaseTitle,
         description: releaseDescription,
-        releaseType: "asap"
+        releaseType: "undecided"
       }
     });
-    releaseId = newReleaseId, devLog.info("Content Release created", {
+    devLog.info("Content Release created", {
       ...logContext,
-      releaseId
+      releaseId: releaseId2
     });
     const sourceDocuments = [
       {
@@ -3072,34 +2585,26 @@ Then return the corrected translation document:`;
         title: sourceDocument.name || sourceDocument.title
       },
       ...references
-    ], sourceDocumentIds = sourceDocuments.map((doc) => doc._id), targetDocumentIds = [];
-    devLog.debug("Prepared document set for translation", {
-      ...logContext,
-      sourceDocumentIds: sourceDocumentIds.length,
-      totalTranslationJobs: sourceDocumentIds.length * targetLanguages.length
-    });
-    const translationPrompts = await fetchTranslationPrompts({
+    ], sourceDocumentIds = sourceDocuments.map((doc) => doc._id), versionedTargetDocumentIds = [], translationPrompts = await fetchTranslationPrompts({
       client,
       sourceLanguage,
       targetLanguages,
       sourceDocument
     });
-    devLog.info("Translation prompts", translationPrompts), setupTranslationJobStatuses(dispatch, sourceDocuments, targetLanguages);
+    setupTranslationJobStatuses(dispatch, sourceDocuments, targetLanguages);
     const translationTasks = sourceDocumentIds.flatMap(
       (documentId) => targetLanguages.map(async (targetLanguage) => {
         try {
           await translationSemaphore.withPermit(async () => {
             const document = await client.withConfig({
-              // This enables us to detect documents that might be stale due to unpublished changes
-              perspective: "raw"
-            }).fetch("*[_id == $id][0]", {
-              id: documentId
-            });
-            if (document && releaseId) {
-              const targetDocumentId = await translateDocument({
+              perspective: "drafts"
+            }).getDocument(documentId);
+            if (document || devLog.error("\u274C SOURCE DOCUMENT NOT FOUND", { documentId }), document && releaseId2) {
+              const versionedTargetDocumentId = await translateDocument({
                 dispatch,
                 client,
                 sourceDocument: document,
+                sourceLanguage,
                 targetLanguage,
                 languageFieldName,
                 shouldOverwriteFreshTranslations,
@@ -3107,9 +2612,9 @@ Then return the corrected translation document:`;
                 translationPrompts,
                 translationMode,
                 openaiConfig,
-                releaseId
+                releaseId: releaseId2
               });
-              targetDocumentId && targetDocumentIds.push(targetDocumentId);
+              versionedTargetDocumentId && versionedTargetDocumentIds.push(versionedTargetDocumentId);
             }
           });
         } catch (error) {
@@ -3125,25 +2630,21 @@ Then return the corrected translation document:`;
         }
       })
     ), results = await Promise.allSettled(translationTasks), succeeded = results.filter((r) => r.status === "fulfilled").length, failed = results.filter((r) => r.status === "rejected").length;
-    devLog.info("Translation tasks summary", {
+    devLog.info("Translation tasks completed", {
       ...logContext,
       total: results.length,
       succeeded,
-      failed
-    }), devLog.info("All translation tasks completed", {
-      ...logContext,
-      targetDocumentIds: targetDocumentIds.length
+      failed,
+      targetDocuments: versionedTargetDocumentIds.length
     }), dispatch({
       type: "SET_OVERALL_STATUS",
       payload: "linking_references"
-    }), devLog.debug("Starting reference localization", {
-      ...logContext,
-      documentsToLocalize: targetDocumentIds.length
     }), await Promise.all(
-      targetDocumentIds.map(async (documentId) => {
+      versionedTargetDocumentIds.map(async (documentId) => {
         await localizeReferences({
           client,
           documentId,
+          sourceLanguage,
           languageFieldName
         });
       })
@@ -3153,26 +2654,13 @@ Then return the corrected translation document:`;
       ...logContext,
       succeeded,
       failed
-    }), dispatch({ type: "SET_OVERALL_STATUS", payload: "completed" })) : (devLog.info("Document set translation completed successfully", logContext), dispatch({ type: "SET_OVERALL_STATUS", payload: "completed" })), devLog.timeEnd("translateDocumentSet"), devLog.groupEnd();
+    }), dispatch({ type: "SET_OVERALL_STATUS", payload: "completed" })) : dispatch({ type: "SET_OVERALL_STATUS", payload: "completed" }), devLog.timeEnd("translateDocumentSet"), devLog.groupEnd();
   } catch (error) {
-    if (devLog.error(
+    throw devLog.error(
       "translateDocumentSet failed with unexpected error",
       error instanceof Error ? error : new Error(String(error)),
       logContext
-    ), releaseId)
-      try {
-        await client.releases.delete({ releaseId }), devLog.warn("Deleted release due to fatal error", {
-          ...logContext,
-          releaseId
-        });
-      } catch (cleanupError) {
-        devLog.error(
-          "Failed to cleanup release",
-          cleanupError instanceof Error ? cleanupError : new Error(String(cleanupError)),
-          logContext
-        );
-      }
-    throw devLog.timeEnd("translateDocumentSet"), devLog.groupEnd(), dispatch({ type: "SET_OVERALL_STATUS", payload: "error" }), error;
+    ), devLog.timeEnd("translateDocumentSet"), devLog.groupEnd(), dispatch({ type: "SET_OVERALL_STATUS", payload: "error" }), error;
   }
 }, ActionButtonBar = ({ setIsDialogOpen }) => {
   const {
@@ -3593,24 +3081,12 @@ Then return the corrected translation document:`;
               " \u2014 ",
               job._id.slice(-6)
             ] }),
-            !["completed", "skipped", "error"].includes(job.status) && /* @__PURE__ */ jsxs(Stack, { space: 2, children: [
-              /* @__PURE__ */ jsx(Text, { size: 1, weight: "semibold", children: getStatusLabel(job.status) }),
-              job.reasoningProgress && /* @__PURE__ */ jsx(Card, { tone: "primary", padding: 3, radius: 2, children: /* @__PURE__ */ jsxs(Stack, { space: 2, children: [
-                /* @__PURE__ */ jsx(Text, { size: 1, weight: "semibold", children: "\u{1F914} GPT-5 Reasoning" }),
-                /* @__PURE__ */ jsx(Text, { size: 1, style: { fontStyle: "italic" }, children: job.reasoningProgress })
-              ] }) })
-            ] }),
-            job.status === "completed" && job.tokensUsed ? /* @__PURE__ */ jsxs(Stack, { space: 2, children: [
-              /* @__PURE__ */ jsxs(Text, { size: 1, muted: !0, children: [
-                job.tokensUsed.toLocaleString(),
-                " tokens (~$",
-                job.estimatedCost?.toFixed(4),
-                ")"
-              ] }),
-              job.reasoningSummary && /* @__PURE__ */ jsx(Card, { tone: "primary", padding: 2, radius: 2, children: /* @__PURE__ */ jsxs(Text, { size: 1, children: [
-                "\u{1F4A1} ",
-                job.reasoningSummary
-              ] }) })
+            !["completed", "skipped", "error"].includes(job.status) && /* @__PURE__ */ jsx(Text, { size: 1, weight: "semibold", children: getStatusLabel(job.status) }),
+            job.status === "completed" && job.tokensUsed ? /* @__PURE__ */ jsxs(Text, { size: 1, muted: !0, children: [
+              job.tokensUsed.toLocaleString(),
+              " tokens (~$",
+              job.estimatedCost?.toFixed(4),
+              ")"
             ] }) : null,
             job.status === "error" && job.errorMessage ? /* @__PURE__ */ jsx(Card, { tone: "critical", padding: 2, radius: 2, children: /* @__PURE__ */ jsxs(Text, { size: 1, children: [
               "Error: ",
@@ -3724,26 +3200,9 @@ Then return the corrected translation document:`;
   "completed"
 ], STATES_IN_WHICH_TO_SHOW_ERROR = ["error"], TranslationDialog = ({ setIsDialogOpen }) => {
   const { overallStatus, document } = useTranslationContext();
-  return devLog.debug("TranslationDialog rendered", {
-    documentId: document._id,
-    overallStatus,
-    component: "TranslationDialog"
-  }), STATES_IN_WHICH_TO_SHOW_CONFIG.includes(overallStatus) ? (devLog.debug("Showing translation config view", {
-    documentId: document._id,
-    overallStatus,
-    component: "TranslationDialog"
-  }), /* @__PURE__ */ jsx(TranslationConfigView, { setIsDialogOpen })) : STATES_IN_WHICH_TO_SHOW_TRANSLATION_PROGRESS.includes(overallStatus) ? (devLog.debug("Showing translation progress panel", {
-    documentId: document._id,
-    overallStatus,
-    component: "TranslationDialog"
-  }), /* @__PURE__ */ jsx(TranslationStatusPanel, {})) : STATES_IN_WHICH_TO_SHOW_ERROR.includes(overallStatus) ? (devLog.warn("Translation error state reached", {
+  return STATES_IN_WHICH_TO_SHOW_CONFIG.includes(overallStatus) ? /* @__PURE__ */ jsx(TranslationConfigView, { setIsDialogOpen }) : STATES_IN_WHICH_TO_SHOW_TRANSLATION_PROGRESS.includes(overallStatus) ? /* @__PURE__ */ jsx(TranslationStatusPanel, {}) : STATES_IN_WHICH_TO_SHOW_ERROR.includes(overallStatus) ? /* @__PURE__ */ jsx("div", { children: "Error occurred" }) : (devLog.warn("Unhandled translation dialog state", {
     documentId: document._id,
-    overallStatus,
-    component: "TranslationDialog"
-  }), /* @__PURE__ */ jsx("div", { children: "Error occurred" })) : (devLog.warn("Unhandled translation dialog state", {
-    documentId: document._id,
-    overallStatus,
-    component: "TranslationDialog"
+    overallStatus
   }), /* @__PURE__ */ jsx("div", { children: "Unhandled overall state" }));
 }, getTranslateAction = (config) => ({ draft, published }) => {
   const document = draft ?? published, [isDialogOpen, setIsDialogOpen] = useState(!1);