@ottocode/sdk 0.1.173

package/src/providers/src/anthropic-caching.ts

@@ -0,0 +1,202 @@
+type MessageBlock = {
+	type: string;
+	cache_control?: { type: string };
+	[key: string]: unknown;
+};
+
+type Message = {
+	role: string;
+	content: unknown;
+	[key: string]: unknown;
+};
+
+type ParsedBody = {
+	system?: MessageBlock[];
+	messages?: Message[];
+	[key: string]: unknown;
+};
+
+export function addAnthropicCacheControl(parsed: ParsedBody): ParsedBody {
+	const MAX_SYSTEM_CACHE = 1;
+	const MAX_MESSAGE_CACHE = 1;
+	let systemCacheUsed = 0;
+	let messageCacheUsed = 0;
+
+	if (parsed.system && Array.isArray(parsed.system)) {
+		parsed.system = parsed.system.map((block, index) => {
+			if (block.cache_control) return block;
+			if (
+				systemCacheUsed < MAX_SYSTEM_CACHE &&
+				index === 0 &&
+				block.type === 'text'
+			) {
+				systemCacheUsed++;
+				return { ...block, cache_control: { type: 'ephemeral' } };
+			}
+			return block;
+		});
+	}
+
+	if (parsed.messages && Array.isArray(parsed.messages)) {
+		const messageCount = parsed.messages.length;
+		parsed.messages = parsed.messages.map((msg, msgIndex) => {
+			const isLast = msgIndex === messageCount - 1;
+
+			if (Array.isArray(msg.content)) {
+				const blocks = msg.content as MessageBlock[];
+				const content = blocks.map((block, blockIndex) => {
+					if (block.cache_control) return block;
+					if (
+						isLast &&
+						messageCacheUsed < MAX_MESSAGE_CACHE &&
+						blockIndex === blocks.length - 1
+					) {
+						messageCacheUsed++;
+						return { ...block, cache_control: { type: 'ephemeral' } };
+					}
+					return block;
+				});
+				return { ...msg, content };
+			}
+
+			if (
+				isLast &&
+				messageCacheUsed < MAX_MESSAGE_CACHE &&
+				typeof msg.content === 'string'
+			) {
+				messageCacheUsed++;
+				return {
+					...msg,
+					content: [
+						{
+							type: 'text',
+							text: msg.content,
+							cache_control: { type: 'ephemeral' },
+						},
+					],
+				};
+			}
+
+			return msg;
+		});
+	}
+
+	return parsed;
+}
+
+export function createAnthropicCachingFetch(): typeof fetch {
+	return async (input: RequestInfo | URL, init?: RequestInit) => {
+		let body = init?.body;
+		if (body && typeof body === 'string') {
+			try {
+				const parsed = JSON.parse(body);
+				const modified = addAnthropicCacheControl(parsed);
+				body = JSON.stringify(modified);
+			} catch {
+				// If parsing fails, send as-is
+			}
+		}
+		return fetch(input, { ...init, body });
+	};
+}
+
+export function createConditionalCachingFetch(
+	shouldCache: (model: string) => boolean,
+	model: string,
+): typeof fetch {
+	return async (input: RequestInfo | URL, init?: RequestInit) => {
+		if (!shouldCache(model)) {
+			return fetch(input, init);
+		}
+
+		let body = init?.body;
+		if (body && typeof body === 'string') {
+			try {
+				const parsed = JSON.parse(body);
+
+				const MAX_SYSTEM_CACHE = 1;
+				const MAX_MESSAGE_CACHE = 1;
+				let systemCacheUsed = 0;
+				let messageCacheUsed = 0;
+
+				if (parsed.messages && Array.isArray(parsed.messages)) {
+					const messageCount = parsed.messages.length;
+					parsed.messages = parsed.messages.map(
+						(msg: Message, msgIndex: number) => {
+							if (msg.role === 'system' && systemCacheUsed < MAX_SYSTEM_CACHE) {
+								systemCacheUsed++;
+								if (typeof msg.content === 'string') {
+									return {
+										...msg,
+										content: [
+											{
+												type: 'text',
+												text: msg.content,
+												cache_control: { type: 'ephemeral' },
+											},
+										],
+									};
+								}
+								if (Array.isArray(msg.content)) {
+									const blocks = msg.content as MessageBlock[];
+									const content = blocks.map((block, i) => {
+										if (i === blocks.length - 1 && !block.cache_control) {
+											return { ...block, cache_control: { type: 'ephemeral' } };
+										}
+										return block;
+									});
+									return { ...msg, content };
+								}
+							}
+
+							const isLast = msgIndex === messageCount - 1;
+
+							if (Array.isArray(msg.content)) {
+								const blocks = msg.content as MessageBlock[];
+								const content = blocks.map((block, blockIndex) => {
+									if (block.cache_control) return block;
+									if (
+										isLast &&
+										messageCacheUsed < MAX_MESSAGE_CACHE &&
+										blockIndex === blocks.length - 1
+									) {
+										messageCacheUsed++;
+										return { ...block, cache_control: { type: 'ephemeral' } };
+									}
+									return block;
+								});
+								return { ...msg, content };
+							}
+
+							if (
+								isLast &&
+								messageCacheUsed < MAX_MESSAGE_CACHE &&
+								typeof msg.content === 'string'
+							) {
+								messageCacheUsed++;
+								return {
+									...msg,
+									content: [
+										{
+											type: 'text',
+											text: msg.content,
+											cache_control: { type: 'ephemeral' },
+										},
+									],
+								};
+							}
+
+							return msg;
+						},
+					);
+				}
+
+				body = JSON.stringify(parsed);
+			} catch {
+				// If parsing fails, send as-is
+			}
+		}
+
+		return fetch(input, { ...init, body });
+	};
+}

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

@@ -0,0 +1,157 @@
+import { createAnthropic } from '@ai-sdk/anthropic';
+import { addAnthropicCacheControl } from './anthropic-caching.ts';
+
+const CLAUDE_CLI_VERSION = '1.0.61';
+
+export type AnthropicOAuthConfig = {
+	oauth: {
+		access: string;
+		refresh: string;
+		expires: number;
+	};
+	toolNameTransformer?: (name: string) => string;
+};
+
+function buildOAuthHeaders(accessToken: string): Record<string, string> {
+	const headers: Record<string, string> = {
+		authorization: `Bearer ${accessToken}`,
+		'anthropic-beta':
+			'claude-code-20250219,oauth-2025-04-20,interleaved-thinking-2025-05-14',
+		'anthropic-dangerous-direct-browser-access': 'true',
+		'anthropic-version': '2023-06-01',
+		'user-agent': `claude-cli/${CLAUDE_CLI_VERSION} (external, cli)`,
+		'x-app': 'cli',
+		'content-type': 'application/json',
+		accept: 'application/json',
+		'x-stainless-arch': process.arch === 'arm64' ? 'arm64' : 'x64',
+		'x-stainless-helper-method': 'stream',
+		'x-stainless-lang': 'js',
+		'x-stainless-os':
+			process.platform === 'darwin'
+				? 'MacOS'
+				: process.platform === 'win32'
+					? 'Windows'
+					: 'Linux',
+		'x-stainless-package-version': '0.70.0',
+		'x-stainless-retry-count': '0',
+		'x-stainless-runtime': 'node',
+		'x-stainless-runtime-version': process.version,
+		'x-stainless-timeout': '600',
+	};
+	return headers;
+}
+
+function filterExistingHeaders(
+	initHeaders: HeadersInit | undefined,
+): Record<string, string> {
+	const headers: Record<string, string> = {};
+	if (!initHeaders) return headers;
+
+	if (initHeaders instanceof Headers) {
+		initHeaders.forEach((value, key) => {
+			if (key.toLowerCase() !== 'x-api-key') {
+				headers[key] = value;
+			}
+		});
+	} else if (Array.isArray(initHeaders)) {
+		for (const [key, value] of initHeaders) {
+			if (
+				key &&
+				key.toLowerCase() !== 'x-api-key' &&
+				typeof value === 'string'
+			) {
+				headers[key] = value;
+			}
+		}
+	} else {
+		for (const [key, value] of Object.entries(initHeaders)) {
+			if (key.toLowerCase() !== 'x-api-key' && typeof value === 'string') {
+				headers[key] = value;
+			}
+		}
+	}
+	return headers;
+}
+
+export function createAnthropicOAuthFetch(
+	config: AnthropicOAuthConfig,
+): typeof fetch {
+	const { oauth, toolNameTransformer } = config;
+
+	return async (input: string | URL | Request, init?: RequestInit) => {
+		const existingHeaders = filterExistingHeaders(init?.headers);
+		const oauthHeaders = buildOAuthHeaders(oauth.access);
+		const headers = { ...existingHeaders, ...oauthHeaders };
+
+		let url = typeof input === 'string' ? input : input.toString();
+		if (url.includes('/v1/messages') && !url.includes('beta=true')) {
+			url += url.includes('?') ? '&beta=true' : '?beta=true';
+		}
+
+		let body = init?.body;
+		if (body && typeof body === 'string') {
+			try {
+				const parsed = JSON.parse(body);
+
+				if (toolNameTransformer) {
+					if (parsed.tools && Array.isArray(parsed.tools)) {
+						parsed.tools = parsed.tools.map(
+							(tool: { name: string; [key: string]: unknown }) => ({
+								...tool,
+								name: toolNameTransformer(tool.name),
+							}),
+						);
+					}
+
+					if (parsed.messages && Array.isArray(parsed.messages)) {
+						parsed.messages = parsed.messages.map(
+							(msg: { content: unknown; [key: string]: unknown }) => {
+								if (Array.isArray(msg.content)) {
+									const content = msg.content.map(
+										(block: {
+											type: string;
+											name?: string;
+											[key: string]: unknown;
+										}) => {
+											if (
+												(block.type === 'tool_use' ||
+													block.type === 'tool_result') &&
+												block.name
+											) {
+												return {
+													...block,
+													name: toolNameTransformer(block.name),
+												};
+											}
+											return block;
+										},
+									);
+									return { ...msg, content };
+								}
+								return msg;
+							},
+						);
+					}
+				}
+
+				const withCache = addAnthropicCacheControl(parsed);
+				body = JSON.stringify(withCache);
+			} catch {
+				// If parsing fails, send as-is
+			}
+		}
+
+		return fetch(url, { ...init, body, headers });
+	};
+}
+
+export function createAnthropicOAuthModel(
+	model: string,
+	config: AnthropicOAuthConfig,
+) {
+	const customFetch = createAnthropicOAuthFetch(config);
+	return createAnthropic({
+		apiKey: '',
+		fetch: customFetch as typeof fetch,
+	})(model);
+}

package/src/providers/src/authorization.ts

@@ -0,0 +1,17 @@
+import {
+	isAuthorized as mgrIsAuthorized,
+	ensureEnv as mgrEnsureEnv,
+} from '../../config/src/index.ts';
+import type { OttoConfig } from '../../config/src/index.ts';
+import type { ProviderId } from '../../types/src/index.ts';
+
+export async function isProviderAuthorized(
+	cfg: OttoConfig,
+	provider: ProviderId,
+) {
+	return await mgrIsAuthorized(provider, cfg.projectRoot);
+}
+
+export async function ensureProviderEnv(cfg: OttoConfig, provider: ProviderId) {
+	await mgrEnsureEnv(provider, cfg.projectRoot);
+}

package/src/providers/src/catalog-manual.ts

@@ -0,0 +1,135 @@
+import type {
+	ModelInfo,
+	ProviderCatalogEntry,
+	ProviderId,
+	ProviderFamily,
+} from '../../types/src/index.ts';
+
+type CatalogMap = Partial<Record<ProviderId, ProviderCatalogEntry>>;
+
+const SETU_ID: ProviderId = 'setu';
+
+const isAllowedOpenAIModel = (id: string): boolean => {
+	if (id === 'codex-mini-latest') return true;
+	if (id.startsWith('gpt-5')) return true;
+	if (id.includes('codex')) return true;
+	return false;
+};
+
+const isAllowedAnthropicModel = (id: string): boolean => {
+	if (id.includes('-3-5-') || id.includes('-3.5-')) return true;
+	if (id.match(/claude-(haiku|sonnet|opus)-3/)) return true;
+	if (id.includes('-4-') || id.includes('-4.')) return true;
+	if (id.match(/claude-(haiku|sonnet|opus)-4/)) return true;
+	return false;
+};
+
+const isAllowedGoogleModel = (id: string): boolean => {
+	if (id.startsWith('gemini-3')) return true;
+	return false;
+};
+
+const SETU_SOURCES: Array<{
+	id: ProviderId;
+	npm: string;
+	family: ProviderFamily;
+}> = [
+	{
+		id: 'openai',
+		npm: '@ai-sdk/openai',
+		family: 'openai',
+	},
+	{
+		id: 'anthropic',
+		npm: '@ai-sdk/anthropic',
+		family: 'anthropic',
+	},
+	{
+		id: 'moonshot',
+		npm: '@ai-sdk/openai-compatible',
+		family: 'moonshot',
+	},
+	{
+		id: 'google',
+		npm: '@ai-sdk/google',
+		family: 'google',
+	},
+];
+
+function cloneModel(model: ModelInfo): ModelInfo {
+	return {
+		...model,
+		modalities: model.modalities
+			? {
+					input: model.modalities.input
+						? [...model.modalities.input]
+						: undefined,
+					output: model.modalities.output
+						? [...model.modalities.output]
+						: undefined,
+				}
+			: undefined,
+		cost: model.cost ? { ...model.cost } : undefined,
+		limit: model.limit ? { ...model.limit } : undefined,
+		provider: model.provider ? { ...model.provider } : undefined,
+	};
+}
+
+function buildSetuEntry(base: CatalogMap): ProviderCatalogEntry | null {
+	const setuModels = SETU_SOURCES.flatMap(({ id, npm, family }) => {
+		const allModels = base[id]?.models ?? [];
+		const sourceModels = allModels.filter((model) => {
+			if (id === 'openai') return isAllowedOpenAIModel(model.id);
+			if (id === 'anthropic') return isAllowedAnthropicModel(model.id);
+			if (id === 'google') return isAllowedGoogleModel(model.id);
+			return true;
+		});
+		return sourceModels.map((model) => {
+			const cloned = cloneModel(model);
+			cloned.provider = { ...(cloned.provider ?? {}), npm, family };
+			return cloned;
+		});
+	});
+
+	if (!setuModels.length) return null;
+
+	setuModels.sort((a, b) => {
+		const providerA = a.provider?.npm ?? '';
+		const providerB = b.provider?.npm ?? '';
+		if (providerA === providerB) {
+			return a.id.localeCompare(b.id);
+		}
+		if (providerA === '@ai-sdk/openai') return -1;
+		if (providerB === '@ai-sdk/openai') return 1;
+		return providerA.localeCompare(providerB);
+	});
+
+	const defaultModelId = 'codex-mini-latest';
+	const defaultIdx = setuModels.findIndex((m) => m.id === defaultModelId);
+	if (defaultIdx > 0) {
+		const [picked] = setuModels.splice(defaultIdx, 1);
+		setuModels.unshift(picked);
+	}
+
+	return {
+		id: SETU_ID,
+		label: 'Setu',
+		env: ['SETU_PRIVATE_KEY'],
+		api: 'https://setu.ottocode.io/v1',
+		doc: 'https://setu.ottocode.io/docs',
+		models: setuModels,
+	};
+}
+
+export function mergeManualCatalog(
+	base: CatalogMap,
+): Record<ProviderId, ProviderCatalogEntry> {
+	const manualEntry = buildSetuEntry(base);
+	const merged: Record<ProviderId, ProviderCatalogEntry> = {
+		...(base as Record<ProviderId, ProviderCatalogEntry>),
+	};
+	if (manualEntry) {
+		merged[SETU_ID] = manualEntry;
+	}
+	return merged;
+}

package/src/providers/src/catalog-merged.ts

@@ -0,0 +1,9 @@
+import type {
+	ProviderCatalogEntry,
+	ProviderId,
+} from '../../types/src/index.ts';
+import { catalog as generatedCatalog } from './catalog.ts';
+import { mergeManualCatalog } from './catalog-manual.ts';
+
+export const catalog: Record<ProviderId, ProviderCatalogEntry> =
+	mergeManualCatalog(generatedCatalog);