@braze/sanity-plugin-ai-translation 0.2.21 → 0.2.23

package/dist/index.js

@@ -1,4 +1,4 @@
-import { useClient, defineType, defineField, pathToString, definePlugin } from "sanity";
+import { useClient, defineType, defineField, pathToString, getPublishedId, 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";
@@ -1227,8 +1228,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
       };
@@ -1833,7 +1834,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 +1885,7 @@ const fetchTranslationPrompts = async ({
       _type: "internationalizedArrayReferenceValue",
       value: {
         _type: "reference",
-        _ref: undraftId(newDocument._id),
+        _ref: getPublishedId(newDocument._id),
         _weak: !0,
         _strengthenOnPublish: {
           _type: "reference",
@@ -1892,7 +1895,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 +1925,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 +1979,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,6 +2281,125 @@ const fetchTranslationPrompts = async ({
         type: "metadata_changed"
       }) : key !== "text" && validateStructureRecursive(origObj[key], modObj[key], [...path, key], errors));
   }
+}, getOpenAITranslation = async ({
+  dispatch,
+  sourceDocument,
+  languageFieldName,
+  translationPrompts,
+  targetLanguage,
+  openaiConfig
+}) => {
+  const sourceLanguage = sourceDocument[languageFieldName], logContext = {
+    sourceId: sourceDocument._id,
+    sourceLanguage
+  };
+  try {
+    const sourceText = serializeDocument(sourceDocument), prompt = buildTranslationPrompt({
+      sourceText,
+      sourceLanguage,
+      targetLanguage,
+      translationPrompts
+    }), response = await callGPT5(openaiConfig.apiKey, {
+      messages: [
+        {
+          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
+    }), result = deserializeDocument(sourceDocument, response.content), validation = validateStructureIntegrity(sourceDocument, result);
+    if (!validation.valid) {
+      devLog.error("Structure validation failed", {
+        ...logContext,
+        errors: validation.errors
+      });
+      const unexpectedErrors = validation.errors.filter(
+        (err) => !(err.path.length === 1 && err.path[0] === languageFieldName)
+      );
+      if (unexpectedErrors.length > 0)
+        throw new Error(
+          `Structure validation failed: ${unexpectedErrors.length} errors. First: ${unexpectedErrors[0].type} at ${unexpectedErrors[0].path.join(".")}`
+        );
+    }
+    return setJobStatus(dispatch, sourceDocument._id, targetLanguage, "translating_with_openai", {
+      tokensUsed: response.tokensUsed.total,
+      estimatedCost: response.cost
+    }), result;
+  } catch (error) {
+    throw devLog.error("OpenAI translation failed", error instanceof Error ? error : new Error(String(error)), logContext), error;
+  }
+}, buildTranslationPrompt = ({
+  sourceText,
+  sourceLanguage,
+  targetLanguage,
+  translationPrompts
+}) => {
+  const { globalPrompt, localeInstructions, protectedPhrases } = translationPrompts, localePrompt = localeInstructions[targetLanguage]?.prompt, glossaryTerms = localeInstructions[targetLanguage]?.glossaryTerms;
+  return `# TRANSLATION TASK
+
+Translate this ${sourceLanguage} document into ${targetLanguage}.
+
+## Guidelines
+
+${globalPrompt ? `### General Guidelines
+${globalPrompt}
+` : ""}
+${localePrompt ? `### ${targetLanguage} Guidelines
+${localePrompt}
+` : ""}
+${glossaryTerms ? `### Required Terminology
+${glossaryTerms}
+` : ""}
+${protectedPhrases?.length ? `### Protected Phrases (do not translate)
+${protectedPhrases.join(", ")}
+` : ""}
+
+## Source Document (${sourceLanguage})
+
+\`\`\`
+${sourceText}
+\`\`\`
+
+## Instructions
+
+1. Translate all text content into ${targetLanguage}
+2. Follow the guidelines and terminology requirements above
+3. Preserve protected phrases exactly as they appear
+4. Return the document 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 used significant reasoning to make translation decisions, you may include a brief summary:
+<reasoning>
+Brief summary of key translation decisions and reasoning
+</reasoning>
+
+Then return the translated document:`;
+}, 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
+  };
 }, assembleTranslationPrompt = (context, components) => {
   const sections = [
     {
@@ -2457,454 +2502,126 @@ ${glossaryTerms}`, buildStyleGuideSection = (globalPrompt, localePrompt) => {
     "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 ({
-  dispatch,
-  client,
-  schemaId,
+}, assembleLanguageSpecs = ({
   sourceDocument,
-  targetLanguage,
   languageFieldName,
-  translationTarget,
-  translationPrompts,
-  translationMode,
-  openaiConfig,
-  releaseId,
-  isNewTranslation
+  targetLanguage
 }) => {
-  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
-      });
-      const existingDoc = await client.getDocument(existingTranslationId);
-      if (!existingDoc)
-        throw new Error(`Existing translation document not found: ${existingTranslationId}`);
-      await client.action({
-        actionType: "sanity.action.document.version.create",
-        publishedId: existingTranslationId,
-        document: {
-          ...existingDoc,
-          _id: `versions.${releaseId}.${existingTranslationId}`
-        }
-      }), versionedDocumentId = `versions.${releaseId}.${existingTranslationId}`, baseDocumentId = existingTranslationId, devLog.info("Existing translation version created", {
-        ...logContext,
-        versionedDocumentId
-      });
-      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;
+  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
     }
-    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,
+  };
+}, getSanityAgentTranslation = async ({
   sourceDocument,
   targetLanguage,
   languageFieldName,
-  versionedDocumentId,
+  schemaId,
+  client,
   translationPrompts
 }) => {
-  const logContext = {
+  analyzeDocumentContent(sourceDocument);
+  const { styleGuide } = assembleTranslationPrompt(
+    {
+      // Always fresh translation in a version
+      targetLanguage,
+      sourceLanguage: sourceDocument[languageFieldName]
+    },
+    {
+      globalPrompt: translationPrompts.globalPrompt,
+      localePrompt: translationPrompts.localeInstructions[targetLanguage]?.prompt,
+      glossaryTerms: translationPrompts.localeInstructions[targetLanguage]?.glossaryTerms
+    }
+  ), { fromLanguage, toLanguage } = assembleLanguageSpecs({
+    sourceDocument,
+    languageFieldName,
+    targetLanguage
+  });
+  return await client.agent.action.translate({
+    schemaId,
+    toLanguage,
+    fromLanguage,
     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 ({
+    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,
-  targetDocument,
   targetLanguage,
+  existingTranslationId,
   languageFieldName,
   translationPrompts,
+  translationMode,
   openaiConfig,
-  isReview
+  releaseId
 }) => {
-  const sourceLanguage = sourceDocument[languageFieldName], logContext = {
-    sourceId: sourceDocument._id,
-    targetId: targetDocument._id,
-    targetLanguage,
-    sourceLanguage,
-    isReview
-  };
-  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({
-      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, {
-      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: "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);
-    if (!validation.valid) {
-      devLog.error("Structure validation failed", {
-        ...logContext,
-        errors: validation.errors
+  let translatedDoc;
+  switch (translationMode) {
+    case "sanity-only": {
+      setJobStatus(dispatch, sourceDocument._id, targetLanguage, "translating"), translatedDoc = await getSanityAgentTranslation({
+        sourceDocument,
+        targetLanguage,
+        languageFieldName,
+        schemaId,
+        client,
+        translationPrompts
       });
-      const unexpectedErrors = validation.errors.filter(
-        (err) => !(err.path.length === 1 && err.path[0] === languageFieldName)
-      );
-      if (unexpectedErrors.length > 0)
-        throw new Error(
-          `Structure validation failed: ${unexpectedErrors.length} errors. First: ${unexpectedErrors[0].type} at ${unexpectedErrors[0].path.join(".")}`
-        );
+      break;
     }
-    devLog.info("Structure validation passed", logContext);
-    const status = isReview ? "reviewing_with_openai" : "translating_with_openai";
-    return setJobStatus(dispatch, sourceDocument._id, targetLanguage, status, {
-      tokensUsed: response.tokensUsed.total,
-      estimatedCost: response.cost,
-      reasoningSummary: response.reasoningSummary
-    }), result;
-  } catch (error) {
-    throw devLog.error("OpenAI translation failed", error instanceof Error ? error : new Error(String(error)), logContext), error;
+    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}`);
   }
-}, buildTranslationPrompt = ({
-  sourceText,
-  sourceLanguage,
-  targetLanguage,
-  translationPrompts
-}) => {
-  const { globalPrompt, localeInstructions, protectedPhrases } = translationPrompts, localePrompt = localeInstructions[targetLanguage]?.prompt, glossaryTerms = localeInstructions[targetLanguage]?.glossaryTerms;
-  return `# TRANSLATION TASK
-
-Translate this ${sourceLanguage} document into ${targetLanguage}.
-
-## Guidelines
-
-${globalPrompt ? `### General Guidelines
-${globalPrompt}
-` : ""}
-${localePrompt ? `### ${targetLanguage} Guidelines
-${localePrompt}
-` : ""}
-${glossaryTerms ? `### Required Terminology
-${glossaryTerms}
-` : ""}
-${protectedPhrases?.length ? `### Protected Phrases (do not translate)
-${protectedPhrases.join(", ")}
-` : ""}
-
-## Source Document (${sourceLanguage})
-
-\`\`\`
-${sourceText}
-\`\`\`
-
-## Instructions
-
-1. Translate all text content into ${targetLanguage}
-2. Follow the guidelines and terminology requirements above
-3. Preserve protected phrases exactly as they appear
-4. Return the document 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 used significant reasoning to make translation decisions, you may include a brief summary:
-<reasoning>
-Brief summary of key translation decisions and reasoning
-</reasoning>
-
-Then return the translated document:`;
-}, buildReviewPrompt = ({
-  sourceText,
-  translatedText,
-  sourceLanguage,
-  targetLanguage,
-  translationPrompts
-}) => {
-  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.
-
-## 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?
-
-## Guidelines
-
-${globalPrompt ? `### General Guidelines
-${globalPrompt}
-` : ""}
-${localePrompt ? `### ${targetLanguage} Guidelines
-${localePrompt}
-` : ""}
-${glossaryTerms ? `### Required Terminology
-${glossaryTerms}
-` : ""}
-${protectedPhrases?.length ? `### Protected Phrases (must preserve)
-${protectedPhrases.join(", ")}
-` : ""}
-
-## Source Document (${sourceLanguage})
-
-\`\`\`
-${sourceText}
-\`\`\`
-
-## Current Translation (${targetLanguage})
-
-\`\`\`
-${translatedText}
-\`\`\`
-
-## Instructions
-
-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>
-
-Then return the corrected translation document:`;
+  if (!translatedDoc)
+    return null;
+  const targetDocumentPublishedId = existingTranslationId || uuid(), targetDocumentVersionId = `versions.${releaseId}.${targetDocumentPublishedId}`, newDoc = {
+    ...translatedDoc,
+    _id: targetDocumentVersionId
+  };
+  console.log("NEW DOC", newDoc);
+  const createdDoc = await client.action({
+    actionType: "sanity.action.document.version.create",
+    publishedId: targetDocumentPublishedId,
+    document: newDoc
+  });
+  return console.log("CREATED DOC", createdDoc), newDoc;
 }, translateDocument = async ({
   dispatch,
   client,
   sourceDocument,
+  sourceLanguage,
   targetLanguage,
   languageFieldName,
   shouldOverwriteFreshTranslations,
@@ -2923,62 +2640,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,
@@ -2987,8 +2679,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;
@@ -3014,13 +2708,13 @@ 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];
@@ -3029,25 +2723,26 @@ Then return the corrected translation document:`;
     maxConcurrentTranslationJobs && (devLog.debug("Updating translation semaphore permits", {
       ...logContext,
       newPermits: maxConcurrentTranslationJobs
-    }), translationSemaphore.updatePermits(maxConcurrentTranslationJobs)), devLog.info("Starting document set translation", logContext), dispatch({
+    }), 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", {
+    devLog.info("Creating new Content Release for translation batch", {
       ...logContext,
       releaseTitle
     });
-    const { releaseId: newReleaseId } = await client.releases.create({
+    const { releaseId: releaseId2 } = await client.releases.create({
       metadata: {
         title: releaseTitle,
         description: releaseDescription,
-        releaseType: "asap"
+        releaseType: "undecided"
       }
     });
-    releaseId = newReleaseId, devLog.info("Content Release created", {
+    devLog.info("\u2705 NEW CONTENT RELEASE CREATED", {
       ...logContext,
-      releaseId
+      releaseId: releaseId2,
+      releaseTitle
     });
     const sourceDocuments = [
       {
@@ -3075,16 +2770,14 @@ Then return the corrected translation document:`;
         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) {
+              perspective: "drafts"
+            }).getDocument(documentId);
+            if (document || devLog.error("\u274C SOURCE DOCUMENT NOT FOUND", { documentId }), document && releaseId2) {
               const targetDocumentId = await translateDocument({
                 dispatch,
                 client,
                 sourceDocument: document,
+                sourceLanguage,
                 targetLanguage,
                 languageFieldName,
                 shouldOverwriteFreshTranslations,
@@ -3092,7 +2785,7 @@ Then return the corrected translation document:`;
                 translationPrompts,
                 translationMode,
                 openaiConfig,
-                releaseId
+                releaseId: releaseId2
               });
               targetDocumentId && targetDocumentIds.push(targetDocumentId);
             }
@@ -3140,24 +2833,11 @@ Then return the corrected translation document:`;
       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();
   } 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 {
@@ -3578,24 +3258,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: ",