@clinebot/llms 0.0.0

package/src/providers/types/messages.ts

@@ -0,0 +1,158 @@
+/**
+ * Message Types
+ *
+ * Standardized message format for input to providers.
+ * This is a simplified, provider-agnostic format that can be
+ * converted to any provider's native format.
+ */
+
+/**
+ * Message roles
+ */
+export type MessageRole = "user" | "assistant";
+
+/**
+ * Text content block
+ */
+export interface TextContent {
+	type: "text";
+	text: string;
+	/** Thought signature for this text part (Gemini) */
+	signature?: string;
+}
+
+/**
+ * File content block for Cline
+ */
+export interface FileContent {
+	type: "file";
+	content: string;
+	/** Absolute Path */
+	path: string;
+	source?: string;
+}
+
+/**
+ * Image content block
+ */
+export interface ImageContent {
+	type: "image";
+	/** Base64 encoded image data */
+	data: string;
+	/** MIME type (e.g., "image/png", "image/jpeg") */
+	mediaType: string;
+}
+
+/**
+ * Tool use content block (assistant's tool call)
+ */
+export interface ToolUseContent {
+	type: "tool_use";
+	/** Unique ID for this tool call */
+	id: string;
+	/** Name of the tool being called */
+	name: string;
+	/** Arguments for the tool call */
+	input: Record<string, unknown>;
+	/** Thought signature for this function call part (Gemini) */
+	signature?: string;
+}
+
+/**
+ * Tool result content block (user's response to tool call)
+ */
+export interface ToolResultContent {
+	type: "tool_result";
+	/** ID of the tool call this is responding to */
+	tool_use_id: string;
+	/** Result content (can be text or error) */
+	content: string | Array<TextContent | ImageContent | FileContent>;
+	/** Whether this result represents an error */
+	is_error?: boolean;
+}
+
+/**
+ * Thinking/reasoning content block
+ */
+export interface ThinkingContent {
+	type: "thinking";
+	/** The thinking/reasoning text */
+	thinking: string;
+	/** Signature for the thinking block (provider-specific) */
+	signature?: string;
+}
+
+/**
+ * Redacted thinking content block
+ */
+export interface RedactedThinkingContent {
+	type: "redacted_thinking";
+	/** Encrypted/redacted data */
+	data: string;
+}
+
+/**
+ * Union of all content block types
+ */
+export type ContentBlock =
+	| TextContent
+	| ImageContent
+	| ToolUseContent
+	| ToolResultContent
+	| ThinkingContent
+	| FileContent
+	| RedactedThinkingContent;
+
+/**
+ * A single message in the conversation
+ */
+export interface Message {
+	/** Message role */
+	role: MessageRole;
+	/** Message content - can be a simple string or array of content blocks */
+	content: string | ContentBlock[];
+}
+
+/**
+ * Extended message with metadata (used for storage/history)
+ */
+export interface MessageWithMetadata extends Message {
+	/** Unique message ID */
+	id?: string;
+	/** Provider ID used to generate this message */
+	providerId?: string;
+	/** Model ID used to generate this message */
+	modelId?: string;
+	/** Model info at the time of generation */
+	modelInfo?: {
+		id: string;
+		provider: string;
+	};
+	/** Token usage metrics */
+	metrics?: {
+		inputTokens?: number;
+		outputTokens?: number;
+		cacheReadTokens?: number;
+		cacheWriteTokens?: number;
+		cost?: number;
+	};
+	/** Timestamp of when the message was created */
+	ts?: number;
+}
+
+/**
+ * Tool definition for native tool calling
+ */
+export interface ToolDefinition {
+	/** Tool name */
+	name: string;
+	/** Tool description */
+	description: string;
+	/** JSON Schema for the tool's input parameters */
+	inputSchema: {
+		type: "object";
+		properties: Record<string, unknown>;
+		required?: string[];
+		additionalProperties?: boolean;
+	};
+}

package/src/providers/types/model-info.test.ts

@@ -0,0 +1,57 @@
+import { describe, expect, it } from "vitest";
+import type { ModelInfo } from "../../models/schemas/model";
+import {
+	getModelPricing,
+	hasModelCapability,
+	supportsModelThinking,
+} from "./model-info";
+
+function createModel(overrides: Partial<ModelInfo> = {}): ModelInfo {
+	return {
+		id: "test-model",
+		...overrides,
+	};
+}
+
+describe("model-info helpers", () => {
+	it("checks capabilities safely when capabilities are absent", () => {
+		const info = createModel();
+
+		expect(hasModelCapability(info, "reasoning")).toBe(false);
+	});
+
+	it("detects capability membership when present", () => {
+		const info = createModel({
+			capabilities: ["tools", "reasoning"],
+		});
+
+		expect(hasModelCapability(info, "reasoning")).toBe(true);
+		expect(hasModelCapability(info, "images")).toBe(false);
+	});
+
+	it("detects thinking support from either thinkingConfig or reasoning capability", () => {
+		const byCapability = createModel({
+			capabilities: ["reasoning"],
+		});
+		const byConfig = createModel({
+			thinkingConfig: { maxBudget: 1024 },
+		});
+		const unsupported = createModel({
+			capabilities: ["tools"],
+		});
+
+		expect(supportsModelThinking(byCapability)).toBe(true);
+		expect(supportsModelThinking(byConfig)).toBe(true);
+		expect(supportsModelThinking(unsupported)).toBe(false);
+	});
+
+	it("returns pricing if set, otherwise empty pricing object", () => {
+		const priced = createModel({
+			pricing: { input: 1.2, output: 2.4 },
+		});
+		const unpriced = createModel();
+
+		expect(getModelPricing(priced)).toEqual({ input: 1.2, output: 2.4 });
+		expect(getModelPricing(unpriced)).toEqual({});
+	});
+});

package/src/providers/types/model-info.ts

@@ -0,0 +1,65 @@
+/**
+ * Model Information Types
+ *
+ * Re-exports model types from @clinebot/models (the single source of truth)
+ * and provides provider-specific helpers and aliases.
+ */
+
+import type {
+	ModelCapability,
+	ModelInfo,
+	ModelPricing,
+	ThinkingConfig,
+} from "../../models/schemas/model";
+import { ApiFormat } from "../../models/schemas/model";
+
+export type { ModelCapability, ModelInfo, ModelPricing, ThinkingConfig };
+export { ApiFormat };
+export type { ApiFormat as ApiFormatType } from "../../models/schemas/model";
+
+// =============================================================================
+// Helper Functions
+// =============================================================================
+
+/**
+ * Check if a model has a specific capability
+ */
+export function hasModelCapability(
+	info: ModelInfo,
+	capability: ModelCapability,
+): boolean {
+	return info.capabilities?.includes(capability) ?? false;
+}
+
+/**
+ * Check if a model supports explicit thinking/reasoning controls.
+ */
+export function supportsModelThinking(info: ModelInfo): boolean {
+	return Boolean(info.thinkingConfig) || hasModelCapability(info, "reasoning");
+}
+
+/**
+ * Get pricing for a model
+ */
+export function getModelPricing(info: ModelInfo): ModelPricing {
+	return info.pricing ?? {};
+}
+
+// =============================================================================
+// Model with ID
+// =============================================================================
+
+/**
+ * Model with its identifier
+ */
+export interface ModelWithId {
+	id: string;
+	info: ModelInfo;
+}
+
+// =============================================================================
+// Type Aliases (for backwards compatibility)
+// =============================================================================
+
+/** Alias for ModelInfo - all model types use the same interface */
+export type OpenAICompatibleModelInfo = ModelInfo;

package/src/providers/types/provider-ids.test.ts

@@ -0,0 +1,12 @@
+import { describe, expect, it } from "vitest";
+import { getProviderIds } from "../../models/registry";
+import { BUILT_IN_PROVIDER_IDS } from "./provider-ids";
+
+describe("provider-ids", () => {
+	it("keeps built-in provider ids aligned with model registry loaders", () => {
+		const registryProviderIds = new Set(getProviderIds());
+		for (const providerId of BUILT_IN_PROVIDER_IDS) {
+			expect(registryProviderIds.has(providerId)).toBe(true);
+		}
+	});
+});

package/src/providers/types/provider-ids.ts

@@ -0,0 +1,89 @@
+/**
+ * Built-in provider IDs
+ *
+ * Single source of truth for all built-in provider identifiers.
+ * Use BUILT_IN_PROVIDER_IDS for runtime operations (validation, iteration)
+ * Use BuiltInProviderId type for compile-time type safety
+ */
+
+export enum BUILT_IN_PROVIDER {
+	// First-party
+	ANTHROPIC = "anthropic",
+	CLAUDE_CODE = "claude-code",
+	CLINE = "cline",
+	// OpenAI variants
+	OPENAI = "openai", // OpenAi Completions
+	OPENAI_NATIVE = "openai-native",
+	OPENAI_CODEX = "openai-codex",
+	// CLI / Subscription-based providers
+	OPENCODE = "opencode",
+	// Cloud providers
+	BEDROCK = "bedrock",
+	VERTEX = "vertex",
+	GEMINI = "gemini",
+	// Local/self-hosted
+	OLLAMA = "ollama",
+	LMSTUDIO = "lmstudio",
+	// OpenAI-compatible
+	DEEPSEEK = "deepseek",
+	XAI = "xai",
+	TOGETHER = "together",
+	FIREWORKS = "fireworks",
+	GROQ = "groq",
+	CEREBRAS = "cerebras",
+	SAMBANOVA = "sambanova",
+	NEBIUS = "nebius",
+	BASETEN = "baseten",
+	REQUESTY = "requesty",
+	LITELLM = "litellm",
+	HUGGINGFACE = "huggingface",
+	VERCEL_AI_GATEWAY = "vercel-ai-gateway",
+	AIHUBMIX = "aihubmix",
+	HICAP = "hicap",
+	NOUS_RESEARCH = "nousResearch",
+	HUAWEI_CLOUD_MAAS = "huawei-cloud-maas",
+	// Regional/specialized
+	QWEN = "qwen",
+	QWEN_CODE = "qwen-code",
+	DOUBAO = "doubao",
+	MISTRAL = "mistral",
+	MOONSHOT = "moonshot",
+	ASKSAGE = "asksage",
+	ZAI = "zai",
+	MINIMAX = "minimax",
+	DIFY = "dify",
+	OCA = "oca",
+	SAPAICORE = "sapaicore",
+	// Aggregators
+	OPENROUTER = "openrouter",
+}
+
+/**
+ * Provider ID aliases normalized to canonical built-in IDs.
+ *
+ * Keep this map as the single source of truth for alias handling.
+ */
+export const PROVIDER_ID_ALIASES: Record<string, BUILT_IN_PROVIDER> = {
+	openai: BUILT_IN_PROVIDER.OPENAI_NATIVE,
+	togetherai: BUILT_IN_PROVIDER.TOGETHER,
+	"sap-ai-core": BUILT_IN_PROVIDER.SAPAICORE,
+};
+
+export const BUILT_IN_PROVIDER_IDS = Object.values(BUILT_IN_PROVIDER) as [
+	BUILT_IN_PROVIDER,
+	...BUILT_IN_PROVIDER[],
+];
+
+/** Type derived from the array - use for type annotations */
+export type BuiltInProviderId = (typeof BUILT_IN_PROVIDER_IDS)[number];
+
+/** Check if a string is a valid built-in provider ID */
+export function isBuiltInProviderId(id: string): id is BuiltInProviderId {
+	return BUILT_IN_PROVIDER_IDS.includes(id as BuiltInProviderId);
+}
+
+/** Normalize provider aliases to canonical IDs */
+export function normalizeProviderId(providerId: string): string {
+	const normalized = providerId.trim();
+	return PROVIDER_ID_ALIASES[normalized] ?? normalized;
+}

package/src/providers/types/settings.test.ts

@@ -0,0 +1,49 @@
+import { resolveProviderModelCatalogKeys } from "@clinebot/shared";
+import { describe, expect, it } from "vitest";
+import { getGeneratedModelsForProvider } from "../../models/generated-access";
+import type { ProviderSettings } from "./settings";
+import { toProviderConfig } from "./settings";
+
+describe("toProviderConfig", () => {
+	it("backfills knownModels from generated catalogs for anthropic", () => {
+		const anthropicModels = getGeneratedModelsForProvider("anthropic");
+		const modelId = Object.keys(anthropicModels)[0];
+		expect(modelId).toBeTruthy();
+		if (!modelId) {
+			return;
+		}
+
+		const settings: ProviderSettings = {
+			provider: "anthropic",
+			apiKey: "test-key",
+			model: modelId,
+		};
+
+		const config = toProviderConfig(settings);
+
+		expect(config.knownModels?.[modelId]).toEqual(anthropicModels[modelId]);
+		expect(config.knownModels?.[modelId]?.pricing).toBeDefined();
+	});
+
+	it("hydrates cline knownModels using shared catalog key mapping", () => {
+		const gatewayModels = Object.assign(
+			{},
+			...resolveProviderModelCatalogKeys("cline").map((providerId) =>
+				getGeneratedModelsForProvider(providerId),
+			),
+		);
+		const modelId = "openai/gpt-5.3-codex";
+		expect(gatewayModels[modelId]).toBeDefined();
+
+		const settings: ProviderSettings = {
+			provider: "cline",
+			apiKey: "test-key",
+			model: modelId,
+		};
+
+		const config = toProviderConfig(settings);
+
+		expect(config.knownModels?.[modelId]).toEqual(gatewayModels[modelId]);
+		expect(config.knownModels?.[modelId]?.pricing).toBeDefined();
+	});
+});