@ottocode/sdk 0.1.173

package/src/providers/src/copilot-client.ts

@@ -0,0 +1,39 @@
+import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
+import type { OAuth } from '../../types/src/index.ts';
+
+const COPILOT_BASE_URL = 'https://api.githubcopilot.com';
+
+export type CopilotOAuthConfig = {
+	oauth: OAuth;
+};
+
+export function createCopilotFetch(config: CopilotOAuthConfig): typeof fetch {
+	return async (
+		input: string | URL | Request,
+		init?: RequestInit,
+	): Promise<Response> => {
+		const headers = new Headers(init?.headers);
+		headers.delete('Authorization');
+		headers.delete('authorization');
+		headers.set('Authorization', `Bearer ${config.oauth.refresh}`);
+		headers.set('Openai-Intent', 'conversation-edits');
+		headers.set('User-Agent', 'ottocode');
+
+		return fetch(input, {
+			...init,
+			headers,
+		});
+	};
+}
+
+export function createCopilotModel(model: string, config: CopilotOAuthConfig) {
+	const customFetch = createCopilotFetch(config);
+
+	const provider = createOpenAICompatible({
+		name: 'github-copilot',
+		baseURL: COPILOT_BASE_URL,
+		apiKey: 'copilot-oauth',
+		fetch: customFetch,
+	});
+	return provider.chatModel(model);
+}

package/src/providers/src/env.ts

@@ -0,0 +1,31 @@
+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',
+	copilot: 'GITHUB_TOKEN',
+	setu: 'SETU_PRIVATE_KEY',
+	zai: 'ZAI_API_KEY',
+	'zai-coding': 'ZAI_API_KEY',
+	moonshot: 'MOONSHOT_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/google-client.ts

@@ -0,0 +1,16 @@
+import { google, createGoogleGenerativeAI } from '@ai-sdk/google';
+
+export type GoogleProviderConfig = {
+	apiKey?: string;
+};
+
+export function createGoogleModel(
+	model: string,
+	config?: GoogleProviderConfig,
+) {
+	if (config?.apiKey) {
+		const instance = createGoogleGenerativeAI({ apiKey: config.apiKey });
+		return instance(model);
+	}
+	return google(model);
+}

package/src/providers/src/index.ts

@@ -0,0 +1,75 @@
+export { isProviderAuthorized, ensureProviderEnv } from './authorization.ts';
+export { catalog } from './catalog-merged.ts';
+export type {
+	ProviderId,
+	ModelInfo,
+	ModelProviderBinding,
+	ProviderCatalogEntry,
+} from '../../types/src/index.ts';
+export {
+	isProviderId,
+	providerIds,
+	defaultModelFor,
+	hasModel,
+	getFastModel,
+	getFastModelForAuth,
+	getModelNpmBinding,
+	isAnthropicBasedModel,
+	getUnderlyingProviderKey,
+	getModelFamily,
+	getModelInfo,
+	modelSupportsReasoning,
+} from './utils.ts';
+export type { UnderlyingProviderKey } from './utils.ts';
+export { validateProviderModel } from './validate.ts';
+export { estimateModelCostUsd } from './pricing.ts';
+export { providerEnvVar, readEnvKey, setEnvKey } from './env.ts';
+export {
+	createSetuFetch,
+	createSetuModel,
+	fetchSetuBalance,
+	getPublicKeyFromPrivate,
+	fetchSolanaUsdcBalance,
+} from './setu-client.ts';
+export type {
+	SetuAuth,
+	SetuProviderOptions,
+	SetuPaymentCallbacks,
+	SetuBalanceResponse,
+	SolanaUsdcBalanceResponse,
+} from './setu-client.ts';
+export {
+	createOpenAIOAuthFetch,
+	createOpenAIOAuthModel,
+} from './openai-oauth-client.ts';
+export type { OpenAIOAuthConfig } from './openai-oauth-client.ts';
+export {
+	isModelAllowedForOAuth,
+	filterModelsForAuthType,
+	getOAuthModelPrefixes,
+} from './oauth-models.ts';
+export {
+	addAnthropicCacheControl,
+	createAnthropicCachingFetch,
+	createConditionalCachingFetch,
+} from './anthropic-caching.ts';
+export {
+	createAnthropicOAuthFetch,
+	createAnthropicOAuthModel,
+} from './anthropic-oauth-client.ts';
+export type { AnthropicOAuthConfig } from './anthropic-oauth-client.ts';
+export { createGoogleModel } from './google-client.ts';
+export type { GoogleProviderConfig } from './google-client.ts';
+export { createZaiModel, createZaiCodingModel } from './zai-client.ts';
+export type { ZaiProviderConfig } from './zai-client.ts';
+export {
+	getOpenRouterInstance,
+	createOpenRouterModel,
+} from './openrouter-client.ts';
+export type { OpenRouterProviderConfig } from './openrouter-client.ts';
+export { createOpencodeModel } from './opencode-client.ts';
+export type { OpencodeProviderConfig } from './opencode-client.ts';
+export { createMoonshotModel } from './moonshot-client.ts';
+export type { MoonshotProviderConfig } from './moonshot-client.ts';
+export { createCopilotFetch, createCopilotModel } from './copilot-client.ts';
+export type { CopilotOAuthConfig } from './copilot-client.ts';

package/src/providers/src/moonshot-client.ts

@@ -0,0 +1,25 @@
+import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
+import { catalog } from './catalog-merged.ts';
+
+export type MoonshotProviderConfig = {
+	apiKey?: string;
+	baseURL?: string;
+};
+
+export function createMoonshotModel(
+	model: string,
+	config?: MoonshotProviderConfig,
+) {
+	const entry = catalog.moonshot;
+	const baseURL = config?.baseURL || entry?.api || 'https://api.moonshot.ai/v1';
+	const apiKey = config?.apiKey || process.env.MOONSHOT_API_KEY || '';
+	const headers = apiKey ? { Authorization: `Bearer ${apiKey}` } : undefined;
+
+	const instance = createOpenAICompatible({
+		name: entry?.label ?? 'Moonshot AI',
+		baseURL,
+		headers,
+	});
+
+	return instance(model);
+}

package/src/providers/src/oauth-models.ts

@@ -0,0 +1,39 @@
+import type { ProviderId, ModelInfo } from '../../types/src/index.ts';
+
+const OAUTH_MODEL_PREFIXES: Partial<Record<ProviderId, string[]>> = {
+	anthropic: ['claude-haiku-4-5', 'claude-opus-4-5', 'claude-sonnet-4-5'],
+	openai: [
+		'gpt-5.2-codex',
+		'gpt-5.1-codex-max',
+		'gpt-5.1-codex-mini',
+		'gpt-5.2',
+	],
+};
+
+export function isModelAllowedForOAuth(
+	provider: ProviderId,
+	modelId: string,
+): boolean {
+	const prefixes = OAUTH_MODEL_PREFIXES[provider];
+	if (!prefixes) return true;
+	return prefixes.some((prefix) => modelId.startsWith(prefix));
+}
+
+export function filterModelsForAuthType(
+	provider: ProviderId,
+	models: ModelInfo[],
+	authType: 'api' | 'oauth' | 'wallet' | undefined,
+): ModelInfo[] {
+	if (authType !== 'oauth') return models;
+	const prefixes = OAUTH_MODEL_PREFIXES[provider];
+	if (!prefixes) return models;
+	return models.filter((m) =>
+		prefixes.some((prefix) => m.id.startsWith(prefix)),
+	);
+}
+
+export function getOAuthModelPrefixes(
+	provider: ProviderId,
+): string[] | undefined {
+	return OAUTH_MODEL_PREFIXES[provider];
+}

package/src/providers/src/openai-oauth-client.ts

@@ -0,0 +1,108 @@
+import { createOpenAI } from '@ai-sdk/openai';
+import type { OAuth } from '../../types/src/index.ts';
+import { refreshOpenAIToken } from '../../auth/src/openai-oauth.ts';
+import { setAuth, getAuth } from '../../auth/src/index.ts';
+
+const CODEX_API_ENDPOINT = 'https://chatgpt.com/backend-api/codex/responses';
+
+export type OpenAIOAuthConfig = {
+	oauth: OAuth;
+	projectRoot?: string;
+};
+
+async function ensureValidToken(
+	oauth: OAuth,
+	projectRoot?: string,
+): Promise<{ access: string; accountId?: string }> {
+	if (oauth.access && oauth.expires > Date.now()) {
+		return { access: oauth.access, accountId: oauth.accountId };
+	}
+
+	try {
+		const newTokens = await refreshOpenAIToken(oauth.refresh);
+		const updatedOAuth: OAuth = {
+			type: 'oauth',
+			access: newTokens.access,
+			refresh: newTokens.refresh,
+			expires: newTokens.expires,
+			accountId: oauth.accountId,
+			idToken: newTokens.idToken,
+		};
+		await setAuth('openai', updatedOAuth, projectRoot, 'global');
+		return { access: newTokens.access, accountId: oauth.accountId };
+	} catch {
+		return { access: oauth.access, accountId: oauth.accountId };
+	}
+}
+
+function rewriteUrl(url: string): string {
+	const parsed = new URL(url);
+	if (
+		parsed.pathname.includes('/v1/responses') ||
+		parsed.pathname.includes('/chat/completions')
+	) {
+		return CODEX_API_ENDPOINT;
+	}
+	return url;
+}
+
+export function createOpenAIOAuthFetch(config: OpenAIOAuthConfig) {
+	let currentOAuth = config.oauth;
+
+	const customFetch = async (
+		input: Parameters<typeof fetch>[0],
+		init?: Parameters<typeof fetch>[1],
+	): Promise<Response> => {
+		const { access: accessToken, accountId } = await ensureValidToken(
+			currentOAuth,
+			config.projectRoot,
+		);
+
+		const originalUrl =
+			typeof input === 'string'
+				? input
+				: input instanceof URL
+					? input.href
+					: input.url;
+		const targetUrl = rewriteUrl(originalUrl);
+
+		const headers = new Headers(init?.headers);
+		headers.delete('Authorization');
+		headers.delete('authorization');
+		headers.set('authorization', `Bearer ${accessToken}`);
+		headers.set('originator', 'otto');
+		if (accountId) {
+			headers.set('ChatGPT-Account-Id', accountId);
+		}
+
+		const response = await fetch(targetUrl, {
+			...init,
+			headers,
+		});
+
+		if (response.status === 401) {
+			const refreshed = await getAuth('openai', config.projectRoot);
+			if (refreshed?.type === 'oauth') {
+				currentOAuth = refreshed;
+			}
+		}
+
+		return response;
+	};
+
+	return customFetch as typeof fetch;
+}
+
+export function createOpenAIOAuthModel(
+	model: string,
+	config: OpenAIOAuthConfig,
+) {
+	const customFetch = createOpenAIOAuthFetch(config);
+
+	const provider = createOpenAI({
+		apiKey: 'chatgpt-oauth',
+		fetch: customFetch,
+	});
+
+	return provider.responses(model);
+}

package/src/providers/src/opencode-client.ts

@@ -0,0 +1,64 @@
+import { createOpenAI } from '@ai-sdk/openai';
+import { createAnthropic } from '@ai-sdk/anthropic';
+import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
+import { catalog } from './catalog-merged.ts';
+import { createAnthropicCachingFetch } from './anthropic-caching.ts';
+import type { ProviderId } from '../../types/src/index.ts';
+
+export type OpencodeProviderConfig = {
+	apiKey?: string;
+};
+
+function normalizeModelIdentifier(provider: ProviderId, model: string): string {
+	const prefix = `${provider}/`;
+	return model.startsWith(prefix) ? model.slice(prefix.length) : model;
+}
+
+export function createOpencodeModel(
+	model: string,
+	config?: OpencodeProviderConfig,
+) {
+	const entry = catalog.opencode;
+	const normalizedModel = normalizeModelIdentifier('opencode', model);
+	const modelInfo =
+		entry?.models.find((m) => m.id === normalizedModel) ??
+		entry?.models.find((m) => m.id === model);
+	const resolvedModelId = modelInfo?.id ?? normalizedModel ?? model;
+	const binding = modelInfo?.provider?.npm ?? entry?.npm;
+	const apiKey = config?.apiKey ?? process.env.OPENCODE_API_KEY ?? '';
+	const baseURL =
+		modelInfo?.provider?.baseURL ||
+		modelInfo?.provider?.api ||
+		entry?.api ||
+		'https://opencode.ai/zen/v1';
+	const headers = apiKey ? { Authorization: `Bearer ${apiKey}` } : undefined;
+
+	if (binding === '@ai-sdk/openai') {
+		const instance = createOpenAI({ apiKey, baseURL });
+		return instance(resolvedModelId);
+	}
+	if (binding === '@ai-sdk/anthropic') {
+		const cachingFetch = createAnthropicCachingFetch();
+		const instance = createAnthropic({
+			apiKey,
+			baseURL,
+			fetch: cachingFetch as typeof fetch,
+		});
+		return instance(resolvedModelId);
+	}
+	if (binding === '@ai-sdk/openai-compatible') {
+		const instance = createOpenAICompatible({
+			name: entry?.label ?? 'opencode',
+			baseURL,
+			headers,
+		});
+		return instance(resolvedModelId);
+	}
+
+	const defaultInstance = createOpenAICompatible({
+		name: entry?.label ?? 'opencode',
+		baseURL,
+		headers,
+	});
+	return defaultInstance(resolvedModelId);
+}

package/src/providers/src/openrouter-client.ts

@@ -0,0 +1,31 @@
+import { createOpenRouter } from '@openrouter/ai-sdk-provider';
+import { createConditionalCachingFetch } from './anthropic-caching.ts';
+import { getModelNpmBinding } from './utils.ts';
+
+export type OpenRouterProviderConfig = {
+	apiKey?: string;
+};
+
+function isAnthropicModel(model: string): boolean {
+	const npm = getModelNpmBinding('openrouter', model);
+	return npm === '@ai-sdk/anthropic';
+}
+
+export function getOpenRouterInstance(
+	model?: string,
+	config?: OpenRouterProviderConfig,
+) {
+	const apiKey = config?.apiKey ?? process.env.OPENROUTER_API_KEY ?? '';
+	const customFetch = model
+		? createConditionalCachingFetch(isAnthropicModel, model)
+		: undefined;
+	return createOpenRouter({ apiKey, fetch: customFetch });
+}
+
+export function createOpenRouterModel(
+	model: string,
+	config?: OpenRouterProviderConfig,
+) {
+	const openrouter = getOpenRouterInstance(model, config);
+	return openrouter.chat(model);
+}

package/src/providers/src/pricing.ts

@@ -0,0 +1,178 @@
+import { catalog } from './catalog-merged.ts';
+import type { ModelInfo, ProviderId } from '../../types/src/index.ts';
+
+type ProviderName = ProviderId;
+
+type UsageLike = {
+	inputTokens?: number | null;
+	outputTokens?: number | null;
+	cachedInputTokens?: number | null;
+	cacheCreationInputTokens?: 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
+	],
+	setu: [
+		// Pricing from catalog entries; leave empty here
+	],
+	zai: [
+		// Pricing from catalog entries; leave empty here
+	],
+	'zai-coding': [
+		// Pricing from catalog entries; leave empty here
+	],
+	moonshot: [
+		// Pricing from catalog entries; leave empty here
+	],
+	copilot: [],
+};
+
+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;
+	const cachedInputTokens =
+		typeof usage.cachedInputTokens === 'number' ? usage.cachedInputTokens : 0;
+	const cacheCreationInputTokens =
+		typeof usage.cacheCreationInputTokens === 'number'
+			? usage.cacheCreationInputTokens
+			: 0;
+	if (
+		!inputTokens &&
+		!outputTokens &&
+		!cachedInputTokens &&
+		!cacheCreationInputTokens
+	)
+		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 cacheReadPerMillion =
+			typeof m.cost?.cacheRead === 'number' ? m.cost.cacheRead : 0;
+		const cacheWritePerMillion =
+			typeof m.cost?.cacheWrite === 'number' ? m.cost.cacheWrite : 0;
+		const nonCachedInput = Math.max(
+			0,
+			inputTokens - cachedInputTokens - cacheCreationInputTokens,
+		);
+		const inputCost = (nonCachedInput * inputPerMillion) / 1_000_000;
+		const outputCost = (outputTokens * outputPerMillion) / 1_000_000;
+		const cacheReadCost = (cachedInputTokens * cacheReadPerMillion) / 1_000_000;
+		const cacheWriteCost =
+			(cacheCreationInputTokens * cacheWritePerMillion) / 1_000_000;
+		const total = inputCost + outputCost + cacheReadCost + cacheWriteCost;
+		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 nonCachedInputFallback = Math.max(
+		0,
+		inputTokens - cachedInputTokens - cacheCreationInputTokens,
+	);
+	const inputCost =
+		(nonCachedInputFallback * 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;
+}