@strapi-ai/translator 0.0.1

package/dist/server/src/application/assemble-translation-patch.d.ts

@@ -0,0 +1,3 @@
+import { TranslatableUnit, TranslatedUnit } from '../domain/translation-unit';
+import { TranslationPatch } from '../domain/translation-patch';
+export declare const assembleTranslationPatch: (sourceUnits: TranslatableUnit[], translatedUnits: TranslatedUnit[]) => TranslationPatch;

package/dist/server/src/application/extract-translatable-units.d.ts

@@ -0,0 +1,9 @@
+import { TranslatableUnit } from '../domain/translation-unit';
+import { ValueCodec } from '../domain/value-codecs';
+type Schema = Record<string, any>;
+export interface ExtractTranslatableUnitsOptions {
+    excludeFieldNames?: string[];
+    valueCodecs?: ValueCodec[];
+}
+export declare const extractTranslatableUnits: (contentType: Schema, entry: Record<string, any>, components?: Record<string, Schema>, options?: ExtractTranslatableUnitsOptions) => TranslatableUnit[];
+export {};

package/dist/server/src/application/translate-entry.d.ts

@@ -0,0 +1,17 @@
+import { TranslationSessionEvent } from '../domain/translation-event';
+import { FieldPath } from '../domain/field-path';
+import { TranslationProvider } from './translation-provider';
+type Schema = Record<string, any>;
+export interface TranslateEntryInput {
+    contentType: Schema;
+    entry: Record<string, any>;
+    components?: Record<string, Schema>;
+    sourceLocale?: string;
+    targetLocale: string;
+    translator: TranslationProvider;
+    signal?: AbortSignal;
+    include?: FieldPath[];
+    concurrency?: number;
+}
+export declare function translateEntry(input: TranslateEntryInput): AsyncGenerator<TranslationSessionEvent>;
+export {};

package/dist/server/src/application/translation-provider.d.ts

@@ -0,0 +1,33 @@
+import { TranslatableUnit } from '../domain/translation-unit';
+export interface TranslationProviderContext {
+    sourceLocale?: string;
+    targetLocale: string;
+}
+export type TranslationProviderEvent = {
+    type: 'delta';
+    delta: string;
+    content: string;
+} | {
+    type: 'completed';
+    translatedText: string;
+} | {
+    type: 'retry_scheduled';
+    attempt: number;
+    delayMs: number;
+    reason: string;
+    status?: number;
+} | {
+    type: 'fallback_used';
+    fromModel: string;
+    toModel: string;
+    reason: string;
+};
+export declare class TranslationCredentialError extends Error {
+    readonly cause?: unknown;
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+export interface TranslationProvider {
+    translateUnit(unit: TranslatableUnit, context: TranslationProviderContext, signal?: AbortSignal): AsyncGenerator<TranslationProviderEvent>;
+}

package/dist/server/src/bootstrap.d.ts

@@ -0,0 +1,5 @@
+import { Core } from '@strapi/strapi';
+declare const _default: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => void;
+export default _default;

package/dist/server/src/config/index.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    default: () => import('../domain/translation-config').EditableTranslationConfig;
+    validator(config: Record<string, unknown>): void;
+};
+export default _default;

package/dist/server/src/controllers/index.d.ts

@@ -0,0 +1,27 @@
+declare const _default: {
+    translation: ({ strapi }: {
+        strapi: import('@strapi/types/dist/core').Strapi;
+    }) => {
+        getConfig(ctx: Omit<import('koa').Context, "request"> & {
+            request: import('koa').Request & {
+                body?: unknown;
+            };
+        }): Promise<void>;
+        setConfig(ctx: Omit<import('koa').Context, "request"> & {
+            request: import('koa').Request & {
+                body?: unknown;
+            };
+        }): Promise<void>;
+        listModels(ctx: Omit<import('koa').Context, "request"> & {
+            request: import('koa').Request & {
+                body?: import('./translation.controller').ListModelsRequest;
+            };
+        }): Promise<void>;
+        translate(ctx: Omit<import('koa').Context, "request"> & {
+            request: import('koa').Request & {
+                body?: import('./translation.controller').TranslateRequest;
+            };
+        }): Promise<void>;
+    };
+};
+export default _default;

package/dist/server/src/controllers/translation.controller.d.ts

@@ -0,0 +1,28 @@
+import { Context } from 'koa';
+import { Core } from '@strapi/strapi';
+type AdminRequestContext<Body = unknown> = Omit<Context, 'request'> & {
+    request: Context['request'] & {
+        body?: Body;
+    };
+};
+export interface TranslateRequest {
+    contentType?: Record<string, any>;
+    entry?: Record<string, any>;
+    components?: Record<string, any>;
+    sourceLocale?: string;
+    targetLocale?: string;
+    include?: Array<Array<string | number>>;
+}
+export interface ListModelsRequest {
+    apiKey?: string;
+    baseUrl?: string;
+}
+declare const controllers: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    getConfig(ctx: AdminRequestContext): Promise<void>;
+    setConfig(ctx: AdminRequestContext): Promise<void>;
+    listModels(ctx: AdminRequestContext<ListModelsRequest>): Promise<void>;
+    translate(ctx: AdminRequestContext<TranslateRequest>): Promise<void>;
+};
+export default controllers;

package/dist/server/src/domain/field-path.d.ts

@@ -0,0 +1,6 @@
+export type FieldPathSegment = string | number;
+export type FieldPath = readonly FieldPathSegment[];
+export declare const pathToId: (path: FieldPath) => string;
+export declare const sanitizeFieldPaths: (value: unknown) => FieldPath[] | undefined;
+export declare const pathsEqual: (left: FieldPath, right: FieldPath) => boolean;
+export declare const cloneWithSetByPath: <T>(source: T, path: FieldPath, value: unknown) => T;

package/dist/server/src/domain/translation-config.d.ts

@@ -0,0 +1,27 @@
+export interface TranslationConfig {
+    apiKey: string;
+    baseUrl: string;
+    model: string;
+    fallbackModel: string;
+    systemPrompt: string;
+    temperature: number;
+    maxTokens: number;
+    concurrency: number;
+    maxRetries: number;
+    retryBaseDelayMs: number;
+    retryMaxDelayMs: number;
+}
+export type EditableTranslationConfig = Omit<TranslationConfig, 'apiKey'>;
+export interface TranslationConfigUpdateInput extends Partial<EditableTranslationConfig> {
+    apiKey?: string | null;
+}
+export interface PublicTranslationConfig extends EditableTranslationConfig {
+    apiKeyConfigured: boolean;
+    apiKeyPreview: string;
+}
+export declare const DEFAULT_TRANSLATION_CONFIG: TranslationConfig;
+export declare const pickEditableTranslationConfig: (input: Record<string, unknown> | null | undefined) => Partial<EditableTranslationConfig>;
+export declare const normalizeTranslationConfig: (input?: Partial<TranslationConfig>) => TranslationConfig;
+export declare const selectEditableTranslationConfig: (config: TranslationConfig) => EditableTranslationConfig;
+export declare const normalizeEditableTranslationConfig: (input?: Partial<EditableTranslationConfig>) => EditableTranslationConfig;
+export declare const toPublicTranslationConfig: (config: TranslationConfig) => PublicTranslationConfig;

package/dist/server/src/domain/translation-event.d.ts

@@ -0,0 +1,59 @@
+import { FieldPath } from './field-path';
+import { TranslationPatch } from './translation-patch';
+import { TranslatableUnit } from './translation-unit';
+export interface TranslationSessionSummary {
+    totalUnits: number;
+    succeededUnits: number;
+    failedUnits: number;
+    failedUnitIds: string[];
+}
+export type TranslationSessionEvent = {
+    type: 'session_started';
+    sourceLocale?: string;
+    targetLocale: string;
+    totalUnits: number;
+    unitPaths: FieldPath[];
+} | {
+    type: 'unit_started';
+    unit: TranslatableUnit;
+} | {
+    type: 'unit_delta';
+    unitId: string;
+    path: FieldPath;
+    delta: string;
+    content: string;
+} | {
+    type: 'unit_retry_scheduled';
+    unitId: string;
+    path: FieldPath;
+    attempt: number;
+    delayMs: number;
+    reason: string;
+} | {
+    type: 'unit_fallback_used';
+    unitId: string;
+    path: FieldPath;
+    fromModel: string;
+    toModel: string;
+    reason: string;
+} | {
+    type: 'unit_completed';
+    unitId: string;
+    path: FieldPath;
+    translatedText: string;
+} | {
+    type: 'unit_failed';
+    unitId: string;
+    path: FieldPath;
+    error: string;
+} | {
+    type: 'session_completed';
+    patch: TranslationPatch;
+    summary: TranslationSessionSummary;
+} | {
+    type: 'session_aborted';
+    summary: TranslationSessionSummary;
+} | {
+    type: 'session_failed';
+    error: string;
+};

package/dist/server/src/domain/translation-patch.d.ts

@@ -0,0 +1,11 @@
+import { FieldPath } from './field-path';
+export interface TranslationPatchOperation {
+    unitId: string;
+    path: FieldPath;
+    value: unknown;
+}
+export interface TranslationPatch {
+    operations: TranslationPatchOperation[];
+}
+export declare const createEmptyTranslationPatch: () => TranslationPatch;
+export declare const applyTranslationPatch: <T>(source: T, patch: TranslationPatch) => T;

package/dist/server/src/domain/translation-unit.d.ts

@@ -0,0 +1,28 @@
+import { FieldPath } from './field-path';
+export type TranslatableFieldType = 'string' | 'text' | 'richtext' | 'blocks' | 'json';
+export interface TranslatableUnit {
+    id: string;
+    path: FieldPath;
+    fieldName: string;
+    fieldType: TranslatableFieldType;
+    sourceValue: unknown;
+    encodedText: string;
+    metadata: {
+        schemaType: string;
+        component?: string;
+        dynamicZoneComponent?: string;
+    };
+}
+export interface TranslatedUnit {
+    id: string;
+    path: FieldPath;
+    translatedText: string;
+}
+export declare const createTranslatableUnit: (input: {
+    path: FieldPath;
+    fieldName: string;
+    fieldType: TranslatableFieldType;
+    sourceValue: unknown;
+    encodedText: string;
+    metadata?: TranslatableUnit["metadata"];
+}) => TranslatableUnit;

package/dist/server/src/domain/value-codecs/index.d.ts

@@ -0,0 +1,3 @@
+import { ValueCodec } from './types';
+export declare const createDefaultValueCodecs: () => ValueCodec[];
+export type { EncodedValueUnit, ValueCodec } from './types';

package/dist/server/src/domain/value-codecs/string-codec.d.ts

@@ -0,0 +1,2 @@
+import { ValueCodec } from './types';
+export declare const createStringValueCodec: () => ValueCodec;

package/dist/server/src/domain/value-codecs/structured-value-codec.d.ts

@@ -0,0 +1,3 @@
+import { TranslatableFieldType } from '../translation-unit';
+import { ValueCodec } from './types';
+export declare const createStructuredValueCodec: (fieldType: Extract<TranslatableFieldType, "blocks" | "json">) => ValueCodec;

package/dist/server/src/domain/value-codecs/types.d.ts

@@ -0,0 +1,11 @@
+import { FieldPath } from '../field-path';
+import { TranslatableFieldType } from '../translation-unit';
+export interface EncodedValueUnit {
+    pathSuffix: FieldPath;
+    sourceValue: string;
+    encodedText: string;
+}
+export interface ValueCodec {
+    fieldTypes: TranslatableFieldType[];
+    extract(value: unknown): EncodedValueUnit[];
+}

package/dist/server/src/index.d.ts

@@ -0,0 +1,64 @@
+declare const _default: {
+    register(): void;
+    bootstrap: ({ strapi }: {
+        strapi: import('@strapi/types/dist/core').Strapi;
+    }) => void;
+    destroy(): void;
+    config: {
+        default: () => import('./domain/translation-config').EditableTranslationConfig;
+        validator(config: Record<string, unknown>): void;
+    };
+    controllers: {
+        translation: ({ strapi }: {
+            strapi: import('@strapi/types/dist/core').Strapi;
+        }) => {
+            getConfig(ctx: Omit<import('koa').Context, "request"> & {
+                request: import('koa').Request & {
+                    body?: unknown;
+                };
+            }): Promise<void>;
+            setConfig(ctx: Omit<import('koa').Context, "request"> & {
+                request: import('koa').Request & {
+                    body?: unknown;
+                };
+            }): Promise<void>;
+            listModels(ctx: Omit<import('koa').Context, "request"> & {
+                request: import('koa').Request & {
+                    body?: import('./controllers/translation.controller').ListModelsRequest;
+                };
+            }): Promise<void>;
+            translate(ctx: Omit<import('koa').Context, "request"> & {
+                request: import('koa').Request & {
+                    body?: import('./controllers/translation.controller').TranslateRequest;
+                };
+            }): Promise<void>;
+        };
+    };
+    routes: {
+        admin: {
+            type: string;
+            routes: {
+                method: string;
+                path: string;
+                handler: string;
+                config: {
+                    policies: {
+                        name: string;
+                        config: {
+                            actions: string[];
+                        };
+                    }[];
+                };
+            }[];
+        };
+    };
+    services: {
+        'translation-session-service': ({ strapi }: {
+            strapi: import('@strapi/types/dist/core').Strapi;
+        }) => import('./infrastructure/strapi/translation-session-service').TranslationSessionService;
+    };
+    contentTypes: {};
+    policies: {};
+    middlewares: {};
+};
+export default _default;

package/dist/server/src/infrastructure/llm/chat-completion-client.d.ts

@@ -0,0 +1,18 @@
+export interface ChatMessage {
+    role: 'system' | 'user' | 'assistant';
+    content: string;
+}
+export interface ChatCompletionRequest {
+    model: string;
+    messages: ChatMessage[];
+    temperature: number;
+    maxTokens?: number;
+    signal?: AbortSignal;
+}
+export interface ChatCompletionStreamChunk {
+    delta: string;
+    finishReason?: string;
+}
+export interface ChatCompletionClient {
+    streamCompletion(request: ChatCompletionRequest): AsyncGenerator<ChatCompletionStreamChunk>;
+}

package/dist/server/src/infrastructure/llm/llm-translation-provider.d.ts

@@ -0,0 +1,15 @@
+import { TranslationProvider } from '../../application/translation-provider';
+import { ChatCompletionClient } from './chat-completion-client';
+export interface LLMTranslationProviderConfig {
+    client: ChatCompletionClient;
+    model: string;
+    fallbackModel?: string;
+    systemPrompt: string;
+    temperature: number;
+    maxTokens?: number;
+    maxRetries: number;
+    retryBaseDelayMs?: number;
+    retryMaxDelayMs?: number;
+    sleep?: (ms: number) => Promise<void>;
+}
+export declare const createLLMTranslationProvider: (config: LLMTranslationProviderConfig) => TranslationProvider;

package/dist/server/src/infrastructure/llm/model-list-client.d.ts

@@ -0,0 +1,19 @@
+export interface ProviderModel {
+    id: string;
+    label: string;
+}
+export type ModelListFetch = (input: string, init?: {
+    headers?: Record<string, string>;
+    signal?: AbortSignal;
+}) => Promise<{
+    ok: boolean;
+    status: number;
+    statusText: string;
+    json: () => Promise<unknown>;
+}>;
+export interface ModelListClientConfig {
+    apiKey: string;
+    baseUrl: string;
+    fetch?: ModelListFetch;
+}
+export declare const listOpenAICompatibleModels: (config: ModelListClientConfig) => Promise<ProviderModel[]>;

package/dist/server/src/infrastructure/llm/openai-chat-completion-client.d.ts

@@ -0,0 +1,6 @@
+import { ChatCompletionClient } from './chat-completion-client';
+export interface OpenAIChatCompletionClientConfig {
+    apiKey: string;
+    baseUrl: string;
+}
+export declare const createOpenAIChatCompletionClient: (config: OpenAIChatCompletionClientConfig) => ChatCompletionClient;

package/dist/server/src/infrastructure/strapi/reconcile-schema.d.ts

@@ -0,0 +1,7 @@
+import { Core } from '@strapi/strapi';
+type Schema = Record<string, any>;
+export declare const reconcileContentTypeSchema: (strapi: Core.Strapi, contentType: Schema, components?: Record<string, Schema>) => {
+    contentType: Schema;
+    components: Record<string, Schema>;
+};
+export {};

package/dist/server/src/infrastructure/strapi/secret-cipher.d.ts

@@ -0,0 +1,8 @@
+export interface SecretCipher {
+    encrypt: (plain: string) => string;
+    decrypt: (payload: string) => string;
+}
+export interface SecretCipherConfig {
+    key: string;
+}
+export declare const createSecretCipher: (config: SecretCipherConfig) => SecretCipher;

package/dist/server/src/infrastructure/strapi/translation-config-repository.d.ts

@@ -0,0 +1,16 @@
+import { Core } from '@strapi/strapi';
+import { PublicTranslationConfig, TranslationConfig, TranslationConfigUpdateInput } from '../../domain/translation-config';
+import { SecretCipher } from './secret-cipher';
+export declare const PLUGIN_ID = "ai-translator";
+type StrapiConfigRepositoryOptions = {
+    pluginId?: string;
+    storeKey?: string;
+    cipher?: SecretCipher;
+};
+export interface TranslationConfigRepository {
+    getConfig: () => Promise<TranslationConfig>;
+    getPublicConfig: () => Promise<PublicTranslationConfig>;
+    setEditableConfig: (input: TranslationConfigUpdateInput) => Promise<PublicTranslationConfig>;
+}
+export declare const createTranslationConfigRepository: (strapi: Core.Strapi, options?: StrapiConfigRepositoryOptions) => TranslationConfigRepository;
+export {};

package/dist/server/src/infrastructure/strapi/translation-session-service.d.ts

@@ -0,0 +1,37 @@
+import { Core } from '@strapi/strapi';
+import { TranslationProvider } from '../../application/translation-provider';
+import { TranslationSessionEvent } from '../../domain/translation-event';
+import { PublicTranslationConfig, TranslationConfigUpdateInput } from '../../domain/translation-config';
+import { ChatCompletionClient } from '../llm/chat-completion-client';
+import { LLMTranslationProviderConfig } from '../llm/llm-translation-provider';
+import { OpenAIChatCompletionClientConfig } from '../llm/openai-chat-completion-client';
+import { ModelListClientConfig, ProviderModel } from '../llm/model-list-client';
+import { TranslationConfigRepository } from './translation-config-repository';
+type Schema = Record<string, any>;
+export interface TranslationSessionInput {
+    contentType: Schema;
+    entry: Record<string, any>;
+    components?: Record<string, Schema>;
+    sourceLocale?: string;
+    targetLocale: string;
+    signal?: AbortSignal;
+    include?: unknown;
+}
+export interface ListModelsDraftCredentials {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export interface TranslationSessionService {
+    getConfig: () => Promise<PublicTranslationConfig>;
+    updateConfig: (input: TranslationConfigUpdateInput) => Promise<PublicTranslationConfig>;
+    listModels: (draft?: ListModelsDraftCredentials) => Promise<ProviderModel[]>;
+    createTranslationStream: (input: TranslationSessionInput) => AsyncGenerator<TranslationSessionEvent>;
+}
+interface TranslationSessionServiceDependencies {
+    configRepository?: TranslationConfigRepository;
+    createChatClient?: (config: OpenAIChatCompletionClientConfig) => ChatCompletionClient;
+    createTranslationProvider?: (config: LLMTranslationProviderConfig) => TranslationProvider;
+    listModels?: (config: ModelListClientConfig) => Promise<ProviderModel[]>;
+}
+export declare const createTranslationSessionService: (strapi: Core.Strapi, dependencies?: TranslationSessionServiceDependencies) => TranslationSessionService;
+export {};

package/dist/server/src/routes/index.d.ts

@@ -0,0 +1,19 @@
+declare const _default: {
+    admin: {
+        type: string;
+        routes: {
+            method: string;
+            path: string;
+            handler: string;
+            config: {
+                policies: {
+                    name: string;
+                    config: {
+                        actions: string[];
+                    };
+                }[];
+            };
+        }[];
+    };
+};
+export default _default;

package/dist/server/src/services/index.d.ts

@@ -0,0 +1,7 @@
+import { Core } from '@strapi/strapi';
+declare const _default: {
+    'translation-session-service': ({ strapi }: {
+        strapi: Core.Strapi;
+    }) => import('../infrastructure/strapi/translation-session-service').TranslationSessionService;
+};
+export default _default;

package/package.json

@@ -0,0 +1,87 @@
+{
+  "name": "@strapi-ai/translator",
+  "version": "0.0.1",
+  "description": "AI translation workflow plugin for Strapi",
+  "keywords": [
+    "strapi",
+    "plugin",
+    "translation",
+    "ai",
+    "llm"
+  ],
+  "license": "MIT",
+  "author": "brighill (https://github.com/brighill)",
+  "homepage": "https://github.com/strapi-ai/translator#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/strapi-ai/translator.git"
+  },
+  "bugs": {
+    "url": "https://github.com/strapi-ai/translator/issues"
+  },
+  "engines": {
+    "node": ">=20.0.0 <=24.x.x"
+  },
+  "type": "commonjs",
+  "exports": {
+    "./package.json": "./package.json",
+    "./strapi-admin": {
+      "types": "./dist/admin/src/index.d.ts",
+      "source": "./admin/src/index.ts",
+      "import": "./dist/admin/index.mjs",
+      "require": "./dist/admin/index.js",
+      "default": "./dist/admin/index.js"
+    },
+    "./strapi-server": {
+      "types": "./dist/server/src/index.d.ts",
+      "source": "./server/src/index.ts",
+      "import": "./dist/server/index.mjs",
+      "require": "./dist/server/index.js",
+      "default": "./dist/server/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "strapi-plugin build",
+    "watch": "strapi-plugin watch",
+    "check": "tsc --noEmit -p server/tsconfig.json && tsc --noEmit -p admin/tsconfig.json",
+    "verify": "strapi-plugin verify"
+  },
+  "dependencies": {
+    "openai": "^6.46.0",
+    "react-intl": "^7.1.11"
+  },
+  "devDependencies": {
+    "@strapi/design-system": "^2.2.2",
+    "@strapi/icons": "^2.2.2",
+    "@strapi/sdk-plugin": "^6.1.1",
+    "@strapi/strapi": "^5.50.1",
+    "@strapi/typescript-utils": "^5.50.1",
+    "@strapi/utils": "^5.50.1",
+    "@types/react": "^18.3.31",
+    "@types/react-dom": "^18.3.7",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "react-router-dom": "^6.30.0",
+    "styled-components": "^6.4.3",
+    "typescript": "^5.9.3"
+  },
+  "peerDependencies": {
+    "@strapi/design-system": "^2.0.0",
+    "@strapi/icons": "^2.0.0",
+    "@strapi/strapi": ">=5.12.3 <6.0.0",
+    "@strapi/utils": ">=5.12.3 <6.0.0",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "react-router-dom": "^6.30.0",
+    "styled-components": "^6.1.17"
+  },
+  "strapi": {
+    "kind": "plugin",
+    "name": "ai-translator",
+    "displayName": "AI Translator",
+    "description": "Translate localized content with any OpenAI-compatible model, with streaming review before apply"
+  }
+}