Claude Code opened to any LLM — OpenAI, Gemini, DeepSeek, Ollama, and 200+ models via OpenAI-compatible API shim
TypeScript
feat: add OpenAI-compatible provider shim — use any LLM with Claude Code
did:key:z6MkqDnb7Siv3Cwj7pGJq4T5EsUisECqR8KpnDLwcaZq5TPr619b5fb603af
diff --git a/src/services/api/client.ts b/src/services/api/client.tsindex 8c1feb6..1a022f0 100644--- a/src/services/api/client.ts+++ b/src/services/api/client.ts@@ -150,6 +150,14 @@ export async function getAnthropicClient({fetch: resolvedFetch,}),}+ if (isEnvTruthy(process.env.CLAUDE_CODE_USE_OPENAI)) {+ const { createOpenAIShimClient } = await import('./openaiShim.js')+ return createOpenAIShimClient({+ defaultHeaders,+ maxRetries,+ timeout: parseInt(process.env.API_TIMEOUT_MS || String(600 * 1000), 10),+ }) as unknown as Anthropic+ }if (isEnvTruthy(process.env.CLAUDE_CODE_USE_BEDROCK)) {const { AnthropicBedrock } = await import('@anthropic-ai/bedrock-sdk')// Use region override for small fast model if specifieddiff --git a/src/services/api/openaiShim.ts b/src/services/api/openaiShim.tsnew file mode 100644index 0000000..c3ca339--- /dev/null+++ b/src/services/api/openaiShim.ts@@ -0,0 +1,724 @@+/**+ * OpenAI-compatible API shim for Claude Code.+ *+ * Translates Anthropic SDK calls (anthropic.beta.messages.create) into+ * OpenAI-compatible chat completion requests and streams back events+ * in the Anthropic streaming format so the rest of the codebase is unaware.+ *+ * Supports: OpenAI, Azure OpenAI, Ollama, LM Studio, OpenRouter,+ * Together, Groq, Fireworks, DeepSeek, Mistral, and any OpenAI-compatible API.+ *+ * Environment variables:+ * CLAUDE_CODE_USE_OPENAI=1 — enable this provider+ * OPENAI_API_KEY=sk-... — API key (optional for local models)+ * OPENAI_BASE_URL=http://... — base URL (default: https://api.openai.com/v1)+ * OPENAI_MODEL=gpt-4o — default model override+ */++// ---------------------------------------------------------------------------+// Types — minimal subset of Anthropic SDK types we need to produce+// ---------------------------------------------------------------------------++interface AnthropicUsage {+ input_tokens: number+ output_tokens: number+ cache_creation_input_tokens: number+ cache_read_input_tokens: number+}++interface AnthropicStreamEvent {+ type: string+ message?: Record<string, unknown>+ index?: number+ content_block?: Record<string, unknown>+ delta?: Record<string, unknown>+ usage?: Partial<AnthropicUsage>+}++// ---------------------------------------------------------------------------+// Message format conversion: Anthropic → OpenAI+// ---------------------------------------------------------------------------++interface OpenAIMessage {+ role: 'system' | 'user' | 'assistant' | 'tool'+ content?: string | Array<{ type: string; text?: string; image_url?: { url: string } }>+ tool_calls?: Array<{+ id: string+ type: 'function'+ function: { name: string; arguments: string }+ }>+ tool_call_id?: string+ name?: string+}++interface OpenAITool {+ type: 'function'+ function: {+ name: string+ description: string+ parameters: Record<string, unknown>+ strict?: boolean+ }+}++function convertSystemPrompt(+ system: unknown,+): string {+ if (!system) return ''+ if (typeof system === 'string') return system+ if (Array.isArray(system)) {+ return system+ .map((block: { type?: string; text?: string }) =>+ block.type === 'text' ? block.text ?? '' : '',+ )+ .join('\n\n')+ }+ return String(system)+}++function convertContentBlocks(+ content: unknown,+): string | Array<{ type: string; text?: string; image_url?: { url: string } }> {+ if (typeof content === 'string') return content+ if (!Array.isArray(content)) return String(content ?? '')++ const parts: Array<{ type: string; text?: string; image_url?: { url: string } }> = []+ for (const block of content) {+ switch (block.type) {+ case 'text':+ parts.push({ type: 'text', text: block.text ?? '' })+ break+ case 'image': {+ const src = block.source+ if (src?.type === 'base64') {+ parts.push({+ type: 'image_url',+ image_url: {+ url: `data:${src.media_type};base64,${src.data}`,+ },+ })+ } else if (src?.type === 'url') {+ parts.push({ type: 'image_url', image_url: { url: src.url } })+ }+ break+ }+ case 'tool_use':+ // handled separately+ break+ case 'tool_result':+ // handled separately+ break+ case 'thinking':+ // Append thinking as text with a marker for models that support reasoning+ if (block.thinking) {+ parts.push({ type: 'text', text: `<thinking>${block.thinking}</thinking>` })+ }+ break+ default:+ if (block.text) {+ parts.push({ type: 'text', text: block.text })+ }+ }+ }++ if (parts.length === 0) return ''+ if (parts.length === 1 && parts[0].type === 'text') return parts[0].text ?? ''+ return parts+}++function convertMessages(+ messages: Array<{ role: string; message?: { role?: string; content?: unknown }; content?: unknown }>,+ system: unknown,+): OpenAIMessage[] {+ const result: OpenAIMessage[] = []++ // System message first+ const sysText = convertSystemPrompt(system)+ if (sysText) {+ result.push({ role: 'system', content: sysText })+ }++ for (const msg of messages) {+ // Claude Code wraps messages in { role, message: { role, content } }+ const inner = msg.message ?? msg+ const role = (inner as { role?: string }).role ?? msg.role+ const content = (inner as { content?: unknown }).content++ if (role === 'user') {+ // Check for tool_result blocks in user messages+ if (Array.isArray(content)) {+ const toolResults = content.filter((b: { type?: string }) => b.type === 'tool_result')+ const otherContent = content.filter((b: { type?: string }) => b.type !== 'tool_result')++ // Emit tool results as tool messages+ for (const tr of toolResults) {+ const trContent = Array.isArray(tr.content)+ ? tr.content.map((c: { text?: string }) => c.text ?? '').join('\n')+ : typeof tr.content === 'string'+ ? tr.content+ : JSON.stringify(tr.content ?? '')+ result.push({+ role: 'tool',+ tool_call_id: tr.tool_use_id ?? 'unknown',+ content: tr.is_error ? `Error: ${trContent}` : trContent,+ })+ }++ // Emit remaining user content+ if (otherContent.length > 0) {+ result.push({+ role: 'user',+ content: convertContentBlocks(otherContent),+ })+ }+ } else {+ result.push({+ role: 'user',+ content: convertContentBlocks(content),+ })+ }+ } else if (role === 'assistant') {+ // Check for tool_use blocks+ if (Array.isArray(content)) {+ const toolUses = content.filter((b: { type?: string }) => b.type === 'tool_use')+ const textContent = content.filter(+ (b: { type?: string }) => b.type !== 'tool_use' && b.type !== 'thinking',+ )++ const assistantMsg: OpenAIMessage = {+ role: 'assistant',+ content: convertContentBlocks(textContent) as string,+ }++ if (toolUses.length > 0) {+ assistantMsg.tool_calls = toolUses.map(+ (tu: { id?: string; name?: string; input?: unknown }) => ({+ id: tu.id ?? `call_${Math.random().toString(36).slice(2)}`,+ type: 'function' as const,+ function: {+ name: tu.name ?? 'unknown',+ arguments:+ typeof tu.input === 'string'+ ? tu.input+ : JSON.stringify(tu.input ?? {}),+ },+ }),+ )+ }++ result.push(assistantMsg)+ } else {+ result.push({+ role: 'assistant',+ content: convertContentBlocks(content) as string,+ })+ }+ }+ }++ return result+}++function convertTools(+ tools: Array<{ name: string; description?: string; input_schema?: Record<string, unknown> }>,+): OpenAITool[] {+ return tools+ .filter(t => t.name !== 'ToolSearchTool') // Not relevant for OpenAI+ .map(t => ({+ type: 'function' as const,+ function: {+ name: t.name,+ description: t.description ?? '',+ parameters: t.input_schema ?? { type: 'object', properties: {} },+ },+ }))+}++// ---------------------------------------------------------------------------+// Streaming: OpenAI SSE → Anthropic stream events+// ---------------------------------------------------------------------------++interface OpenAIStreamChunk {+ id: string+ object: string+ model: string+ choices: Array<{+ index: number+ delta: {+ role?: string+ content?: string | null+ tool_calls?: Array<{+ index: number+ id?: string+ type?: string+ function?: { name?: string; arguments?: string }+ }>+ }+ finish_reason: string | null+ }>+ usage?: {+ prompt_tokens?: number+ completion_tokens?: number+ total_tokens?: number+ }+}++function makeMessageId(): string {+ return `msg_${Math.random().toString(36).slice(2)}${Date.now().toString(36)}`+}++/**+ * Async generator that transforms an OpenAI SSE stream into+ * Anthropic-format BetaRawMessageStreamEvent objects.+ */+async function* openaiStreamToAnthropic(+ response: Response,+ model: string,+): AsyncGenerator<AnthropicStreamEvent> {+ const messageId = makeMessageId()+ let contentBlockIndex = 0+ const activeToolCalls = new Map<number, { id: string; name: string; index: number }>()+ let hasEmittedContentStart = false++ // Emit message_start+ yield {+ type: 'message_start',+ message: {+ id: messageId,+ type: 'message',+ role: 'assistant',+ content: [],+ model,+ stop_reason: null,+ stop_sequence: null,+ usage: {+ input_tokens: 0,+ output_tokens: 0,+ cache_creation_input_tokens: 0,+ cache_read_input_tokens: 0,+ },+ },+ }++ const reader = response.body?.getReader()+ if (!reader) return++ const decoder = new TextDecoder()+ let buffer = ''++ while (true) {+ const { done, value } = await reader.read()+ if (done) break++ buffer += decoder.decode(value, { stream: true })+ const lines = buffer.split('\n')+ buffer = lines.pop() ?? ''++ for (const line of lines) {+ const trimmed = line.trim()+ if (!trimmed || trimmed === 'data: [DONE]') continue+ if (!trimmed.startsWith('data: ')) continue++ let chunk: OpenAIStreamChunk+ try {+ chunk = JSON.parse(trimmed.slice(6))+ } catch {+ continue+ }++ for (const choice of chunk.choices ?? []) {+ const delta = choice.delta++ // Text content+ if (delta.content) {+ if (!hasEmittedContentStart) {+ yield {+ type: 'content_block_start',+ index: contentBlockIndex,+ content_block: { type: 'text', text: '' },+ }+ hasEmittedContentStart = true+ }+ yield {+ type: 'content_block_delta',+ index: contentBlockIndex,+ delta: { type: 'text_delta', text: delta.content },+ }+ }++ // Tool calls+ if (delta.tool_calls) {+ for (const tc of delta.tool_calls) {+ if (tc.id && tc.function?.name) {+ // New tool call starting+ if (hasEmittedContentStart) {+ yield {+ type: 'content_block_stop',+ index: contentBlockIndex,+ }+ contentBlockIndex+++ hasEmittedContentStart = false+ }++ const toolBlockIndex = contentBlockIndex+ activeToolCalls.set(tc.index, {+ id: tc.id,+ name: tc.function.name,+ index: toolBlockIndex,+ })++ yield {+ type: 'content_block_start',+ index: toolBlockIndex,+ content_block: {+ type: 'tool_use',+ id: tc.id,+ name: tc.function.name,+ input: {},+ },+ }+ contentBlockIndex++++ // Emit any initial arguments+ if (tc.function.arguments) {+ yield {+ type: 'content_block_delta',+ index: toolBlockIndex,+ delta: {+ type: 'input_json_delta',+ partial_json: tc.function.arguments,+ },+ }+ }+ } else if (tc.function?.arguments) {+ // Continuation of existing tool call+ const active = activeToolCalls.get(tc.index)+ if (active) {+ yield {+ type: 'content_block_delta',+ index: active.index,+ delta: {+ type: 'input_json_delta',+ partial_json: tc.function.arguments,+ },+ }+ }+ }+ }+ }++ // Finish+ if (choice.finish_reason) {+ // Close any open content blocks+ if (hasEmittedContentStart) {+ yield {+ type: 'content_block_stop',+ index: contentBlockIndex,+ }+ }+ // Close active tool calls+ for (const [, tc] of activeToolCalls) {+ yield { type: 'content_block_stop', index: tc.index }+ }++ const stopReason =+ choice.finish_reason === 'tool_calls'+ ? 'tool_use'+ : choice.finish_reason === 'length'+ ? 'max_tokens'+ : 'end_turn'++ yield {+ type: 'message_delta',+ delta: { stop_reason: stopReason, stop_sequence: null },+ usage: {+ output_tokens: chunk.usage?.completion_tokens ?? 0,+ },+ }+ }+ }+ }+ }++ yield { type: 'message_stop' }+}++// ---------------------------------------------------------------------------+// The shim client — duck-types as Anthropic SDK+// ---------------------------------------------------------------------------++interface ShimCreateParams {+ model: string+ messages: Array<Record<string, unknown>>+ system?: unknown+ tools?: Array<Record<string, unknown>>+ max_tokens: number+ stream?: boolean+ temperature?: number+ top_p?: number+ tool_choice?: unknown+ metadata?: unknown+ [key: string]: unknown+}++class OpenAIShimStream {+ private generator: AsyncGenerator<AnthropicStreamEvent>+ // The controller property is checked by claude.ts to distinguish streams from error messages+ controller = new AbortController()++ constructor(generator: AsyncGenerator<AnthropicStreamEvent>) {+ this.generator = generator+ }++ async *[Symbol.asyncIterator]() {+ yield* this.generator+ }+}++class OpenAIShimMessages {+ private baseUrl: string+ private apiKey: string+ private defaultHeaders: Record<string, string>++ constructor(+ baseUrl: string,+ apiKey: string,+ defaultHeaders: Record<string, string>,+ ) {+ this.baseUrl = baseUrl+ this.apiKey = apiKey+ this.defaultHeaders = defaultHeaders+ }++ create(+ params: ShimCreateParams,+ options?: { signal?: AbortSignal; headers?: Record<string, string> },+ ) {+ const self = this++ // Return a thenable that also has .withResponse()+ const promise = (async () => {+ const response = await self._doRequest(params, options)+ if (params.stream) {+ return new OpenAIShimStream(+ openaiStreamToAnthropic(response, params.model),+ )+ }+ // Non-streaming: parse the full response and convert+ const data = await response.json()+ return self._convertNonStreamingResponse(data, params.model)+ })()++ // Add .withResponse() for streaming path (claude.ts uses this)+ ;(promise as unknown as Record<string, unknown>).withResponse =+ async () => {+ const data = await promise+ return {+ data,+ response: new Response(),+ request_id: makeMessageId(),+ }+ }++ return promise+ }++ private async _doRequest(+ params: ShimCreateParams,+ options?: { signal?: AbortSignal; headers?: Record<string, string> },+ ): Promise<Response> {+ const openaiMessages = convertMessages(+ params.messages as Array<{+ role: string+ message?: { role?: string; content?: unknown }+ content?: unknown+ }>,+ params.system,+ )++ const body: Record<string, unknown> = {+ model: params.model,+ messages: openaiMessages,+ max_tokens: params.max_tokens,+ stream: params.stream ?? false,+ }++ if (params.stream) {+ body.stream_options = { include_usage: true }+ }++ if (params.temperature !== undefined) body.temperature = params.temperature+ if (params.top_p !== undefined) body.top_p = params.top_p++ // Convert tools+ if (params.tools && params.tools.length > 0) {+ const converted = convertTools(+ params.tools as Array<{+ name: string+ description?: string+ input_schema?: Record<string, unknown>+ }>,+ )+ if (converted.length > 0) {+ body.tools = converted+ // Convert tool_choice+ if (params.tool_choice) {+ const tc = params.tool_choice as { type?: string; name?: string }+ if (tc.type === 'auto') {+ body.tool_choice = 'auto'+ } else if (tc.type === 'tool' && tc.name) {+ body.tool_choice = {+ type: 'function',+ function: { name: tc.name },+ }+ } else if (tc.type === 'any') {+ body.tool_choice = 'required'+ }+ }+ }+ }++ const url = `${this.baseUrl}/chat/completions`+ const headers: Record<string, string> = {+ 'Content-Type': 'application/json',+ ...this.defaultHeaders,+ ...(options?.headers ?? {}),+ }++ if (this.apiKey) {+ headers['Authorization'] = `Bearer ${this.apiKey}`+ }++ const response = await fetch(url, {+ method: 'POST',+ headers,+ body: JSON.stringify(body),+ signal: options?.signal,+ })++ if (!response.ok) {+ const errorBody = await response.text().catch(() => 'unknown error')+ throw new Error(+ `OpenAI API error ${response.status}: ${errorBody}`,+ )+ }++ return response+ }++ private _convertNonStreamingResponse(+ data: {+ id?: string+ model?: string+ choices?: Array<{+ message?: {+ role?: string+ content?: string | null+ tool_calls?: Array<{+ id: string+ function: { name: string; arguments: string }+ }>+ }+ finish_reason?: string+ }>+ usage?: {+ prompt_tokens?: number+ completion_tokens?: number+ }+ },+ model: string,+ ) {+ const choice = data.choices?.[0]+ const content: Array<Record<string, unknown>> = []++ if (choice?.message?.content) {+ content.push({ type: 'text', text: choice.message.content })+ }++ if (choice?.message?.tool_calls) {+ for (const tc of choice.message.tool_calls) {+ let input: unknown+ try {+ input = JSON.parse(tc.function.arguments)+ } catch {+ input = { raw: tc.function.arguments }+ }+ content.push({+ type: 'tool_use',+ id: tc.id,+ name: tc.function.name,+ input,+ })+ }+ }++ const stopReason =+ choice?.finish_reason === 'tool_calls'+ ? 'tool_use'+ : choice?.finish_reason === 'length'+ ? 'max_tokens'+ : 'end_turn'++ return {+ id: data.id ?? makeMessageId(),+ type: 'message',+ role: 'assistant',+ content,+ model: data.model ?? model,+ stop_reason: stopReason,+ stop_sequence: null,+ usage: {+ input_tokens: data.usage?.prompt_tokens ?? 0,+ output_tokens: data.usage?.completion_tokens ?? 0,+ cache_creation_input_tokens: 0,+ cache_read_input_tokens: 0,+ },+ }+ }+}++class OpenAIShimBeta {+ messages: OpenAIShimMessages++ constructor(+ baseUrl: string,+ apiKey: string,+ defaultHeaders: Record<string, string>,+ ) {+ this.messages = new OpenAIShimMessages(baseUrl, apiKey, defaultHeaders)+ }+}++/**+ * Creates an Anthropic SDK-compatible client that routes requests+ * to an OpenAI-compatible API endpoint.+ *+ * Usage:+ * CLAUDE_CODE_USE_OPENAI=1 OPENAI_API_KEY=sk-... OPENAI_MODEL=gpt-4o+ */+export function createOpenAIShimClient(options: {+ defaultHeaders?: Record<string, string>+ maxRetries?: number+ timeout?: number+}): unknown {+ const baseUrl = (+ process.env.OPENAI_BASE_URL ??+ process.env.OPENAI_API_BASE ??+ 'https://api.openai.com/v1'+ ).replace(/\/+$/, '')++ const apiKey = process.env.OPENAI_API_KEY ?? ''++ const headers = {+ ...(options.defaultHeaders ?? {}),+ }++ const beta = new OpenAIShimBeta(baseUrl, apiKey, headers)++ // Duck-type as Anthropic client+ return {+ beta,+ // Some code paths access .messages directly (non-beta)+ messages: beta.messages,+ }+}diff --git a/src/utils/auth.ts b/src/utils/auth.tsindex 64a6180..ebae9f9 100644--- a/src/utils/auth.ts+++ b/src/utils/auth.ts@@ -1728,12 +1728,13 @@ export function getSubscriptionName(): string {}}-/** Check if using third-party services (Bedrock or Vertex or Foundry) */+/** Check if using third-party services (Bedrock or Vertex or Foundry or OpenAI-compatible) */export function isUsing3PServices(): boolean {return !!(isEnvTruthy(process.env.CLAUDE_CODE_USE_BEDROCK) ||isEnvTruthy(process.env.CLAUDE_CODE_USE_VERTEX) ||- isEnvTruthy(process.env.CLAUDE_CODE_USE_FOUNDRY)+ isEnvTruthy(process.env.CLAUDE_CODE_USE_FOUNDRY) ||+ isEnvTruthy(process.env.CLAUDE_CODE_USE_OPENAI))}diff --git a/src/utils/model/configs.ts b/src/utils/model/configs.tsindex 89f243d..0ffd0b5 100644--- a/src/utils/model/configs.ts+++ b/src/utils/model/configs.ts@@ -3,6 +3,17 @@ import type { APIProvider } from './providers.js'export type ModelConfig = Record<APIProvider, ModelName>+// ---------------------------------------------------------------------------+// OpenAI-compatible model mappings+// Maps Claude model tiers to sensible defaults for popular providers.+// Override with OPENAI_MODEL, ANTHROPIC_MODEL, or settings.model+// ---------------------------------------------------------------------------+export const OPENAI_MODEL_DEFAULTS = {+ opus: 'gpt-4o', // best reasoning+ sonnet: 'gpt-4o-mini', // balanced+ haiku: 'gpt-4o-mini', // fast & cheap+} as const+// @[MODEL LAUNCH]: Add a new CLAUDE_*_CONFIG constant here. Double check the correct model strings// here since the pattern may change.@@ -11,6 +22,7 @@ export const CLAUDE_3_7_SONNET_CONFIG = {bedrock: 'us.anthropic.claude-3-7-sonnet-20250219-v1:0',vertex: 'claude-3-7-sonnet@20250219',foundry: 'claude-3-7-sonnet',+ openai: 'gpt-4o-mini',} as const satisfies ModelConfigexport const CLAUDE_3_5_V2_SONNET_CONFIG = {@@ -18,6 +30,7 @@ export const CLAUDE_3_5_V2_SONNET_CONFIG = {bedrock: 'anthropic.claude-3-5-sonnet-20241022-v2:0',vertex: 'claude-3-5-sonnet-v2@20241022',foundry: 'claude-3-5-sonnet',+ openai: 'gpt-4o-mini',} as const satisfies ModelConfigexport const CLAUDE_3_5_HAIKU_CONFIG = {@@ -25,6 +38,7 @@ export const CLAUDE_3_5_HAIKU_CONFIG = {bedrock: 'us.anthropic.claude-3-5-haiku-20241022-v1:0',vertex: 'claude-3-5-haiku@20241022',foundry: 'claude-3-5-haiku',+ openai: 'gpt-4o-mini',} as const satisfies ModelConfigexport const CLAUDE_HAIKU_4_5_CONFIG = {@@ -32,6 +46,7 @@ export const CLAUDE_HAIKU_4_5_CONFIG = {bedrock: 'us.anthropic.claude-haiku-4-5-20251001-v1:0',vertex: 'claude-haiku-4-5@20251001',foundry: 'claude-haiku-4-5',+ openai: 'gpt-4o-mini',} as const satisfies ModelConfigexport const CLAUDE_SONNET_4_CONFIG = {@@ -39,6 +54,7 @@ export const CLAUDE_SONNET_4_CONFIG = {bedrock: 'us.anthropic.claude-sonnet-4-20250514-v1:0',vertex: 'claude-sonnet-4@20250514',foundry: 'claude-sonnet-4',+ openai: 'gpt-4o-mini',} as const satisfies ModelConfigexport const CLAUDE_SONNET_4_5_CONFIG = {@@ -46,6 +62,7 @@ export const CLAUDE_SONNET_4_5_CONFIG = {bedrock: 'us.anthropic.claude-sonnet-4-5-20250929-v1:0',vertex: 'claude-sonnet-4-5@20250929',foundry: 'claude-sonnet-4-5',+ openai: 'gpt-4o',} as const satisfies ModelConfigexport const CLAUDE_OPUS_4_CONFIG = {@@ -53,6 +70,7 @@ export const CLAUDE_OPUS_4_CONFIG = {bedrock: 'us.anthropic.claude-opus-4-20250514-v1:0',vertex: 'claude-opus-4@20250514',foundry: 'claude-opus-4',+ openai: 'gpt-4o',} as const satisfies ModelConfigexport const CLAUDE_OPUS_4_1_CONFIG = {@@ -60,6 +78,7 @@ export const CLAUDE_OPUS_4_1_CONFIG = {bedrock: 'us.anthropic.claude-opus-4-1-20250805-v1:0',vertex: 'claude-opus-4-1@20250805',foundry: 'claude-opus-4-1',+ openai: 'gpt-4o',} as const satisfies ModelConfigexport const CLAUDE_OPUS_4_5_CONFIG = {@@ -67,6 +86,7 @@ export const CLAUDE_OPUS_4_5_CONFIG = {bedrock: 'us.anthropic.claude-opus-4-5-20251101-v1:0',vertex: 'claude-opus-4-5@20251101',foundry: 'claude-opus-4-5',+ openai: 'gpt-4o',} as const satisfies ModelConfigexport const CLAUDE_OPUS_4_6_CONFIG = {@@ -74,6 +94,7 @@ export const CLAUDE_OPUS_4_6_CONFIG = {bedrock: 'us.anthropic.claude-opus-4-6-v1',vertex: 'claude-opus-4-6',foundry: 'claude-opus-4-6',+ openai: 'gpt-4o',} as const satisfies ModelConfigexport const CLAUDE_SONNET_4_6_CONFIG = {@@ -81,6 +102,7 @@ export const CLAUDE_SONNET_4_6_CONFIG = {bedrock: 'us.anthropic.claude-sonnet-4-6',vertex: 'claude-sonnet-4-6',foundry: 'claude-sonnet-4-6',+ openai: 'gpt-4o',} as const satisfies ModelConfig// @[MODEL LAUNCH]: Register the new config here.diff --git a/src/utils/model/model.ts b/src/utils/model/model.tsindex 85e369f..decb34e 100644--- a/src/utils/model/model.ts+++ b/src/utils/model/model.ts@@ -34,7 +34,12 @@ export type ModelName = stringexport type ModelSetting = ModelName | ModelAlias | nullexport function getSmallFastModel(): ModelName {- return process.env.ANTHROPIC_SMALL_FAST_MODEL || getDefaultHaikuModel()+ if (process.env.ANTHROPIC_SMALL_FAST_MODEL) return process.env.ANTHROPIC_SMALL_FAST_MODEL+ // For OpenAI provider, use OPENAI_MODEL or a sensible default+ if (getAPIProvider() === 'openai') {+ return process.env.OPENAI_MODEL || 'gpt-4o-mini'+ }+ return getDefaultHaikuModel()}export function isNonCustomOpusModel(model: ModelName): boolean {@@ -66,7 +71,7 @@ export function getUserSpecifiedModelSetting(): ModelSetting | undefined {specifiedModel = modelOverride} else {const settings = getSettings_DEPRECATED() || {}- specifiedModel = process.env.ANTHROPIC_MODEL || settings.model || undefined+ specifiedModel = process.env.ANTHROPIC_MODEL || process.env.OPENAI_MODEL || settings.model || undefined}// Ignore the user-specified model if it's not in the availableModels allowlist.@@ -106,6 +111,10 @@ export function getDefaultOpusModel(): ModelName {if (process.env.ANTHROPIC_DEFAULT_OPUS_MODEL) {return process.env.ANTHROPIC_DEFAULT_OPUS_MODEL}+ // OpenAI provider: use user-specified model or default+ if (getAPIProvider() === 'openai') {+ return process.env.OPENAI_MODEL || 'gpt-4o'+ }// 3P providers (Bedrock, Vertex, Foundry) — kept as a separate branch// even when values match, since 3P availability lags firstParty and// these will diverge again at the next model launch.@@ -120,6 +129,10 @@ export function getDefaultSonnetModel(): ModelName {if (process.env.ANTHROPIC_DEFAULT_SONNET_MODEL) {return process.env.ANTHROPIC_DEFAULT_SONNET_MODEL}+ // OpenAI provider+ if (getAPIProvider() === 'openai') {+ return process.env.OPENAI_MODEL || 'gpt-4o'+ }// Default to Sonnet 4.5 for 3P since they may not have 4.6 yetif (getAPIProvider() !== 'firstParty') {return getModelStrings().sonnet45@@ -132,6 +145,10 @@ export function getDefaultHaikuModel(): ModelName {if (process.env.ANTHROPIC_DEFAULT_HAIKU_MODEL) {return process.env.ANTHROPIC_DEFAULT_HAIKU_MODEL}+ // OpenAI provider+ if (getAPIProvider() === 'openai') {+ return process.env.OPENAI_MODEL || 'gpt-4o-mini'+ }// Haiku 4.5 is available on all platforms (first-party, Foundry, Bedrock, Vertex)return getModelStrings().haiku45diff --git a/src/utils/model/providers.ts b/src/utils/model/providers.tsindex aba9b7d..48acd52 100644--- a/src/utils/model/providers.ts+++ b/src/utils/model/providers.ts@@ -1,16 +1,18 @@import type { AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS } from '../../services/analytics/index.js'import { isEnvTruthy } from '../envUtils.js'-export type APIProvider = 'firstParty' | 'bedrock' | 'vertex' | 'foundry'+export type APIProvider = 'firstParty' | 'bedrock' | 'vertex' | 'foundry' | 'openai'export function getAPIProvider(): APIProvider {- return isEnvTruthy(process.env.CLAUDE_CODE_USE_BEDROCK)- ? 'bedrock'- : isEnvTruthy(process.env.CLAUDE_CODE_USE_VERTEX)- ? 'vertex'- : isEnvTruthy(process.env.CLAUDE_CODE_USE_FOUNDRY)- ? 'foundry'- : 'firstParty'+ return isEnvTruthy(process.env.CLAUDE_CODE_USE_OPENAI)+ ? 'openai'+ : isEnvTruthy(process.env.CLAUDE_CODE_USE_BEDROCK)+ ? 'bedrock'+ : isEnvTruthy(process.env.CLAUDE_CODE_USE_VERTEX)+ ? 'vertex'+ : isEnvTruthy(process.env.CLAUDE_CODE_USE_FOUNDRY)+ ? 'foundry'+ : 'firstParty'}export function getAPIProviderForStatsig(): AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS {