@plasius/ai 1.1.4 → 1.1.6

package/CHANGELOG.md

@@ -9,15 +9,35 @@ The format is based on **[Keep a Changelog](https://keepachangelog.com/en/1.1.0/
 ## [Unreleased]
 
 - **Added**
-  - (placeholder)
+  - Added built-in provider adapter factories:
+    - `createOpenAIAdapter` for chat, speech synthesis, transcription, image generation, and model generation.
+    - `createGeminiAdapter` for chat, image generation, and model generation.
+  - Added shared HTTP resilience policy contracts (`HttpClientPolicy`) and transport helper for consistent retry/timeout behavior across adapters.
+  - Added generic multi-capability adapter contracts (`AICapabilityAdapter`, request context/request types) and `createAdapterPlatform` for routing chat/voice/image/video/model operations.
+  - Added `AICapability.Model`, `ModelCompletion`, `modelCompletionSchema`, and `AIPlatform.generateModel(...)`.
+  - Added generic video-provider adapter contracts (`VideoProviderAdapter`, request/result types).
+  - Added `createHttpVideoProviderAdapter` for host-defined HTTP endpoint mapping.
+  - Added `createVideoProviderPlatform` to compose `AIPlatform` video/balance behavior from adapters.
 
 - **Changed**
+  - Updated docs and examples to use built-in OpenAI/Gemini adapter factories with developer-supplied API keys.
+  - Hardened OpenAI/Gemini/video HTTP adapters with internet-friendly client behavior:
+    - request timeout defaults
+    - exponential backoff with jitter
+    - `Retry-After` handling
+    - retry on transient status codes (`408`, `409`, `425`, `429`, `500`, `502`, `503`, `504`)
+  - Hardened provisional adapters to align with injected-key usage:
+    - Removed provisional `OpenAIPlatform` runtime scaffold (`src/platform/openai.ts`) in favor of `createOpenAIAdapter`.
+    - `createVideoProviderPlatform` now validates non-empty API key input.
+    - `createHttpVideoProviderAdapter` now validates API keys and uses request-scoped `fetchFn` for URL image uploads.
   - Hardened GitHub CD publish flow to publish only after successful install, test, and build, then push tags/releases post-publish.
   - Standardized npm publish path on workflow-dispatched `.github/workflows/cd.yml` using provenance and production environment secrets.
   - Replaced `audit:deps` from `depcheck` to `npm ls --all --omit=optional --omit=peer > /dev/null 2>&1 || true` to avoid deprecated dependency-chain risk.
+  - Refactored video editor/balance components to rely on injected provider adapters instead of hardcoded vendor wiring.
+  - Removed provider-specific identifiers from code roots to enforce public package boundaries.
 
 - **Fixed**
-  - (placeholder)
+  - `pack:check` now passes vendor-namespace checks for `src/**` by using generic provider naming in runtime/editor code.
 
 - **Security**
   - Removed `depcheck` (and its `multimatch`/`minimatch` chain) from devDependencies to resolve reported high-severity audit findings.

package/README.md

@@ -15,8 +15,9 @@ AI capability contracts and completion schemas for Plasius applications.
 This package currently provides:
 
 - capability contracts (`AICapability`, `AIPlatform`)
-- completion model interfaces (`ChatCompletion`, `ImageCompletion`, etc.)
+- completion model interfaces (`ChatCompletion`, `ImageCompletion`, `ModelCompletion`, etc.)
 - schema definitions for completion entities
+- adapter contracts/factories for multi-provider routing with developer-supplied API keys
 
 Provider wiring and runtime adapters are documented in [`docs/providers.md`](./docs/providers.md).
 
@@ -65,6 +66,9 @@ const platform: AIPlatform = {
   produceVideo: async () => {
     throw new Error("Not implemented");
   },
+  generateModel: async () => {
+    throw new Error("Not implemented");
+  },
   checkBalance: async () => ({
     id: crypto.randomUUID(),
     partitionKey: "user-1",
@@ -84,12 +88,25 @@ void platform;
 
 - `AICapability`: enum describing logical capability routing.
 - `AIPlatform`: interface your runtime adapter must implement.
+- Generic multi-capability adapter contracts and helpers:
+  - `AICapabilityAdapter`
+  - `AdapterPlatformProps`
+  - `HttpClientPolicy`
+  - `createAdapterPlatform`
+  - `createOpenAIAdapter`
+  - `createGeminiAdapter`
+- Generic video-provider adapter contracts and helpers:
+  - `VideoProviderAdapter`
+  - `VideoGenerationRequest`
+  - `createHttpVideoProviderAdapter`
+  - `createVideoProviderPlatform`
 - `Completion` + typed completion variants:
   - `ChatCompletion`
   - `TextCompletion`
   - `ImageCompletion`
   - `SpeechCompletion`
   - `VideoCompletion`
+  - `ModelCompletion`
   - `BalanceCompletion`
 - Schemas:
   - `completionSchema`
@@ -98,6 +115,7 @@ void platform;
   - `imageCompletionSchema`
   - `speechCompletionSchema`
   - `videoCompletionSchema`
+  - `modelCompletionSchema`
   - `balanceCompletionSchema`
 
 ## Documentation
@@ -109,9 +127,90 @@ void platform;
 ## Known Limitations
 
 - `src/lib/*` currently contains placeholder files and is not part of the public API.
-- Runtime provider adapters are still under stabilization and should be wrapped by host applications.
+- Provider-specific runtime adapters are still under stabilization and should be wrapped by host applications.
 - The package focuses on contracts/schemas first; runtime behavior is expected to be composed by consumers.
 
+### Multi-Capability Adapter Composition
+
+```ts
+import {
+  AICapability,
+  createAdapterPlatform,
+  createGeminiAdapter,
+  createOpenAIAdapter,
+} from "@plasius/ai";
+
+const openAIAdapter = createOpenAIAdapter({
+  id: "openai",
+  httpPolicy: {
+    maxAttempts: 3,
+    timeoutMs: 30000,
+    baseDelayMs: 250,
+    maxDelayMs: 4000,
+    jitterRatio: 0.2,
+  },
+  defaultModels: {
+    chat: "gpt-4.1-mini",
+    speech: "gpt-4o-mini-tts",
+    transcription: "gpt-4o-mini-transcribe",
+    image: "gpt-image-1",
+    model: "gpt-4.1-mini",
+  },
+});
+
+const geminiAdapter = createGeminiAdapter({
+  id: "gemini",
+  httpPolicy: {
+    maxAttempts: 3,
+    timeoutMs: 30000,
+  },
+  defaultModels: {
+    chat: "gemini-2.0-flash",
+    image: "imagen-3.0-generate-002",
+    model: "gemini-2.0-flash",
+  },
+});
+
+const platform = await createAdapterPlatform("user-1", {
+  adapters: [openAIAdapter, geminiAdapter],
+  apiKeys: {
+    openai: process.env.OPENAI_API_KEY ?? "",
+    gemini: process.env.GEMINI_API_KEY ?? "",
+  },
+  defaultAdapterByCapability: {
+    [AICapability.Chat]: "openai",
+    [AICapability.Speech]: "openai",
+    [AICapability.Image]: "gemini",
+    [AICapability.Model]: "gemini",
+  },
+});
+
+void platform;
+```
+
+### Generic Video Adapter Composition
+
+```ts
+import {
+  createHttpVideoProviderAdapter,
+  createVideoProviderPlatform,
+} from "@plasius/ai";
+
+const videoAdapter = createHttpVideoProviderAdapter({
+  uploadImagePath: "/provider/image/upload",
+  generateVideoPath: "/provider/video/generate",
+  getVideoResultPath: (videoId) => `/provider/video/result/${videoId}`,
+  getBalancePath: "/provider/account/balance",
+});
+
+const platform = await createVideoProviderPlatform("user-1", {
+  apiKey: process.env.PROVIDER_API_KEY ?? "",
+  adapter: videoAdapter,
+});
+
+void platform;
+```
+
 ## Development
 
 ```bash

package/dist/components/pixelverse/balance.d.ts

@@ -1,4 +1,8 @@
-export default function Balance({ apiKey }: {
+import type { VideoProviderAdapter } from "../../platform/video-provider-adapter.js";
+export interface BalanceProps {
     apiKey: string;
-}): import("react/jsx-runtime").JSX.Element;
+    adapter: VideoProviderAdapter;
+    refreshMs?: number;
+}
+export default function Balance({ apiKey, adapter, refreshMs }: BalanceProps): import("react/jsx-runtime").JSX.Element;
 //# sourceMappingURL=balance.d.ts.map

package/dist/components/pixelverse/balance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"balance.d.ts","sourceRoot":"","sources":["../../../src/components/pixelverse/balance.tsx"],"names":[],"mappings":"AAcA,MAAM,CAAC,OAAO,UAAU,OAAO,CAAC,EAAE,MAAM,EAAE,EAAE;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,2CAkD7D"}
+{"version":3,"file":"balance.d.ts","sourceRoot":"","sources":["../../../src/components/pixelverse/balance.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAmB,oBAAoB,EAAE,MAAM,0CAA0C,CAAC;AAGtG,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,oBAAoB,CAAC;IAC9B,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,CAAC,OAAO,UAAU,OAAO,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,SAAkB,EAAE,EAAE,YAAY,2CAyCpF"}

package/dist/components/pixelverse/balance.js

@@ -1,40 +1,30 @@
 import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 import { useEffect, useState } from "react";
-import { v4 as uuidv4 } from "uuid";
 import styles from "./balance.module.css";
-export default function Balance({ apiKey }) {
+export default function Balance({ apiKey, adapter, refreshMs = 600000 }) {
     const [balance, setBalance] = useState(null);
     const fetchBalance = async () => {
+        if (!adapter.getBalance) {
+            setBalance({ monthlyCredit: 0, packageCredit: 0 });
+            return;
+        }
         try {
-            const response = await fetch("/pixelapi/openapi/v2/account/balance", {
-                method: "GET",
-                headers: {
-                    "API-KEY": apiKey,
-                    "AI-trace-ID": uuidv4(),
-                    Accept: "application/json",
-                    "Content-Type": "application/json",
-                },
-                referrerPolicy: "no-referrer",
+            const value = await adapter.getBalance({
+                apiKey,
+                traceId: crypto.randomUUID(),
             });
-            if (!response.ok) {
-                console.error("Failed to fetch balance:", response.status, response.statusText);
-                return;
-            }
-            const data = (await response.json());
-            if (data?.Resp) {
-                setBalance(data.Resp);
-            }
+            setBalance(value);
         }
         catch (err) {
             console.error("fetchBalance() error", err);
         }
     };
     useEffect(() => {
-        void fetchBalance(); // initial load
+        void fetchBalance();
         const intervalId = setInterval(() => {
             void fetchBalance();
-        }, 600000);
+        }, refreshMs);
         return () => clearInterval(intervalId);
-    }, [apiKey]);
-    return (_jsx("div", { className: styles.balance_container, children: balance ? (_jsxs("div", { children: [_jsxs("p", { children: ["Monthly Credit: ", balance.credit_monthly] }), _jsxs("p", { children: ["Package Credit: ", balance.credit_package] })] })) : (_jsx("p", { children: "Loading balance..." })) }));
+    }, [apiKey, adapter, refreshMs]);
+    return (_jsx("div", { className: styles.balance_container, children: balance ? (_jsxs("div", { children: [_jsxs("p", { children: ["Monthly Credit: ", balance.monthlyCredit] }), _jsxs("p", { children: ["Package Credit: ", balance.packageCredit] })] })) : (_jsx("p", { children: "Loading balance..." })) }));
 }

package/dist/components/pixelverse/index.d.ts

@@ -1,3 +1,3 @@
 export * from "./balance.js";
-export * from "./pixelverseeditor.js";
+export * from "./video-generation-editor.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/components/pixelverse/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/pixelverse/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/pixelverse/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,8BAA8B,CAAC"}

package/dist/components/pixelverse/index.js

@@ -1,2 +1,2 @@
 export * from "./balance.js";
-export * from "./pixelverseeditor.js";
+export * from "./video-generation-editor.js";

package/dist/components/pixelverse/video-generation-editor.d.ts

@@ -0,0 +1,10 @@
+import type { VideoGenerationRequest, VideoProviderAdapter } from "../../platform/video-provider-adapter.js";
+export interface VideoGenerationEditorProps {
+    apiKey: string;
+    adapter: VideoProviderAdapter;
+    onVideoGenerated?: (videoUrl: string) => void;
+    initialRequest?: Partial<Omit<VideoGenerationRequest, "imageId">>;
+}
+export declare function VideoGenerationEditor({ apiKey, adapter, onVideoGenerated, initialRequest, }: VideoGenerationEditorProps): import("react/jsx-runtime").JSX.Element;
+export default VideoGenerationEditor;
+//# sourceMappingURL=video-generation-editor.d.ts.map

package/dist/components/pixelverse/video-generation-editor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"video-generation-editor.d.ts","sourceRoot":"","sources":["../../../src/components/pixelverse/video-generation-editor.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,sBAAsB,EACtB,oBAAoB,EACrB,MAAM,0CAA0C,CAAC;AAElD,MAAM,WAAW,0BAA0B;IACzC,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,oBAAoB,CAAC;IAC9B,gBAAgB,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IAC9C,cAAc,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,sBAAsB,EAAE,SAAS,CAAC,CAAC,CAAC;CACnE;AA8CD,wBAAgB,qBAAqB,CAAC,EACpC,MAAM,EACN,OAAO,EACP,gBAAgB,EAChB,cAAc,GACf,EAAE,0BAA0B,2CAkG5B;AAED,eAAe,qBAAqB,CAAC"}

package/dist/components/pixelverse/video-generation-editor.js

@@ -0,0 +1,79 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from "react";
+import Balance from "./balance.js";
+const defaultRequest = {
+    prompt: "",
+    model: "standard",
+    motionMode: "normal",
+    quality: "720p",
+    durationSeconds: 5,
+    watermark: false,
+};
+function toRequest(overrides) {
+    return {
+        ...defaultRequest,
+        ...overrides,
+    };
+}
+async function waitForVideoCompletion(adapter, videoId, apiKey, maxRetries = 20, delayMs = 3000) {
+    for (let attempt = 0; attempt < maxRetries; attempt += 1) {
+        await new Promise((resolve) => setTimeout(resolve, delayMs));
+        const result = await adapter.getVideoResult(videoId, {
+            apiKey,
+            traceId: crypto.randomUUID(),
+        });
+        if (result.state === "completed" && result.videoUrl) {
+            return result.videoUrl;
+        }
+        if (result.state === "failed") {
+            throw new Error("Video generation failed.");
+        }
+    }
+    throw new Error("Timed out waiting for video generation result.");
+}
+export function VideoGenerationEditor({ apiKey, adapter, onVideoGenerated, initialRequest, }) {
+    const [videoUrl, setVideoUrl] = useState("");
+    const [selectedFile, setSelectedFile] = useState(null);
+    const [loading, setLoading] = useState(false);
+    const [videoReady, setVideoReady] = useState(false);
+    const [request, setRequest] = useState(toRequest(initialRequest));
+    const handleFileChange = (event) => {
+        const file = event.target.files?.[0] ?? null;
+        setSelectedFile(file);
+    };
+    const handleRegenerate = () => {
+        void handleUploadProcess();
+    };
+    const handleUploadProcess = async () => {
+        if (!selectedFile) {
+            return;
+        }
+        setLoading(true);
+        setVideoReady(false);
+        try {
+            const uploaded = await adapter.uploadImage(selectedFile, {
+                apiKey,
+                traceId: crypto.randomUUID(),
+            });
+            const generated = await adapter.generateVideo({
+                ...request,
+                imageId: uploaded.imageId,
+            }, {
+                apiKey,
+                traceId: crypto.randomUUID(),
+            });
+            const generatedUrl = await waitForVideoCompletion(adapter, generated.videoId, apiKey);
+            setVideoUrl(generatedUrl);
+            setVideoReady(true);
+            onVideoGenerated?.(generatedUrl);
+        }
+        finally {
+            setLoading(false);
+        }
+    };
+    return (_jsxs("div", { children: [_jsx(Balance, { apiKey: apiKey, adapter: adapter }), !videoReady && !selectedFile && (_jsxs("div", { children: [_jsx("p", { children: "Drag/Drop or Click HERE to upload" }), _jsx("input", { title: "Upload Image", type: "file", accept: ".jpg,.jpeg,.png,.webp", onChange: handleFileChange })] })), !videoReady ? (_jsx("div", { children: _jsxs("label", { children: ["Prompt", _jsx("textarea", { value: request.prompt, onChange: (event) => setRequest((previous) => ({
+                                ...previous,
+                                prompt: event.target.value,
+                            })) })] }) })) : null, loading && _jsx("div", { children: "Loading..." }), !videoReady && selectedFile && !loading && (_jsx("button", { onClick: handleUploadProcess, children: "Start Upload" })), videoReady && (_jsxs("div", { children: [_jsx("video", { src: videoUrl, controls: true }), _jsx("button", { onClick: handleRegenerate, children: "Regenerate" })] }))] }));
+}
+export default VideoGenerationEditor;

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

@@ -0,0 +1,60 @@
+import { AICapability, type AIPlatform, type BalanceCompletion, type ChatCompletion, type ImageCompletion, type ModelCompletion, type SpeechCompletion, type TextCompletion, type VideoCompletion } from "./index.js";
+export interface AdapterRequestContext {
+    userId: string;
+    providerId: string;
+    apiKey: string;
+    traceId: string;
+}
+export interface AdapterChatRequest extends AdapterRequestContext {
+    input: string;
+    context: string;
+    model: string;
+}
+export interface AdapterSynthesizeSpeechRequest extends AdapterRequestContext {
+    input: string;
+    voice: string;
+    context: string;
+    model: string;
+}
+export interface AdapterTranscribeSpeechRequest extends AdapterRequestContext {
+    input: Buffer;
+    context: string;
+    model: string;
+}
+export interface AdapterGenerateImageRequest extends AdapterRequestContext {
+    input: string;
+    context: string;
+    model: string;
+}
+export interface AdapterVideoRequest extends AdapterRequestContext {
+    input: string;
+    image: URL;
+    context: string;
+    model: string;
+}
+export interface AdapterGenerateModelRequest extends AdapterRequestContext {
+    input: string;
+    context: string;
+    model: string;
+}
+export interface AdapterBalanceRequest extends AdapterRequestContext {
+}
+export interface AICapabilityAdapter {
+    id: string;
+    capabilities: AICapability[];
+    canHandle?: (capabilities: AICapability[]) => Promise<boolean> | boolean;
+    chatWithAI?: (request: AdapterChatRequest) => Promise<ChatCompletion>;
+    synthesizeSpeech?: (request: AdapterSynthesizeSpeechRequest) => Promise<SpeechCompletion>;
+    transcribeSpeech?: (request: AdapterTranscribeSpeechRequest) => Promise<TextCompletion>;
+    generateImage?: (request: AdapterGenerateImageRequest) => Promise<ImageCompletion>;
+    produceVideo?: (request: AdapterVideoRequest) => Promise<VideoCompletion>;
+    generateModel?: (request: AdapterGenerateModelRequest) => Promise<ModelCompletion>;
+    checkBalance?: (request: AdapterBalanceRequest) => Promise<BalanceCompletion>;
+}
+export interface AdapterPlatformProps {
+    adapters: AICapabilityAdapter[];
+    apiKeys: Record<string, string>;
+    defaultAdapterByCapability?: Partial<Record<AICapability, string>>;
+}
+export declare function createAdapterPlatform(userId: string, props: AdapterPlatformProps): Promise<AIPlatform>;
+//# sourceMappingURL=adapter-platform.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"adapter-platform.d.ts","sourceRoot":"","sources":["../../src/platform/adapter-platform.ts"],"names":[],"mappings":"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"}

package/dist/platform/adapter-platform.js

@@ -0,0 +1,222 @@
+import { performance } from "node:perf_hooks";
+import { AICapability, } from "./index.js";
+function createCompletionBase(type, model, requestor, durationMs) {
+    return {
+        partitionKey: requestor,
+        id: crypto.randomUUID(),
+        type,
+        model,
+        createdAt: new Date().toISOString(),
+        durationMs,
+        usage: {},
+    };
+}
+function createAdapterContext(requestorId, adapter, apiKey) {
+    return {
+        userId: requestorId,
+        providerId: adapter.id,
+        apiKey,
+        traceId: crypto.randomUUID(),
+    };
+}
+function requiresOperationalMethod(capability, adapter) {
+    switch (capability) {
+        case AICapability.Chat:
+            return typeof adapter.chatWithAI === "function";
+        case AICapability.Text:
+            return true;
+        case AICapability.Speech:
+            return (typeof adapter.synthesizeSpeech === "function" ||
+                typeof adapter.transcribeSpeech === "function");
+        case AICapability.Image:
+            return typeof adapter.generateImage === "function";
+        case AICapability.Video:
+            return typeof adapter.produceVideo === "function";
+        case AICapability.Balance:
+            return typeof adapter.checkBalance === "function";
+        case AICapability.Model:
+            return typeof adapter.generateModel === "function";
+        default:
+            return false;
+    }
+}
+export async function createAdapterPlatform(userId, props) {
+    const adapterById = new Map();
+    for (const adapter of props.adapters) {
+        if (!adapter.id || adapter.id.trim().length === 0) {
+            throw new Error("Adapter id must be a non-empty string.");
+        }
+        if (adapterById.has(adapter.id)) {
+            throw new Error(`Duplicate adapter id "${adapter.id}" detected.`);
+        }
+        adapterById.set(adapter.id, adapter);
+    }
+    const resolveApiKey = (providerId) => {
+        const value = props.apiKeys[providerId];
+        if (typeof value !== "string") {
+            return undefined;
+        }
+        const trimmed = value.trim();
+        return trimmed.length > 0 ? trimmed : undefined;
+    };
+    const resolveAdapter = (capability, method, options) => {
+        const configuredId = props.defaultAdapterByCapability?.[capability];
+        const fail = (message) => {
+            if (options.required) {
+                throw new Error(message);
+            }
+            return undefined;
+        };
+        if (configuredId) {
+            const configured = adapterById.get(configuredId);
+            if (!configured) {
+                return fail(`Configured adapter "${configuredId}" for capability "${capability}" was not found.`);
+            }
+            if (!configured.capabilities.includes(capability)) {
+                return fail(`Configured adapter "${configuredId}" does not declare capability "${capability}".`);
+            }
+            if (typeof configured[method] !== "function") {
+                return fail(`Configured adapter "${configuredId}" does not implement "${method}" for capability "${capability}".`);
+            }
+            const apiKey = resolveApiKey(configured.id);
+            if (!apiKey) {
+                return fail(`Missing API key for configured adapter "${configured.id}".`);
+            }
+            return { adapter: configured, apiKey };
+        }
+        const fallback = props.adapters.find((candidate) => {
+            return (candidate.capabilities.includes(capability) &&
+                typeof candidate[method] === "function");
+        });
+        if (!fallback) {
+            return fail(`No adapter found for capability "${capability}" implementing "${method}".`);
+        }
+        const apiKey = resolveApiKey(fallback.id);
+        if (!apiKey) {
+            return fail(`Missing API key for adapter "${fallback.id}".`);
+        }
+        return { adapter: fallback, apiKey };
+    };
+    const canHandle = async (_requestorId, capabilities) => {
+        for (const capability of capabilities) {
+            const configuredId = props.defaultAdapterByCapability?.[capability];
+            const adapter = configuredId
+                ? adapterById.get(configuredId)
+                : props.adapters.find((candidate) => candidate.capabilities.includes(capability));
+            if (!adapter) {
+                return false;
+            }
+            if (!adapter.capabilities.includes(capability)) {
+                return false;
+            }
+            if (!resolveApiKey(adapter.id)) {
+                return false;
+            }
+            if (!requiresOperationalMethod(capability, adapter)) {
+                return false;
+            }
+            if (adapter.canHandle) {
+                const accepted = await adapter.canHandle([capability]);
+                if (!accepted) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    };
+    const chatWithAI = async (requestorId, input, context, model) => {
+        const resolved = resolveAdapter(AICapability.Chat, "chatWithAI", {
+            required: true,
+        });
+        return resolved.adapter.chatWithAI({
+            ...createAdapterContext(requestorId, resolved.adapter, resolved.apiKey),
+            input,
+            context,
+            model,
+        });
+    };
+    const synthesizeSpeech = async (requestorId, input, voice, context, model) => {
+        const resolved = resolveAdapter(AICapability.Speech, "synthesizeSpeech", {
+            required: true,
+        });
+        return resolved.adapter.synthesizeSpeech({
+            ...createAdapterContext(requestorId, resolved.adapter, resolved.apiKey),
+            input,
+            voice,
+            context,
+            model,
+        });
+    };
+    const transcribeSpeech = async (requestorId, input, context, model) => {
+        const resolved = resolveAdapter(AICapability.Speech, "transcribeSpeech", {
+            required: true,
+        });
+        return resolved.adapter.transcribeSpeech({
+            ...createAdapterContext(requestorId, resolved.adapter, resolved.apiKey),
+            input,
+            context,
+            model,
+        });
+    };
+    const generateImage = async (requestorId, input, context, model) => {
+        const resolved = resolveAdapter(AICapability.Image, "generateImage", {
+            required: true,
+        });
+        return resolved.adapter.generateImage({
+            ...createAdapterContext(requestorId, resolved.adapter, resolved.apiKey),
+            input,
+            context,
+            model,
+        });
+    };
+    const produceVideo = async (requestorId, input, image, context, model) => {
+        const resolved = resolveAdapter(AICapability.Video, "produceVideo", {
+            required: true,
+        });
+        return resolved.adapter.produceVideo({
+            ...createAdapterContext(requestorId, resolved.adapter, resolved.apiKey),
+            input,
+            image,
+            context,
+            model,
+        });
+    };
+    const generateModel = async (requestorId, input, context, model) => {
+        const resolved = resolveAdapter(AICapability.Model, "generateModel", {
+            required: true,
+        });
+        return resolved.adapter.generateModel({
+            ...createAdapterContext(requestorId, resolved.adapter, resolved.apiKey),
+            input,
+            context,
+            model,
+        });
+    };
+    const checkBalance = async (requestorId) => {
+        const startedAt = performance.now();
+        const resolved = resolveAdapter(AICapability.Balance, "checkBalance", {
+            required: false,
+        });
+        if (!resolved || !resolved.adapter.checkBalance) {
+            const durationMs = performance.now() - startedAt;
+            const base = createCompletionBase("balanceCompletion", "", requestorId, durationMs);
+            return {
+                ...base,
+                balance: 0,
+            };
+        }
+        return resolved.adapter.checkBalance(createAdapterContext(requestorId, resolved.adapter, resolved.apiKey));
+    };
+    const currentBalance = (await checkBalance(userId)).balance;
+    return {
+        canHandle,
+        chatWithAI,
+        synthesizeSpeech,
+        transcribeSpeech,
+        generateImage,
+        produceVideo,
+        generateModel,
+        checkBalance,
+        currentBalance,
+    };
+}

package/dist/platform/gemini-adapter.d.ts

@@ -0,0 +1,15 @@
+import { type AICapabilityAdapter } from "./index.js";
+import { type HttpClientPolicy } from "./http-resilience.js";
+export interface GeminiAdapterOptions {
+    id?: string;
+    baseUrl?: string;
+    fetchFn?: typeof fetch;
+    httpPolicy?: HttpClientPolicy;
+    defaultModels?: {
+        chat?: string;
+        image?: string;
+        model?: string;
+    };
+}
+export declare function createGeminiAdapter(options?: GeminiAdapterOptions): AICapabilityAdapter;
+//# sourceMappingURL=gemini-adapter.d.ts.map