@plasius/ai 1.1.4 → 1.1.6

package/dist/platform/openai-adapter.js

@@ -0,0 +1,398 @@
+import { performance } from "node:perf_hooks";
+import { AICapability, } from "./index.js";
+import { fetchWithPolicy } from "./http-resilience.js";
+function normalizeBaseUrl(baseUrl) {
+    const normalized = (baseUrl ?? "https://api.openai.com/v1").trim();
+    return normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
+}
+function resolveFetch(fetchFn) {
+    const resolved = fetchFn ?? (typeof fetch !== "undefined" ? fetch : undefined);
+    if (!resolved) {
+        throw new Error("No fetch implementation available for OpenAI adapter.");
+    }
+    return resolved;
+}
+function asRecord(value) {
+    return value && typeof value === "object" ? value : {};
+}
+function asNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function asString(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+async function parseResponseBody(response) {
+    const contentType = response.headers.get("content-type") ?? "";
+    if (contentType.includes("application/json")) {
+        return await response.json();
+    }
+    const text = await response.text();
+    if (!text) {
+        return undefined;
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+function resolveErrorMessage(body, fallback) {
+    const payload = asRecord(body);
+    const nested = asRecord(payload.error);
+    return (asString(nested.message) ??
+        asString(payload.message) ??
+        asString(payload.error) ??
+        fallback);
+}
+function requireApiKey(apiKey) {
+    const trimmed = apiKey.trim();
+    if (!trimmed) {
+        throw new Error("OpenAI API key is required.");
+    }
+    return trimmed;
+}
+function usageFromPayload(payload) {
+    const usagePayload = asRecord(payload);
+    const inputTokens = usagePayload.prompt_tokens ?? usagePayload.input_tokens;
+    const outputTokens = usagePayload.completion_tokens ?? usagePayload.output_tokens;
+    const totalTokens = usagePayload.total_tokens;
+    const usage = {};
+    if (asNumber(inputTokens) !== undefined) {
+        usage.inputTokens = inputTokens;
+    }
+    if (asNumber(outputTokens) !== undefined) {
+        usage.outputTokens = outputTokens;
+    }
+    if (asNumber(totalTokens) !== undefined) {
+        usage.totalTokens = totalTokens;
+    }
+    return Object.keys(usage).length > 0 ? usage : undefined;
+}
+function createBaseCompletion(type, model, requestor, durationMs, usage) {
+    return {
+        partitionKey: requestor,
+        id: crypto.randomUUID(),
+        type,
+        model,
+        createdAt: new Date().toISOString(),
+        durationMs,
+        usage: usage ?? {},
+    };
+}
+function extractChatMessage(body) {
+    const root = asRecord(body);
+    const choices = Array.isArray(root.choices) ? root.choices : [];
+    const firstChoice = choices[0] && typeof choices[0] === "object" ? asRecord(choices[0]) : {};
+    const message = asRecord(firstChoice.message);
+    const content = message.content;
+    if (typeof content === "string" && content.length > 0) {
+        return content;
+    }
+    if (Array.isArray(content)) {
+        const text = content
+            .map((part) => {
+            const maybePart = asRecord(part);
+            return asString(maybePart.text) ?? "";
+        })
+            .join("")
+            .trim();
+        if (text.length > 0) {
+            return text;
+        }
+    }
+    throw new Error("OpenAI chat response did not contain assistant content.");
+}
+function extractImageUrl(body) {
+    const root = asRecord(body);
+    const data = Array.isArray(root.data) ? root.data : [];
+    const first = data[0] && typeof data[0] === "object" ? asRecord(data[0]) : {};
+    const url = asString(first.url);
+    const b64 = asString(first.b64_json);
+    if (url) {
+        return new URL(url);
+    }
+    if (b64) {
+        return new URL(`data:image/png;base64,${b64}`);
+    }
+    throw new Error("OpenAI image generation response did not contain image data.");
+}
+function extractTranscriptionText(body) {
+    const root = asRecord(body);
+    const text = asString(root.text) ?? asString(root.output_text);
+    if (!text) {
+        throw new Error("OpenAI transcription response did not contain text.");
+    }
+    return text;
+}
+function parseGeneratedModel(content) {
+    const trimmed = content.trim();
+    if (!trimmed) {
+        return {
+            modelId: crypto.randomUUID(),
+        };
+    }
+    try {
+        const parsed = JSON.parse(trimmed);
+        const root = asRecord(parsed);
+        const modelId = asString(root.modelId);
+        const artifactUrl = asString(root.artifactUrl);
+        if (modelId) {
+            return {
+                modelId,
+                artifactUrl: artifactUrl ? new URL(artifactUrl) : undefined,
+            };
+        }
+    }
+    catch {
+        // Fallback to plain text handling below.
+    }
+    return {
+        modelId: trimmed,
+    };
+}
+export function createOpenAIAdapter(options = {}) {
+    const providerId = (options.id ?? "openai").trim() || "openai";
+    const baseUrl = normalizeBaseUrl(options.baseUrl);
+    const fetcher = resolveFetch(options.fetchFn);
+    const chatWithAI = async (request) => {
+        const startedAt = performance.now();
+        const apiKey = requireApiKey(request.apiKey);
+        const resolvedModel = request.model || options.defaultModels?.chat || "gpt-4.1-mini";
+        const response = await fetchWithPolicy({
+            url: `${baseUrl}/chat/completions`,
+            operation: "OpenAI chat request",
+            fetchFn: fetcher,
+            policy: options.httpPolicy,
+            createRequestInit: () => ({
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${apiKey}`,
+                    "Content-Type": "application/json",
+                    "Idempotency-Key": request.traceId,
+                    "X-Request-Id": request.traceId,
+                    "X-Plasius-Client": "@plasius/ai/openai-adapter",
+                },
+                body: JSON.stringify({
+                    model: resolvedModel,
+                    messages: [
+                        ...(request.context
+                            ? [{ role: "system", content: request.context }]
+                            : []),
+                        { role: "user", content: request.input },
+                    ],
+                }),
+            }),
+        });
+        const body = await parseResponseBody(response);
+        if (!response.ok) {
+            throw new Error(resolveErrorMessage(body, `OpenAI chat request failed (${response.status} ${response.statusText}).`));
+        }
+        const message = extractChatMessage(body);
+        const usage = usageFromPayload(asRecord(body).usage);
+        const durationMs = performance.now() - startedAt;
+        const base = createBaseCompletion("chat", resolvedModel, request.userId, durationMs, usage);
+        return {
+            ...base,
+            message,
+            outputUser: "assistant",
+        };
+    };
+    const synthesizeSpeech = async (request) => {
+        const startedAt = performance.now();
+        const apiKey = requireApiKey(request.apiKey);
+        const resolvedModel = request.model || options.defaultModels?.speech || "gpt-4o-mini-tts";
+        const resolvedVoice = request.voice || options.speech?.voice || "alloy";
+        const resolvedFormat = options.speech?.format ?? "mp3";
+        const response = await fetchWithPolicy({
+            url: `${baseUrl}/audio/speech`,
+            operation: "OpenAI speech synthesis",
+            fetchFn: fetcher,
+            policy: options.httpPolicy,
+            createRequestInit: () => ({
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${apiKey}`,
+                    "Content-Type": "application/json",
+                    "Idempotency-Key": request.traceId,
+                    "X-Request-Id": request.traceId,
+                    "X-Plasius-Client": "@plasius/ai/openai-adapter",
+                },
+                body: JSON.stringify({
+                    model: resolvedModel,
+                    input: request.input,
+                    voice: resolvedVoice,
+                    format: resolvedFormat,
+                }),
+            }),
+        });
+        if (!response.ok) {
+            const errorBody = await parseResponseBody(response);
+            throw new Error(resolveErrorMessage(errorBody, `OpenAI speech synthesis failed (${response.status} ${response.statusText}).`));
+        }
+        const mimeTypeHeader = response.headers.get("content-type");
+        const mimeType = (mimeTypeHeader?.split(";")[0]?.trim() || "audio/mpeg").toLowerCase();
+        const bytes = Buffer.from(await response.arrayBuffer()).toString("base64");
+        const durationMs = performance.now() - startedAt;
+        const base = createBaseCompletion("speech", resolvedModel, request.userId, durationMs);
+        return {
+            ...base,
+            url: new URL(`data:${mimeType};base64,${bytes}`),
+        };
+    };
+    const transcribeSpeech = async (request) => {
+        const startedAt = performance.now();
+        const apiKey = requireApiKey(request.apiKey);
+        const resolvedModel = request.model || options.defaultModels?.transcription || "gpt-4o-mini-transcribe";
+        const response = await fetchWithPolicy({
+            url: `${baseUrl}/audio/transcriptions`,
+            operation: "OpenAI transcription",
+            fetchFn: fetcher,
+            policy: options.httpPolicy,
+            createRequestInit: () => {
+                const formData = new FormData();
+                formData.append("model", resolvedModel);
+                const fileBytes = Uint8Array.from(request.input);
+                formData.append("file", new Blob([fileBytes], { type: "application/octet-stream" }), "audio.webm");
+                return {
+                    method: "POST",
+                    headers: {
+                        Authorization: `Bearer ${apiKey}`,
+                        "Idempotency-Key": request.traceId,
+                        "X-Request-Id": request.traceId,
+                        "X-Plasius-Client": "@plasius/ai/openai-adapter",
+                    },
+                    body: formData,
+                };
+            },
+        });
+        const body = await parseResponseBody(response);
+        if (!response.ok) {
+            throw new Error(resolveErrorMessage(body, `OpenAI transcription failed (${response.status} ${response.statusText}).`));
+        }
+        const message = extractTranscriptionText(body);
+        const durationMs = performance.now() - startedAt;
+        const base = createBaseCompletion("text", resolvedModel, request.userId, durationMs);
+        return {
+            ...base,
+            message,
+        };
+    };
+    const generateImage = async (request) => {
+        const startedAt = performance.now();
+        const apiKey = requireApiKey(request.apiKey);
+        const resolvedModel = request.model || options.defaultModels?.image || "gpt-image-1";
+        const combinedPrompt = request.context
+            ? `${request.context}\n\n${request.input}`
+            : request.input;
+        const response = await fetchWithPolicy({
+            url: `${baseUrl}/images/generations`,
+            operation: "OpenAI image generation",
+            fetchFn: fetcher,
+            policy: options.httpPolicy,
+            createRequestInit: () => ({
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${apiKey}`,
+                    "Content-Type": "application/json",
+                    "Idempotency-Key": request.traceId,
+                    "X-Request-Id": request.traceId,
+                    "X-Plasius-Client": "@plasius/ai/openai-adapter",
+                },
+                body: JSON.stringify({
+                    model: resolvedModel,
+                    prompt: combinedPrompt,
+                    size: options.image?.size ?? "1024x1024",
+                    response_format: "b64_json",
+                }),
+            }),
+        });
+        const body = await parseResponseBody(response);
+        if (!response.ok) {
+            throw new Error(resolveErrorMessage(body, `OpenAI image generation failed (${response.status} ${response.statusText}).`));
+        }
+        const url = extractImageUrl(body);
+        const usage = usageFromPayload(asRecord(body).usage);
+        const durationMs = performance.now() - startedAt;
+        const base = createBaseCompletion("image", resolvedModel, request.userId, durationMs, usage);
+        return {
+            ...base,
+            url,
+        };
+    };
+    const generateModel = async (request) => {
+        const startedAt = performance.now();
+        const apiKey = requireApiKey(request.apiKey);
+        const resolvedModel = request.model || options.defaultModels?.model || "gpt-4.1-mini";
+        const systemInstruction = [
+            request.context,
+            "Return JSON only with fields modelId (string) and optional artifactUrl (string URL).",
+        ]
+            .filter(Boolean)
+            .join("\n");
+        const response = await fetchWithPolicy({
+            url: `${baseUrl}/chat/completions`,
+            operation: "OpenAI model generation",
+            fetchFn: fetcher,
+            policy: options.httpPolicy,
+            createRequestInit: () => ({
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${apiKey}`,
+                    "Content-Type": "application/json",
+                    "Idempotency-Key": request.traceId,
+                    "X-Request-Id": request.traceId,
+                    "X-Plasius-Client": "@plasius/ai/openai-adapter",
+                },
+                body: JSON.stringify({
+                    model: resolvedModel,
+                    response_format: { type: "json_object" },
+                    messages: [
+                        { role: "system", content: systemInstruction },
+                        { role: "user", content: request.input },
+                    ],
+                }),
+            }),
+        });
+        const body = await parseResponseBody(response);
+        if (!response.ok) {
+            throw new Error(resolveErrorMessage(body, `OpenAI model generation failed (${response.status} ${response.statusText}).`));
+        }
+        const responseText = extractChatMessage(body);
+        const parsed = parseGeneratedModel(responseText);
+        const usage = usageFromPayload(asRecord(body).usage);
+        const durationMs = performance.now() - startedAt;
+        const base = createBaseCompletion("model", resolvedModel, request.userId, durationMs, usage);
+        return {
+            ...base,
+            modelId: parsed.modelId,
+            artifactUrl: parsed.artifactUrl,
+        };
+    };
+    const checkBalance = async (request) => {
+        const startedAt = performance.now();
+        const resolvedModel = options.defaultModels?.chat ?? "";
+        const durationMs = performance.now() - startedAt;
+        const base = createBaseCompletion("balanceCompletion", resolvedModel, request.userId, durationMs);
+        return {
+            ...base,
+            balance: 0,
+        };
+    };
+    return {
+        id: providerId,
+        capabilities: [
+            AICapability.Chat,
+            AICapability.Speech,
+            AICapability.Image,
+            AICapability.Model,
+            AICapability.Balance,
+        ],
+        chatWithAI,
+        synthesizeSpeech,
+        transcribeSpeech,
+        generateImage,
+        generateModel,
+        checkBalance,
+    };
+}

package/dist/platform/video-provider-adapter.d.ts

@@ -0,0 +1,54 @@
+import { type HttpClientPolicy } from "./http-resilience.js";
+export interface ProviderBalance {
+    monthlyCredit: number;
+    packageCredit: number;
+}
+export interface VideoUploadResult {
+    imageId: number;
+}
+export interface VideoGenerationRequest {
+    imageId: number;
+    prompt: string;
+    negativePrompt?: string;
+    templateId?: string;
+    seed?: number;
+    durationSeconds?: number;
+    model?: string;
+    motionMode?: string;
+    quality?: string;
+    watermark?: boolean;
+}
+export interface VideoGenerationResult {
+    videoId: number;
+}
+export type VideoJobState = "pending" | "completed" | "failed";
+export interface VideoJobResult {
+    state: VideoJobState;
+    videoUrl?: string;
+}
+export interface VideoProviderRequestContext {
+    apiKey: string;
+    traceId?: string;
+    fetchFn?: typeof fetch;
+}
+export interface VideoProviderAdapter {
+    uploadImage(image: File | URL, context: VideoProviderRequestContext): Promise<VideoUploadResult>;
+    generateVideo(request: VideoGenerationRequest, context: VideoProviderRequestContext): Promise<VideoGenerationResult>;
+    getVideoResult(videoId: number, context: VideoProviderRequestContext): Promise<VideoJobResult>;
+    getBalance?(context: VideoProviderRequestContext): Promise<ProviderBalance>;
+}
+export interface HttpVideoProviderAdapterConfig {
+    uploadImagePath: string;
+    generateVideoPath: string;
+    getVideoResultPath: (videoId: number) => string;
+    getBalancePath?: string;
+    httpPolicy?: HttpClientPolicy;
+    mapUploadImageId?: (data: unknown) => number | undefined;
+    mapGeneratedVideoId?: (data: unknown) => number | undefined;
+    mapVideoResult?: (data: unknown) => VideoJobResult;
+    mapBalance?: (data: unknown) => ProviderBalance;
+    mapGenerateRequestBody?: (request: VideoGenerationRequest) => unknown;
+    additionalHeaders?: Record<string, string>;
+}
+export declare function createHttpVideoProviderAdapter(config: HttpVideoProviderAdapterConfig): VideoProviderAdapter;
+//# sourceMappingURL=video-provider-adapter.d.ts.map

package/dist/platform/video-provider-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"video-provider-adapter.d.ts","sourceRoot":"","sources":["../../src/platform/video-provider-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAE9E,MAAM,WAAW,eAAe;IAC9B,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,MAAM,aAAa,GAAG,SAAS,GAAG,WAAW,GAAG,QAAQ,CAAC;AAE/D,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,aAAa,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,2BAA2B;IAC1C,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,OAAO,KAAK,CAAC;CACxB;AAED,MAAM,WAAW,oBAAoB;IACnC,WAAW,CACT,KAAK,EAAE,IAAI,GAAG,GAAG,EACjB,OAAO,EAAE,2BAA2B,GACnC,OAAO,CAAC,iBAAiB,CAAC,CAAC;IAC9B,aAAa,CACX,OAAO,EAAE,sBAAsB,EAC/B,OAAO,EAAE,2BAA2B,GACnC,OAAO,CAAC,qBAAqB,CAAC,CAAC;IAClC,cAAc,CACZ,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,2BAA2B,GACnC,OAAO,CAAC,cAAc,CAAC,CAAC;IAC3B,UAAU,CAAC,CAAC,OAAO,EAAE,2BAA2B,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;CAC7E;AAED,MAAM,WAAW,8BAA8B;IAC7C,eAAe,EAAE,MAAM,CAAC;IACxB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,kBAAkB,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,CAAC;IAChD,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,UAAU,CAAC,EAAE,gBAAgB,CAAC;IAC9B,gBAAgB,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,MAAM,GAAG,SAAS,CAAC;IACzD,mBAAmB,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,MAAM,GAAG,SAAS,CAAC;IAC5D,cAAc,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,cAAc,CAAC;IACnD,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,eAAe,CAAC;IAChD,sBAAsB,CAAC,EAAE,CAAC,OAAO,EAAE,sBAAsB,KAAK,OAAO,CAAC;IACtE,iBAAiB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC5C;AAqGD,wBAAgB,8BAA8B,CAC5C,MAAM,EAAE,8BAA8B,GACrC,oBAAoB,CAkItB"}

package/dist/platform/video-provider-adapter.js

@@ -0,0 +1,165 @@
+import { fetchWithPolicy } from "./http-resilience.js";
+function asRecord(value) {
+    return value && typeof value === "object" ? value : {};
+}
+function asNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function asString(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function requireJson(value, label, mapper) {
+    const id = mapper(value);
+    if (!id) {
+        throw new Error(`Invalid ${label} response.`);
+    }
+    return id;
+}
+function defaultRequestBody(request) {
+    const body = {
+        img_id: request.imageId,
+        prompt: request.prompt,
+        duration: request.durationSeconds ?? 5,
+        model: request.model ?? "standard",
+        motion_mode: request.motionMode ?? "normal",
+        quality: request.quality ?? "720p",
+        water_mark: request.watermark ?? false,
+    };
+    if (request.seed !== undefined) {
+        body.seed = request.seed;
+    }
+    if (request.templateId) {
+        body.template_id = request.templateId;
+    }
+    if (request.negativePrompt) {
+        body.negative_prompt = request.negativePrompt;
+    }
+    return body;
+}
+function defaultHeaders(context) {
+    const apiKey = context.apiKey.trim();
+    if (!apiKey) {
+        throw new Error("Provider API key is required.");
+    }
+    return {
+        "API-KEY": apiKey,
+        "AI-trace-ID": context.traceId ?? crypto.randomUUID(),
+        Accept: "application/json",
+        "X-Plasius-Client": "@plasius/ai/video-http-adapter",
+    };
+}
+function defaultUploadMapper(data) {
+    const root = asRecord(data);
+    const resp = asRecord(root.Resp);
+    return asNumber(resp.id);
+}
+function defaultVideoIdMapper(data) {
+    const root = asRecord(data);
+    const resp = asRecord(root.Resp);
+    return asNumber(resp.id);
+}
+function defaultResultMapper(data) {
+    const root = asRecord(data);
+    const resp = asRecord(root.Resp);
+    const status = asNumber(resp.status);
+    const url = asString(resp.url);
+    if (status === 1 && url) {
+        return { state: "completed", videoUrl: url };
+    }
+    if (status === -1) {
+        return { state: "failed" };
+    }
+    return { state: "pending" };
+}
+function defaultBalanceMapper(data) {
+    const root = asRecord(data);
+    const resp = asRecord(root.Resp);
+    return {
+        monthlyCredit: asNumber(resp.credit_monthly) ?? 0,
+        packageCredit: asNumber(resp.credit_package) ?? 0,
+    };
+}
+export function createHttpVideoProviderAdapter(config) {
+    const fetchJson = async (path, createRequestInit, context) => {
+        const fetchFn = context.fetchFn ?? fetch;
+        const response = await fetchWithPolicy({
+            url: path,
+            operation: "Video provider HTTP request",
+            fetchFn,
+            policy: config.httpPolicy,
+            createRequestInit,
+        });
+        if (!response.ok) {
+            throw new Error(`Provider request failed (${response.status} ${response.statusText}).`);
+        }
+        return response.json();
+    };
+    const uploadImage = async (image, context) => {
+        const fetchFn = context.fetchFn ?? fetch;
+        const data = await fetchJson(config.uploadImagePath, async () => {
+            const formData = new FormData();
+            if (image instanceof File) {
+                formData.append("image", image, "upload-image");
+            }
+            else {
+                const blob = await fetchFn(image.toString()).then((result) => result.blob());
+                formData.append("image", blob, "upload-image");
+            }
+            return {
+                method: "POST",
+                headers: {
+                    ...defaultHeaders(context),
+                    ...config.additionalHeaders,
+                },
+                body: formData,
+            };
+        }, context);
+        const imageId = requireJson(data, "image upload", config.mapUploadImageId ?? defaultUploadMapper);
+        return { imageId };
+    };
+    const generateVideo = async (request, context) => {
+        const data = await fetchJson(config.generateVideoPath, () => {
+            const body = JSON.stringify(config.mapGenerateRequestBody?.(request) ?? defaultRequestBody(request));
+            return {
+                method: "POST",
+                headers: {
+                    ...defaultHeaders(context),
+                    "Content-Type": "application/json",
+                    ...config.additionalHeaders,
+                },
+                body,
+            };
+        }, context);
+        const videoId = requireJson(data, "video generation", config.mapGeneratedVideoId ?? defaultVideoIdMapper);
+        return { videoId };
+    };
+    const getVideoResult = async (videoId, context) => {
+        const data = await fetchJson(config.getVideoResultPath(videoId), () => ({
+            method: "GET",
+            headers: {
+                ...defaultHeaders(context),
+                ...config.additionalHeaders,
+            },
+        }), context);
+        return (config.mapVideoResult ?? defaultResultMapper)(data);
+    };
+    const getBalance = config.getBalancePath
+        ? async (context) => {
+            const data = await fetchJson(config.getBalancePath, () => ({
+                method: "GET",
+                headers: {
+                    ...defaultHeaders(context),
+                    "Content-Type": "application/json",
+                    ...config.additionalHeaders,
+                },
+            }), context);
+            return (config.mapBalance ?? defaultBalanceMapper)(data);
+        }
+        : undefined;
+    return {
+        uploadImage,
+        generateVideo,
+        getVideoResult,
+        getBalance,
+    };
+}

package/dist/platform/video-provider-platform.d.ts

@@ -0,0 +1,13 @@
+import type { AIPlatform } from "./index.js";
+import type { VideoGenerationRequest, VideoProviderAdapter } from "./video-provider-adapter.js";
+export interface VideoProviderPlatformProps {
+    apiKey: string;
+    adapter: VideoProviderAdapter;
+    polling?: {
+        maxRetries?: number;
+        delayMs?: number;
+    };
+    defaultVideoRequest?: Partial<Omit<VideoGenerationRequest, "imageId" | "prompt">>;
+}
+export declare function createVideoProviderPlatform(userId: string, props: VideoProviderPlatformProps): Promise<AIPlatform>;
+//# sourceMappingURL=video-provider-platform.d.ts.map

package/dist/platform/video-provider-platform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"video-provider-platform.d.ts","sourceRoot":"","sources":["../../src/platform/video-provider-platform.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,UAAU,EASX,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EACV,sBAAsB,EAEtB,oBAAoB,EACrB,MAAM,6BAA6B,CAAC;AAErC,MAAM,WAAW,0BAA0B;IACzC,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,oBAAoB,CAAC;IAC9B,OAAO,CAAC,EAAE;QACR,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB,CAAC;IACF,mBAAmB,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,sBAAsB,EAAE,SAAS,GAAG,QAAQ,CAAC,CAAC,CAAC;CACnF;AA8CD,wBAAsB,2BAA2B,CAC/C,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,0BAA0B,GAChC,OAAO,CAAC,UAAU,CAAC,CAmIrB"}