Rename providers to ic-anthropic/ic-openai with model catalog from models.dev

Custom provider names avoid conflicts with built-in OpenCode providers.
An hourly cron fetches models from models.dev and caches them in KV.
The discovery endpoint includes the full model catalog per provider.

Author: tygern

src/discovery.ts

@@ -1,29 +1,48 @@
-export const PROVIDERS = ['anthropic', 'openai'] as const;
+export const GATEWAY_PROVIDERS = ['anthropic', 'openai'] as const;
 
-export type Provider = (typeof PROVIDERS)[number];
+export type GatewayProvider = (typeof GATEWAY_PROVIDERS)[number];
 
-export function isProvider(value: string): value is Provider {
-	return (PROVIDERS as readonly string[]).includes(value);
+export function isGatewayProvider(value: string): value is GatewayProvider {
+	return (GATEWAY_PROVIDERS as readonly string[]).includes(value);
 }
 
-export function buildDiscoveryPayload(origin: string) {
+type ProviderConfig = {
+	gateway: GatewayProvider;
+	npm: string;
+	name: string;
+};
+
+const PROVIDER_CONFIG: Record<string, ProviderConfig> = {
+	'ic-anthropic': { gateway: 'anthropic', npm: '@ai-sdk/anthropic', name: 'IC Anthropic' },
+	'ic-openai': { gateway: 'openai', npm: '@ai-sdk/openai', name: 'IC OpenAI' },
+};
+
+export const OPENCODE_PROVIDERS = Object.keys(PROVIDER_CONFIG);
+
+type Models = Record<string, Record<string, unknown>>;
+
+export function buildDiscoveryPayload(origin: string, modelsByGateway: Record<string, Models> = {}) {
+	const provider: Record<string, unknown> = {};
+
+	for (const [name, config] of Object.entries(PROVIDER_CONFIG)) {
+		const models = modelsByGateway[config.gateway] ?? {};
+		provider[name] = {
+			npm: config.npm,
+			name: config.name,
+			env: ['CF_ACCESS_TOKEN'],
+			options: { baseURL: `${origin}/v1/${config.gateway}` },
+			...(Object.keys(models).length > 0 ? { models } : {}),
+		};
+	}
+
 	return {
 		auth: {
 			command: ['cloudflared', 'access', 'login', '--no-verbose', origin],
 			env: 'CF_ACCESS_TOKEN',
 		},
 		config: {
-			enabled_providers: [...PROVIDERS],
-			provider: {
-				anthropic: {
-					env: ['CF_ACCESS_TOKEN'],
-					options: { baseURL: `${origin}/v1/anthropic` },
-				},
-				openai: {
-					env: ['CF_ACCESS_TOKEN'],
-					options: { baseURL: `${origin}/v1/openai` },
-				},
-			},
+			enabled_providers: [...OPENCODE_PROVIDERS],
+			provider,
 		},
 	};
 }

src/index.ts

@@ -1,9 +1,10 @@
 import { Hono, type MiddlewareHandler } from 'hono';
-import { buildDiscoveryPayload, isProvider, type Provider } from './discovery';
+import { buildDiscoveryPayload, GATEWAY_PROVIDERS, isGatewayProvider, type GatewayProvider } from './discovery';
 import { createAuthMiddleware, type AuthVariables } from './auth';
 import { createLoggingMiddleware } from './logging';
 import { GatewayProxy } from './gateway';
 import { JwtVerifier } from './jwt';
+import { ModelCatalog } from './models';
 import { landingPage } from './landing';
 
 type Bindings = {
@@ -12,6 +13,7 @@ type Bindings = {
 	CF_ACCOUNT_ID: string;
 	CF_GATEWAY_NAME: string;
 	CF_AIG_TOKEN: string;
+	MODELS: KVNamespace;
 };
 
 type App = { Bindings: Bindings; Variables: AuthVariables };
@@ -24,11 +26,23 @@ let authMiddleware: MiddlewareHandler<App> | undefined;
 
 app.use(createLoggingMiddleware());
 
-app.get('/.well-known/opencode', (c) => c.json(buildDiscoveryPayload(new URL(c.req.url).origin)));
+app.get('/.well-known/opencode', async (c) => {
+	const origin = new URL(c.req.url).origin;
+	const catalog = new ModelCatalog(c.env.MODELS);
+	const modelsByGateway: Record<string, Record<string, Record<string, unknown>>> = {};
+
+	await Promise.all(
+		GATEWAY_PROVIDERS.map(async (provider) => {
+			modelsByGateway[provider] = await catalog.getModels(provider);
+		}),
+	);
+
+	return c.json(buildDiscoveryPayload(origin, modelsByGateway));
+});
 
 app.use('/v1/*', async (c, next) => {
 	const provider = c.req.path.split('/')[2];
-	if (!provider || !isProvider(provider)) return c.json({ error: 'Unknown provider' }, 404);
+	if (!provider || !isGatewayProvider(provider)) return c.json({ error: 'Unknown provider' }, 404);
 	await next();
 });
 
@@ -41,11 +55,17 @@ app.use('/v1/*', (c, next) => {
 
 app.all('/v1/:provider/*', (c) => {
 	const proxy = new GatewayProxy(c.env.CF_ACCOUNT_ID, c.env.CF_GATEWAY_NAME, c.env.CF_AIG_TOKEN);
-	return proxy.proxy(c.req.raw, c.req.param('provider') as Provider, c.get('userEmail'));
+	return proxy.proxy(c.req.raw, c.req.param('provider') as GatewayProvider, c.get('userEmail'));
 });
 
 app.get('/', (c) => c.html(landingPage(new URL(c.req.url).origin)));
 
 app.all('*', (c) => c.json({ error: 'Not found' }, 404));
 
-export default app;
+export default {
+	fetch: app.fetch,
+	async scheduled(_controller: ScheduledController, env: Bindings, _ctx: ExecutionContext) {
+		const catalog = new ModelCatalog(env.MODELS);
+		await catalog.refresh();
+	},
+};

src/models.ts

@@ -0,0 +1,37 @@
+import { GATEWAY_PROVIDERS, type GatewayProvider } from './discovery';
+
+export type FetchFn = typeof fetch;
+
+type ModelsDevProvider = {
+	models: Record<string, Record<string, unknown>>;
+};
+
+export class ModelCatalog {
+	constructor(
+		private readonly kv: KVNamespace,
+		private readonly fetchFn: FetchFn = globalThis.fetch.bind(globalThis),
+	) {}
+
+	async refresh(): Promise<void> {
+		const response = await this.fetchFn('https://models.dev/api.json');
+		if (!response.ok) {
+			throw new Error(`models.dev returned ${response.status}`);
+		}
+
+		const catalog = (await response.json()) as Record<string, ModelsDevProvider>;
+
+		await Promise.all(
+			GATEWAY_PROVIDERS.map((provider) => {
+				const entry = catalog[provider];
+				if (!entry?.models) return Promise.resolve();
+				return this.kv.put(`models:${provider}`, JSON.stringify(entry.models));
+			}),
+		);
+	}
+
+	async getModels(provider: GatewayProvider): Promise<Record<string, Record<string, unknown>>> {
+		const raw = await this.kv.get(`models:${provider}`);
+		if (!raw) return {};
+		return JSON.parse(raw) as Record<string, Record<string, unknown>>;
+	}
+}

test/discovery.spec.ts

@@ -3,24 +3,51 @@ import { buildDiscoveryPayload } from '../src/discovery';
 
 describe('buildDiscoveryPayload', () => {
 	const origin = 'https://opencode.icap.dev';
-	const payload = buildDiscoveryPayload(origin);
 
 	it('includes cloudflared auth command', () => {
+		const payload = buildDiscoveryPayload(origin);
 		expect(payload.auth.command).toEqual(['cloudflared', 'access', 'login', '--no-verbose', origin]);
 		expect(payload.auth.env).toBe('CF_ACCESS_TOKEN');
 	});
 
-	it('restricts to proxied providers', () => {
-		expect(payload.config.enabled_providers).toEqual(['anthropic', 'openai']);
+	it('restricts to custom-named providers', () => {
+		const payload = buildDiscoveryPayload(origin);
+		expect(payload.config.enabled_providers).toEqual(['ic-anthropic', 'ic-openai']);
 	});
 
-	it('configures anthropic provider with proxy base URL', () => {
-		expect(payload.config.provider.anthropic.env).toEqual(['CF_ACCESS_TOKEN']);
-		expect(payload.config.provider.anthropic.options.baseURL).toBe(`${origin}/v1/anthropic`);
+	it('configures ic-anthropic with npm package and proxy base URL', () => {
+		const payload = buildDiscoveryPayload(origin);
+		const provider = payload.config.provider['ic-anthropic'] as Record<string, unknown>;
+		expect(provider.npm).toBe('@ai-sdk/anthropic');
+		expect(provider.name).toBe('IC Anthropic');
+		expect(provider.env).toEqual(['CF_ACCESS_TOKEN']);
+		expect((provider.options as Record<string, string>).baseURL).toBe(`${origin}/v1/anthropic`);
 	});
 
-	it('configures openai provider with proxy base URL', () => {
-		expect(payload.config.provider.openai.env).toEqual(['CF_ACCESS_TOKEN']);
-		expect(payload.config.provider.openai.options.baseURL).toBe(`${origin}/v1/openai`);
+	it('configures ic-openai with npm package and proxy base URL', () => {
+		const payload = buildDiscoveryPayload(origin);
+		const provider = payload.config.provider['ic-openai'] as Record<string, unknown>;
+		expect(provider.npm).toBe('@ai-sdk/openai');
+		expect(provider.name).toBe('IC OpenAI');
+		expect(provider.env).toEqual(['CF_ACCESS_TOKEN']);
+		expect((provider.options as Record<string, string>).baseURL).toBe(`${origin}/v1/openai`);
+	});
+
+	it('omits models when none are provided', () => {
+		const payload = buildDiscoveryPayload(origin);
+		const provider = payload.config.provider['ic-anthropic'] as Record<string, unknown>;
+		expect(provider).not.toHaveProperty('models');
+	});
+
+	it('includes models when provided', () => {
+		const models = {
+			anthropic: { 'claude-sonnet-4-5': { name: 'Claude Sonnet 4.5' } },
+			openai: { 'gpt-4o': { name: 'GPT-4o' } },
+		};
+		const payload = buildDiscoveryPayload(origin, models);
+		const anthropic = payload.config.provider['ic-anthropic'] as Record<string, unknown>;
+		const openai = payload.config.provider['ic-openai'] as Record<string, unknown>;
+		expect(anthropic.models).toEqual(models.anthropic);
+		expect(openai.models).toEqual(models.openai);
 	});
 });

test/env.d.ts

@@ -2,5 +2,6 @@ declare module "cloudflare:test" {
 	interface ProvidedEnv extends Env {
 		CF_ACCESS_AUD: string;
 		CF_AIG_TOKEN: string;
+		MODELS: KVNamespace;
 	}
 }

test/index.spec.ts

@@ -23,8 +23,27 @@ describe('integration', () => {
 			'https://opencode.icap.dev',
 		]);
 		expect(body.auth.env).toBe('CF_ACCESS_TOKEN');
-		expect(body.config.provider.anthropic.options.baseURL).toBe('https://opencode.icap.dev/v1/anthropic');
-		expect(body.config.provider.openai.options.baseURL).toBe('https://opencode.icap.dev/v1/openai');
+		expect(body.config.enabled_providers).toEqual(['ic-anthropic', 'ic-openai']);
+		expect(body.config.provider['ic-anthropic'].npm).toBe('@ai-sdk/anthropic');
+		expect(body.config.provider['ic-anthropic'].options.baseURL).toBe(
+			'https://opencode.icap.dev/v1/anthropic',
+		);
+		expect(body.config.provider['ic-openai'].npm).toBe('@ai-sdk/openai');
+		expect(body.config.provider['ic-openai'].options.baseURL).toBe(
+			'https://opencode.icap.dev/v1/openai',
+		);
+	});
+
+	it('includes models from KV in discovery config', async () => {
+		const models = { 'claude-sonnet-4-5': { name: 'Claude Sonnet 4.5' } };
+		await env.MODELS.put('models:anthropic', JSON.stringify(models));
+
+		const response = await SELF.fetch('https://opencode.icap.dev/.well-known/opencode');
+		const body = (await response.json()) as any;
+
+		expect(body.config.provider['ic-anthropic'].models).toEqual(models);
+
+		await env.MODELS.delete('models:anthropic');
 	});
 
 	it('rejects proxy requests without authorization', async () => {

test/models.spec.ts

@@ -0,0 +1,106 @@
+import { env } from 'cloudflare:test';
+import { describe, it, expect, beforeEach } from 'vitest';
+import { ModelCatalog, type FetchFn } from '../src/models';
+
+const modelsDevResponse = {
+	anthropic: {
+		id: 'anthropic',
+		npm: '@ai-sdk/anthropic',
+		name: 'Anthropic',
+		models: {
+			'claude-sonnet-4-5': {
+				id: 'claude-sonnet-4-5',
+				name: 'Claude Sonnet 4.5',
+				limit: { context: 200000, output: 64000 },
+			},
+		},
+	},
+	openai: {
+		id: 'openai',
+		npm: '@ai-sdk/openai',
+		name: 'OpenAI',
+		models: {
+			'gpt-4o': {
+				id: 'gpt-4o',
+				name: 'GPT-4o',
+				limit: { context: 128000, output: 16384 },
+			},
+		},
+	},
+	groq: {
+		id: 'groq',
+		npm: '@ai-sdk/groq',
+		name: 'Groq',
+		models: { 'llama-3': { id: 'llama-3', name: 'Llama 3' } },
+	},
+};
+
+function fakeFetch(status: number, body: unknown): FetchFn {
+	return async () => new Response(JSON.stringify(body), { status });
+}
+
+describe('ModelCatalog', () => {
+	beforeEach(async () => {
+		await env.MODELS.delete('models:anthropic');
+		await env.MODELS.delete('models:openai');
+	});
+
+	describe('refresh', () => {
+		it('fetches models from models.dev and stores them in KV', async () => {
+			const catalog = new ModelCatalog(env.MODELS, fakeFetch(200, modelsDevResponse));
+
+			await catalog.refresh();
+
+			const anthropicRaw = await env.MODELS.get('models:anthropic');
+			const openaiRaw = await env.MODELS.get('models:openai');
+			expect(JSON.parse(anthropicRaw!)).toEqual(modelsDevResponse.anthropic.models);
+			expect(JSON.parse(openaiRaw!)).toEqual(modelsDevResponse.openai.models);
+		});
+
+		it('does not store models for unsupported providers', async () => {
+			const catalog = new ModelCatalog(env.MODELS, fakeFetch(200, modelsDevResponse));
+
+			await catalog.refresh();
+
+			const groqRaw = await env.MODELS.get('models:groq');
+			expect(groqRaw).toBeNull();
+		});
+
+		it('throws on non-200 responses', async () => {
+			const catalog = new ModelCatalog(env.MODELS, fakeFetch(500, { error: 'server error' }));
+
+			await expect(catalog.refresh()).rejects.toThrow('models.dev returned 500');
+		});
+
+		it('handles a provider missing from the response', async () => {
+			const partial = { anthropic: modelsDevResponse.anthropic };
+			const catalog = new ModelCatalog(env.MODELS, fakeFetch(200, partial));
+
+			await catalog.refresh();
+
+			const anthropicRaw = await env.MODELS.get('models:anthropic');
+			const openaiRaw = await env.MODELS.get('models:openai');
+			expect(JSON.parse(anthropicRaw!)).toEqual(modelsDevResponse.anthropic.models);
+			expect(openaiRaw).toBeNull();
+		});
+	});
+
+	describe('getModels', () => {
+		it('returns models from KV', async () => {
+			await env.MODELS.put('models:anthropic', JSON.stringify(modelsDevResponse.anthropic.models));
+			const catalog = new ModelCatalog(env.MODELS);
+
+			const models = await catalog.getModels('anthropic');
+
+			expect(models).toEqual(modelsDevResponse.anthropic.models);
+		});
+
+		it('returns an empty object when KV has no data', async () => {
+			const catalog = new ModelCatalog(env.MODELS);
+
+			const models = await catalog.getModels('anthropic');
+
+			expect(models).toEqual({});
+		});
+	});
+});

vitest.config.mts

@@ -11,6 +11,7 @@ export default defineWorkersConfig({
 						CF_ACCESS_AUD: "test-access-aud",
 						CF_AIG_TOKEN: "test-aig-token",
 					},
+					kvNamespaces: ["MODELS"],
 				},
 			},
 		},

worker-configuration.d.ts

@@ -1,11 +1,12 @@
 /* eslint-disable */
-// Generated by Wrangler by running `wrangler types` (hash: 592ea5fe1962a513e697fc8b06eb4519)
-// Runtime types generated with workerd@1.20260421.1 2026-04-21 nodejs_compat
+// Generated by Wrangler by running `wrangler types` (hash: bb57a9ace762d20fc8a33632362b5d42)
+// Runtime types generated with workerd@1.20260421.1 2026-03-10 nodejs_compat
 declare namespace Cloudflare {
 	interface GlobalProps {
 		mainModule: typeof import("./src/index");
 	}
 	interface Env {
+		MODELS: KVNamespace;
 		CF_ACCESS_TEAM_DOMAIN: "initialcapacity.cloudflareaccess.com";
 		CF_ACCOUNT_ID: "8a4e4c15971c03154164931e43651ae4";
 		CF_GATEWAY_NAME: "ai-gateway";