feat: 完成 openai 接口兼容

Author: claude-code-best

bun.lock

@@ -53,6 +53,7 @@
   },
   "dependencies": {},
   "devDependencies": {
+    "openai": "^4.73.0",
     "@alcalzone/ansi-tokenize": "^0.3.0",
     "@ant/claude-for-chrome-mcp": "workspace:*",
     "@ant/computer-use-input": "workspace:*",

docs/plans/openai-compatibility.md

@@ -1301,6 +1301,15 @@ async function* queryModel(
     API_MAX_MEDIA_PER_REQUEST,
   )
 
+  // OpenAI-compatible provider: delegate to the OpenAI adapter layer
+  // after shared preprocessing (message normalization, tool filtering,
+  // media stripping) but before Anthropic-specific logic (betas, thinking, caching).
+  if (getAPIProvider() === 'openai') {
+    const { queryModelOpenAI } = await import('./openai/index.js')
+    yield* queryModelOpenAI(messagesForAPI, systemPrompt, filteredTools, signal, options)
+    return
+  }
+
   // Instrumentation: Track message count after normalization
   logEvent('tengu_api_after_normalize', {
     postNormalizedMessageCount: messagesForAPI.length,

package.json

@@ -0,0 +1,158 @@
+import { describe, expect, test } from 'bun:test'
+import { anthropicMessagesToOpenAI } from '../convertMessages.js'
+
+// SystemPrompt is `readonly string[]` — pass string arrays
+describe('anthropicMessagesToOpenAI', () => {
+  test('converts system prompt to system message', () => {
+    const result = anthropicMessagesToOpenAI(
+      [{ role: 'user', content: 'hello' }],
+      ['You are helpful.'] as any,
+    )
+    expect(result[0]).toEqual({ role: 'system', content: 'You are helpful.' })
+  })
+
+  test('joins multiple system prompt strings', () => {
+    const result = anthropicMessagesToOpenAI(
+      [{ role: 'user', content: 'hi' }],
+      ['Part 1', 'Part 2'] as any,
+    )
+    expect(result[0]).toEqual({ role: 'system', content: 'Part 1\n\nPart 2' })
+  })
+
+  test('skips empty system prompt', () => {
+    const result = anthropicMessagesToOpenAI(
+      [{ role: 'user', content: 'hi' }],
+      [] as any,
+    )
+    expect(result[0].role).toBe('user')
+  })
+
+  test('converts simple user text message', () => {
+    const result = anthropicMessagesToOpenAI(
+      [{ role: 'user', content: 'hello world' }],
+      [] as any,
+    )
+    expect(result).toEqual([{ role: 'user', content: 'hello world' }])
+  })
+
+  test('converts user message with content array', () => {
+    const result = anthropicMessagesToOpenAI(
+      [{
+        role: 'user',
+        content: [
+          { type: 'text', text: 'line 1' },
+          { type: 'text', text: 'line 2' },
+        ],
+      }],
+      [] as any,
+    )
+    expect(result).toEqual([{ role: 'user', content: 'line 1\nline 2' }])
+  })
+
+  test('converts assistant message with text', () => {
+    const result = anthropicMessagesToOpenAI(
+      [{ role: 'assistant', content: 'response text' }],
+      [] as any,
+    )
+    expect(result).toEqual([{ role: 'assistant', content: 'response text' }])
+  })
+
+  test('converts assistant message with tool_use', () => {
+    const result = anthropicMessagesToOpenAI(
+      [{
+        role: 'assistant',
+        content: [
+          { type: 'text', text: 'Let me help.' },
+          {
+            type: 'tool_use' as const,
+            id: 'toolu_123',
+            name: 'bash',
+            input: { command: 'ls' },
+          },
+        ],
+      }],
+      [] as any,
+    )
+    expect(result).toEqual([{
+      role: 'assistant',
+      content: 'Let me help.',
+      tool_calls: [{
+        id: 'toolu_123',
+        type: 'function',
+        function: { name: 'bash', arguments: '{"command":"ls"}' },
+      }],
+    }])
+  })
+
+  test('converts tool_result to tool message', () => {
+    const result = anthropicMessagesToOpenAI(
+      [{
+        role: 'user',
+        content: [
+          {
+            type: 'tool_result' as const,
+            tool_use_id: 'toolu_123',
+            content: 'file1.txt\nfile2.txt',
+          },
+        ],
+      }],
+      [] as any,
+    )
+    expect(result).toEqual([{
+      role: 'tool',
+      tool_call_id: 'toolu_123',
+      content: 'file1.txt\nfile2.txt',
+    }])
+  })
+
+  test('strips thinking blocks', () => {
+    const result = anthropicMessagesToOpenAI(
+      [{
+        role: 'assistant',
+        content: [
+          { type: 'thinking' as const, thinking: 'internal thoughts...' },
+          { type: 'text', text: 'visible response' },
+        ],
+      }],
+      [] as any,
+    )
+    expect(result).toEqual([{ role: 'assistant', content: 'visible response' }])
+  })
+
+  test('handles full conversation with tools', () => {
+    const result = anthropicMessagesToOpenAI(
+      [
+        { role: 'user', content: 'list files' },
+        {
+          role: 'assistant',
+          content: [
+            {
+              type: 'tool_use' as const,
+              id: 'toolu_abc',
+              name: 'bash',
+              input: { command: 'ls' },
+            },
+          ],
+        },
+        {
+          role: 'user',
+          content: [
+            {
+              type: 'tool_result' as const,
+              tool_use_id: 'toolu_abc',
+              content: 'file.txt',
+            },
+          ],
+        },
+      ],
+      ['You are helpful.'] as any,
+    )
+
+    expect(result).toHaveLength(4)
+    expect(result[0].role).toBe('system')
+    expect(result[1].role).toBe('user')
+    expect(result[2].role).toBe('assistant')
+    expect((result[2] as any).tool_calls).toBeDefined()
+    expect(result[3].role).toBe('tool')
+  })
+})

src/services/api/claude.ts

@@ -0,0 +1,85 @@
+import { describe, expect, test } from 'bun:test'
+import { anthropicToolsToOpenAI, anthropicToolChoiceToOpenAI } from '../convertTools.js'
+
+describe('anthropicToolsToOpenAI', () => {
+  test('converts basic tool', () => {
+    const tools = [
+      {
+        type: 'custom',
+        name: 'bash',
+        description: 'Run a bash command',
+        input_schema: {
+          type: 'object',
+          properties: { command: { type: 'string' } },
+          required: ['command'],
+        },
+      },
+    ]
+
+    const result = anthropicToolsToOpenAI(tools as any)
+
+    expect(result).toEqual([{
+      type: 'function',
+      function: {
+        name: 'bash',
+        description: 'Run a bash command',
+        parameters: {
+          type: 'object',
+          properties: { command: { type: 'string' } },
+          required: ['command'],
+        },
+      },
+    }])
+  })
+
+  test('uses empty schema when input_schema missing', () => {
+    const tools = [{ type: 'custom', name: 'noop', description: 'no-op' }]
+    const result = anthropicToolsToOpenAI(tools as any)
+
+    expect(result[0].function.parameters).toEqual({ type: 'object', properties: {} })
+  })
+
+  test('strips Anthropic-specific fields', () => {
+    const tools = [
+      {
+        type: 'custom',
+        name: 'bash',
+        description: 'Run bash',
+        input_schema: { type: 'object', properties: {} },
+        cache_control: { type: 'ephemeral' },
+        defer_loading: true,
+      },
+    ]
+    const result = anthropicToolsToOpenAI(tools as any)
+
+    expect((result[0] as any).cache_control).toBeUndefined()
+    expect((result[0] as any).defer_loading).toBeUndefined()
+  })
+
+  test('handles empty tools array', () => {
+    expect(anthropicToolsToOpenAI([])).toEqual([])
+  })
+})
+
+describe('anthropicToolChoiceToOpenAI', () => {
+  test('maps auto', () => {
+    expect(anthropicToolChoiceToOpenAI({ type: 'auto' })).toBe('auto')
+  })
+
+  test('maps any to required', () => {
+    expect(anthropicToolChoiceToOpenAI({ type: 'any' })).toBe('required')
+  })
+
+  test('maps tool to function', () => {
+    const result = anthropicToolChoiceToOpenAI({ type: 'tool', name: 'bash' })
+    expect(result).toEqual({ type: 'function', function: { name: 'bash' } })
+  })
+
+  test('returns undefined for undefined input', () => {
+    expect(anthropicToolChoiceToOpenAI(undefined)).toBeUndefined()
+  })
+
+  test('returns undefined for unknown type', () => {
+    expect(anthropicToolChoiceToOpenAI({ type: 'unknown' })).toBeUndefined()
+  })
+})

src/services/api/openai/__tests__/convertMessages.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, test, beforeEach, afterEach } from 'bun:test'
+import { resolveOpenAIModel } from '../modelMapping.js'
+
+// Cache is module-level, so we need to invalidate it by changing env vars
+describe('resolveOpenAIModel', () => {
+  const originalEnv = {
+    OPENAI_MODEL: process.env.OPENAI_MODEL,
+    OPENAI_MODEL_MAP: process.env.OPENAI_MODEL_MAP,
+  }
+
+  beforeEach(() => {
+    // Reset env and clear module cache between tests
+    delete process.env.OPENAI_MODEL
+    delete process.env.OPENAI_MODEL_MAP
+  })
+
+  afterEach(() => {
+    process.env.OPENAI_MODEL = originalEnv.OPENAI_MODEL
+    process.env.OPENAI_MODEL_MAP = originalEnv.OPENAI_MODEL_MAP
+  })
+
+  test('OPENAI_MODEL env var overrides all', () => {
+    process.env.OPENAI_MODEL = 'my-custom-model'
+    // Need to reimport to bust cache — but since resolveOpenAIModel reads env at call time
+    // for OPENAI_MODEL, this should work
+    expect(resolveOpenAIModel('claude-sonnet-4-6')).toBe('my-custom-model')
+  })
+
+  test('maps known Anthropic model via DEFAULT_MODEL_MAP', () => {
+    // claude-sonnet-4-6 → gpt-4o per default map
+    expect(resolveOpenAIModel('claude-sonnet-4-6')).toBe('gpt-4o')
+  })
+
+  test('maps haiku model', () => {
+    expect(resolveOpenAIModel('claude-haiku-4-5-20251001')).toBe('gpt-4o-mini')
+  })
+
+  test('maps opus model', () => {
+    expect(resolveOpenAIModel('claude-opus-4-6')).toBe('o3')
+  })
+
+  test('passes through unknown model name', () => {
+    expect(resolveOpenAIModel('some-random-model')).toBe('some-random-model')
+  })
+
+  test('strips [1m] suffix', () => {
+    // claude-sonnet-4-6[1m] → gpt-4o (same as without suffix)
+    expect(resolveOpenAIModel('claude-sonnet-4-6[1m]')).toBe('gpt-4o')
+  })
+})