@clinebot/llms 0.0.0

package/package.json

@@ -0,0 +1,66 @@
+{
+	"name": "@clinebot/llms",
+	"version": "0.0.0",
+	"main": "./dist/index.js",
+	"module": "./dist/index.js",
+	"dependencies": {
+		"@clinebot/shared": "workspace:*",
+		"@ai-sdk/amazon-bedrock": "^4.0.67",
+		"@ai-sdk/google-vertex": "^4.0.74",
+		"@ai-sdk/mistral": "^3.0.24",
+		"@anthropic-ai/sdk": "^0.78.0",
+		"@aws-sdk/credential-providers": "^3.922.0",
+		"@google/genai": "^1.43.0",
+		"@streamparser/json": "^0.0.21",
+		"ai": "^6.0.112",
+		"ai-sdk-provider-claude-code": "^3.4.3",
+		"ai-sdk-provider-codex-cli": "^1.1.0",
+		"ai-sdk-provider-opencode-sdk": "^2.1.2",
+		"dify-ai-provider": "^1.1.0",
+		"nanoid": "^5.1.6",
+		"openai": "^6.25.0",
+		"zod": "^4.3.6"
+	},
+	"peerDependencies": {
+		"@aws-sdk/client-bedrock-runtime": "^3.0.0"
+	},
+	"exports": {
+		".": {
+			"browser": "./dist/index.browser.js",
+			"react-server": "./dist/index.browser.js",
+			"development": "./src/index.ts",
+			"import": "./dist/index.js",
+			"types": "./dist/index.d.ts"
+		},
+		"./node": {
+			"development": "./src/index.ts",
+			"import": "./dist/index.js",
+			"types": "./dist/index.d.ts"
+		},
+		"./browser": {
+			"development": "./src/index.browser.ts",
+			"import": "./dist/index.browser.js",
+			"types": "./dist/index.browser.d.ts"
+		}
+	},
+	"description": "Config-driven SDK for selecting, extending, and instantiating LLM providers and models",
+	"files": [
+		"dist",
+		"src"
+	],
+	"peerDependenciesMeta": {
+		"@aws-sdk/client-bedrock-runtime": {
+			"optional": true
+		}
+	},
+	"scripts": {
+		"build": "bun run bun.mts && bun tsc -p tsconfig.build.json",
+		"typecheck": "bun tsc -p tsconfig.dev.json --noEmit",
+		"test": "vitest run",
+		"test:watch": "vitest",
+		"clean": "rm -rf dist node_modules",
+		"generate:models": "bun run scripts/generate-models.ts"
+	},
+	"type": "module",
+	"types": "./dist/index.d.ts"
+}

package/src/catalog.ts

@@ -0,0 +1,20 @@
+import type { ProviderCapability } from "./models/schemas/index";
+import {
+	buildOpenAICompatibleProviderDefaults,
+	type OpenAICompatibleProviderDefaults,
+} from "./providers/shared/openai-compatible";
+
+export * as models from "./models/index";
+export type { ProviderCapability } from "./models/schemas/index";
+
+export interface CatalogProviderDefaults
+	extends Omit<OpenAICompatibleProviderDefaults, "capabilities"> {
+	capabilities?: ProviderCapability[];
+}
+
+export const OPENAI_COMPATIBLE_PROVIDERS: Record<
+	string,
+	CatalogProviderDefaults
+> = buildOpenAICompatibleProviderDefaults({
+	includeKnownModels: true,
+});

package/src/config-browser.ts

@@ -0,0 +1,11 @@
+import type { LlmsConfig } from "./types";
+
+export function defineLlmsConfig(config: LlmsConfig): LlmsConfig {
+	return config;
+}
+
+export async function loadLlmsConfigFromFile(): Promise<LlmsConfig> {
+	throw new Error(
+		"loadLlmsConfigFromFile is Node-only. Use @clinebot/llms in a Node runtime or pass a config object directly in browser runtimes.",
+	);
+}

package/src/config.ts

@@ -0,0 +1,49 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import type { LlmsConfig } from "./types";
+
+export function defineLlmsConfig(config: LlmsConfig): LlmsConfig {
+	return config;
+}
+
+export async function loadLlmsConfigFromFile(
+	configPath: string,
+): Promise<LlmsConfig> {
+	const resolvedPath = path.resolve(configPath);
+	const raw = await readFile(resolvedPath, "utf8");
+
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(raw);
+	} catch (error) {
+		const details = error instanceof Error ? error.message : String(error);
+		throw new Error(
+			`Failed to parse JSON config at "${resolvedPath}": ${details}`,
+		);
+	}
+
+	return assertLlmsConfig(parsed, resolvedPath);
+}
+
+function assertLlmsConfig(value: unknown, source: string): LlmsConfig {
+	if (!value || typeof value !== "object") {
+		throw new Error(`Invalid llms config in "${source}": expected an object.`);
+	}
+
+	const config = value as Record<string, unknown>;
+	const providers = config.providers;
+
+	if (!Array.isArray(providers)) {
+		throw new Error(
+			`Invalid llms config in "${source}": "providers" must be an array.`,
+		);
+	}
+
+	if (!providers.length) {
+		throw new Error(
+			`Invalid llms config in "${source}": "providers" cannot be empty.`,
+		);
+	}
+
+	return value as LlmsConfig;
+}

package/src/index.browser.ts

@@ -0,0 +1,9 @@
+export { defineLlmsConfig, loadLlmsConfigFromFile } from "./config-browser";
+export * as models from "./models/index";
+export * as providers from "./providers/public.browser";
+export type {
+	CustomProviderConfig,
+	LlmsConfig,
+	LlmsSdk,
+	ProviderSelectionConfig,
+} from "./types";

package/src/index.ts

@@ -0,0 +1,10 @@
+export { defineLlmsConfig } from "./config";
+export * as models from "./models/index";
+export * as providers from "./providers/public";
+export { createLlmsSdk } from "./sdk";
+export type {
+	CustomProviderConfig,
+	LlmsConfig,
+	LlmsSdk,
+	ProviderSelectionConfig,
+} from "./types";

package/src/live-providers.test.ts

@@ -0,0 +1,137 @@
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { describe, it } from "vitest";
+import { providers } from "./index";
+
+type ProviderConfig = providers.ProviderConfig;
+type ProviderSettings = providers.ProviderSettings;
+
+interface StoredProviderSettingsEntryLike {
+	settings?: unknown;
+}
+
+interface StoredProviderSettingsLike {
+	providers?: Record<string, unknown>;
+}
+
+interface ProviderTarget {
+	label: string;
+	config: ProviderConfig;
+}
+
+const LIVE_TEST_ENABLED = process.env.LLMS_LIVE_TESTS === "1";
+const PROVIDERS_FILE_ENV = "LLMS_LIVE_PROVIDERS_PATH";
+const PROVIDER_TIMEOUT_MS = Number(
+	process.env.LLMS_LIVE_PROVIDER_TIMEOUT_MS ?? "90000",
+);
+
+const liveDescribe = LIVE_TEST_ENABLED ? describe : describe.skip;
+
+function requireProvidersFilePath(): string {
+	const filePath = process.env[PROVIDERS_FILE_ENV];
+	if (!filePath) {
+		throw new Error(
+			`Set ${PROVIDERS_FILE_ENV} to a providers.json file path before running live provider tests.`,
+		);
+	}
+	return path.resolve(filePath);
+}
+
+function toTargetsFromStoredFormat(
+	json: StoredProviderSettingsLike,
+): ProviderTarget[] {
+	const entries = Object.entries(json.providers ?? {});
+	return entries.map(([entryKey, entryValue]) => {
+		const maybeEntry = entryValue as StoredProviderSettingsEntryLike;
+		const rawSettings = maybeEntry.settings ?? entryValue;
+		const parsed = providers.ProviderSettingsSchema.parse(
+			rawSettings,
+		) as ProviderSettings;
+		return {
+			label: `${entryKey} (${parsed.provider})`,
+			config: providers.toProviderConfig(parsed),
+		};
+	});
+}
+
+function loadProviderTargets(filePath: string): ProviderTarget[] {
+	const raw = readFileSync(filePath, "utf8");
+	const parsed = JSON.parse(raw) as unknown;
+
+	if (Array.isArray(parsed)) {
+		return parsed.map((entry, index) => {
+			const settings = providers.ProviderSettingsSchema.parse(
+				entry,
+			) as ProviderSettings;
+			return {
+				label: `index:${index} (${settings.provider})`,
+				config: providers.toProviderConfig(settings),
+			};
+		});
+	}
+
+	const maybeStored = parsed as StoredProviderSettingsLike;
+	return toTargetsFromStoredFormat(maybeStored);
+}
+
+async function withTimeout<T>(
+	promise: Promise<T>,
+	timeoutMs: number,
+	label: string,
+): Promise<T> {
+	let timeout: NodeJS.Timeout | undefined;
+	const timeoutPromise = new Promise<T>((_, reject) => {
+		timeout = setTimeout(() => {
+			reject(new Error(`Timed out after ${timeoutMs}ms: ${label}`));
+		}, timeoutMs);
+	});
+
+	try {
+		return await Promise.race([promise, timeoutPromise]);
+	} finally {
+		if (timeout) {
+			clearTimeout(timeout);
+		}
+	}
+}
+
+async function runPrompt(target: ProviderTarget): Promise<void> {
+	const handler = await providers.createHandlerAsync(target.config);
+	const stream = handler.createMessage("You are a concise assistant.", [
+		{ role: "user", content: "Reply with the single word OK." },
+	]);
+
+	for await (const chunk of stream) {
+		if (chunk.type === "done" && !chunk.success) {
+			throw new Error(chunk.error ?? "done chunk reported success=false");
+		}
+	}
+}
+
+liveDescribe("live provider smoke test", () => {
+	it("reads configured providers from json and reports providers with failed responses", async () => {
+		const filePath = requireProvidersFilePath();
+		const targets = loadProviderTargets(filePath);
+
+		if (!targets.length) {
+			throw new Error(`No providers found in ${filePath}.`);
+		}
+
+		const failures: string[] = [];
+
+		for (const target of targets) {
+			try {
+				await withTimeout(runPrompt(target), PROVIDER_TIMEOUT_MS, target.label);
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				failures.push(`${target.label}: ${message}`);
+			}
+		}
+
+		if (failures.length > 0) {
+			throw new Error(
+				`Providers with error responses (${failures.length}):\n${failures.join("\n")}`,
+			);
+		}
+	}, 300_000);
+});

package/src/models/generated-access.ts

@@ -0,0 +1,41 @@
+import { GENERATED_PROVIDER_MODELS } from "./generated";
+import { sortModelsByReleaseDate } from "./models-dev-catalog";
+import type { ModelInfo } from "./schemas/index";
+
+let sortedGeneratedProviderModelsCache:
+	| Record<string, Record<string, ModelInfo>>
+	| undefined;
+const sortedGeneratedModelsByProviderCache = new Map<
+	string,
+	Record<string, ModelInfo>
+>();
+
+export function getGeneratedProviderModels(): Record<
+	string,
+	Record<string, ModelInfo>
+> {
+	sortedGeneratedProviderModelsCache ??= Object.fromEntries(
+		Object.entries(GENERATED_PROVIDER_MODELS.providers).map(
+			([providerId, models]) => [providerId, sortModelsByReleaseDate(models)],
+		),
+	);
+	return sortedGeneratedProviderModelsCache;
+}
+
+export function getGeneratedModelsVersion(): number {
+	return GENERATED_PROVIDER_MODELS.version;
+}
+
+export function getGeneratedModelsForProvider(
+	providerId: string,
+): Record<string, ModelInfo> {
+	const cached = sortedGeneratedModelsByProviderCache.get(providerId);
+	if (cached) {
+		return cached;
+	}
+	const sorted = sortModelsByReleaseDate(
+		GENERATED_PROVIDER_MODELS.providers[providerId] ?? {},
+	);
+	sortedGeneratedModelsByProviderCache.set(providerId, sorted);
+	return sorted;
+}

package/src/models/generated-provider-loaders.ts

@@ -0,0 +1,166 @@
+/**
+ * Auto-generated provider loader registry.
+ *
+ * WARNING: DO NOT EDIT THIS FILE MANUALLY.
+ *
+ * Generated by: @clinebot/llms/scripts/generate-provider-loaders.ts
+ */
+
+import type { ModelCollection } from "./schemas/index";
+
+export type GeneratedProviderLoaderEntry = readonly [
+	providerId: string,
+	load: () => Promise<ModelCollection>,
+];
+
+export const GENERATED_PROVIDER_LOADER_ENTRIES: GeneratedProviderLoaderEntry[] =
+	[
+		[
+			"aihubmix",
+			async () => (await import("./providers/aihubmix")).AIHUBMIX_PROVIDER,
+		],
+		[
+			"anthropic",
+			async () => (await import("./providers/anthropic")).ANTHROPIC_PROVIDER,
+		],
+		[
+			"asksage",
+			async () => (await import("./providers/asksage")).ASKSAGE_PROVIDER,
+		],
+		[
+			"baseten",
+			async () => (await import("./providers/baseten")).BASETEN_PROVIDER,
+		],
+		[
+			"bedrock",
+			async () => (await import("./providers/bedrock")).BEDROCK_PROVIDER,
+		],
+		[
+			"cerebras",
+			async () => (await import("./providers/cerebras")).CEREBRAS_PROVIDER,
+		],
+		[
+			"claude-code",
+			async () =>
+				(await import("./providers/claude-code")).CLAUDE_CODE_PROVIDER,
+		],
+		["cline", async () => (await import("./providers/cline")).CLINE_PROVIDER],
+		[
+			"deepseek",
+			async () => (await import("./providers/deepseek")).DEEPSEEK_PROVIDER,
+		],
+		["dify", async () => (await import("./providers/dify")).DIFY_PROVIDER],
+		[
+			"doubao",
+			async () => (await import("./providers/doubao")).DOUBAO_PROVIDER,
+		],
+		[
+			"fireworks",
+			async () => (await import("./providers/fireworks")).FIREWORKS_PROVIDER,
+		],
+		[
+			"gemini",
+			async () => (await import("./providers/gemini")).GEMINI_PROVIDER,
+		],
+		["groq", async () => (await import("./providers/groq")).GROQ_PROVIDER],
+		["hicap", async () => (await import("./providers/hicap")).HICAP_PROVIDER],
+		[
+			"huawei-cloud-maas",
+			async () =>
+				(await import("./providers/huawei-cloud-maas"))
+					.HUAWEI_CLOUD_MAAS_PROVIDER,
+		],
+		[
+			"huggingface",
+			async () =>
+				(await import("./providers/huggingface")).HUGGINGFACE_PROVIDER,
+		],
+		[
+			"litellm",
+			async () => (await import("./providers/litellm")).LITELLM_PROVIDER,
+		],
+		[
+			"lmstudio",
+			async () => (await import("./providers/lmstudio")).LMSTUDIO_PROVIDER,
+		],
+		[
+			"minimax",
+			async () => (await import("./providers/minimax")).MINIMAX_PROVIDER,
+		],
+		[
+			"mistral",
+			async () => (await import("./providers/mistral")).MISTRAL_PROVIDER,
+		],
+		[
+			"moonshot",
+			async () => (await import("./providers/moonshot")).MOONSHOT_PROVIDER,
+		],
+		[
+			"nebius",
+			async () => (await import("./providers/nebius")).NEBIUS_PROVIDER,
+		],
+		[
+			"nousResearch",
+			async () =>
+				(await import("./providers/nous-research")).NOUS_RESEARCH_PROVIDER,
+		],
+		["oca", async () => (await import("./providers/oca")).OCA_PROVIDER],
+		[
+			"ollama",
+			async () => (await import("./providers/ollama")).OLLAMA_PROVIDER,
+		],
+		[
+			"openai",
+			async () => (await import("./providers/openai")).OPENAI_PROVIDER,
+		],
+		[
+			"openai-codex",
+			async () =>
+				(await import("./providers/openai-codex")).OPENAI_CODEX_PROVIDER,
+		],
+		[
+			"openai-native",
+			async () => (await import("./providers/openai")).OPENAI_PROVIDER,
+		],
+		[
+			"opencode",
+			async () => (await import("./providers/opencode")).OPENCODE_PROVIDER,
+		],
+		[
+			"openrouter",
+			async () => (await import("./providers/openrouter")).OPENROUTER_PROVIDER,
+		],
+		["qwen", async () => (await import("./providers/qwen")).QWEN_PROVIDER],
+		[
+			"qwen-code",
+			async () => (await import("./providers/qwen-code")).QWEN_CODE_PROVIDER,
+		],
+		[
+			"requesty",
+			async () => (await import("./providers/requesty")).REQUESTY_PROVIDER,
+		],
+		[
+			"sambanova",
+			async () => (await import("./providers/sambanova")).SAMBANOVA_PROVIDER,
+		],
+		[
+			"sapaicore",
+			async () => (await import("./providers/sapaicore")).SAP_AI_CORE_PROVIDER,
+		],
+		[
+			"together",
+			async () => (await import("./providers/together")).TOGETHER_PROVIDER,
+		],
+		[
+			"vercel-ai-gateway",
+			async () =>
+				(await import("./providers/vercel-ai-gateway"))
+					.VERCEL_AI_GATEWAY_PROVIDER,
+		],
+		[
+			"vertex",
+			async () => (await import("./providers/vertex")).VERTEX_PROVIDER,
+		],
+		["xai", async () => (await import("./providers/xai")).XAI_PROVIDER],
+		["zai", async () => (await import("./providers/zai")).ZAI_PROVIDER],
+	];