996 lines
34 KiB
TypeScript
996 lines
34 KiB
TypeScript
|
import { randomBytes } from 'crypto'
|
||
|
|
import { Readable } from 'stream'
|
||
|
|
import type { Context } from 'koa'
|
||
|
|
import { config } from '../config'
|
||
|
|
|
||
|
|
export type ApiMode = 'chat_completions' | 'codex_responses' | 'anthropic_messages' | 'bedrock_converse' | 'codex_app_server'
|
||
|
|
|
||
|
|
export interface ClaudeCodeProxyTargetInput {
|
||
|
|
provider: string
|
||
|
|
model: string
|
||
|
|
baseUrl: string
|
||
|
|
apiKey: string
|
||
|
|
apiMode?: ApiMode
|
||
|
|
}
|
||
|
|
|
||
|
|
interface ClaudeCodeProxyTarget extends ClaudeCodeProxyTargetInput {
|
||
|
|
key: string
|
||
|
|
routeKey: string
|
||
|
|
token: string
|
||
|
|
updatedAt: number
|
||
|
|
}
|
||
|
|
|
||
|
|
const targets = new Map<string, ClaudeCodeProxyTarget>()
|
||
|
|
const CLAUDE_PROXY_VISIBLE_MODELS = [
|
||
|
|
'claude-haiku-4-5',
|
||
|
|
'claude-sonnet-4-6',
|
||
|
|
'claude-opus-4-7',
|
||
|
|
]
|
||
|
|
|
||
|
|
function targetKey(provider: string, model: string, apiMode: ApiMode, baseUrl: string): string {
|
||
|
|
return `${provider}\0${model}\0${apiMode}\0${baseUrl}`
|
||
|
|
}
|
||
|
|
|
||
|
|
function routeKeyFor(provider: string, model: string, apiMode: ApiMode, baseUrl: string): string {
|
||
|
|
return Buffer.from(targetKey(provider, model, apiMode, baseUrl), 'utf-8').toString('base64url')
|
||
|
|
}
|
||
|
|
|
||
|
|
function localProxyBaseUrl(routeKey: string): string {
|
||
|
|
return `http://127.0.0.1:${config.port}/api/claude-code-proxy/${routeKey}`
|
||
|
|
}
|
||
|
|
|
||
|
|
export function registerClaudeCodeProxyTarget(input: ClaudeCodeProxyTargetInput): { baseUrl: string; token: string; routeKey: string } {
|
||
|
|
const provider = input.provider.trim()
|
||
|
|
const model = input.model.trim()
|
||
|
|
const baseUrl = input.baseUrl.replace(/\/+$/, '')
|
||
|
|
const apiMode = input.apiMode || 'chat_completions'
|
||
|
|
const key = targetKey(provider, model, apiMode, baseUrl)
|
||
|
|
const existing = targets.get(key)
|
||
|
|
const routeKey = existing?.routeKey || routeKeyFor(provider, model, apiMode, baseUrl)
|
||
|
|
const token = existing?.token || `hwui_${randomBytes(24).toString('base64url')}`
|
||
|
|
|
||
|
|
targets.set(key, {
|
||
|
|
...input,
|
||
|
|
provider,
|
||
|
|
model,
|
||
|
|
baseUrl,
|
||
|
|
apiMode,
|
||
|
|
key,
|
||
|
|
routeKey,
|
||
|
|
token,
|
||
|
|
updatedAt: Date.now(),
|
||
|
|
})
|
||
|
|
|
||
|
|
return { baseUrl: localProxyBaseUrl(routeKey), token, routeKey }
|
||
|
|
}
|
||
|
|
|
||
|
|
function findTarget(routeKey: string): ClaudeCodeProxyTarget | null {
|
||
|
|
for (const target of targets.values()) {
|
||
|
|
if (target.routeKey === routeKey) return target
|
||
|
|
}
|
||
|
|
return null
|
||
|
|
}
|
||
|
|
|
||
|
|
function authToken(ctx: Context): string {
|
||
|
|
const apiKey = ctx.get('x-api-key').trim()
|
||
|
|
if (apiKey) return apiKey
|
||
|
|
const auth = ctx.get('authorization').trim()
|
||
|
|
const match = auth.match(/^Bearer\s+(.+)$/i)
|
||
|
|
return match?.[1]?.trim() || ''
|
||
|
|
}
|
||
|
|
|
||
|
|
function requireTarget(ctx: Context): ClaudeCodeProxyTarget | null {
|
||
|
|
const target = findTarget(String(ctx.params.key || ''))
|
||
|
|
if (!target) {
|
||
|
|
ctx.status = 404
|
||
|
|
ctx.body = { type: 'error', error: { type: 'not_found_error', message: 'Claude proxy target not found' } }
|
||
|
|
return null
|
||
|
|
}
|
||
|
|
if (authToken(ctx) !== target.token) {
|
||
|
|
ctx.status = 401
|
||
|
|
ctx.body = { type: 'error', error: { type: 'authentication_error', message: 'Invalid Claude proxy token' } }
|
||
|
|
return null
|
||
|
|
}
|
||
|
|
return target
|
||
|
|
}
|
||
|
|
|
||
|
|
function stringifyContent(value: unknown): string {
|
||
|
|
if (typeof value === 'string') return value
|
||
|
|
if (Array.isArray(value)) {
|
||
|
|
return value.map((item) => {
|
||
|
|
if (typeof item === 'string') return item
|
||
|
|
if (item && typeof item === 'object' && 'text' in item) return String((item as any).text || '')
|
||
|
|
return JSON.stringify(item)
|
||
|
|
}).filter(Boolean).join('\n')
|
||
|
|
}
|
||
|
|
if (value == null) return ''
|
||
|
|
return JSON.stringify(value)
|
||
|
|
}
|
||
|
|
|
||
|
|
function shouldPreserveReasoningContent(target: ClaudeCodeProxyTarget): boolean {
|
||
|
|
const identifier = `${target.provider} ${target.model} ${target.baseUrl}`.toLowerCase()
|
||
|
|
return [
|
||
|
|
'deepseek',
|
||
|
|
'moonshot',
|
||
|
|
'kimi',
|
||
|
|
'mimo',
|
||
|
|
'xiaomimimo',
|
||
|
|
].some(part => identifier.includes(part))
|
||
|
|
}
|
||
|
|
|
||
|
|
function anthropicContentToOpenAiMessages(message: any, preserveReasoningContent = false): any[] {
|
||
|
|
const content = message?.content
|
||
|
|
if (!Array.isArray(content)) {
|
||
|
|
return [{ role: message.role, content: stringifyContent(content) }]
|
||
|
|
}
|
||
|
|
|
||
|
|
if (message.role === 'assistant') {
|
||
|
|
const textParts: string[] = []
|
||
|
|
const reasoningParts: string[] = []
|
||
|
|
const toolCalls: any[] = []
|
||
|
|
for (const block of content) {
|
||
|
|
if (block?.type === 'text') textParts.push(String(block.text || ''))
|
||
|
|
if (block?.type === 'thinking' && block.thinking) reasoningParts.push(String(block.thinking))
|
||
|
|
if (block?.type === 'redacted_thinking' && preserveReasoningContent) reasoningParts.push('[redacted thinking]')
|
||
|
|
if (block?.type === 'tool_use') {
|
||
|
|
toolCalls.push({
|
||
|
|
id: String(block.id || `tool_${toolCalls.length}`),
|
||
|
|
type: 'function',
|
||
|
|
function: {
|
||
|
|
name: String(block.name || 'tool'),
|
||
|
|
arguments: JSON.stringify(block.input || {}),
|
||
|
|
},
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
const openAiMessage: any = {
|
||
|
|
role: 'assistant',
|
||
|
|
content: textParts.join('\n') || null,
|
||
|
|
...(toolCalls.length ? { tool_calls: toolCalls } : {}),
|
||
|
|
}
|
||
|
|
if (preserveReasoningContent && (reasoningParts.length || toolCalls.length)) {
|
||
|
|
openAiMessage.reasoning_content = reasoningParts.join('\n') || 'tool call'
|
||
|
|
}
|
||
|
|
return [openAiMessage]
|
||
|
|
}
|
||
|
|
|
||
|
|
const messages: any[] = []
|
||
|
|
const textParts: string[] = []
|
||
|
|
for (const block of content) {
|
||
|
|
if (block?.type === 'text') textParts.push(String(block.text || ''))
|
||
|
|
if (block?.type === 'tool_result') {
|
||
|
|
if (textParts.length) {
|
||
|
|
messages.push({ role: 'user', content: textParts.splice(0).join('\n') })
|
||
|
|
}
|
||
|
|
messages.push({
|
||
|
|
role: 'tool',
|
||
|
|
tool_call_id: String(block.tool_use_id || ''),
|
||
|
|
content: stringifyContent(block.content),
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (textParts.length) messages.push({ role: message.role || 'user', content: textParts.join('\n') })
|
||
|
|
return messages.length ? messages : [{ role: message.role || 'user', content: '' }]
|
||
|
|
}
|
||
|
|
|
||
|
|
function anthropicToOpenAiChat(body: any, target: ClaudeCodeProxyTarget, stream = false): any {
|
||
|
|
const messages: any[] = []
|
||
|
|
const preserveReasoningContent = shouldPreserveReasoningContent(target)
|
||
|
|
const system = body?.system
|
||
|
|
if (system) messages.push({ role: 'system', content: stringifyContent(system) })
|
||
|
|
for (const message of Array.isArray(body?.messages) ? body.messages : []) {
|
||
|
|
messages.push(...anthropicContentToOpenAiMessages(message, preserveReasoningContent))
|
||
|
|
}
|
||
|
|
|
||
|
|
const tools = Array.isArray(body?.tools)
|
||
|
|
? body.tools.map((tool: any) => ({
|
||
|
|
type: 'function',
|
||
|
|
function: {
|
||
|
|
name: String(tool.name || ''),
|
||
|
|
description: String(tool.description || ''),
|
||
|
|
parameters: tool.input_schema || { type: 'object', properties: {} },
|
||
|
|
},
|
||
|
|
})).filter((tool: any) => tool.function.name)
|
||
|
|
: undefined
|
||
|
|
|
||
|
|
return {
|
||
|
|
model: target.model,
|
||
|
|
messages,
|
||
|
|
...(typeof body?.max_tokens === 'number' ? { max_tokens: body.max_tokens } : {}),
|
||
|
|
...(typeof body?.temperature === 'number' ? { temperature: body.temperature } : {}),
|
||
|
|
...(tools?.length ? { tools } : {}),
|
||
|
|
stream,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function anthropicToOpenAiResponsesInput(message: any): any[] {
|
||
|
|
const content = Array.isArray(message?.content) ? message.content : [{ type: 'text', text: stringifyContent(message?.content) }]
|
||
|
|
|
||
|
|
if (message.role === 'assistant') {
|
||
|
|
const items: any[] = []
|
||
|
|
const textParts: string[] = []
|
||
|
|
for (const block of content) {
|
||
|
|
if (block?.type === 'text') textParts.push(String(block.text || ''))
|
||
|
|
if (block?.type === 'tool_use') {
|
||
|
|
if (textParts.length) {
|
||
|
|
items.push({ role: 'assistant', content: textParts.splice(0).join('\n') })
|
||
|
|
}
|
||
|
|
items.push({
|
||
|
|
type: 'function_call',
|
||
|
|
call_id: String(block.id || `tool_${items.length}`),
|
||
|
|
name: String(block.name || 'tool'),
|
||
|
|
arguments: JSON.stringify(block.input || {}),
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (textParts.length) items.push({ role: 'assistant', content: textParts.join('\n') })
|
||
|
|
return items
|
||
|
|
}
|
||
|
|
|
||
|
|
const items: any[] = []
|
||
|
|
const textParts: string[] = []
|
||
|
|
for (const block of content) {
|
||
|
|
if (block?.type === 'text') textParts.push(String(block.text || ''))
|
||
|
|
if (block?.type === 'tool_result') {
|
||
|
|
if (textParts.length) {
|
||
|
|
items.push({ role: 'user', content: textParts.splice(0).join('\n') })
|
||
|
|
}
|
||
|
|
items.push({
|
||
|
|
type: 'function_call_output',
|
||
|
|
call_id: String(block.tool_use_id || ''),
|
||
|
|
output: stringifyContent(block.content),
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (textParts.length) items.push({ role: message.role || 'user', content: textParts.join('\n') })
|
||
|
|
return items.length ? items : [{ role: message.role || 'user', content: '' }]
|
||
|
|
}
|
||
|
|
|
||
|
|
function anthropicToOpenAiResponses(body: any, target: ClaudeCodeProxyTarget, stream = false): any {
|
||
|
|
const input: any[] = []
|
||
|
|
for (const message of Array.isArray(body?.messages) ? body.messages : []) {
|
||
|
|
input.push(...anthropicToOpenAiResponsesInput(message))
|
||
|
|
}
|
||
|
|
|
||
|
|
const tools = Array.isArray(body?.tools)
|
||
|
|
? body.tools.map((tool: any) => ({
|
||
|
|
type: 'function',
|
||
|
|
name: String(tool.name || ''),
|
||
|
|
description: String(tool.description || ''),
|
||
|
|
parameters: tool.input_schema || { type: 'object', properties: {} },
|
||
|
|
})).filter((tool: any) => tool.name)
|
||
|
|
: undefined
|
||
|
|
|
||
|
|
return {
|
||
|
|
model: target.model,
|
||
|
|
input,
|
||
|
|
...(body?.system ? { instructions: stringifyContent(body.system) } : {}),
|
||
|
|
...(typeof body?.max_tokens === 'number' ? { max_output_tokens: body.max_tokens } : {}),
|
||
|
|
...(typeof body?.temperature === 'number' ? { temperature: body.temperature } : {}),
|
||
|
|
...(tools?.length ? { tools } : {}),
|
||
|
|
stream,
|
||
|
|
store: false,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function safeJsonParse(value: string): any {
|
||
|
|
try {
|
||
|
|
return JSON.parse(value)
|
||
|
|
} catch {
|
||
|
|
return {}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function mapStopReason(reason: string | null | undefined, hasTools: boolean): string {
|
||
|
|
if (hasTools) return 'tool_use'
|
||
|
|
if (reason === 'length') return 'max_tokens'
|
||
|
|
if (reason === 'content_filter') return 'stop_sequence'
|
||
|
|
return 'end_turn'
|
||
|
|
}
|
||
|
|
|
||
|
|
function openAiToAnthropicMessage(data: any, target: ClaudeCodeProxyTarget): any {
|
||
|
|
const choice = data?.choices?.[0] || {}
|
||
|
|
const message = choice.message || {}
|
||
|
|
const content: any[] = []
|
||
|
|
if (shouldPreserveReasoningContent(target) && message.reasoning_content) {
|
||
|
|
content.push({ type: 'thinking', thinking: String(message.reasoning_content) })
|
||
|
|
}
|
||
|
|
if (message.content) content.push({ type: 'text', text: String(message.content) })
|
||
|
|
for (const call of Array.isArray(message.tool_calls) ? message.tool_calls : []) {
|
||
|
|
content.push({
|
||
|
|
type: 'tool_use',
|
||
|
|
id: String(call.id || `toolu_${content.length}`),
|
||
|
|
name: String(call.function?.name || 'tool'),
|
||
|
|
input: safeJsonParse(String(call.function?.arguments || '{}')),
|
||
|
|
})
|
||
|
|
}
|
||
|
|
|
||
|
|
const hasTools = content.some(block => block.type === 'tool_use')
|
||
|
|
return {
|
||
|
|
id: String(data?.id || `msg_${Date.now()}`),
|
||
|
|
type: 'message',
|
||
|
|
role: 'assistant',
|
||
|
|
model: target.model,
|
||
|
|
content,
|
||
|
|
stop_reason: mapStopReason(choice.finish_reason, hasTools),
|
||
|
|
stop_sequence: null,
|
||
|
|
usage: {
|
||
|
|
input_tokens: Number(data?.usage?.prompt_tokens || 0),
|
||
|
|
output_tokens: Number(data?.usage?.completion_tokens || 0),
|
||
|
|
},
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function sseEvent(event: string, data: any): string {
|
||
|
|
return `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`
|
||
|
|
}
|
||
|
|
|
||
|
|
function anthropicMessageToSse(message: any): string {
|
||
|
|
let output = ''
|
||
|
|
output += sseEvent('message_start', {
|
||
|
|
type: 'message_start',
|
||
|
|
message: { ...message, content: [], stop_reason: null, usage: { input_tokens: message.usage.input_tokens, output_tokens: 0 } },
|
||
|
|
})
|
||
|
|
|
||
|
|
message.content.forEach((block: any, index: number) => {
|
||
|
|
if (block.type === 'text') {
|
||
|
|
output += sseEvent('content_block_start', { type: 'content_block_start', index, content_block: { type: 'text', text: '' } })
|
||
|
|
if (block.text) output += sseEvent('content_block_delta', { type: 'content_block_delta', index, delta: { type: 'text_delta', text: block.text } })
|
||
|
|
output += sseEvent('content_block_stop', { type: 'content_block_stop', index })
|
||
|
|
} else if (block.type === 'tool_use') {
|
||
|
|
output += sseEvent('content_block_start', {
|
||
|
|
type: 'content_block_start',
|
||
|
|
index,
|
||
|
|
content_block: { type: 'tool_use', id: block.id, name: block.name, input: {} },
|
||
|
|
})
|
||
|
|
output += sseEvent('content_block_delta', {
|
||
|
|
type: 'content_block_delta',
|
||
|
|
index,
|
||
|
|
delta: { type: 'input_json_delta', partial_json: JSON.stringify(block.input || {}) },
|
||
|
|
})
|
||
|
|
output += sseEvent('content_block_stop', { type: 'content_block_stop', index })
|
||
|
|
}
|
||
|
|
})
|
||
|
|
|
||
|
|
output += sseEvent('message_delta', {
|
||
|
|
type: 'message_delta',
|
||
|
|
delta: { stop_reason: message.stop_reason, stop_sequence: null },
|
||
|
|
usage: { output_tokens: message.usage.output_tokens },
|
||
|
|
})
|
||
|
|
output += sseEvent('message_stop', { type: 'message_stop' })
|
||
|
|
return output
|
||
|
|
}
|
||
|
|
|
||
|
|
function anthropicMessagesUrl(target: ClaudeCodeProxyTarget): string {
|
||
|
|
if (/\/v\d+$/i.test(target.baseUrl)) return `${target.baseUrl}/messages`
|
||
|
|
return `${target.baseUrl}/v1/messages`
|
||
|
|
}
|
||
|
|
|
||
|
|
async function readProviderJson(res: Response): Promise<any> {
|
||
|
|
const text = await res.text()
|
||
|
|
try {
|
||
|
|
return JSON.parse(text)
|
||
|
|
} catch {
|
||
|
|
return { error: { message: text || `Provider returned HTTP ${res.status}` } }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function throwProviderError(res: Response, data: any): never {
|
||
|
|
const err = new Error(data?.error?.message || `Provider returned HTTP ${res.status}`)
|
||
|
|
;(err as any).status = res.status
|
||
|
|
;(err as any).providerError = data
|
||
|
|
throw err
|
||
|
|
}
|
||
|
|
|
||
|
|
function anthropicRequestBody(body: any, target: ClaudeCodeProxyTarget): any {
|
||
|
|
return {
|
||
|
|
...body,
|
||
|
|
model: target.model,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
async function callAnthropicMessages(target: ClaudeCodeProxyTarget, body: any): Promise<any> {
|
||
|
|
if (target.apiMode !== 'anthropic_messages') {
|
||
|
|
const err = new Error(`Claude proxy Anthropic adapter only supports anthropic_messages targets, got ${target.apiMode}`)
|
||
|
|
;(err as any).status = 501
|
||
|
|
throw err
|
||
|
|
}
|
||
|
|
const res = await fetch(anthropicMessagesUrl(target), {
|
||
|
|
method: 'POST',
|
||
|
|
headers: {
|
||
|
|
Authorization: `Bearer ${target.apiKey}`,
|
||
|
|
'x-api-key': target.apiKey,
|
||
|
|
'anthropic-version': '2023-06-01',
|
||
|
|
'Content-Type': 'application/json',
|
||
|
|
},
|
||
|
|
body: JSON.stringify(anthropicRequestBody(body, target)),
|
||
|
|
})
|
||
|
|
const data = await readProviderJson(res)
|
||
|
|
if (!res.ok) throwProviderError(res, data)
|
||
|
|
return data
|
||
|
|
}
|
||
|
|
|
||
|
|
async function callOpenAiChat(target: ClaudeCodeProxyTarget, body: any): Promise<any> {
|
||
|
|
if (target.apiMode !== 'chat_completions') {
|
||
|
|
const err = new Error(`Claude proxy MVP only supports chat_completions targets, got ${target.apiMode}`)
|
||
|
|
;(err as any).status = 501
|
||
|
|
throw err
|
||
|
|
}
|
||
|
|
const res = await fetch(`${target.baseUrl}/chat/completions`, {
|
||
|
|
method: 'POST',
|
||
|
|
headers: {
|
||
|
|
Authorization: `Bearer ${target.apiKey}`,
|
||
|
|
'Content-Type': 'application/json',
|
||
|
|
},
|
||
|
|
body: JSON.stringify(anthropicToOpenAiChat(body, target)),
|
||
|
|
})
|
||
|
|
const data = await readProviderJson(res)
|
||
|
|
if (!res.ok) throwProviderError(res, data)
|
||
|
|
return data
|
||
|
|
}
|
||
|
|
|
||
|
|
async function callOpenAiResponses(target: ClaudeCodeProxyTarget, body: any): Promise<any> {
|
||
|
|
if (target.apiMode !== 'codex_responses') {
|
||
|
|
const err = new Error(`Claude proxy responses adapter only supports codex_responses targets, got ${target.apiMode}`)
|
||
|
|
;(err as any).status = 501
|
||
|
|
throw err
|
||
|
|
}
|
||
|
|
const res = await fetch(`${target.baseUrl}/responses`, {
|
||
|
|
method: 'POST',
|
||
|
|
headers: {
|
||
|
|
Authorization: `Bearer ${target.apiKey}`,
|
||
|
|
'Content-Type': 'application/json',
|
||
|
|
},
|
||
|
|
body: JSON.stringify(anthropicToOpenAiResponses(body, target)),
|
||
|
|
})
|
||
|
|
const data = await readProviderJson(res)
|
||
|
|
if (!res.ok) throwProviderError(res, data)
|
||
|
|
return data
|
||
|
|
}
|
||
|
|
|
||
|
|
function responseOutputText(item: any): string {
|
||
|
|
if (item?.type === 'output_text') return String(item.text || '')
|
||
|
|
if (item?.type === 'message' && Array.isArray(item.content)) {
|
||
|
|
return item.content
|
||
|
|
.map((part: any) => {
|
||
|
|
if (part?.type === 'output_text' || part?.type === 'text') return String(part.text || '')
|
||
|
|
return ''
|
||
|
|
})
|
||
|
|
.filter(Boolean)
|
||
|
|
.join('')
|
||
|
|
}
|
||
|
|
return ''
|
||
|
|
}
|
||
|
|
|
||
|
|
function openAiResponsesToAnthropicMessage(data: any, target: ClaudeCodeProxyTarget): any {
|
||
|
|
const content: any[] = []
|
||
|
|
const output = Array.isArray(data?.output) ? data.output : []
|
||
|
|
|
||
|
|
for (const item of output) {
|
||
|
|
const text = responseOutputText(item)
|
||
|
|
if (text) content.push({ type: 'text', text })
|
||
|
|
if (item?.type === 'function_call') {
|
||
|
|
content.push({
|
||
|
|
type: 'tool_use',
|
||
|
|
id: String(item.call_id || item.id || `toolu_${content.length}`),
|
||
|
|
name: String(item.name || 'tool'),
|
||
|
|
input: safeJsonParse(String(item.arguments || '{}')),
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!content.length && data?.output_text) {
|
||
|
|
content.push({ type: 'text', text: String(data.output_text) })
|
||
|
|
}
|
||
|
|
|
||
|
|
const hasTools = content.some(block => block.type === 'tool_use')
|
||
|
|
return {
|
||
|
|
id: String(data?.id || `msg_${Date.now()}`),
|
||
|
|
type: 'message',
|
||
|
|
role: 'assistant',
|
||
|
|
model: target.model,
|
||
|
|
content,
|
||
|
|
stop_reason: hasTools ? 'tool_use' : (data?.status === 'incomplete' ? 'max_tokens' : 'end_turn'),
|
||
|
|
stop_sequence: null,
|
||
|
|
usage: {
|
||
|
|
input_tokens: Number(data?.usage?.input_tokens || 0),
|
||
|
|
output_tokens: Number(data?.usage?.output_tokens || 0),
|
||
|
|
},
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function getReadableStream(res: Response): AsyncIterable<Uint8Array> {
|
||
|
|
const body = res.body
|
||
|
|
if (!body) throw new Error('Provider returned an empty stream')
|
||
|
|
return body as any
|
||
|
|
}
|
||
|
|
|
||
|
|
function parseOpenAiSse(buffer: string): { events: string[]; rest: string } {
|
||
|
|
const events: string[] = []
|
||
|
|
let cursor = 0
|
||
|
|
while (true) {
|
||
|
|
const index = buffer.indexOf('\n\n', cursor)
|
||
|
|
if (index < 0) break
|
||
|
|
events.push(buffer.slice(cursor, index))
|
||
|
|
cursor = index + 2
|
||
|
|
}
|
||
|
|
return { events, rest: buffer.slice(cursor) }
|
||
|
|
}
|
||
|
|
|
||
|
|
function extractSseData(event: string): string[] {
|
||
|
|
return event
|
||
|
|
.split(/\r?\n/)
|
||
|
|
.filter(line => line.startsWith('data:'))
|
||
|
|
.map(line => line.slice(5).trimStart())
|
||
|
|
}
|
||
|
|
|
||
|
|
function openAiFinishToAnthropic(finishReason: string | null | undefined, sawTool: boolean): string {
|
||
|
|
return mapStopReason(finishReason, sawTool)
|
||
|
|
}
|
||
|
|
|
||
|
|
async function openAiChatToAnthropicSseStream(target: ClaudeCodeProxyTarget, body: any): Promise<Readable> {
|
||
|
|
if (target.apiMode !== 'chat_completions') {
|
||
|
|
const err = new Error(`Claude proxy MVP only supports chat_completions targets, got ${target.apiMode}`)
|
||
|
|
;(err as any).status = 501
|
||
|
|
throw err
|
||
|
|
}
|
||
|
|
|
||
|
|
const res = await fetch(`${target.baseUrl}/chat/completions`, {
|
||
|
|
method: 'POST',
|
||
|
|
headers: {
|
||
|
|
Authorization: `Bearer ${target.apiKey}`,
|
||
|
|
'Content-Type': 'application/json',
|
||
|
|
},
|
||
|
|
body: JSON.stringify(anthropicToOpenAiChat(body, target, true)),
|
||
|
|
})
|
||
|
|
if (!res.ok) {
|
||
|
|
let data: any
|
||
|
|
const text = await res.text()
|
||
|
|
try {
|
||
|
|
data = JSON.parse(text)
|
||
|
|
} catch {
|
||
|
|
data = { error: { message: text || `Provider returned HTTP ${res.status}` } }
|
||
|
|
}
|
||
|
|
const err = new Error(data?.error?.message || `Provider returned HTTP ${res.status}`)
|
||
|
|
;(err as any).status = res.status
|
||
|
|
;(err as any).providerError = data
|
||
|
|
throw err
|
||
|
|
}
|
||
|
|
|
||
|
|
const stream = getReadableStream(res)
|
||
|
|
const decoder = new TextDecoder()
|
||
|
|
|
||
|
|
async function* generate() {
|
||
|
|
const messageId = `msg_${Date.now()}`
|
||
|
|
let buffer = ''
|
||
|
|
let thinkingBlockIndex: number | null = null
|
||
|
|
let thinkingBlockStopped = false
|
||
|
|
let textBlockStarted = false
|
||
|
|
let textBlockStopped = false
|
||
|
|
let textBlockIndex: number | null = null
|
||
|
|
let nextIndex = 0
|
||
|
|
let stopReason: string | null = null
|
||
|
|
let outputTokens = 0
|
||
|
|
const toolBlocks = new Map<number, { blockIndex: number; id: string; name: string; started: boolean }>()
|
||
|
|
|
||
|
|
yield sseEvent('message_start', {
|
||
|
|
type: 'message_start',
|
||
|
|
message: {
|
||
|
|
id: messageId,
|
||
|
|
type: 'message',
|
||
|
|
role: 'assistant',
|
||
|
|
model: target.model,
|
||
|
|
content: [],
|
||
|
|
stop_reason: null,
|
||
|
|
stop_sequence: null,
|
||
|
|
usage: { input_tokens: 0, output_tokens: 0 },
|
||
|
|
},
|
||
|
|
})
|
||
|
|
|
||
|
|
const ensureThinkingBlock = function* () {
|
||
|
|
if (thinkingBlockIndex == null) {
|
||
|
|
thinkingBlockIndex = nextIndex++
|
||
|
|
yield sseEvent('content_block_start', {
|
||
|
|
type: 'content_block_start',
|
||
|
|
index: thinkingBlockIndex,
|
||
|
|
content_block: { type: 'thinking', thinking: '' },
|
||
|
|
})
|
||
|
|
}
|
||
|
|
return thinkingBlockIndex
|
||
|
|
}
|
||
|
|
|
||
|
|
const stopThinkingBlock = function* () {
|
||
|
|
if (thinkingBlockIndex != null && !thinkingBlockStopped) {
|
||
|
|
thinkingBlockStopped = true
|
||
|
|
yield sseEvent('content_block_stop', { type: 'content_block_stop', index: thinkingBlockIndex })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
const ensureTextBlock = function* () {
|
||
|
|
if (!textBlockStarted) {
|
||
|
|
textBlockStarted = true
|
||
|
|
textBlockIndex = nextIndex
|
||
|
|
yield sseEvent('content_block_start', {
|
||
|
|
type: 'content_block_start',
|
||
|
|
index: textBlockIndex,
|
||
|
|
content_block: { type: 'text', text: '' },
|
||
|
|
})
|
||
|
|
nextIndex += 1
|
||
|
|
}
|
||
|
|
return textBlockIndex ?? 0
|
||
|
|
}
|
||
|
|
|
||
|
|
const ensureToolBlock = function* (toolIndex: number, id?: string, name?: string) {
|
||
|
|
let block = toolBlocks.get(toolIndex)
|
||
|
|
if (!block) {
|
||
|
|
block = {
|
||
|
|
blockIndex: nextIndex++,
|
||
|
|
id: id || `toolu_${toolIndex}`,
|
||
|
|
name: name || 'tool',
|
||
|
|
started: false,
|
||
|
|
}
|
||
|
|
toolBlocks.set(toolIndex, block)
|
||
|
|
} else {
|
||
|
|
if (id) block.id = id
|
||
|
|
if (name) block.name = name
|
||
|
|
}
|
||
|
|
if (!block.started && block.name) {
|
||
|
|
block.started = true
|
||
|
|
yield sseEvent('content_block_start', {
|
||
|
|
type: 'content_block_start',
|
||
|
|
index: block.blockIndex,
|
||
|
|
content_block: { type: 'tool_use', id: block.id, name: block.name, input: {} },
|
||
|
|
})
|
||
|
|
}
|
||
|
|
return block
|
||
|
|
}
|
||
|
|
|
||
|
|
for await (const chunk of stream) {
|
||
|
|
buffer += decoder.decode(chunk, { stream: true })
|
||
|
|
const parsed = parseOpenAiSse(buffer)
|
||
|
|
buffer = parsed.rest
|
||
|
|
|
||
|
|
for (const event of parsed.events) {
|
||
|
|
for (const dataLine of extractSseData(event)) {
|
||
|
|
if (!dataLine || dataLine === '[DONE]') continue
|
||
|
|
const data = safeJsonParse(dataLine)
|
||
|
|
const choice = data?.choices?.[0]
|
||
|
|
if (!choice) continue
|
||
|
|
|
||
|
|
const delta = choice.delta || {}
|
||
|
|
if (shouldPreserveReasoningContent(target) && typeof delta.reasoning_content === 'string' && delta.reasoning_content) {
|
||
|
|
const index = yield* ensureThinkingBlock()
|
||
|
|
yield sseEvent('content_block_delta', {
|
||
|
|
type: 'content_block_delta',
|
||
|
|
index,
|
||
|
|
delta: { type: 'thinking_delta', thinking: delta.reasoning_content },
|
||
|
|
})
|
||
|
|
}
|
||
|
|
|
||
|
|
if (typeof delta.content === 'string' && delta.content) {
|
||
|
|
yield* stopThinkingBlock()
|
||
|
|
const index = yield* ensureTextBlock()
|
||
|
|
yield sseEvent('content_block_delta', {
|
||
|
|
type: 'content_block_delta',
|
||
|
|
index,
|
||
|
|
delta: { type: 'text_delta', text: delta.content },
|
||
|
|
})
|
||
|
|
}
|
||
|
|
|
||
|
|
for (const toolCall of Array.isArray(delta.tool_calls) ? delta.tool_calls : []) {
|
||
|
|
yield* stopThinkingBlock()
|
||
|
|
if (textBlockStarted && !textBlockStopped) {
|
||
|
|
textBlockStopped = true
|
||
|
|
yield sseEvent('content_block_stop', { type: 'content_block_stop', index: textBlockIndex ?? 0 })
|
||
|
|
}
|
||
|
|
const toolIndex = Number(toolCall.index || 0)
|
||
|
|
const block = yield* ensureToolBlock(
|
||
|
|
toolIndex,
|
||
|
|
toolCall.id ? String(toolCall.id) : undefined,
|
||
|
|
toolCall.function?.name ? String(toolCall.function.name) : undefined,
|
||
|
|
)
|
||
|
|
const argsDelta = toolCall.function?.arguments
|
||
|
|
if (typeof argsDelta === 'string' && argsDelta) {
|
||
|
|
yield sseEvent('content_block_delta', {
|
||
|
|
type: 'content_block_delta',
|
||
|
|
index: block.blockIndex,
|
||
|
|
delta: { type: 'input_json_delta', partial_json: argsDelta },
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (choice.finish_reason) stopReason = String(choice.finish_reason)
|
||
|
|
if (data?.usage?.completion_tokens) outputTokens = Number(data.usage.completion_tokens)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
yield* stopThinkingBlock()
|
||
|
|
if (textBlockStarted && !textBlockStopped) {
|
||
|
|
yield sseEvent('content_block_stop', { type: 'content_block_stop', index: textBlockIndex ?? 0 })
|
||
|
|
}
|
||
|
|
for (const block of toolBlocks.values()) {
|
||
|
|
if (block.started) {
|
||
|
|
yield sseEvent('content_block_stop', { type: 'content_block_stop', index: block.blockIndex })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
yield sseEvent('message_delta', {
|
||
|
|
type: 'message_delta',
|
||
|
|
delta: { stop_reason: openAiFinishToAnthropic(stopReason, toolBlocks.size > 0), stop_sequence: null },
|
||
|
|
usage: { output_tokens: outputTokens },
|
||
|
|
})
|
||
|
|
yield sseEvent('message_stop', { type: 'message_stop' })
|
||
|
|
}
|
||
|
|
|
||
|
|
return Readable.from(generate())
|
||
|
|
}
|
||
|
|
|
||
|
|
async function anthropicMessagesSseStream(target: ClaudeCodeProxyTarget, body: any): Promise<Readable> {
|
||
|
|
if (target.apiMode !== 'anthropic_messages') {
|
||
|
|
const err = new Error(`Claude proxy Anthropic adapter only supports anthropic_messages targets, got ${target.apiMode}`)
|
||
|
|
;(err as any).status = 501
|
||
|
|
throw err
|
||
|
|
}
|
||
|
|
|
||
|
|
const res = await fetch(anthropicMessagesUrl(target), {
|
||
|
|
method: 'POST',
|
||
|
|
headers: {
|
||
|
|
Authorization: `Bearer ${target.apiKey}`,
|
||
|
|
'x-api-key': target.apiKey,
|
||
|
|
'anthropic-version': '2023-06-01',
|
||
|
|
'Content-Type': 'application/json',
|
||
|
|
},
|
||
|
|
body: JSON.stringify(anthropicRequestBody(body, target)),
|
||
|
|
})
|
||
|
|
if (!res.ok) {
|
||
|
|
const data = await readProviderJson(res)
|
||
|
|
throwProviderError(res, data)
|
||
|
|
}
|
||
|
|
return Readable.from(getReadableStream(res))
|
||
|
|
}
|
||
|
|
|
||
|
|
async function openAiResponsesToAnthropicSseStream(target: ClaudeCodeProxyTarget, body: any): Promise<Readable> {
|
||
|
|
if (target.apiMode !== 'codex_responses') {
|
||
|
|
const err = new Error(`Claude proxy responses adapter only supports codex_responses targets, got ${target.apiMode}`)
|
||
|
|
;(err as any).status = 501
|
||
|
|
throw err
|
||
|
|
}
|
||
|
|
|
||
|
|
const res = await fetch(`${target.baseUrl}/responses`, {
|
||
|
|
method: 'POST',
|
||
|
|
headers: {
|
||
|
|
Authorization: `Bearer ${target.apiKey}`,
|
||
|
|
'Content-Type': 'application/json',
|
||
|
|
},
|
||
|
|
body: JSON.stringify(anthropicToOpenAiResponses(body, target, true)),
|
||
|
|
})
|
||
|
|
if (!res.ok) {
|
||
|
|
let data: any
|
||
|
|
const text = await res.text()
|
||
|
|
try {
|
||
|
|
data = JSON.parse(text)
|
||
|
|
} catch {
|
||
|
|
data = { error: { message: text || `Provider returned HTTP ${res.status}` } }
|
||
|
|
}
|
||
|
|
const err = new Error(data?.error?.message || `Provider returned HTTP ${res.status}`)
|
||
|
|
;(err as any).status = res.status
|
||
|
|
;(err as any).providerError = data
|
||
|
|
throw err
|
||
|
|
}
|
||
|
|
|
||
|
|
const stream = getReadableStream(res)
|
||
|
|
const decoder = new TextDecoder()
|
||
|
|
|
||
|
|
async function* generate() {
|
||
|
|
let messageId = `msg_${Date.now()}`
|
||
|
|
let buffer = ''
|
||
|
|
let textBlockIndex: number | null = null
|
||
|
|
let textBlockStopped = false
|
||
|
|
let nextIndex = 0
|
||
|
|
let stopReason: string | null = null
|
||
|
|
let outputTokens = 0
|
||
|
|
const toolBlocks = new Map<string, { blockIndex: number; id: string; name: string; argsDeltaSeen: boolean; stopped: boolean }>()
|
||
|
|
|
||
|
|
yield sseEvent('message_start', {
|
||
|
|
type: 'message_start',
|
||
|
|
message: {
|
||
|
|
id: messageId,
|
||
|
|
type: 'message',
|
||
|
|
role: 'assistant',
|
||
|
|
model: target.model,
|
||
|
|
content: [],
|
||
|
|
stop_reason: null,
|
||
|
|
stop_sequence: null,
|
||
|
|
usage: { input_tokens: 0, output_tokens: 0 },
|
||
|
|
},
|
||
|
|
})
|
||
|
|
|
||
|
|
const ensureTextBlock = function* () {
|
||
|
|
if (textBlockIndex == null) {
|
||
|
|
textBlockIndex = nextIndex++
|
||
|
|
yield sseEvent('content_block_start', {
|
||
|
|
type: 'content_block_start',
|
||
|
|
index: textBlockIndex,
|
||
|
|
content_block: { type: 'text', text: '' },
|
||
|
|
})
|
||
|
|
}
|
||
|
|
return textBlockIndex
|
||
|
|
}
|
||
|
|
|
||
|
|
const ensureToolBlock = function* (key: string, id?: string, name?: string) {
|
||
|
|
let block = toolBlocks.get(key)
|
||
|
|
if (!block) {
|
||
|
|
block = {
|
||
|
|
blockIndex: nextIndex++,
|
||
|
|
id: id || key || `toolu_${toolBlocks.size}`,
|
||
|
|
name: name || 'tool',
|
||
|
|
argsDeltaSeen: false,
|
||
|
|
stopped: false,
|
||
|
|
}
|
||
|
|
toolBlocks.set(key, block)
|
||
|
|
yield sseEvent('content_block_start', {
|
||
|
|
type: 'content_block_start',
|
||
|
|
index: block.blockIndex,
|
||
|
|
content_block: { type: 'tool_use', id: block.id, name: block.name, input: {} },
|
||
|
|
})
|
||
|
|
} else {
|
||
|
|
if (id) block.id = id
|
||
|
|
if (name && block.name === 'tool') block.name = name
|
||
|
|
}
|
||
|
|
return block
|
||
|
|
}
|
||
|
|
|
||
|
|
for await (const chunk of stream) {
|
||
|
|
buffer += decoder.decode(chunk, { stream: true })
|
||
|
|
const parsed = parseOpenAiSse(buffer)
|
||
|
|
buffer = parsed.rest
|
||
|
|
|
||
|
|
for (const event of parsed.events) {
|
||
|
|
for (const dataLine of extractSseData(event)) {
|
||
|
|
if (!dataLine || dataLine === '[DONE]') continue
|
||
|
|
const data = safeJsonParse(dataLine)
|
||
|
|
const eventType = data?.type
|
||
|
|
|
||
|
|
if (eventType === 'response.created') {
|
||
|
|
messageId = String(data?.response?.id || messageId)
|
||
|
|
}
|
||
|
|
|
||
|
|
if (eventType === 'response.output_text.delta') {
|
||
|
|
const deltaText = String(data?.delta || data?.text || '')
|
||
|
|
if (deltaText) {
|
||
|
|
const index = yield* ensureTextBlock()
|
||
|
|
yield sseEvent('content_block_delta', {
|
||
|
|
type: 'content_block_delta',
|
||
|
|
index,
|
||
|
|
delta: { type: 'text_delta', text: deltaText },
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (eventType === 'response.output_text.done' && textBlockIndex != null && !textBlockStopped) {
|
||
|
|
textBlockStopped = true
|
||
|
|
yield sseEvent('content_block_stop', { type: 'content_block_stop', index: textBlockIndex })
|
||
|
|
}
|
||
|
|
|
||
|
|
if (eventType === 'response.output_item.added') {
|
||
|
|
const item = data?.item || data?.output_item
|
||
|
|
if (item?.type === 'function_call') {
|
||
|
|
const key = String(item.call_id || item.id || data.output_index || toolBlocks.size)
|
||
|
|
yield* ensureToolBlock(key, String(item.call_id || item.id || key), item.name ? String(item.name) : undefined)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (eventType === 'response.function_call_arguments.delta') {
|
||
|
|
const key = String(data.call_id || data.item_id || data.output_index || toolBlocks.size)
|
||
|
|
const block = yield* ensureToolBlock(key)
|
||
|
|
const argsDelta = String(data.delta || '')
|
||
|
|
if (argsDelta) {
|
||
|
|
block.argsDeltaSeen = true
|
||
|
|
yield sseEvent('content_block_delta', {
|
||
|
|
type: 'content_block_delta',
|
||
|
|
index: block.blockIndex,
|
||
|
|
delta: { type: 'input_json_delta', partial_json: argsDelta },
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (eventType === 'response.output_item.done') {
|
||
|
|
const item = data?.item || data?.output_item
|
||
|
|
if (item?.type === 'function_call') {
|
||
|
|
const key = String(item.call_id || item.id || data.output_index || toolBlocks.size)
|
||
|
|
const block = yield* ensureToolBlock(key, String(item.call_id || item.id || key), item.name ? String(item.name) : undefined)
|
||
|
|
const args = String(item.arguments || '')
|
||
|
|
if (args && !block.argsDeltaSeen) {
|
||
|
|
yield sseEvent('content_block_delta', {
|
||
|
|
type: 'content_block_delta',
|
||
|
|
index: block.blockIndex,
|
||
|
|
delta: { type: 'input_json_delta', partial_json: args },
|
||
|
|
})
|
||
|
|
}
|
||
|
|
if (!block.stopped) {
|
||
|
|
block.stopped = true
|
||
|
|
yield sseEvent('content_block_stop', { type: 'content_block_stop', index: block.blockIndex })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (eventType === 'response.completed') {
|
||
|
|
const response = data?.response || data
|
||
|
|
outputTokens = Number(response?.usage?.output_tokens || outputTokens)
|
||
|
|
stopReason = response?.status === 'incomplete' ? 'length' : 'stop'
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (textBlockIndex != null && !textBlockStopped) {
|
||
|
|
yield sseEvent('content_block_stop', { type: 'content_block_stop', index: textBlockIndex })
|
||
|
|
}
|
||
|
|
for (const block of toolBlocks.values()) {
|
||
|
|
if (!block.stopped) {
|
||
|
|
yield sseEvent('content_block_stop', { type: 'content_block_stop', index: block.blockIndex })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
yield sseEvent('message_delta', {
|
||
|
|
type: 'message_delta',
|
||
|
|
delta: { stop_reason: openAiFinishToAnthropic(stopReason, toolBlocks.size > 0), stop_sequence: null },
|
||
|
|
usage: { output_tokens: outputTokens },
|
||
|
|
})
|
||
|
|
yield sseEvent('message_stop', { type: 'message_stop' })
|
||
|
|
}
|
||
|
|
|
||
|
|
return Readable.from(generate())
|
||
|
|
}
|
||
|
|
|
||
|
|
export async function claudeProxyModels(ctx: Context) {
|
||
|
|
const target = requireTarget(ctx)
|
||
|
|
if (!target) return
|
||
|
|
const ids = [...new Set([...CLAUDE_PROXY_VISIBLE_MODELS, target.model])]
|
||
|
|
ctx.body = {
|
||
|
|
data: ids.map(id => ({
|
||
|
|
type: 'model',
|
||
|
|
id,
|
||
|
|
display_name: id,
|
||
|
|
created_at: '2026-01-01T00:00:00Z',
|
||
|
|
})),
|
||
|
|
has_more: false,
|
||
|
|
first_id: ids[0],
|
||
|
|
last_id: ids[ids.length - 1],
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
export async function claudeProxyMessages(ctx: Context) {
|
||
|
|
const target = requireTarget(ctx)
|
||
|
|
if (!target) return
|
||
|
|
try {
|
||
|
|
const requestBody = ctx.request.body || {}
|
||
|
|
if ((requestBody as any).stream === true) {
|
||
|
|
const stream = target.apiMode === 'anthropic_messages'
|
||
|
|
? await anthropicMessagesSseStream(target, requestBody)
|
||
|
|
: target.apiMode === 'codex_responses'
|
||
|
|
? await openAiResponsesToAnthropicSseStream(target, requestBody)
|
||
|
|
: await openAiChatToAnthropicSseStream(target, requestBody)
|
||
|
|
ctx.set('Content-Type', 'text/event-stream; charset=utf-8')
|
||
|
|
ctx.set('Cache-Control', 'no-cache')
|
||
|
|
ctx.body = stream
|
||
|
|
} else {
|
||
|
|
const message = target.apiMode === 'anthropic_messages'
|
||
|
|
? await callAnthropicMessages(target, requestBody)
|
||
|
|
: target.apiMode === 'codex_responses'
|
||
|
|
? openAiResponsesToAnthropicMessage(await callOpenAiResponses(target, requestBody), target)
|
||
|
|
: openAiToAnthropicMessage(await callOpenAiChat(target, requestBody), target)
|
||
|
|
ctx.body = message
|
||
|
|
}
|
||
|
|
} catch (err: any) {
|
||
|
|
ctx.status = err.status || 502
|
||
|
|
ctx.body = {
|
||
|
|
type: 'error',
|
||
|
|
error: {
|
||
|
|
type: 'api_error',
|
||
|
|
message: err?.message || 'Claude proxy request failed',
|
||
|
|
provider_error: err?.providerError,
|
||
|
|
},
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|