@agi-cli/sdk 0.1.53 → 0.1.55

package/src/providers/src/env.ts

@@ -0,0 +1,26 @@
+import type { ProviderId } from '../../types/src/index.ts';
+
+const ENV_VARS: Record<ProviderId, string> = {
+	openai: 'OPENAI_API_KEY',
+	anthropic: 'ANTHROPIC_API_KEY',
+	google: 'GOOGLE_GENERATIVE_AI_API_KEY',
+	openrouter: 'OPENROUTER_API_KEY',
+	opencode: 'OPENCODE_API_KEY',
+};
+
+export function providerEnvVar(provider: ProviderId): string {
+	return ENV_VARS[provider];
+}
+
+export function readEnvKey(provider: ProviderId): string | undefined {
+	const key = providerEnvVar(provider);
+	const value = process.env[key];
+	return value?.length ? value : undefined;
+}
+
+export function setEnvKey(provider: ProviderId, value: string | undefined) {
+	const key = providerEnvVar(provider);
+	if (value) {
+		process.env[key] = value;
+	}
+}

package/src/providers/src/index.ts

@@ -0,0 +1,12 @@
+export { isProviderAuthorized, ensureProviderEnv } from './authorization.ts';
+export { catalog } from './catalog.ts';
+export type { ProviderId, ModelInfo } from '../../types/src/index.ts';
+export {
+	isProviderId,
+	providerIds,
+	defaultModelFor,
+	hasModel,
+} from './utils.ts';
+export { validateProviderModel } from './validate.ts';
+export { estimateModelCostUsd } from './pricing.ts';
+export { providerEnvVar, readEnvKey, setEnvKey } from './env.ts';

package/src/providers/src/pricing.ts

@@ -0,0 +1,135 @@
+import { catalog } from './catalog.ts';
+import type { ModelInfo, ProviderId } from '../../types/src/index.ts';
+
+type ProviderName = ProviderId;
+
+type UsageLike = {
+	inputTokens?: number | null;
+	outputTokens?: number | null;
+};
+
+type PricingEntry = {
+	/** Cost in USD per 1 million input tokens */
+	inputPerMillion: number;
+	/** Cost in USD per 1 million output tokens */
+	outputPerMillion: number;
+	match: (model: string) => boolean;
+};
+
+const pricingTable: Record<ProviderName, PricingEntry[]> = {
+	openai: [
+		{
+			match: (model) => model.includes('gpt-4o-mini'),
+			inputPerMillion: 0.15,
+			outputPerMillion: 0.6,
+		},
+		{
+			match: (model) => model.includes('gpt-4o'),
+			inputPerMillion: 5,
+			outputPerMillion: 15,
+		},
+		{
+			match: (model) => model.includes('gpt-4.1-mini'),
+			inputPerMillion: 1,
+			outputPerMillion: 4,
+		},
+		{
+			match: (model) => model.includes('gpt-4.1'),
+			inputPerMillion: 5,
+			outputPerMillion: 15,
+		},
+	],
+	anthropic: [
+		{
+			match: (model) => model.includes('claude-3-haiku'),
+			inputPerMillion: 0.25,
+			outputPerMillion: 1.25,
+		},
+		{
+			match: (model) => model.includes('claude-3-sonnet'),
+			inputPerMillion: 3,
+			outputPerMillion: 15,
+		},
+		{
+			match: (model) => model.includes('claude-3-opus'),
+			inputPerMillion: 15,
+			outputPerMillion: 75,
+		},
+	],
+	google: [
+		{
+			match: (model) => model.includes('gemini-1.5-flash'),
+			inputPerMillion: 0.35,
+			outputPerMillion: 1.05,
+		},
+		{
+			match: (model) => model.includes('gemini-1.5-pro'),
+			inputPerMillion: 3.5,
+			outputPerMillion: 10.5,
+		},
+	],
+	openrouter: [
+		// Prefer catalog pricing; keep empty to defer to catalog or undefined
+	],
+	opencode: [
+		// Pricing from catalog entries; leave empty here
+	],
+};
+
+function findPricing(
+	provider: ProviderName,
+	model: string,
+): PricingEntry | undefined {
+	const entries = pricingTable[provider];
+	if (!entries) return undefined;
+	return entries.find((entry) => {
+		try {
+			return entry.match(model);
+		} catch {
+			return false;
+		}
+	});
+}
+
+function findCatalogModel(
+	provider: ProviderName,
+	model: string,
+): ModelInfo | undefined {
+	const entry = catalog[provider as keyof typeof catalog];
+	if (!entry) return undefined;
+	const idLower = model.toLowerCase();
+	return entry.models.find((m) => m.id?.toLowerCase() === idLower);
+}
+
+export function estimateModelCostUsd(
+	provider: ProviderName,
+	model: string,
+	usage: UsageLike,
+): number | undefined {
+	const inputTokens =
+		typeof usage.inputTokens === 'number' ? usage.inputTokens : 0;
+	const outputTokens =
+		typeof usage.outputTokens === 'number' ? usage.outputTokens : 0;
+	if (!inputTokens && !outputTokens) return undefined;
+
+	// Prefer centralized catalog costs when available
+	const m = findCatalogModel(provider, model);
+	if (m?.cost?.input != null || m?.cost?.output != null) {
+		const inputPerMillion =
+			typeof m.cost?.input === 'number' ? m.cost.input : 0;
+		const outputPerMillion =
+			typeof m.cost?.output === 'number' ? m.cost.output : 0;
+		const inputCost = (inputTokens * inputPerMillion) / 1_000_000;
+		const outputCost = (outputTokens * outputPerMillion) / 1_000_000;
+		const total = inputCost + outputCost;
+		return Number.isFinite(total) ? Number(total.toFixed(6)) : undefined;
+	}
+
+	// Fallback to legacy table if catalog lacks pricing
+	const entry = findPricing(provider, model.toLowerCase());
+	if (!entry) return undefined;
+	const inputCost = (inputTokens * entry.inputPerMillion) / 1_000_000;
+	const outputCost = (outputTokens * entry.outputPerMillion) / 1_000_000;
+	const total = inputCost + outputCost;
+	return Number.isFinite(total) ? Number(total.toFixed(6)) : undefined;
+}

package/src/providers/src/utils.ts

@@ -0,0 +1,24 @@
+import { catalog } from './catalog.ts';
+import type { ProviderId } from '../../types/src/index.ts';
+
+export const providerIds = Object.keys(catalog) as ProviderId[];
+
+export function isProviderId(value: unknown): value is ProviderId {
+	return typeof value === 'string' && providerIds.includes(value as ProviderId);
+}
+
+export function defaultModelFor(provider: ProviderId): string | undefined {
+	return catalog[provider]?.models?.[0]?.id;
+}
+
+export function listModels(provider: ProviderId): string[] {
+	return (catalog[provider]?.models ?? []).map((m) => m.id);
+}
+
+export function hasModel(
+	provider: ProviderId,
+	model: string | undefined,
+): boolean {
+	if (!model) return false;
+	return listModels(provider).includes(model);
+}

package/src/providers/src/validate.ts

@@ -0,0 +1,39 @@
+import { catalog } from './catalog.ts';
+import type { ProviderId } from '../../types/src/index.ts';
+
+export type CapabilityRequest = {
+	wantsToolCalls?: boolean;
+	wantsVision?: boolean; // input image
+};
+
+export function validateProviderModel(
+	provider: string,
+	model: string,
+	cap?: CapabilityRequest,
+) {
+	const p = provider as ProviderId;
+	if (!catalog[p]) {
+		throw new Error(`Provider not supported: ${provider}`);
+	}
+	const entry = catalog[p].models.find((m) => m.id === model);
+	if (!entry) {
+		const list = catalog[p].models
+			.slice(0, 10)
+			.map((m) => m.id)
+			.join(', ');
+		throw new Error(
+			`Model not found for provider ${provider}: ${model}. Example models: ${list}${catalog[p].models.length > 10 ? ', ...' : ''}`,
+		);
+	}
+	if (cap?.wantsToolCalls && !entry.toolCall) {
+		throw new Error(`Model ${model} does not support tool calls.`);
+	}
+	if (cap?.wantsVision) {
+		const inputs = entry.modalities?.input as string[] | undefined;
+		const outputs = entry.modalities?.output as string[] | undefined;
+		const ok =
+			(inputs ?? []).includes('image') || (outputs ?? []).includes('image');
+		if (!ok)
+			throw new Error(`Model ${model} does not support vision input/output.`);
+	}
+}

package/src/types/src/auth.ts

@@ -0,0 +1,26 @@
+import type { ProviderId } from './provider';
+
+/**
+ * API key authentication
+ */
+export type ApiAuth = { type: 'api'; key: string };
+
+/**
+ * OAuth authentication tokens
+ */
+export type OAuth = {
+	type: 'oauth';
+	access: string;
+	refresh: string;
+	expires: number;
+};
+
+/**
+ * Union of all auth types
+ */
+export type AuthInfo = ApiAuth | OAuth;
+
+/**
+ * Collection of auth credentials per provider
+ */
+export type AuthFile = Partial<Record<ProviderId, AuthInfo>>;

package/src/types/src/config.ts

@@ -0,0 +1,40 @@
+import type { ProviderId } from './provider';
+
+/**
+ * Configuration scope - where settings are stored
+ */
+export type Scope = 'global' | 'local';
+
+/**
+ * Provider-specific configuration
+ */
+export type ProviderConfig = { enabled: boolean; apiKey?: string };
+
+/**
+ * Default settings for the CLI
+ */
+export type DefaultConfig = {
+	agent: string;
+	provider: ProviderId;
+	model: string;
+};
+
+/**
+ * Path configuration
+ */
+export type PathConfig = {
+	dataDir: string;
+	dbPath: string;
+	projectConfigPath: string | null;
+	globalConfigPath: string | null;
+};
+
+/**
+ * Complete AGI configuration object
+ */
+export type AGIConfig = {
+	projectRoot: string;
+	defaults: DefaultConfig;
+	providers: Record<ProviderId, ProviderConfig>;
+	paths: PathConfig;
+};

package/src/types/src/index.ts

@@ -0,0 +1,14 @@
+// Provider types
+export type { ProviderId, ModelInfo } from './provider';
+
+// Auth types
+export type { ApiAuth, OAuth, AuthInfo, AuthFile } from './auth';
+
+// Config types
+export type {
+	Scope,
+	ProviderConfig,
+	DefaultConfig,
+	PathConfig,
+	AGIConfig,
+} from './config';

package/src/types/src/provider.ts

@@ -0,0 +1,28 @@
+/**
+ * Provider identifiers for supported AI providers
+ */
+export type ProviderId =
+	| 'openai'
+	| 'anthropic'
+	| 'google'
+	| 'openrouter'
+	| 'opencode';
+
+/**
+ * Information about a specific model
+ */
+export type ModelInfo = {
+	id: string;
+	label?: string;
+	modalities?: { input?: string[]; output?: string[] };
+	toolCall?: boolean;
+	reasoning?: boolean;
+	attachment?: boolean;
+	temperature?: boolean | number;
+	knowledge?: string;
+	releaseDate?: string;
+	lastUpdated?: string;
+	openWeights?: boolean;
+	cost?: { input?: number; output?: number; cacheRead?: number };
+	limit?: { context?: number; output?: number };
+};

package/src/global.d.ts

@@ -1,4 +0,0 @@
-declare module '*.sql' {
-	const sql: string;
-	export default sql;
-}

package/src/tools/builtin/fs.ts

@@ -1 +0,0 @@
-export * from '@agi-cli/core/tools/builtin/fs';

package/src/tools/builtin/git.ts

@@ -1 +0,0 @@
-export * from '@agi-cli/core/tools/builtin/git';

package/src/web-ui.ts

@@ -1,8 +0,0 @@
-export {
-	serveWebUI,
-	getWebUIPath,
-	getIndexPath,
-	isWebUIAvailable,
-} from '@agi-cli/web-ui';
-
-export type { ServeWebUIOptions } from '@agi-cli/web-ui';