@focus-reactive/payload-plugin-translator 0.10.4 → 0.11.1

package/dist/server/features/translate-field/handler.js

@@ -2,6 +2,7 @@ import { getByPath, ServerResponse } from "../../shared";
 import { translateContent } from "../../../core/translation-pipeline";
 import { FieldTranslationInputSchema, MAX_FIELD_VALUE_BYTES } from "./model";
 import { resolveFieldSubtree } from "./resolveFieldSubtree";
+import { fetchSourceDocument } from "../../shared/payload/sourceDocument";
 const byteLength = (value)=>new TextEncoder().encode(JSON.stringify(value) ?? "").length;
 const noop = (value, level, message)=>({
         status: "noop",
@@ -31,16 +32,9 @@ const noop = (value, level, message)=>({
         const { collection_slug, field_path, target_lng, source_lng, doc_id } = parsed.data;
         const fields = this.config.schemaMap.get(collection_slug);
         if (!fields) return ServerResponse.badRequest(`Collection "${collection_slug}" is not available for translation`);
-        // Read the source value from the saved document in `source_lng` (fallbackLocale: false so an
-        // empty source reads as empty → noop, not a fallback). The doc also lets the resolver
-        // disambiguate `blocks` — their `blockType` lives in the data.
-        const sourceDoc = await req.payload.findByID({
-            collection: collection_slug,
-            id: doc_id,
-            locale: source_lng,
-            fallbackLocale: false,
-            depth: 0
-        });
+        // The whole document, not just the field: the resolver needs it to disambiguate `blocks`, whose
+        // `blockType` lives in the data.
+        const sourceDoc = await fetchSourceDocument(req.payload, collection_slug, doc_id, source_lng);
         const sourceValue = getByPath(sourceDoc, field_path);
         // Guard the *translated* payload (held synchronously through the provider call), not the
         // request body, which now carries no field value.

package/dist/server/modules/auto-translate/AutoTranslateEnqueue.hook.js

@@ -1,3 +1,4 @@
+import { hasDraftsEnabled } from "payload/shared";
 import { hasSourceContentChanged } from "../../../core/domain/auto-translate";
 import { AUTO_TRANSLATE_CUSTOM_KEY } from "../../../core/domain/auto-translate";
 import { AUTO_TRANSLATE_SKIP_CONTEXT_KEY } from "../../../types/AutoTranslateContext";
@@ -31,7 +32,7 @@ import { buildAutoTranslateTasks, passesPublishGate } from "./AutoTranslate.poli
                 return doc;
             }
             if (req.locale !== sourceLocale) return doc;
-            const hasDrafts = Boolean(collection.versions && collection.versions.drafts);
+            const hasDrafts = hasDraftsEnabled(collection);
             if (!passesPublishGate(doc, hasDrafts)) return doc;
             const schema = schemaMap.get(collection.slug);
             if (schema && !hasSourceContentChanged(previousDoc, doc, schema)) return doc;

package/dist/server/shared/guards/index.d.ts

@@ -1,3 +1,2 @@
 export type { TranslatableField } from "./field-guards";
 export { isTranslatableField, isLocalizedField, isRelationshipField } from "./field-guards";
-export { collectionHasDrafts } from "./collection-guards";

package/dist/server/shared/guards/index.js

@@ -1,4 +1,3 @@
 export { isTranslatableField, isLocalizedField, isRelationshipField } from "./field-guards";
-export { collectionHasDrafts } from "./collection-guards";
 
 //# sourceMappingURL=index.js.map

package/dist/server/shared/payload/sourceDocument.d.ts

@@ -1,8 +1,6 @@
 import type { CollectionSlug, Payload } from "payload";
 /**
- * Fetch a document's source-locale data with the exact shape the provenance fingerprint depends on
- * (`depth: 0`, the given locale). Used by the translation **write** path (fingerprints the source it
- * just translated) and, through {@link ProvenanceService}, by the staleness **read** path
- * (re-fingerprints the live source), so the fingerprint baseline can never drift between the two.
+ * The single source read: what "translate from X" resolves to. Both translation write paths and
+ * the staleness recompute must go through here, or the fingerprints they compare drift apart.
  */
 export declare function fetchSourceDocument(payload: Payload, collection: CollectionSlug, id: string, locale: string): Promise<import("payload").JsonObject & import("payload").TypeWithID>;

package/dist/server/shared/payload/sourceDocument.js

@@ -1,14 +1,19 @@
 /**
- * Fetch a document's source-locale data with the exact shape the provenance fingerprint depends on
- * (`depth: 0`, the given locale). Used by the translation **write** path (fingerprints the source it
- * just translated) and, through {@link ProvenanceService}, by the staleness **read** path
- * (re-fingerprints the live source), so the fingerprint baseline can never drift between the two.
+ * The single source read: what "translate from X" resolves to. Both translation write paths and
+ * the staleness recompute must go through here, or the fingerprints they compare drift apart.
  */ export function fetchSourceDocument(payload, collection, id, locale) {
     return payload.findByID({
         collection,
         id,
         locale,
-        depth: 0
+        depth: 0,
+        // The current version, as the editor sees it. A published-row read is empty whenever the source
+        // locale is unpublished — which is exactly what a publish scoped to the target locale leaves
+        // behind — and then every fresh translation fingerprints as stale.
+        draft: true,
+        // Payload's locale fallback resolves an empty source locale to the default locale's text, so
+        // "translate from fr" would translate English and fingerprint English as the French source.
+        fallbackLocale: false
     });
 }
 

package/dist/translation-providers/index.d.ts

@@ -1,2 +1,3 @@
 export type { TranslationProvider, TranslationInput, TranslationOutput, } from "../core/domain/translation-providers";
+export * from "./shared";
 export * from "./openai";

package/dist/translation-providers/index.js

@@ -1,10 +1,4 @@
-// Translation-provider implementations (adapters), one directory per vendor. Payload-free and
-// opt-in — each vendor pulls its own deps (e.g. `openai`). Kept OUT of the framework-agnostic core
-// so the core stays dependency-free; the PORT they implement lives in the core and is re-exported
-// here for convenience. Naming is explicit ("translation-providers") to leave room for other kinds
-// of providers later without a collision.
-// The port (contract) — source of truth is the core.
-// Vendor implementations.
+export * from "./shared";
 export * from "./openai";
 
 //# sourceMappingURL=index.js.map

package/dist/translation-providers/openai/OpenAI.shapes.d.ts

@@ -0,0 +1,52 @@
+export type OpenAIChatMessage = {
+    role: "system" | "user";
+    content: string;
+};
+/**
+ * `schema` is `Record<string, unknown>`, not `unknown`: a widened field is not assignable to the
+ * SDK's closed union and OpenAI.shapes.test.ts stops compiling.
+ */
+export type OpenAIResponseFormat = {
+    type: "json_object";
+} | {
+    type: "json_schema";
+    json_schema: {
+        name: string;
+        strict?: boolean;
+        schema: Record<string, unknown>;
+    };
+};
+export type OpenAIChatParams = {
+    model: string;
+    messages: OpenAIChatMessage[];
+    response_format?: OpenAIResponseFormat;
+    temperature?: number;
+    top_p?: number;
+    frequency_penalty?: number;
+    presence_penalty?: number;
+};
+export type OpenAIChatResult = {
+    choices: Array<{
+        message?: {
+            content?: string | null;
+        };
+    }>;
+};
+export type OpenAIRequestOptions = {
+    signal?: AbortSignal;
+};
+/**
+ * Any client with a `chat.completions.create` of this shape.
+ *
+ * Method syntax, not a property with a function type: property syntax is checked contravariantly
+ * under strictFunctionTypes and the real SDK's overloaded `create` stops being assignable.
+ *
+ * @since 0.11.0
+ */
+export type OpenAIClientShape = {
+    chat: {
+        completions: {
+            create(params: OpenAIChatParams, options?: OpenAIRequestOptions): Promise<OpenAIChatResult>;
+        };
+    };
+};

package/dist/translation-providers/openai/OpenAI.shapes.js

@@ -0,0 +1,13 @@
+// Never import from `openai` here, in any position: an SDK type would enter this package's emitted
+// declarations and force every consumer to install the SDK to type-check. Chat Completions rather
+// than the Responses API — that is what Azure, OpenRouter and LiteLLM gateways implement.
+/**
+ * Any client with a `chat.completions.create` of this shape.
+ *
+ * Method syntax, not a property with a function type: property syntax is checked contravariantly
+ * under strictFunctionTypes and the real SDK's overloaded `create` stops being assignable.
+ *
+ * @since 0.11.0
+ */ export { };
+
+//# sourceMappingURL=OpenAI.shapes.js.map

package/dist/translation-providers/openai/OpenAITranslation.provider.d.ts

@@ -1,145 +1,84 @@
-import type { TranslationProvider, TranslationInput, TranslationOutput } from "../../core/domain/translation-providers/TranslationProvider.interface";
-import type { ChatModel } from "openai/resources/index.mjs";
-/**
- * Function to transform text in dry run mode.
- * Receives the original text and returns the transformed text.
- */
-type DryRunTransformer = (text: string) => string | Promise<string>;
-/**
- * Configuration for dry run mode with custom transformer.
- */
-export type DryRunConfig = {
-    /** Custom transformer function for text */
-    transform: DryRunTransformer;
-    /** Delay in milliseconds before returning mock translation (simulates API latency) */
-    timeout?: number;
-};
-/**
- * Context passed to the system prompt builder function.
- */
-export type SystemPromptContext = {
-    /** Source language code (e.g., 'en', 'de') */
-    sourceLang: string;
-    /** Target language code (e.g., 'fr', 'es') */
-    targetLang: string;
-    /** Default system prompt that can be extended or replaced */
-    defaultPrompt: string;
-};
-/**
- * Function to build a custom system prompt for translation.
- */
-type SystemPromptBuilder = (context: SystemPromptContext) => string;
-export type OpenAIProviderConfig = {
-    /** OpenAI API key (required). Read it from an env var — never hard-code it. */
-    apiKey: string;
+import type { TranslationProvider } from "../../core/domain/translation-providers";
+import type { DryRunConfig, SystemPromptBuilder } from "../shared";
+import type { OpenAIClientShape } from "./OpenAI.shapes";
+import type { OpenAISamplingParams, OpenAIStructuredOutput } from "./openAIComplete";
+type OpenAIProviderBase = {
     /**
-     * OpenAI model to use for translation.
+     * Model used for translation.
      *
-     * @default 'gpt-4o'
-     *
-     * @example
-     * model: 'gpt-4o-mini'
+     * @default 'gpt-4o' — may move in a minor release; pin it if you need reproducibility.
      */
-    model?: (string & {}) | ChatModel;
+    model?: string;
     /**
-     * Custom system prompt builder for translation.
-     * Receives context with source/target languages and the default prompt.
-     *
-     * @example
-     * // Add custom instructions
-     * systemPrompt: ({ sourceLang, targetLang, defaultPrompt }) =>
-     *   `${defaultPrompt}\nUse formal language. Keep brand names unchanged.`
-     *
-     * @example
-     * // Completely custom prompt
-     * systemPrompt: ({ sourceLang, targetLang }) =>
-     *   `Translate JSON values from ${sourceLang} to ${targetLang}. Be concise.`
+     * Custom system-prompt builder. Receives the source and target languages plus the prompt this
+     * package would otherwise send, so you can extend it rather than rewrite it.
      */
     systemPrompt?: SystemPromptBuilder;
     /**
-     * When enabled, simulates translations without making actual API calls to OpenAI.
-     *
-     * - `true` — uses default transformer that reverses the text
-     * - `{ transform, timeout? }` — custom transformer with optional delay
-     *
-     * @example
-     * // Default behavior (reverse text, no delay)
-     * dryRun: true
-     *
-     * @example
-     * // Custom transformer with delay
-     * dryRun: {
-     *   transform: (text) => `[TRANSLATED] ${text}`,
-     *   timeout: 1000, // 1 second delay
-     * }
+     * Simulate translations without calling OpenAI — see {@link DryRunConfig}.
      *
      * @default false
+     * @deprecated Pass your own `client`, or build a provider with `createTranslationProvider({
+     * complete })`. Remove in next major. See docs/DEPRECATIONS.md#provider-dry-run
      */
     dryRun?: boolean | DryRunConfig;
     /**
-     * Per-request timeout in milliseconds for the OpenAI client. A translation job blocks on this
-     * call, so the OpenAI SDK default (10 minutes) is usually too long. Omit to keep the SDK default.
+     * Per-request timeout in milliseconds for the client this package builds.
      *
-     * @example
-     * timeout: 60_000 // 60s
+     * Ignored when you pass your own `client` — then the timeout is whatever you configured on it.
      *
+     * @default 60000
      * @since 0.6.0
      */
     timeout?: number;
     /**
-     * Maximum automatic retries the OpenAI client performs on transient errors (429, 5xx, network).
-     * Omit to keep the SDK default (2). Set `0` to disable retries.
+     * Maximum automatic retries on transient errors (429, 5xx, network) for the client this package
+     * builds. Ignored when you pass your own `client`.
      *
+     * @default the SDK's own default (2)
      * @since 0.6.0
      */
     maxRetries?: number;
-};
-/** @deprecated Use `createOpenAIProvider` function instead */
-export declare class OpenAITranslationProvider implements TranslationProvider {
-    private openAiClient;
-    private readonly config;
-    constructor(config: OpenAIProviderConfig);
-    translate(content: TranslationInput, souceLng: string, targetLng: string): Promise<TranslationOutput | null>;
     /**
-     * Builds the system prompt for translation.
-     */
-    private buildSystemPrompt;
-    /**
-     * Returns the transformer function for dry run mode.
-     * If dryRun is an object with transform, returns it.
-     * If dryRun is true, returns the default transformer that reverses text.
+     * Sampling parameters — see {@link OpenAISamplingParams}, which survives this option.
+     *
+     * @since 0.11.0
      */
-    private getDryRunTransformer;
+    sampling?: OpenAISamplingParams;
     /**
-     * Returns the timeout for dry run mode.
-     * If dryRun is an object with timeout, returns it.
-     * Otherwise returns 0 (no delay).
+     * Which structured-output envelope to send — see {@link OpenAIStructuredOutput}, which documents
+     * the trade-off and survives this option.
+     *
+     * @since 0.11.0
      */
-    private getDryRunTimeout;
-    private createMockTranslation;
+    structuredOutput?: OpenAIStructuredOutput;
+};
+/**
+ * Configuration for {@link createOpenAIProvider}: an API key **or** a ready-made client, never both.
+ *
+ * @deprecated Construct the client yourself and pass it to `openAIComplete`, which stays.
+ * Remove in next major. See docs/DEPRECATIONS.md#openai-client-construction
+ */
+export type OpenAIProviderConfig = OpenAIProviderBase & ({
+    apiKey: string;
+    client?: never;
+} | {
     /**
-     * Recursively transforms the values of an object or array using the provided transformer function.
-     * @param obj The object or value to transform.
-     * @param transformer The function to apply to each value.
-     * @returns The transformed object, array, or value.
+     * A ready-made client — the OpenAI SDK client, Azure, OpenRouter, a proxy. On this path the
+     * `openai` package is never loaded and `timeout` / `maxRetries` are yours, not ours.
+     *
+     * @since 0.11.0
      */
-    private transformObjectValues;
-}
+    client: OpenAIClientShape;
+    apiKey?: never;
+});
 /**
  * Creates an OpenAI translation provider.
  *
- * @example
- * ```ts
- * // Basic usage
- * createOpenAIProvider({ apiKey: process.env.OPENAI_API_KEY })
- *
- * // With options
- * createOpenAIProvider({
- *   apiKey: process.env.OPENAI_API_KEY,
- *   model: 'gpt-4o-mini',
- *   systemPrompt: ({ defaultPrompt }) => `${defaultPrompt}\nUse formal language.`,
- * })
- * ```
+ * @deprecated What this adds over `openAIComplete` is building the SDK client for you, and
+ * carrying `openai` as an optional dependency to do it. Construct the client yourself instead:
+ * `createTranslationProvider({ complete: openAIComplete({ client, model }) })`. Remove in next
+ * major. See the recipe in the README and docs/DEPRECATIONS.md#openai-client-construction
  */
-export declare function createOpenAIProvider(config: OpenAIProviderConfig): OpenAITranslationProvider;
+export declare function createOpenAIProvider(config: OpenAIProviderConfig): TranslationProvider;
 export {};

package/dist/translation-providers/openai/OpenAITranslation.provider.js

@@ -1,144 +1,56 @@
-import OpenAI from "openai";
-import { isObject } from "../../core/kernel/utils/isObject";
-/** @deprecated Use `createOpenAIProvider` function instead */ export class OpenAITranslationProvider {
-    openAiClient;
-    config;
-    constructor(config){
-        // `timeout`/`maxRetries` are passed through to the OpenAI SDK; `undefined` keeps the SDK
-        // defaults (10 min timeout, 2 retries). A blocking translation job rarely wants the full 10 min.
-        this.openAiClient = new OpenAI({
-            apiKey: config.apiKey,
-            timeout: config.timeout,
-            maxRetries: config.maxRetries
-        });
-        this.config = config;
-    }
-    async translate(content, souceLng, targetLng) {
-        if (this.config.dryRun) {
-            console.info("[DRY RUN] Translation simulation:", {
-                content,
-                sourceLang: souceLng,
-                targetLang: targetLng,
-                provider: "OpenAI"
-            });
-            const timeout = this.getDryRunTimeout();
-            if (timeout > 0) await new Promise((resolve)=>setTimeout(resolve, timeout));
-            const transformer = this.getDryRunTransformer();
-            return this.createMockTranslation(content, transformer);
-        }
-        const systemPrompt = this.buildSystemPrompt(souceLng, targetLng);
-        const chatCompletion = await this.openAiClient.chat.completions.create({
-            messages: [
-                {
-                    role: "system",
-                    content: systemPrompt
-                },
-                {
-                    role: "user",
-                    content: JSON.stringify(content)
-                }
-            ],
-            model: this.config.model ?? "gpt-4o",
-            temperature: 0,
-            top_p: 1,
-            frequency_penalty: 0,
-            presence_penalty: 0,
-            response_format: {
-                type: "json_object"
-            }
-        });
-        // Guard `choices[0]`: an empty `choices` array (e.g. content-filtered response) would otherwise
-        // throw a TypeError instead of the intended graceful `null`.
-        const translatedContent = chatCompletion.choices[0]?.message?.content;
-        if (!translatedContent) return null;
-        try {
-            return JSON.parse(translatedContent);
-        } catch  {
-            return null;
-        }
-    }
-    /**
-   * Builds the system prompt for translation.
-   */ buildSystemPrompt(sourceLang, targetLang) {
-        const defaultPrompt = `Translate the values from the JSON that the user will send you${sourceLang ? ` from ${sourceLang}` : ""} into ${targetLang}. Keep all JSON keys exactly as they are, only translate the values.
-The response should be a valid JSON object with the same structure and keys as the input, but with translated values.
-Maintain any special formatting, placeholders, or variables within the values if they exist.`;
-        if (this.config.systemPrompt) {
-            return this.config.systemPrompt({
-                sourceLang,
-                targetLang,
-                defaultPrompt
-            });
-        }
-        return defaultPrompt;
-    }
-    /**
-   * Returns the transformer function for dry run mode.
-   * If dryRun is an object with transform, returns it.
-   * If dryRun is true, returns the default transformer that reverses text.
-   */ getDryRunTransformer() {
-        if (typeof this.config.dryRun === "object" && this.config.dryRun.transform) {
-            return this.config.dryRun.transform;
-        }
-        return (text)=>text.split("").reverse().join("");
-    }
-    /**
-   * Returns the timeout for dry run mode.
-   * If dryRun is an object with timeout, returns it.
-   * Otherwise returns 0 (no delay).
-   */ getDryRunTimeout() {
-        if (typeof this.config.dryRun === "object" && this.config.dryRun.timeout) {
-            return this.config.dryRun.timeout;
-        }
-        return 0;
-    }
-    async createMockTranslation(content, transformer) {
-        try {
-            const mockTranslation = await this.transformObjectValues(content, async (value)=>{
-                if (typeof value === "string" && value.trim()) return transformer(value);
-                return value;
-            });
-            return mockTranslation;
-        } catch  {
-            return null;
-        }
-    }
-    /**
-   * Recursively transforms the values of an object or array using the provided transformer function.
-   * @param obj The object or value to transform.
-   * @param transformer The function to apply to each value.
-   * @returns The transformed object, array, or value.
-   */ async transformObjectValues(obj, transformer) {
-        if (Array.isArray(obj)) {
-            return Promise.all(obj.map((item)=>this.transformObjectValues(item, transformer)));
-        }
-        if (isObject(obj)) {
-            const result = {};
-            for (const [key, value] of Object.entries(obj)){
-                result[key] = await this.transformObjectValues(value, transformer);
-            }
-            return result;
-        }
-        return transformer(obj);
-    }
-}
+import { createTranslationProvider } from "../shared";
+import { loadOpenAIClient } from "./loadOpenAIClient";
+import { openAIComplete } from "./openAIComplete";
+const DEFAULT_MODEL = "gpt-4o";
+/** The SDK's own default is ten minutes — far too long when a translation blocks a live editor request. */ const DEFAULT_TIMEOUT_MS = 60_000;
 /**
  * Creates an OpenAI translation provider.
  *
- * @example
- * ```ts
- * // Basic usage
- * createOpenAIProvider({ apiKey: process.env.OPENAI_API_KEY })
- *
- * // With options
- * createOpenAIProvider({
- *   apiKey: process.env.OPENAI_API_KEY,
- *   model: 'gpt-4o-mini',
- *   systemPrompt: ({ defaultPrompt }) => `${defaultPrompt}\nUse formal language.`,
- * })
- * ```
+ * @deprecated What this adds over `openAIComplete` is building the SDK client for you, and
+ * carrying `openai` as an optional dependency to do it. Construct the client yourself instead:
+ * `createTranslationProvider({ complete: openAIComplete({ client, model }) })`. Remove in next
+ * major. See the recipe in the README and docs/DEPRECATIONS.md#openai-client-construction
  */ export function createOpenAIProvider(config) {
-    return new OpenAITranslationProvider(config);
+    const { model = DEFAULT_MODEL, systemPrompt, dryRun, sampling, structuredOutput } = config;
+    // The promise, not the client: two concurrent first calls would otherwise each start their own
+    // import. Per instance, never module-level — one consumer's client must not reach a differently
+    // configured provider in the same process.
+    let clientPromise;
+    const loadClientAndForgetOnFailure = async ()=>{
+        try {
+            // `apiKey` goes through unchanged — never defaulted to "". The SDK checks for `undefined`, so an
+            // empty string would build a client that 401s on every request instead of saying the key is
+            // missing.
+            return await loadOpenAIClient({
+                apiKey: config.apiKey,
+                timeout: config.timeout ?? DEFAULT_TIMEOUT_MS,
+                maxRetries: config.maxRetries
+            });
+        } catch (error) {
+            // A cached rejected promise makes one bad first call permanent — the job runner's retries
+            // would replay the same stale error.
+            clientPromise = undefined;
+            throw error;
+        }
+    };
+    const resolveClient = ()=>{
+        if (config.client) return Promise.resolve(config.client);
+        clientPromise ??= loadClientAndForgetOnFailure();
+        return clientPromise;
+    };
+    return createTranslationProvider({
+        systemPrompt,
+        dryRun,
+        complete: async (request)=>{
+            const client = await resolveClient();
+            return openAIComplete({
+                client,
+                model,
+                sampling,
+                structuredOutput
+            })(request);
+        }
+    });
 }
 
 //# sourceMappingURL=OpenAITranslation.provider.js.map

package/dist/translation-providers/openai/OpenAITranslationLegacy.provider.d.ts

@@ -0,0 +1,11 @@
+import type { TranslationInput, TranslationOutput, TranslationProvider } from "../../core/domain/translation-providers";
+import type { OpenAIProviderConfig } from "./OpenAITranslation.provider";
+/**
+ * @deprecated Use {@link createOpenAIProvider} instead.
+ * See docs/DEPRECATIONS.md#openai-translation-provider-class
+ */
+export declare class OpenAITranslationProvider implements TranslationProvider {
+    private readonly inner;
+    constructor(config: OpenAIProviderConfig);
+    translate(input: TranslationInput, sourceLng: string, targetLng: string): Promise<TranslationOutput | null>;
+}

package/dist/translation-providers/openai/OpenAITranslationLegacy.provider.js

@@ -0,0 +1,15 @@
+import { createOpenAIProvider } from "./OpenAITranslation.provider";
+/**
+ * @deprecated Use {@link createOpenAIProvider} instead.
+ * See docs/DEPRECATIONS.md#openai-translation-provider-class
+ */ export class OpenAITranslationProvider {
+    inner;
+    constructor(config){
+        this.inner = createOpenAIProvider(config);
+    }
+    translate(input, sourceLng, targetLng) {
+        return this.inner.translate(input, sourceLng, targetLng);
+    }
+}
+
+//# sourceMappingURL=OpenAITranslationLegacy.provider.js.map

package/dist/translation-providers/openai/index.d.ts

@@ -1 +1,6 @@
-export { OpenAITranslationProvider, createOpenAIProvider, type OpenAIProviderConfig, type DryRunConfig, type SystemPromptContext, } from "./OpenAITranslation.provider";
+export { createOpenAIProvider } from "./OpenAITranslation.provider";
+export { OpenAITranslationProvider } from "./OpenAITranslationLegacy.provider";
+export type { OpenAIProviderConfig } from "./OpenAITranslation.provider";
+export type { OpenAIClientShape } from "./OpenAI.shapes";
+export { openAIComplete } from "./openAIComplete";
+export type { OpenAISamplingParams, OpenAIStructuredOutput } from "./openAIComplete";

package/dist/translation-providers/openai/index.js

@@ -1,5 +1,5 @@
-// OpenAI translation provider — one vendor implementation of the core `TranslationProvider`
-// port. Payload-free; pulls the `openai` SDK (opt-in).
-export { OpenAITranslationProvider, createOpenAIProvider } from "./OpenAITranslation.provider";
+export { createOpenAIProvider } from "./OpenAITranslation.provider";
+export { OpenAITranslationProvider } from "./OpenAITranslationLegacy.provider";
+export { openAIComplete } from "./openAIComplete";
 
 //# sourceMappingURL=index.js.map

package/dist/translation-providers/openai/loadOpenAIClient.d.ts

@@ -0,0 +1,24 @@
+import type { OpenAIClientShape } from "./OpenAI.shapes";
+export type OpenAIClientOptions = {
+    apiKey?: string;
+    timeout?: number;
+    maxRetries?: number;
+};
+type OpenAISdkModule = {
+    default: new (opts: OpenAIClientOptions) => unknown;
+};
+export type OpenAISdkImporter = () => Promise<OpenAISdkModule>;
+/**
+ * Was `moduleSpecifier` itself missing, or one of its dependencies? Exported for its own test; not
+ * public API.
+ */
+export declare function isModuleNotFound(cause: unknown, moduleSpecifier: string): boolean;
+/**
+ * Constructs an OpenAI SDK client, importing the `openai` package on every call — callers memoize.
+ * Reached only when a consumer passed `apiKey`; a consumer who injects a `client` never runs this
+ * module.
+ *
+ * @throws ProviderConfigurationError for a missing package, a broken install, or rejected options.
+ */
+export declare function loadOpenAIClient(options: OpenAIClientOptions, importSdk?: OpenAISdkImporter): Promise<OpenAIClientShape>;
+export {};