@braze/sanity-plugin-ai-translation 0.2.87 → 0.3.0

package/dist/index.js

@@ -1,7 +1,8 @@
-import { getPublishedId, pathToString, useClient, useWorkspace, validateDocument, defineType, defineField, definePlugin } from "sanity";
+import { useClient, getPublishedId, pathToString, useWorkspace, validateDocument, defineType, defineField, definePlugin } from "sanity";
 import { jsx, jsxs, Fragment } from "react/jsx-runtime";
 import { WarningOutlineIcon, ErrorOutlineIcon, CheckmarkIcon, SyncIcon, PanelRightIcon, SearchIcon, CircleIcon, ArrowRightIcon, ResetIcon, TranslateIcon } from "@sanity/icons";
-import { createContext, useReducer, useRef, useEffect, useContext, useMemo, useState, useCallback } from "react";
+import { createContext, useEffect, useReducer, useRef, useContext, useMemo, useState, useCallback } from "react";
+import { devLog, retryWithBackoff, isNetworkError, isSanityMutationError } from "./_chunks-es/retry.js";
 import defaults from "lodash.defaults";
 import { Card, Stack, Flex, Text, Box, Heading, Button, Spinner, Badge, Inline, Radio, Checkbox, Grid, TextInput, Select, Label, Code, Tooltip } from "@sanity/ui";
 import { IntentLink } from "sanity/router";
@@ -11,59 +12,55 @@ import { uuid } from "@sanity/uuid";
 import cloneDeep from "lodash.clonedeep";
 import get from "lodash.get";
 import set from "lodash.set";
-const isLoggingEnabled = () => process.env.NEXT_PUBLIC_SANITY_STUDIO_AI_TRANSLATION_PLUGIN_LOGGING === "true" || process.env.SANITY_STUDIO_AI_TRANSLATION_PLUGIN_LOGGING === "true", devLog = {
-  info: (message, context) => {
-    isLoggingEnabled() && console.info("[AI Translation]", message, context ? JSON.stringify(context, null, 2) : "");
-  },
-  warn: (message, context) => {
-    isLoggingEnabled() && console.warn("[AI Translation]", message, context ? JSON.stringify(context, null, 2) : "");
-  },
-  error: (message, error, context) => {
-    isLoggingEnabled() && console.error("[AI Translation]", message, error, context ? JSON.stringify(context, null, 2) : "");
-  },
-  debug: (message, data, context) => {
-    isLoggingEnabled() && console.debug("[AI Translation]", message, data, context ? JSON.stringify(context, null, 2) : "");
-  },
-  group: (label, context) => {
-    isLoggingEnabled() && console.group(`[AI Translation] ${label}`, context ? JSON.stringify(context, null, 2) : "");
-  },
-  groupEnd: () => {
-    isLoggingEnabled() && console.groupEnd();
-  },
-  time: (label) => {
-    isLoggingEnabled() && console.time(`[AI Translation] ${label}`);
-  },
-  timeEnd: (label) => {
-    isLoggingEnabled() && console.timeEnd(`[AI Translation] ${label}`);
-  }
-}, validateOpenAIApiKey = async (apiKey, model = "gpt-5") => {
+const DEFAULT_TRANSLATION_FUNCTION_NAME = "ai-translation", DEFAULT_MODEL = "gpt-5", TRANSLATION_FUNCTION_TIMEOUT_MS = 9e5, isOpenAIConfigured = (openaiConfig) => !!(openaiConfig?.enabled && typeof openaiConfig.stackId == "string" && openaiConfig.stackId.trim() !== ""), supportsFunctionInvoke = (client) => typeof client.functions?.invoke == "function", toNumber = (value) => typeof value == "number" && Number.isFinite(value) ? value : 0, parseResult = (result, functionName) => {
+  const value = result ?? {};
+  if (typeof value.content != "string")
+    throw new Error(`OpenAI translation function "${functionName}" returned no translated content`);
+  const tokensUsed = value.tokensUsed ?? {};
+  return {
+    content: value.content,
+    tokensUsed: {
+      prompt: toNumber(tokensUsed.prompt),
+      completion: toNumber(tokensUsed.completion),
+      reasoning: toNumber(tokensUsed.reasoning),
+      total: toNumber(tokensUsed.total),
+      cached: toNumber(tokensUsed.cached)
+    }
+  };
+}, invokeTranslationFunction = async ({
+  client,
+  openaiConfig,
+  messages
+}) => {
+  if (!isOpenAIConfigured(openaiConfig))
+    throw new Error("OpenAI mode requires openai.enabled and openai.stackId");
+  if (!supportsFunctionInvoke(client))
+    throw new Error("OpenAI mode requires @sanity/client 8.1 or newer in Studio to invoke the translation function");
+  const functionName = openaiConfig.functionName || DEFAULT_TRANSLATION_FUNCTION_NAME, payload = {
+    model: openaiConfig.model || DEFAULT_MODEL,
+    messages,
+    reasoningEffort: openaiConfig.reasoningEffort
+  };
+  devLog.debug("Invoking OpenAI translation function", {
+    functionName,
+    stackId: openaiConfig.stackId,
+    model: payload.model,
+    reasoningEffort: payload.reasoningEffort,
+    messages: messages.map((m) => ({ role: m.role, contentLength: m.content.length }))
+  });
+  let result;
   try {
-    const response = await fetch("https://api.openai.com/v1/models", {
-      method: "GET",
-      headers: {
-        Authorization: `Bearer ${apiKey}`
-      }
-    });
-    if (!response.ok)
-      return {
-        valid: !1,
-        error: (await response.json()).error?.message || "Invalid API key"
-      };
-    const availableModels = (await response.json()).data.map((m) => m.id);
-    return availableModels.includes(model) ? {
-      valid: !0,
-      modelAvailable: availableModels
-    } : {
-      valid: !1,
-      error: `Model ${model} not available. Try: ${availableModels.slice(0, 5).join(", ")}`
-    };
+    result = await client.functions.invoke(
+      functionName,
+      { event: { data: payload }, stackId: openaiConfig.stackId, timeout: TRANSLATION_FUNCTION_TIMEOUT_MS },
+      { sync: !0 }
+    );
   } catch (error) {
-    return {
-      valid: !1,
-      error: error instanceof Error ? error.message : "Network error"
-    };
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`OpenAI translation function "${functionName}" failed: ${message}`);
   }
-}, undraftId = (id) => id.replace(/^drafts\./, ""), activeTranslations = /* @__PURE__ */ new Map(), registerActiveTranslation = (documentId, releaseId) => {
+  return parseResult(result, functionName);
+}, undraftId = (id) => id.replace(/^drafts\./, ""), draftId = (id) => `drafts.${undraftId(id)}`, activeTranslations = /* @__PURE__ */ new Map(), registerActiveTranslation = (documentId, releaseId) => {
   const entry = {
     state: {
       documentId,
@@ -102,7 +99,7 @@ const isLoggingEnabled = () => process.env.NEXT_PUBLIC_SANITY_STUDIO_AI_TRANSLAT
     try {
       subscriber(entry.state);
     } catch (error) {
-      console.error("Error in active translation subscriber:", error);
+      devLog.error("Error in active translation subscriber", error);
     }
 }, forceCleanupActiveTranslation = (documentId) => {
   activeTranslations.delete(documentId);
@@ -253,7 +250,14 @@ const isLoggingEnabled = () => process.env.NEXT_PUBLIC_SANITY_STUDIO_AI_TRANSLAT
     supportedLanguages: config.supportedLanguages?.map((l) => l.id),
     component: "TranslationContextProvider"
   });
-  const defaultReleaseTitle = generateDefaultReleaseTitle(document), activeTranslation = getActiveTranslation(document._id), initialContext = {
+  const defaultReleaseTitle = generateDefaultReleaseTitle(document), client = useClient({ apiVersion: "vX" }), openaiConfigured = isOpenAIConfigured(config?.openai), openaiAvailable = openaiConfigured && supportsFunctionInvoke(client);
+  useEffect(() => {
+    openaiConfigured && !openaiAvailable && devLog.warn("OpenAI mode is configured but the Studio client cannot invoke functions", {
+      requires: "@sanity/client 8.1 or newer",
+      component: "TranslationContextProvider"
+    });
+  }, [openaiConfigured, openaiAvailable]);
+  const activeTranslation = getActiveTranslation(document._id), initialContext = {
     document,
     config,
     // If there's an active translation, restore its state
@@ -266,8 +270,8 @@ const isLoggingEnabled = () => process.env.NEXT_PUBLIC_SANITY_STUDIO_AI_TRANSLAT
     selectedReferenceIds: /* @__PURE__ */ new Set(),
     // Restore jobs from active translation if available
     translationJobs: activeTranslation?.translationJobs ?? /* @__PURE__ */ new Map(),
-    translationMode: config?.openai?.defaultMode || "sanity-only",
-    openaiValidated: !1,
+    translationMode: openaiAvailable && config.openai?.defaultMode || "sanity-only",
+    openaiValidated: openaiAvailable,
     releaseConfig: {
       mode: "new",
       newReleaseTitle: defaultReleaseTitle
@@ -302,30 +306,6 @@ const isLoggingEnabled = () => process.env.NEXT_PUBLIC_SANITY_STUDIO_AI_TRANSLAT
       unsubscribe();
     };
   }, [document._id]), useEffect(() => {
-    (async () => {
-      if (config?.openai?.enabled && config?.openai?.apiKey)
-        try {
-          const validation = await validateOpenAIApiKey(config.openai.apiKey, config.openai.model || "gpt-5");
-          dispatch({
-            type: "SET_OPENAI_VALIDATED",
-            payload: validation.valid
-          }), validation.valid ? devLog.info("OpenAI API key validated successfully", {
-            model: config.openai.model || "gpt-5",
-            component: "TranslationContextProvider"
-          }) : devLog.error("OpenAI API key validation failed", {
-            error: validation.error,
-            component: "TranslationContextProvider"
-          });
-        } catch (error) {
-          devLog.error("OpenAI validation error", error instanceof Error ? error : new Error(String(error)), {
-            component: "TranslationContextProvider"
-          }), dispatch({
-            type: "SET_OPENAI_VALIDATED",
-            payload: !1
-          });
-        }
-    })();
-  }, [config?.openai?.apiKey, config?.openai?.enabled, config?.openai?.model]), useEffect(() => {
     const currentRefsKey = context.references.map((ref) => ref._id).sort().join(",");
     if (currentRefsKey !== lastProcessedRefsRef.current) {
       if (context.references.length > 0) {
@@ -361,7 +341,12 @@ const isLoggingEnabled = () => process.env.NEXT_PUBLIC_SANITY_STUDIO_AI_TRANSLAT
       "useTranslationContext must be used within a TranslationContextProvider with document and config props"
     );
   return context;
-}, checkSourceDrafts = async ({
+};
+async function fetchSourceDocument(client, documentId, perspective) {
+  const publishedId = undraftId(documentId), [draft, published] = await client.getDocuments([draftId(publishedId), publishedId]);
+  return perspective === "published" ? published : draft ?? published;
+}
+const checkSourceDrafts = async ({
   client,
   referenceIds
 }) => {
@@ -449,10 +434,10 @@ const isLoggingEnabled = () => process.env.NEXT_PUBLIC_SANITY_STUDIO_AI_TRANSLAT
     return devLog.debug("No stale drafts found", { sourceDocumentId }), [];
   const draftMap = new Map(drafts.map((d) => [d._id, d])), results = [];
   for (const entry of deduped) {
-    const draftId = `drafts.${entry.targetId}`, draft = draftMap.get(draftId);
+    const draftId2 = `drafts.${entry.targetId}`, draft = draftMap.get(draftId2);
     draft && results.push({
       targetId: entry.targetId,
-      draftId,
+      draftId: draftId2,
       _type: draft._type,
       title: draft.title || draft.name,
       sourceDocumentId: entry.sourceDocumentId,
@@ -498,7 +483,7 @@ const isLoggingEnabled = () => process.env.NEXT_PUBLIC_SANITY_STUDIO_AI_TRANSLAT
       translationHistory: []
     });
   } catch (error) {
-    throw console.error(sourceDocument._id, "Error creating translation metadata:", error), error;
+    throw devLog.error("Error creating translation metadata", error, { documentId: sourceDocument._id }), error;
   }
 }, checkDocumentConflicts = async ({
   client,
@@ -587,115 +572,6 @@ const isLoggingEnabled = () => process.env.NEXT_PUBLIC_SANITY_STUDIO_AI_TRANSLAT
   }
   return allConflicts;
 };
-function isNetworkError(error) {
-  if (!error) return !1;
-  if (error instanceof TypeError) {
-    const message = error.message.toLowerCase();
-    return message.includes("fetch") || message.includes("network") || message.includes("connection") || message.includes("failed to fetch") || message.includes("networkerror");
-  }
-  if (error && typeof error == "object" && "code" in error) {
-    const code = error.code;
-    return ["ECONNRESET", "ETIMEDOUT", "ENOTFOUND", "ECONNREFUSED", "EHOSTUNREACH"].includes(code);
-  }
-  if (error && typeof error == "object" && "response" in error) {
-    const response = error.response;
-    if (response?.status)
-      return response.status >= 500 || response.status === 429;
-  }
-  if (error instanceof Error) {
-    const message = error.message.toLowerCase();
-    if (/\b(50[0-9]|429)\b/.test(message) || message.includes("rate limit"))
-      return !0;
-  }
-  return !1;
-}
-function isSanityMutationError(error) {
-  if (!error) return !1;
-  if (error instanceof Error) {
-    const message = error.message.toLowerCase();
-    return [
-      "validation",
-      "schema",
-      "invalid document",
-      "invalid field",
-      "type mismatch",
-      "reference",
-      "patch",
-      "mutation",
-      "document structure",
-      "required field",
-      "field type",
-      "sanity"
-    ].some((pattern) => message.includes(pattern));
-  }
-  if (error && typeof error == "object") {
-    const errorObj = error;
-    if (("statusCode" in errorObj || "response" in errorObj || "details" in errorObj) && "statusCode" in errorObj) {
-      const statusCode = errorObj.statusCode;
-      if (statusCode >= 400 && statusCode < 500 && statusCode !== 429)
-        return !0;
-    }
-  }
-  return !1;
-}
-const DEFAULT_RETRY_OPTIONS = {
-  maxAttempts: 2,
-  initialDelayMs: 0,
-  maxDelayMs: 5e3,
-  backoffMultiplier: 2,
-  retryableErrors: isNetworkError,
-  logRetries: !0
-};
-function calculateDelay(attempt, options) {
-  const delay = options.initialDelayMs * options.backoffMultiplier ** attempt;
-  return Math.min(delay, options.maxDelayMs);
-}
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-async function retryWithBackoff(operation, options = {}) {
-  const opts = {
-    ...DEFAULT_RETRY_OPTIONS,
-    ...options,
-    retryableErrors: options.retryableErrors || DEFAULT_RETRY_OPTIONS.retryableErrors
-  };
-  let lastError;
-  const maxAttempts = opts.maxAttempts + 1;
-  for (let attempt = 1; attempt <= maxAttempts; attempt++)
-    try {
-      const result = await operation();
-      return attempt > 1 && opts.logRetries && devLog.info(`Operation succeeded after ${attempt} attempts`, {
-        ...opts.context,
-        attempt,
-        totalAttempts: attempt
-      }), result;
-    } catch (error) {
-      if (lastError = error, !opts.retryableErrors(error))
-        throw opts.logRetries && devLog.warn("Error is not retryable, aborting retries", {
-          ...opts.context,
-          attempt,
-          error: error instanceof Error ? error.message : String(error)
-        }), error;
-      if (attempt >= maxAttempts)
-        throw opts.logRetries && devLog.error(
-          `Operation failed after ${maxAttempts} attempts`,
-          error instanceof Error ? error : new Error(String(error)),
-          {
-            ...opts.context,
-            totalAttempts: maxAttempts
-          }
-        ), error;
-      const delay = calculateDelay(attempt - 1, opts);
-      opts.logRetries && devLog.warn(`Operation failed, retrying in ${delay}ms (attempt ${attempt}/${maxAttempts})`, {
-        ...opts.context,
-        attempt,
-        totalAttempts: maxAttempts,
-        delayMs: delay,
-        error: error instanceof Error ? error.message : String(error)
-      }), delay > 0 && await sleep(delay);
-    }
-  throw lastError;
-}
 class Semaphore {
   permits;
   queue = [];
@@ -1662,127 +1538,7 @@ class TransformRegistry {
     }), matches[0];
   }
 }
-const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKey, request) => (request.model || "gpt-5").startsWith("gpt-5") ? await callGPT5ResponsesAPI(apiKey, request) : await callChatCompletionsAPI(apiKey, request), callGPT5ResponsesAPI = async (apiKey, request) => {
-  const model = request.model || "gpt-5", requestBody = {
-    model: model === "gpt-5" ? "gpt-5.1" : model,
-    // Map gpt-5 to gpt-5.1, use others as-is
-    input: request.messages
-    // Uses 'input' instead of 'messages'
-  };
-  request.reasoningEffort && (requestBody.reasoning = {
-    effort: request.reasoningEffort,
-    summary: "auto"
-    // Enable automatic reasoning summaries
-  }), devLog.debug("OpenAI GPT-5 Request", {
-    model: requestBody.model,
-    reasoningEffort: request.reasoningEffort,
-    messages: request.messages.map((m) => ({
-      role: m.role,
-      contentLength: m.content.length,
-      contentPreview: m.content.substring(0, 500) + (m.content.length > 500 ? "..." : "")
-    }))
-  }), devLog.debug("OpenAI GPT-5 Full Prompt", {
-    messages: request.messages
-  });
-  const response = await retryWithBackoff(
-    async () => {
-      const fetchResponse = await fetch("https://api.openai.com/v1/responses", {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${apiKey}`
-        },
-        body: JSON.stringify(requestBody)
-      });
-      if (!fetchResponse.ok) {
-        const errorMessage = `GPT-5 API error: ${(await fetchResponse.json()).error?.message || "Unknown error"}`, errorObj = new Error(errorMessage);
-        throw errorObj.response = { status: fetchResponse.status }, errorObj;
-      }
-      return fetchResponse;
-    },
-    {
-      maxAttempts: 2,
-      initialDelayMs: 0,
-      retryableErrors: isNetworkError,
-      context: { model: requestBody.model, endpoint: "responses" }
-    }
-  );
-  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,
-    cached: result.usage?.input_tokens_details?.cached_tokens || 0
-  };
-  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
-  };
-}, callChatCompletionsAPI = async (apiKey, request) => {
-  const model = request.model || "gpt-4o", requestBody = {
-    model,
-    messages: request.messages,
-    temperature: request.temperature ?? 0.3
-  };
-  devLog.debug("OpenAI Chat Completions Request", {
-    model,
-    temperature: request.temperature ?? 0.3,
-    messages: request.messages.map((m) => ({
-      role: m.role,
-      contentLength: m.content.length,
-      contentPreview: m.content.substring(0, 500) + (m.content.length > 500 ? "..." : "")
-    }))
-  }), devLog.debug("OpenAI Chat Completions Full Prompt", {
-    messages: request.messages
-  });
-  const response = await retryWithBackoff(
-    async () => {
-      const fetchResponse = await fetch("https://api.openai.com/v1/chat/completions", {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${apiKey}`
-        },
-        body: JSON.stringify(requestBody)
-      });
-      if (!fetchResponse.ok) {
-        const errorMessage = `OpenAI API error: ${(await fetchResponse.json()).error?.message || "Unknown error"}`, errorObj = new Error(errorMessage);
-        throw errorObj.response = { status: fetchResponse.status }, errorObj;
-      }
-      return fetchResponse;
-    },
-    {
-      maxAttempts: 2,
-      initialDelayMs: 0,
-      retryableErrors: isNetworkError,
-      context: { model, endpoint: "chat/completions" }
-    }
-  );
-  if (!response.ok) {
-    const error = await response.json();
-    throw new Error(`OpenAI API error: ${error.error?.message || "Unknown error"}`);
-  }
-  const result = await response.json(), usage = result.usage || {}, tokensUsed = {
-    prompt: usage.prompt_tokens || 0,
-    completion: usage.completion_tokens || 0,
-    reasoning: usage.reasoning_tokens || 0,
-    total: usage.total_tokens || 0,
-    cached: usage.prompt_tokens_details?.cached_tokens || 0
-  };
-  return {
-    content: result.choices[0].message.content || "",
-    tokensUsed
-  };
-}, deserializeDocument = (originalDoc, reviewedText) => {
+const globalTransformRegistry = new TransformRegistry(), deserializeDocument = (originalDoc, reviewedText) => {
   devLog.debug("Raw GPT-5 response received", {
     length: reviewedText.length,
     preview: reviewedText.substring(0, 1e3),
@@ -2382,6 +2138,7 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
   }
 }, getOpenAITranslation = async ({
   dispatch,
+  client,
   sourceDocument,
   languageFieldName,
   translationPrompts,
@@ -2410,16 +2167,16 @@ const globalTransformRegistry = new TransformRegistry(), callGPT5 = async (apiKe
       targetLanguage,
       translationPrompts,
       errorContext
-    }), response = await callGPT5(openaiConfig.apiKey, {
+    }), response = await invokeTranslationFunction({
+      client,
+      openaiConfig,
       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
+      ]
     });
     openaiResponseContent = response.content, devLog.info("OpenAI translation response received", {
       ...logContext,
@@ -2727,25 +2484,18 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
     languageFieldName
   });
   const documentAfterUnset = unsetDocumentFields(sourceDocument, safeUnsetFields), { preserveFieldPatterns } = normalizeUnsetFields(safeUnsetFields);
-  let documentWithPreserved = documentAfterUnset;
+  let preservedValues = {};
   if (preserveFieldPatterns.length > 0 && existingTranslationId)
     try {
       const publishedTarget = await client.getDocument(existingTranslationId);
-      if (publishedTarget) {
-        const { excludedValues: preserveValues } = filterExcludedFields(
-          publishedTarget,
-          preserveFieldPatterns
-        );
-        Object.keys(preserveValues).length > 0 && (documentWithPreserved = restoreExcludedFields(documentAfterUnset, preserveValues), devLog.info("Preserved fields from published target during re-translation", {
-          documentId: sourceDocument._id,
-          existingTranslationId,
-          preservedFields: Object.keys(preserveValues)
-        }));
-      } else
-        devLog.debug("Published target not found for preserveExisting fields", {
-          documentId: sourceDocument._id,
-          existingTranslationId
-        });
+      publishedTarget ? (preservedValues = filterExcludedFields(publishedTarget, preserveFieldPatterns).excludedValues, Object.keys(preservedValues).length > 0 && devLog.info("Preserving fields from published target during re-translation", {
+        documentId: sourceDocument._id,
+        existingTranslationId,
+        preservedFields: Object.keys(preservedValues)
+      })) : devLog.debug("Published target not found for preserveExisting fields", {
+        documentId: sourceDocument._id,
+        existingTranslationId
+      });
     } catch (error) {
       devLog.warn("Failed to fetch published target for preserveExisting fields", {
         documentId: sourceDocument._id,
@@ -2764,10 +2514,10 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
     documentType: sourceDocument._type,
     excludeFields: safeExcludeFields,
     excludeFieldsLength: safeExcludeFields?.length ?? 0,
-    sourceHasTitle: "title" in documentWithPreserved,
-    sourceTitleValue: documentWithPreserved.title
+    sourceHasTitle: "title" in documentAfterUnset,
+    sourceTitleValue: documentAfterUnset.title
   });
-  const { filteredDocument, excludedValues } = filterExcludedFields(documentWithPreserved, safeExcludeFields);
+  const { filteredDocument, excludedValues } = filterExcludedFields(documentAfterUnset, safeExcludeFields);
   devLog.info("After filtering excluded fields", {
     documentId: sourceDocument._id,
     filteredHasTitle: "title" in filteredDocument,
@@ -2830,7 +2580,7 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
         }
       }
       case "openai-only": {
-        if (!openaiConfig?.enabled || !openaiConfig?.apiKey)
+        if (!isOpenAIConfigured(openaiConfig))
           throw new Error("OpenAI is not configured but openai-only mode was selected");
         setJobStatus(
           dispatch,
@@ -2842,6 +2592,7 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
         );
         const result = await getOpenAITranslation({
           dispatch,
+          client,
           sourceDocument: documentToTranslate,
           targetLanguage,
           languageFieldName,
@@ -2861,32 +2612,39 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
   };
   if (translatedDoc = (await performTranslation()).document, !translatedDoc)
     return null;
-  let transformedResult;
-  Object.keys(originalStructure).length > 0 ? (devLog.debug("Restoring field transforms after translation", {
-    documentId: sourceDocument._id,
-    documentType: sourceDocument._type
-  }), transformedResult = restoreTransforms({
-    translatedDocument: translatedDoc,
-    originalStructure,
-    registry: globalTransformRegistry,
-    schemaType: sourceDocument._type
-  })) : transformedResult = translatedDoc;
   const excludedValuesToRestore = { ...excludedValues };
-  delete excludedValuesToRestore[languageFieldName], devLog.info("Before restoring excluded fields", {
-    documentId: sourceDocument._id,
-    excludedFieldCount: Object.keys(excludedValues).length,
-    excludedValuesKeys: Object.keys(excludedValues),
-    languageFieldExcluded: languageFieldName in excludedValues,
-    transformedResultHasTitle: "title" in transformedResult,
-    transformedResultTitle: transformedResult.title
-  });
-  const finalDoc = restoreExcludedFields(transformedResult, excludedValuesToRestore);
-  devLog.info("After restoring excluded fields", {
-    documentId: sourceDocument._id,
-    finalDocHasTitle: "title" in finalDoc,
-    finalDocTitle: finalDoc.title
-  });
-  const targetDocumentPublishedId = existingTranslationId || uuid(), targetDocumentVersionId = `versions.${releaseId}.${targetDocumentPublishedId}`, newDoc = {
+  delete excludedValuesToRestore[languageFieldName];
+  const finalizeDocument = (translated) => {
+    let transformedResult;
+    Object.keys(originalStructure).length > 0 ? (devLog.debug("Restoring field transforms after translation", {
+      documentId: sourceDocument._id,
+      documentType: sourceDocument._type
+    }), transformedResult = restoreTransforms({
+      translatedDocument: translated,
+      originalStructure,
+      registry: globalTransformRegistry,
+      schemaType: sourceDocument._type
+    })) : transformedResult = translated;
+    const withoutUnsetFields = unsetDocumentFields(transformedResult, safeUnsetFields);
+    devLog.info("Before restoring excluded fields", {
+      documentId: sourceDocument._id,
+      excludedFieldCount: Object.keys(excludedValues).length,
+      excludedValuesKeys: Object.keys(excludedValues),
+      languageFieldExcluded: languageFieldName in excludedValues,
+      transformedResultHasTitle: "title" in withoutUnsetFields,
+      transformedResultTitle: withoutUnsetFields.title
+    });
+    const finalDoc2 = restoreExcludedFields(
+      restoreExcludedFields(withoutUnsetFields, excludedValuesToRestore),
+      preservedValues
+    );
+    return devLog.info("After restoring excluded fields", {
+      documentId: sourceDocument._id,
+      finalDocHasTitle: "title" in finalDoc2,
+      finalDocTitle: finalDoc2.title,
+      preservedFields: Object.keys(preservedValues)
+    }), finalDoc2;
+  }, finalDoc = finalizeDocument(translatedDoc), targetDocumentPublishedId = existingTranslationId || uuid(), targetDocumentVersionId = `versions.${releaseId}.${targetDocumentPublishedId}`, newDoc = {
     ...finalDoc,
     _id: targetDocumentVersionId
   };
@@ -2925,15 +2683,8 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
       const errorContext = `Previous translation attempt failed with Sanity validation error: ${previousError.message}. Please ensure the translated document structure exactly matches the source document structure.`;
       if (translatedDoc = (await performTranslation(errorContext)).document, !translatedDoc)
         throw new Error("Translation retry failed: no document returned");
-      let retryTransformedResult;
-      Object.keys(originalStructure).length > 0 ? retryTransformedResult = restoreTransforms({
-        translatedDocument: translatedDoc,
-        originalStructure,
-        registry: globalTransformRegistry,
-        schemaType: sourceDocument._type
-      }) : retryTransformedResult = translatedDoc;
       const retryNewDoc = {
-        ...restoreExcludedFields(retryTransformedResult, excludedValuesToRestore),
+        ...finalizeDocument(translatedDoc),
         _id: targetDocumentVersionId
       };
       return await retryWithBackoff(
@@ -3224,9 +2975,11 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
         }
         try {
           await translationSemaphore.withPermit(async () => {
-            const document = await client.withConfig({
-              perspective: sourcePerspective ?? "drafts"
-            }).getDocument(documentId);
+            const document = await fetchSourceDocument(
+              client,
+              documentId,
+              sourcePerspective ?? "drafts"
+            );
             if (document || devLog.error("\u274C SOURCE DOCUMENT NOT FOUND", { documentId }), document && releaseId) {
               const versionedTargetDocumentId = await translateDocument({
                 dispatch,
@@ -3415,12 +3168,8 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
     hasRun.current || (hasRun.current = !0, (async () => {
       onResult(documentId, { isValidating: !0, errors: [] });
       try {
-        const publishedId = getPublishedId(documentId), draftId = `drafts.${publishedId}`;
-        let doc;
-        if (perspective === "published" ? doc = await client.fetch("*[_id == $publishedId][0]", { publishedId }) : doc = await client.fetch(
-          "*[_id in [$draftId, $publishedId]] | order(_id desc) [0]",
-          { draftId, publishedId }
-        ), !doc) {
+        const doc = await fetchSourceDocument(client, documentId, perspective);
+        if (!doc) {
           devLog.warn("Document not found for validation", { documentId, perspective }), onResult(documentId, { isValidating: !1, errors: [] });
           return;
         }
@@ -3436,14 +3185,13 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
           component: "DocumentValidator"
         }), onResult(documentId, { isValidating: !1, errors });
       } catch (error) {
-        devLog.error(
-          "Failed to validate document",
-          error instanceof Error ? error : new Error(String(error)),
-          { documentId, component: "DocumentValidator" }
-        ), onResult(documentId, { isValidating: !1, errors: [] });
+        devLog.error("Failed to validate document", error instanceof Error ? error : new Error(String(error)), {
+          documentId,
+          component: "DocumentValidator"
+        }), onResult(documentId, { isValidating: !1, errors: [] });
       }
     })());
-  }, [documentId, documentType, perspective, onResult, client, workspace]), null;
+  }, [documentId, perspective, onResult, client, workspace]), null;
 }, PreflightView = () => {
   const {
     document,
@@ -3605,9 +3353,7 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
   }, []), sourceRefDraftIds = useMemo(
     () => new Set(sourceRefsWithDrafts.map((d) => d.publishedId)),
     [sourceRefsWithDrafts]
-  ), isLoading = someStillValidating || isSourceDraftCheckLoading || isDraftCheckLoading || isCheckingConflicts, hasStaleDrafts = staleDrafts.length > 0, draftsDismissed = draftAction === "continue", canStartTranslation = !isLoading && !hasValidationErrors && !conflictContext && (!hasStaleDrafts || draftsDismissed), handleCancelConflict = useCallback(() => {
-    setConflictContext(null);
-  }, []), handleReplaceConflict = useCallback(() => {
+  ), isLoading = someStillValidating || isSourceDraftCheckLoading || isDraftCheckLoading || isCheckingConflicts, hasStaleDrafts = staleDrafts.length > 0, draftsDismissed = draftAction === "continue", canStartTranslation = !isLoading && !hasValidationErrors && !conflictContext && (!hasStaleDrafts || draftsDismissed), handleReplaceConflict = useCallback(() => {
     conflictContext && startTranslation(!0, conflictContext.releaseId);
   }, [startTranslation, conflictContext]), handleSkipConflicts = useCallback(() => {
     conflictContext && startTranslation(!1, conflictContext.releaseId, conflictContext.conflicts);
@@ -3617,7 +3363,7 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
     {
       conflicts: conflictContext.conflicts,
       totalTranslations,
-      onCancel: handleCancelConflict,
+      onCancel: handleBack,
       onReplace: handleReplaceConflict,
       onSkipConflicts: handleSkipConflicts
     }
@@ -3711,14 +3457,7 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
           ] }),
           /* @__PURE__ */ jsx(DocumentOpenerButton, { documentId: draft.targetId, documentType: draft._type })
         ] }, draft.draftId)) }) }) }),
-        /* @__PURE__ */ jsx(
-          Button,
-          {
-            mode: "ghost",
-            text: "Continue Anyway",
-            onClick: () => setDraftAction("continue")
-          }
-        )
+        /* @__PURE__ */ jsx(Button, { mode: "ghost", text: "Continue Anyway", onClick: () => setDraftAction("continue") })
       ] })
     ] }) }),
     /* @__PURE__ */ jsxs(Flex, { justify: "space-between", gap: 2, children: [
@@ -4207,12 +3946,12 @@ ${protectedPhrases.join(", ")}`, buildStyleGuideSection = (globalPrompt, localeP
   ] }) });
 }, TranslationModePanel = () => {
   const { config, translationMode, openaiValidated, dispatch } = useTranslationContext();
-  if (!config?.openai?.enabled || !config?.openai?.apiKey)
+  if (!isOpenAIConfigured(config?.openai))
     return null;
   if (!openaiValidated)
     return /* @__PURE__ */ jsx(Card, { tone: "caution", padding: 4, border: !0, children: /* @__PURE__ */ jsxs(Stack, { space: 2, children: [
-      /* @__PURE__ */ jsx(Text, { weight: "semibold", children: "OpenAI Configuration" }),
-      /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: "Validating API key..." })
+      /* @__PURE__ */ jsx(Text, { weight: "semibold", children: "OpenAI Unavailable" }),
+      /* @__PURE__ */ jsx(Text, { size: 1, muted: !0, children: "This Studio's Sanity client cannot invoke the translation function. OpenAI mode requires @sanity/client 8.1 or newer." })
     ] }) });
   const handleModeChange = (mode) => {
     dispatch({