@openclaw/deepinfra-provider 0.0.0 → 2026.6.9-beta.1

package/README.md

@@ -1,3 +1,12 @@
-# @openclaw/deepinfra-provider
+# OpenClaw DeepInfra Provider
 
-Reserved placeholder for the official OpenClaw plugin package. Use a published release version instead.
+Official OpenClaw provider plugin for DeepInfra.
+
+Install from OpenClaw:
+
+```bash
+openclaw plugins install @openclaw/deepinfra-provider
+openclaw gateway restart
+```
+
+See <https://docs.openclaw.ai/providers/deepinfra> for setup and configuration.

package/dist/api.js

@@ -0,0 +1,9 @@
+import { r as DEEPINFRA_DEFAULT_MODEL_REF } from "./provider-models-BLNlFB8o.js";
+import { buildDeepInfraImageGenerationProvider } from "./image-generation-provider.js";
+import { deepinfraMediaUnderstandingProvider } from "./media-understanding-provider.js";
+import { deepinfraMemoryEmbeddingProviderAdapter } from "./memory-embedding-adapter.js";
+import { applyDeepInfraConfig } from "./onboard.js";
+import { buildDeepInfraProvider, buildStaticDeepInfraProvider } from "./provider-catalog.js";
+import { buildDeepInfraSpeechProvider } from "./speech-provider.js";
+import { buildDeepInfraVideoGenerationProvider } from "./video-generation-provider.js";
+export { DEEPINFRA_DEFAULT_MODEL_REF, applyDeepInfraConfig, buildDeepInfraImageGenerationProvider, buildDeepInfraProvider, buildDeepInfraSpeechProvider, buildDeepInfraVideoGenerationProvider, buildStaticDeepInfraProvider, deepinfraMediaUnderstandingProvider, deepinfraMemoryEmbeddingProviderAdapter };

package/dist/cache-wrapper.js

@@ -0,0 +1,13 @@
+import { applyAnthropicEphemeralCacheControlMarkers, streamWithPayloadPatch } from "openclaw/plugin-sdk/provider-stream";
+//#region extensions/deepinfra/cache-wrapper.ts
+function createDeepInfraAnthropicCacheWrapper(baseStreamFn) {
+	return ((model, context, options) => {
+		const modelIdRaw = model.id;
+		if (!(typeof modelIdRaw === "string" ? modelIdRaw.toLowerCase() : "").startsWith("anthropic/")) return baseStreamFn(model, context, options);
+		return streamWithPayloadPatch(baseStreamFn, model, context, options, (payload) => {
+			applyAnthropicEphemeralCacheControlMarkers(payload);
+		});
+	});
+}
+//#endregion
+export { createDeepInfraAnthropicCacheWrapper };

package/dist/embedding-provider.js

@@ -0,0 +1,27 @@
+import { t as DEEPINFRA_BASE_URL } from "./provider-models-BLNlFB8o.js";
+import { DEEPINFRA_EMBED_FALLBACK_MODELS, normalizeDeepInfraModelRef } from "./media-models.js";
+import { createRemoteEmbeddingProvider, resolveRemoteEmbeddingClient } from "openclaw/plugin-sdk/memory-core-host-engine-embeddings";
+//#region extensions/deepinfra/embedding-provider.ts
+const DEFAULT_DEEPINFRA_EMBEDDING_MODEL = DEEPINFRA_EMBED_FALLBACK_MODELS[0];
+async function createDeepInfraEmbeddingProvider(options) {
+	const defaultModel = options.defaultModel ?? DEFAULT_DEEPINFRA_EMBEDDING_MODEL;
+	const client = await resolveRemoteEmbeddingClient({
+		provider: "deepinfra",
+		options: {
+			...options,
+			model: normalizeDeepInfraModelRef(options.model, defaultModel)
+		},
+		defaultBaseUrl: DEEPINFRA_BASE_URL,
+		normalizeModel: (model) => normalizeDeepInfraModelRef(model, defaultModel)
+	});
+	return {
+		provider: createRemoteEmbeddingProvider({
+			id: "deepinfra",
+			client,
+			errorPrefix: "DeepInfra embeddings API error"
+		}),
+		client
+	};
+}
+//#endregion
+export { DEFAULT_DEEPINFRA_EMBEDDING_MODEL, createDeepInfraEmbeddingProvider };

package/dist/image-generation-provider.js

@@ -0,0 +1,86 @@
+import { t as DEEPINFRA_BASE_URL } from "./provider-models-BLNlFB8o.js";
+import { DEEPINFRA_IMAGE_FALLBACK_MODELS, normalizeDeepInfraBaseUrl, normalizeDeepInfraModelRef } from "./media-models.js";
+import { createOpenAiCompatibleImageGenerationProvider, imageSourceUploadFileName } from "openclaw/plugin-sdk/image-generation";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/deepinfra/image-generation-provider.ts
+const DEEPINFRA_IMAGE_SIZES = [
+	"512x512",
+	"1024x1024",
+	"1024x1792",
+	"1792x1024"
+];
+const MAX_DEEPINFRA_INPUT_IMAGES = 1;
+function buildDeepInfraImageGenerationProvider(options) {
+	const ids = options?.imageGenModels && options.imageGenModels.length > 0 ? options.imageGenModels.map((model) => model.id) : [...DEEPINFRA_IMAGE_FALLBACK_MODELS];
+	return createOpenAiCompatibleImageGenerationProvider({
+		id: "deepinfra",
+		label: "DeepInfra",
+		defaultModel: ids[0] ?? DEEPINFRA_IMAGE_FALLBACK_MODELS[0],
+		models: ids,
+		capabilities: {
+			generate: {
+				maxCount: 4,
+				supportsSize: true,
+				supportsAspectRatio: false,
+				supportsResolution: false
+			},
+			edit: {
+				enabled: true,
+				maxCount: 1,
+				maxInputImages: MAX_DEEPINFRA_INPUT_IMAGES,
+				supportsSize: true,
+				supportsAspectRatio: false,
+				supportsResolution: false
+			},
+			geometry: { sizes: [...DEEPINFRA_IMAGE_SIZES] }
+		},
+		defaultBaseUrl: DEEPINFRA_BASE_URL,
+		normalizeModel: normalizeDeepInfraModelRef,
+		resolveBaseUrl: ({ providerConfig }) => normalizeDeepInfraBaseUrl(providerConfig?.baseUrl, DEEPINFRA_BASE_URL),
+		resolveAllowPrivateNetwork: () => false,
+		useConfiguredRequest: true,
+		resolveCount: ({ req, mode }) => mode === "edit" ? 1 : req.count ?? 1,
+		buildGenerateRequest: ({ req, model, count }) => ({
+			kind: "json",
+			body: {
+				model,
+				prompt: req.prompt,
+				n: count,
+				size: normalizeOptionalString(req.size) ?? "1024x1024",
+				response_format: "b64_json"
+			}
+		}),
+		buildEditRequest: ({ req, inputImages, model, count }) => {
+			const image = inputImages[0];
+			if (!image) throw new Error("DeepInfra image edit missing reference image.");
+			const form = new FormData();
+			form.set("model", model);
+			form.set("prompt", req.prompt);
+			form.set("n", String(count));
+			form.set("size", normalizeOptionalString(req.size) ?? "1024x1024");
+			form.set("response_format", "b64_json");
+			const mimeType = normalizeOptionalString(image.mimeType) ?? "image/png";
+			form.append("image", new Blob([new Uint8Array(image.buffer)], { type: mimeType }), imageSourceUploadFileName({
+				image,
+				index: 0
+			}));
+			return {
+				kind: "multipart",
+				form
+			};
+		},
+		response: {
+			defaultMimeType: "image/jpeg",
+			sniffMimeType: true
+		},
+		tooManyInputImagesError: "DeepInfra image editing supports one reference image.",
+		missingApiKeyError: "DeepInfra API key missing",
+		emptyResponseError: "DeepInfra image response did not include generated image data",
+		failureLabels: {
+			generate: "DeepInfra image generation failed",
+			edit: "DeepInfra image edit failed"
+		}
+	});
+}
+//#endregion
+export { buildDeepInfraImageGenerationProvider };

package/dist/index.js

@@ -0,0 +1,118 @@
+import { createDeepInfraAnthropicCacheWrapper } from "./cache-wrapper.js";
+import { l as getDeepInfraSurfaceFallbackCatalog, r as DEEPINFRA_DEFAULT_MODEL_REF, s as discoverDeepInfraModels, u as hasDeepInfraApiKey } from "./provider-models-BLNlFB8o.js";
+import { buildDeepInfraImageGenerationProvider } from "./image-generation-provider.js";
+import { buildDeepInfraMediaUnderstandingProvider } from "./media-understanding-provider.js";
+import { buildDeepInfraMemoryEmbeddingAdapter } from "./memory-embedding-adapter.js";
+import { applyDeepInfraConfig } from "./onboard.js";
+import { buildDeepInfraApiKeyCatalog, buildStaticDeepInfraProvider } from "./provider-catalog.js";
+import { buildDeepInfraSpeechProvider } from "./speech-provider.js";
+import { listDeepInfraImageGenCatalog, listDeepInfraVideoGenCatalog } from "./surface-model-catalogs.js";
+import { buildDeepInfraVideoGenerationProvider } from "./video-generation-provider.js";
+import { readConfiguredProviderCatalogEntries } from "openclaw/plugin-sdk/provider-catalog-shared";
+import { defineSingleProviderPluginEntry } from "openclaw/plugin-sdk/provider-entry";
+import { PASSTHROUGH_GEMINI_REPLAY_HOOKS } from "openclaw/plugin-sdk/provider-model-shared";
+import { createOpenRouterWrapper, isProxyReasoningUnsupported } from "openclaw/plugin-sdk/provider-stream";
+//#region extensions/deepinfra/index.ts
+const PROVIDER_ID = "deepinfra";
+var deepinfra_default = defineSingleProviderPluginEntry({
+	id: PROVIDER_ID,
+	name: "DeepInfra Provider",
+	description: "Bundled DeepInfra provider plugin",
+	provider: {
+		label: "DeepInfra",
+		docsPath: "/providers/deepinfra",
+		auth: [{
+			methodId: "api-key",
+			label: "DeepInfra API key",
+			hint: "Unified API for open source models",
+			optionKey: "deepinfraApiKey",
+			flagName: "--deepinfra-api-key",
+			envVar: "DEEPINFRA_API_KEY",
+			promptMessage: "Enter DeepInfra API key",
+			noteTitle: "DeepInfra",
+			noteMessage: ["DeepInfra provides an OpenAI-compatible API for open source and frontier models.", "Get your API key at: https://deepinfra.com/dash/api_keys"].join("\n"),
+			defaultModel: DEEPINFRA_DEFAULT_MODEL_REF,
+			applyConfig: (cfg) => applyDeepInfraConfig(cfg),
+			wizard: {
+				choiceId: "deepinfra-api-key",
+				choiceLabel: "DeepInfra API key",
+				choiceHint: "Unified API for open source models",
+				groupId: PROVIDER_ID,
+				groupLabel: "DeepInfra",
+				groupHint: "Unified API for open source models"
+			}
+		}],
+		catalog: {
+			order: "simple",
+			run: (ctx) => buildDeepInfraApiKeyCatalog(ctx),
+			staticRun: async () => ({ provider: buildStaticDeepInfraProvider() })
+		},
+		augmentModelCatalog: async ({ config, env, agentDir }) => {
+			const configured = readConfiguredProviderCatalogEntries({
+				config,
+				providerId: PROVIDER_ID
+			});
+			const hasApiKey = hasDeepInfraApiKey({
+				env,
+				agentDir,
+				config
+			});
+			const seen = new Set(configured.map((entry) => entry.id));
+			const discovered = await discoverDeepInfraModels({
+				hasApiKey,
+				env,
+				agentDir
+			});
+			const merged = [...configured];
+			for (const model of discovered) {
+				if (seen.has(model.id)) continue;
+				seen.add(model.id);
+				const input = model.input;
+				merged.push({
+					provider: PROVIDER_ID,
+					id: model.id,
+					name: model.name ?? model.id,
+					...typeof model.contextWindow === "number" && model.contextWindow > 0 ? { contextWindow: model.contextWindow } : {},
+					...typeof model.reasoning === "boolean" ? { reasoning: model.reasoning } : {},
+					...input && input.length > 0 ? { input } : {}
+				});
+			}
+			return merged;
+		},
+		normalizeConfig: ({ providerConfig }) => providerConfig,
+		normalizeTransport: ({ api, baseUrl }) => baseUrl === "https://api.deepinfra.com/v1/openai" ? {
+			api,
+			baseUrl
+		} : void 0,
+		...PASSTHROUGH_GEMINI_REPLAY_HOOKS,
+		wrapStreamFn: (ctx) => {
+			const thinkingLevel = isProxyReasoningUnsupported(ctx.modelId) ? void 0 : ctx.thinkingLevel;
+			return createDeepInfraAnthropicCacheWrapper(createOpenRouterWrapper(ctx.streamFn, thinkingLevel));
+		},
+		isModernModelRef: () => true,
+		isCacheTtlEligible: (ctx) => ctx.modelId.toLowerCase().startsWith("anthropic/")
+	},
+	register(api) {
+		const catalog = getDeepInfraSurfaceFallbackCatalog();
+		api.registerImageGenerationProvider(buildDeepInfraImageGenerationProvider({ imageGenModels: catalog.imageGen }));
+		api.registerModelCatalogProvider({
+			provider: PROVIDER_ID,
+			kinds: ["image_generation"],
+			liveCatalog: listDeepInfraImageGenCatalog
+		});
+		api.registerMediaUnderstandingProvider(buildDeepInfraMediaUnderstandingProvider({
+			vlmModels: catalog.vlm,
+			sttModels: catalog.stt
+		}));
+		api.registerMemoryEmbeddingProvider(buildDeepInfraMemoryEmbeddingAdapter({ embedModels: catalog.embed }));
+		api.registerSpeechProvider(buildDeepInfraSpeechProvider({ ttsModels: catalog.tts }));
+		api.registerVideoGenerationProvider(buildDeepInfraVideoGenerationProvider({ videoGenModels: catalog.videoGen }));
+		api.registerModelCatalogProvider({
+			provider: PROVIDER_ID,
+			kinds: ["video_generation"],
+			liveCatalog: listDeepInfraVideoGenCatalog
+		});
+	}
+});
+//#endregion
+export { deepinfra_default as default };

package/dist/media-models.js

@@ -0,0 +1,45 @@
+import { t as DEEPINFRA_BASE_URL } from "./provider-models-BLNlFB8o.js";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/deepinfra/media-models.ts
+const DEEPINFRA_NATIVE_BASE_URL = "https://api.deepinfra.com/v1/inference";
+const DEFAULT_DEEPINFRA_IMAGE_SIZE = "1024x1024";
+const DEFAULT_DEEPINFRA_TTS_VOICE = "af_bella";
+const DEEPINFRA_VIDEO_ASPECT_RATIOS = [
+	"16:9",
+	"4:3",
+	"1:1",
+	"3:4",
+	"9:16"
+];
+const DEEPINFRA_VIDEO_DURATIONS = [5, 8];
+const DEEPINFRA_IMAGE_FALLBACK_MODELS = [
+	"black-forest-labs/FLUX-1-schnell",
+	"run-diffusion/Juggernaut-Lightning-Flux",
+	"black-forest-labs/FLUX-1-dev",
+	"Qwen/Qwen-Image-Max",
+	"stabilityai/sdxl-turbo"
+];
+const DEEPINFRA_TTS_FALLBACK_MODELS = [
+	"hexgrad/Kokoro-82M",
+	"Qwen/Qwen3-TTS",
+	"ResembleAI/chatterbox-turbo",
+	"sesame/csm-1b"
+];
+const DEEPINFRA_VIDEO_FALLBACK_MODELS = [
+	"Pixverse/Pixverse-T2V",
+	"Pixverse/Pixverse-T2V-HD",
+	"Wan-AI/Wan2.6-T2V",
+	"google/veo-3.1-fast"
+];
+const DEEPINFRA_STT_FALLBACK_MODELS = ["openai/whisper-large-v3-turbo", "openai/whisper-large-v3"];
+const DEEPINFRA_EMBED_FALLBACK_MODELS = ["BAAI/bge-m3"];
+const DEEPINFRA_VLM_FALLBACK_MODELS = ["moonshotai/Kimi-K2.5"];
+function normalizeDeepInfraModelRef(model, fallback) {
+	const value = normalizeOptionalString(model) ?? fallback;
+	return value.startsWith("deepinfra/") ? value.slice(10) : value;
+}
+function normalizeDeepInfraBaseUrl(value, fallback = DEEPINFRA_BASE_URL) {
+	return (normalizeOptionalString(value) ?? fallback).replace(/\/+$/u, "");
+}
+//#endregion
+export { DEEPINFRA_BASE_URL, DEEPINFRA_EMBED_FALLBACK_MODELS, DEEPINFRA_IMAGE_FALLBACK_MODELS, DEEPINFRA_NATIVE_BASE_URL, DEEPINFRA_STT_FALLBACK_MODELS, DEEPINFRA_TTS_FALLBACK_MODELS, DEEPINFRA_VIDEO_ASPECT_RATIOS, DEEPINFRA_VIDEO_DURATIONS, DEEPINFRA_VIDEO_FALLBACK_MODELS, DEEPINFRA_VLM_FALLBACK_MODELS, DEFAULT_DEEPINFRA_IMAGE_SIZE, DEFAULT_DEEPINFRA_TTS_VOICE, normalizeDeepInfraBaseUrl, normalizeDeepInfraModelRef };

package/dist/media-understanding-provider.js

@@ -0,0 +1,35 @@
+import { t as DEEPINFRA_BASE_URL } from "./provider-models-BLNlFB8o.js";
+import { DEEPINFRA_STT_FALLBACK_MODELS, DEEPINFRA_VLM_FALLBACK_MODELS } from "./media-models.js";
+import { describeImageWithModel, describeImagesWithModel, transcribeOpenAiCompatibleAudio } from "openclaw/plugin-sdk/media-understanding";
+//#region extensions/deepinfra/media-understanding-provider.ts
+function resolveDefault(surfaceModels, fallback) {
+	return surfaceModels?.[0]?.id ?? fallback[0] ?? "";
+}
+async function transcribeDeepInfraAudio(params) {
+	return await transcribeOpenAiCompatibleAudio({
+		...params,
+		provider: "deepinfra",
+		defaultBaseUrl: DEEPINFRA_BASE_URL,
+		defaultModel: resolveDefault(void 0, DEEPINFRA_STT_FALLBACK_MODELS)
+	});
+}
+function buildDeepInfraMediaUnderstandingProvider(options) {
+	return {
+		id: "deepinfra",
+		capabilities: ["image", "audio"],
+		defaultModels: {
+			image: resolveDefault(options?.vlmModels, DEEPINFRA_VLM_FALLBACK_MODELS),
+			audio: resolveDefault(options?.sttModels, DEEPINFRA_STT_FALLBACK_MODELS)
+		},
+		autoPriority: {
+			image: 45,
+			audio: 45
+		},
+		transcribeAudio: transcribeDeepInfraAudio,
+		describeImage: describeImageWithModel,
+		describeImages: describeImagesWithModel
+	};
+}
+const deepinfraMediaUnderstandingProvider = buildDeepInfraMediaUnderstandingProvider();
+//#endregion
+export { buildDeepInfraMediaUnderstandingProvider, deepinfraMediaUnderstandingProvider, transcribeDeepInfraAudio };

package/dist/memory-embedding-adapter.js

@@ -0,0 +1,36 @@
+import { DEFAULT_DEEPINFRA_EMBEDDING_MODEL, createDeepInfraEmbeddingProvider } from "./embedding-provider.js";
+import { isMissingEmbeddingApiKeyError } from "openclaw/plugin-sdk/memory-core-host-engine-embeddings";
+//#region extensions/deepinfra/memory-embedding-adapter.ts
+function buildDeepInfraMemoryEmbeddingAdapter(options) {
+	const defaultModel = options?.embedModels?.[0]?.id ?? DEFAULT_DEEPINFRA_EMBEDDING_MODEL;
+	return {
+		id: "deepinfra",
+		defaultModel,
+		transport: "remote",
+		authProviderId: "deepinfra",
+		autoSelectPriority: 55,
+		allowExplicitWhenConfiguredAuto: true,
+		shouldContinueAutoSelection: isMissingEmbeddingApiKeyError,
+		create: async (createOptions) => {
+			const { provider, client } = await createDeepInfraEmbeddingProvider({
+				...createOptions,
+				provider: "deepinfra",
+				fallback: "none",
+				defaultModel
+			});
+			return {
+				provider,
+				runtime: {
+					id: "deepinfra",
+					cacheKeyData: {
+						provider: "deepinfra",
+						model: client.model
+					}
+				}
+			};
+		}
+	};
+}
+const deepinfraMemoryEmbeddingProviderAdapter = buildDeepInfraMemoryEmbeddingAdapter();
+//#endregion
+export { buildDeepInfraMemoryEmbeddingAdapter, deepinfraMemoryEmbeddingProviderAdapter };

package/dist/onboard.js

@@ -0,0 +1,25 @@
+import { r as DEEPINFRA_DEFAULT_MODEL_REF, t as DEEPINFRA_BASE_URL } from "./provider-models-BLNlFB8o.js";
+import { applyAgentDefaultModelPrimary } from "openclaw/plugin-sdk/provider-onboard";
+//#region extensions/deepinfra/onboard.ts
+function applyDeepInfraProviderConfig(cfg, modelRef = DEEPINFRA_DEFAULT_MODEL_REF) {
+	const models = { ...cfg.agents?.defaults?.models };
+	models[modelRef] = {
+		...models[modelRef],
+		alias: models[modelRef]?.alias ?? "DeepInfra"
+	};
+	return {
+		...cfg,
+		agents: {
+			...cfg.agents,
+			defaults: {
+				...cfg.agents?.defaults,
+				models
+			}
+		}
+	};
+}
+function applyDeepInfraConfig(cfg, modelRef = DEEPINFRA_DEFAULT_MODEL_REF) {
+	return applyAgentDefaultModelPrimary(applyDeepInfraProviderConfig(cfg, modelRef), modelRef);
+}
+//#endregion
+export { DEEPINFRA_BASE_URL, DEEPINFRA_DEFAULT_MODEL_REF, applyDeepInfraConfig, applyDeepInfraProviderConfig };

package/dist/provider-catalog.js

@@ -0,0 +1,30 @@
+import { a as DEEPINFRA_MODEL_CATALOG, o as buildDeepInfraModelDefinition, s as discoverDeepInfraModels, t as DEEPINFRA_BASE_URL } from "./provider-models-BLNlFB8o.js";
+import { buildSingleProviderApiKeyCatalog } from "openclaw/plugin-sdk/provider-catalog-shared";
+//#region extensions/deepinfra/provider-catalog.ts
+function buildStaticDeepInfraProvider() {
+	return {
+		baseUrl: DEEPINFRA_BASE_URL,
+		api: "openai-completions",
+		models: DEEPINFRA_MODEL_CATALOG.map(buildDeepInfraModelDefinition)
+	};
+}
+async function buildDeepInfraProvider(options) {
+	return {
+		baseUrl: DEEPINFRA_BASE_URL,
+		api: "openai-completions",
+		models: await discoverDeepInfraModels(options)
+	};
+}
+function buildDeepInfraApiKeyCatalog(ctx) {
+	return buildSingleProviderApiKeyCatalog({
+		ctx,
+		providerId: "deepinfra",
+		buildProvider: () => buildDeepInfraProvider({
+			hasApiKey: true,
+			env: ctx.env,
+			agentDir: ctx.agentDir
+		})
+	});
+}
+//#endregion
+export { buildDeepInfraApiKeyCatalog, buildDeepInfraProvider, buildStaticDeepInfraProvider };

package/dist/provider-discovery.js

@@ -0,0 +1,18 @@
+import { buildDeepInfraApiKeyCatalog, buildStaticDeepInfraProvider } from "./provider-catalog.js";
+//#region extensions/deepinfra/provider-discovery.ts
+const deepinfraProviderDiscovery = {
+	id: "deepinfra",
+	label: "DeepInfra",
+	docsPath: "/providers/deepinfra",
+	auth: [],
+	catalog: {
+		order: "simple",
+		run: (ctx) => buildDeepInfraApiKeyCatalog(ctx)
+	},
+	staticCatalog: {
+		order: "simple",
+		run: async () => ({ provider: buildStaticDeepInfraProvider() })
+	}
+};
+//#endregion
+export { deepinfraProviderDiscovery as default };