doer-agent 0.8.7 → 0.8.8

package/dist/agent-skill-rpc.js

@@ -75,6 +75,9 @@ function resolveCodexModel(settings) {
     if (providerKey === "zai") {
         return settings.codex.providerModels.zai || "glm-5.2";
     }
+    if (providerKey === "anthropic") {
+        return settings.codex.providerModels.anthropic || "claude-sonnet-4-6";
+    }
     return settings.codex.providerModels[providerKey] || settings.codex.providerModels.openai || "gpt-5.5";
 }
 async function generateSkillViaCodex(args) {

package/dist/codex-app-server-manager.js

@@ -16,10 +16,20 @@ function resolveCodexModel(settings) {
     if (providerKey === "zai") {
         return settings.codex.providerModels.zai || "glm-5.2";
     }
+    if (providerKey === "anthropic") {
+        return settings.codex.providerModels.anthropic || "claude-sonnet-4-6";
+    }
     return settings.codex.providerModels[providerKey] || settings.codex.providerModels.openai || "gpt-5.5";
 }
 function resolveCodexModelContextWindow(settings) {
-    return settings.codex.modelProvider === "zai" ? 258400 : null;
+    if (settings.codex.modelProvider === "zai") {
+        return 258400;
+    }
+    if (settings.codex.modelProvider === "anthropic") {
+        const model = resolveCodexModel(settings);
+        return model.startsWith("claude-haiku-") ? 200000 : 1000000;
+    }
+    return null;
 }
 function buildModelProviderConfigArgs(settings) {
     const provider = settings.codex.customProvider;
@@ -87,7 +97,9 @@ async function buildCodexAppServerArgs(args) {
 }
 async function resolveAppServerSettings(args) {
     const provider = args.settings.codex.customProvider;
-    if (args.settings.codex.modelProvider !== "zai" || provider?.id !== "zai") {
+    const providerId = args.settings.codex.modelProvider;
+    const gatewayProviderIds = new Set(["zai", "anthropic"]);
+    if (!providerId || provider?.id !== providerId || !gatewayProviderIds.has(providerId)) {
         return { settings: args.settings, proxy: null };
     }
     const proxy = await startCodexChatBridge({

package/dist/codex-chat-bridge.js

@@ -1,17 +1,40 @@
 import { randomUUID } from "node:crypto";
 import { createServer } from "node:http";
 const DEFAULT_CHAT_BASE_URL = "https://api.z.ai/api/coding/paas/v4";
+const DEFAULT_ANTHROPIC_BASE_URL = "https://api.anthropic.com/v1";
 const CHAT_BRIDGE_ENV_KEY = "DOER_CODEX_CHAT_BRIDGE_API_KEY";
+const ANTHROPIC_VERSION = "2023-06-01";
+const PROVIDER_ADAPTERS = {
+    anthropic: {
+        kind: "anthropic_messages",
+        defaultBaseUrl: DEFAULT_ANTHROPIC_BASE_URL,
+        upstreamAuthHeaders: (apiKey) => ({
+            "x-api-key": apiKey,
+            "anthropic-version": ANTHROPIC_VERSION,
+        }),
+    },
+    default: {
+        kind: "chat_completions",
+        defaultBaseUrl: DEFAULT_CHAT_BASE_URL,
+        upstreamAuthHeaders: (apiKey) => ({
+            authorization: `Bearer ${apiKey}`,
+        }),
+    },
+};
 function normalizeBaseUrl(value) {
     return value.replace(/\/+$/, "");
 }
+function resolveProviderAdapter(providerId) {
+    return PROVIDER_ADAPTERS[providerId?.trim().toLowerCase() || ""] ?? PROVIDER_ADAPTERS.default;
+}
 function resolveTargetBaseUrl(args) {
     const providerId = args.providerId?.trim().toLowerCase();
     const baseUrl = args.targetBaseUrl?.trim();
     if (providerId === "zai" && (!baseUrl || !baseUrl.includes("/coding/paas/"))) {
         return DEFAULT_CHAT_BASE_URL;
     }
-    return normalizeBaseUrl(baseUrl || DEFAULT_CHAT_BASE_URL);
+    const adapter = resolveProviderAdapter(providerId);
+    return normalizeBaseUrl(baseUrl || adapter.defaultBaseUrl);
 }
 function stringValue(value) {
     return typeof value === "string" && value.trim() ? value.trim() : null;
@@ -67,6 +90,15 @@ function contentToText(value) {
         .filter(Boolean)
         .join("\n");
 }
+function parseJsonObject(value) {
+    try {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
 function responsePartToChatPart(part) {
     if (typeof part === "string") {
         return part ? { type: "text", text: part } : null;
@@ -368,6 +400,160 @@ function buildChatRequest(body, stream, onLog) {
         ...(tools.length > 0 ? { tools } : {}),
     };
 }
+function anthropicContentPartFromChatPart(part) {
+    const type = stringValue(part.type);
+    if (type === "text") {
+        const text = textValue(part.text);
+        return text ? { type: "text", text } : null;
+    }
+    if (type === "image_url") {
+        const rawImageUrl = recordValue(part.image_url);
+        const imageUrl = textValue(part.image_url) ?? textValue(rawImageUrl?.url);
+        const dataUrlMatch = imageUrl?.match(/^data:([^;,]+);base64,(.+)$/);
+        if (!dataUrlMatch) {
+            return null;
+        }
+        return {
+            type: "image",
+            source: {
+                type: "base64",
+                media_type: dataUrlMatch[1],
+                data: dataUrlMatch[2],
+            },
+        };
+    }
+    return null;
+}
+function anthropicContentFromChatContent(content) {
+    if (typeof content === "string") {
+        return content;
+    }
+    if (!Array.isArray(content)) {
+        return "";
+    }
+    const parts = content
+        .map((part) => recordValue(part))
+        .filter((part) => Boolean(part))
+        .map(anthropicContentPartFromChatPart)
+        .filter((part) => Boolean(part));
+    return parts.length > 0 ? parts : "";
+}
+function anthropicMessagesFromChatMessages(messages) {
+    const systemParts = [];
+    const anthropicMessages = [];
+    for (const message of messages) {
+        const role = stringValue(message.role);
+        if (role === "system" || role === "developer") {
+            const text = contentToText(message.content);
+            if (text) {
+                systemParts.push(text);
+            }
+            continue;
+        }
+        if (role === "tool") {
+            const toolUseId = stringValue(message.tool_call_id);
+            if (!toolUseId) {
+                continue;
+            }
+            anthropicMessages.push({
+                role: "user",
+                content: [{
+                        type: "tool_result",
+                        tool_use_id: toolUseId,
+                        content: contentToText(message.content),
+                    }],
+            });
+            continue;
+        }
+        if (role === "assistant") {
+            const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : [];
+            if (toolCalls.length > 0) {
+                const content = toolCalls
+                    .map((toolCall) => {
+                    const toolCallRecord = recordValue(toolCall);
+                    const fn = recordValue(toolCallRecord?.function);
+                    const name = stringValue(fn?.name);
+                    if (!toolCallRecord || !fn || !name) {
+                        return null;
+                    }
+                    return {
+                        type: "tool_use",
+                        id: stringValue(toolCallRecord.id) ?? `call_${randomUUID().replace(/-/g, "")}`,
+                        name,
+                        input: parseJsonObject(typeof fn.arguments === "string" ? fn.arguments : ""),
+                    };
+                })
+                    .filter((item) => item !== null);
+                if (content.length > 0) {
+                    anthropicMessages.push({ role: "assistant", content });
+                }
+                continue;
+            }
+            anthropicMessages.push({ role: "assistant", content: anthropicContentFromChatContent(message.content) });
+            continue;
+        }
+        anthropicMessages.push({ role: "user", content: anthropicContentFromChatContent(message.content) });
+    }
+    return {
+        system: systemParts.length > 0 ? systemParts.join("\n\n") : null,
+        messages: anthropicMessages,
+    };
+}
+function anthropicToolsFromChatTools(tools) {
+    if (!Array.isArray(tools)) {
+        return [];
+    }
+    const converted = tools
+        .map((tool) => {
+        const record = recordValue(tool);
+        const fn = recordValue(record?.function);
+        const name = stringValue(fn?.name);
+        if (!fn || !name) {
+            return null;
+        }
+        return {
+            name,
+            description: stringValue(fn?.description) ?? "",
+            input_schema: schemaValue(fn?.parameters),
+        };
+    });
+    return converted.filter((tool) => tool !== null);
+}
+function anthropicToolChoiceFromChatToolChoice(value) {
+    const text = stringValue(value);
+    if (text === "auto") {
+        return { type: "auto" };
+    }
+    if (text === "required") {
+        return { type: "any" };
+    }
+    if (text === "none") {
+        return undefined;
+    }
+    const record = recordValue(value);
+    const fn = recordValue(record?.function);
+    const name = stringValue(fn?.name);
+    return name ? { type: "tool", name } : undefined;
+}
+function buildAnthropicRequest(body, stream, onLog) {
+    const chatRequest = buildChatRequest(body, stream, onLog);
+    const chatMessages = Array.isArray(chatRequest.messages) ? chatRequest.messages : [];
+    const converted = anthropicMessagesFromChatMessages(chatMessages);
+    const tools = anthropicToolsFromChatTools(chatRequest.tools);
+    const toolChoice = anthropicToolChoiceFromChatToolChoice(chatRequest.tool_choice);
+    return {
+        model: stringValue(chatRequest.model) ?? "claude-sonnet-4-6",
+        messages: converted.messages,
+        stream,
+        max_tokens: finiteNumber(chatRequest.max_tokens) ?? 4096,
+        ...(converted.system ? { system: converted.system } : {}),
+        ...(typeof chatRequest.temperature === "number" ? { temperature: chatRequest.temperature } : {}),
+        ...(typeof chatRequest.top_p === "number" ? { top_p: chatRequest.top_p } : {}),
+        ...(typeof chatRequest.stop === "string" || Array.isArray(chatRequest.stop) ? { stop_sequences: chatRequest.stop } : {}),
+        ...(tools.length > 0 ? { tools } : {}),
+        ...(toolChoice ? { tool_choice: toolChoice } : {}),
+    };
+}
 function upstreamErrorMessage(value) {
     const body = recordValue(value);
     const error = recordValue(body?.error);
@@ -472,6 +658,89 @@ function chatMessageToResponseOutput(message) {
             content: [{ type: "output_text", text: contentToText(message.content), annotations: [] }],
         }];
 }
+function anthropicUsageToResponseUsage(value) {
+    const usage = recordValue(value);
+    if (!usage) {
+        return null;
+    }
+    const inputTokens = finiteNumber(usage.input_tokens) ?? 0;
+    const outputTokens = finiteNumber(usage.output_tokens) ?? 0;
+    return {
+        input_tokens: inputTokens,
+        output_tokens: outputTokens,
+        total_tokens: inputTokens + outputTokens,
+    };
+}
+function anthropicContentToResponseOutput(content) {
+    const blocks = Array.isArray(content) ? content : [];
+    const output = [];
+    const text = blocks
+        .map((block) => {
+        const record = recordValue(block);
+        return stringValue(record?.type) === "text" ? textValue(record?.text) ?? "" : "";
+    })
+        .filter(Boolean)
+        .join("");
+    if (text) {
+        output.push({
+            id: `msg_${randomUUID().replace(/-/g, "")}`,
+            type: "message",
+            status: "completed",
+            role: "assistant",
+            content: [{ type: "output_text", text, annotations: [] }],
+        });
+    }
+    for (const block of blocks) {
+        const record = recordValue(block);
+        if (stringValue(record?.type) !== "tool_use") {
+            continue;
+        }
+        const name = stringValue(record?.name);
+        if (!name) {
+            continue;
+        }
+        const responseName = responsesFunctionCallNameFromChatName(name);
+        output.push({
+            type: "function_call",
+            id: stringValue(record?.id) ?? `fc_${randomUUID().replace(/-/g, "")}`,
+            call_id: stringValue(record?.id) ?? `call_${randomUUID().replace(/-/g, "")}`,
+            ...responseName,
+            arguments: JSON.stringify(record?.input ?? {}),
+            status: "completed",
+        });
+    }
+    return output;
+}
+async function forwardAnthropicNonStreaming(args) {
+    const anthropicRequest = buildAnthropicRequest(args.body, false, args.onLog);
+    const responseMetadata = responseMetadataFromBody(args.body);
+    const upstream = await fetch(`${normalizeBaseUrl(args.targetBaseUrl)}/messages`, {
+        method: "POST",
+        headers: {
+            ...args.upstreamHeaders,
+            "content-type": "application/json",
+        },
+        signal: args.signal,
+        body: JSON.stringify(anthropicRequest),
+    });
+    const upstreamBody = await upstream.json().catch(async () => ({ error: { message: await upstream.text() } }));
+    if (!upstream.ok) {
+        args.res.writeHead(upstream.status, { "content-type": "application/json" });
+        args.res.end(JSON.stringify({
+            error: {
+                message: upstreamErrorMessage(upstreamBody),
+                type: "server_error",
+                status: upstream.status,
+                upstream: recordValue(upstreamBody.error) ?? upstreamBody,
+            },
+        }));
+        return;
+    }
+    const responseId = `resp_${randomUUID().replace(/-/g, "")}`;
+    const usage = anthropicUsageToResponseUsage(upstreamBody.usage);
+    args.res.writeHead(200, { "content-type": "application/json" });
+    args.res.end(JSON.stringify(responseBase(responseId, stringValue(anthropicRequest.model) ?? "claude-sonnet-4-6", anthropicContentToResponseOutput(upstreamBody.content), responseMetadata, usage)));
+}
 async function forwardNonStreaming(args) {
     const chatRequest = buildChatRequest(args.body, false, args.onLog);
     const responseMetadata = responseMetadataFromBody(args.body);
@@ -799,6 +1068,304 @@ async function forwardStreaming(args) {
     writeSse(args.res, "response.completed", { type: "response.completed", response: responseBase(responseId, model, outputItems, responseMetadata, streamUsage) });
     args.res.end();
 }
+async function forwardAnthropicStreaming(args) {
+    const anthropicRequest = buildAnthropicRequest(args.body, true, args.onLog);
+    const model = stringValue(anthropicRequest.model) ?? "claude-sonnet-4-6";
+    const responseMetadata = responseMetadataFromBody(args.body);
+    const responseId = `resp_${randomUUID().replace(/-/g, "")}`;
+    const outputItems = [];
+    const blocks = new Map();
+    let streamUsage = null;
+    args.res.writeHead(200, {
+        "content-type": "text/event-stream; charset=utf-8",
+        "cache-control": "no-cache",
+        connection: "keep-alive",
+    });
+    writeSse(args.res, "response.created", { type: "response.created", response: responseBase(responseId, model, [], responseMetadata) });
+    writeSse(args.res, "response.in_progress", { type: "response.in_progress", response: responseBase(responseId, model, [], responseMetadata, null, "in_progress") });
+    const upstream = await fetch(`${normalizeBaseUrl(args.targetBaseUrl)}/messages`, {
+        method: "POST",
+        headers: {
+            ...args.upstreamHeaders,
+            "content-type": "application/json",
+        },
+        signal: args.signal,
+        body: JSON.stringify(anthropicRequest),
+    });
+    if (!upstream.ok || !upstream.body) {
+        const errorText = await upstream.text();
+        writeFailedSse({
+            errorMessage: `Anthropic Messages upstream failed: ${upstream.status} ${errorText}`,
+            model,
+            res: args.res,
+            responseId,
+            responseMetadata,
+        });
+        args.res.end();
+        return;
+    }
+    const reader = upstream.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let upstreamDone = false;
+    let streamFailed = false;
+    let currentEvent = "";
+    const processAnthropicEvent = (event, data) => {
+        if (!data) {
+            return false;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(data);
+        }
+        catch (error) {
+            writeFailedSse({
+                errorMessage: `Failed to parse Anthropic stream chunk: ${error instanceof Error ? error.message : String(error)}`,
+                model,
+                res: args.res,
+                responseId,
+                responseMetadata,
+            });
+            args.res.end();
+            streamFailed = true;
+            upstreamDone = true;
+            return true;
+        }
+        const type = stringValue(parsed.type) ?? event;
+        if (type === "error") {
+            writeFailedSse({
+                errorMessage: upstreamErrorMessage(parsed),
+                model,
+                res: args.res,
+                responseId,
+                responseMetadata,
+            });
+            args.res.end();
+            streamFailed = true;
+            upstreamDone = true;
+            return true;
+        }
+        if (type === "message_start") {
+            const usage = anthropicUsageToResponseUsage(recordValue(parsed.message)?.usage);
+            if (usage) {
+                streamUsage = usage;
+            }
+            return false;
+        }
+        if (type === "message_delta") {
+            const usage = anthropicUsageToResponseUsage(parsed.usage);
+            if (usage) {
+                streamUsage = {
+                    input_tokens: streamUsage?.input_tokens ?? usage.input_tokens,
+                    output_tokens: usage.output_tokens,
+                    total_tokens: (streamUsage?.input_tokens ?? usage.input_tokens) + usage.output_tokens,
+                };
+            }
+            return false;
+        }
+        if (type === "content_block_start") {
+            const index = finiteNumber(parsed.index) ?? blocks.size;
+            const block = recordValue(parsed.content_block);
+            const blockType = stringValue(block?.type);
+            if (blockType === "text") {
+                const itemId = `msg_${randomUUID().replace(/-/g, "")}`;
+                blocks.set(index, {
+                    id: itemId,
+                    outputIndex: index,
+                    type: "text",
+                    text: "",
+                    toolId: "",
+                    toolName: "",
+                    toolInputJson: "",
+                    started: true,
+                });
+                writeSse(args.res, "response.output_item.added", {
+                    type: "response.output_item.added",
+                    output_index: index,
+                    item: { id: itemId, type: "message", status: "in_progress", role: "assistant", content: [] },
+                });
+                writeSse(args.res, "response.content_part.added", {
+                    type: "response.content_part.added",
+                    item_id: itemId,
+                    output_index: index,
+                    content_index: 0,
+                    part: { type: "output_text", text: "", annotations: [] },
+                });
+            }
+            else if (blockType === "tool_use") {
+                const toolId = stringValue(block?.id) ?? `call_${randomUUID().replace(/-/g, "")}`;
+                const toolName = stringValue(block?.name) ?? "";
+                const responseName = responsesFunctionCallNameFromChatName(toolName);
+                const itemId = `fc_${toolId.replace(/[^a-zA-Z0-9_-]/g, "")}`;
+                blocks.set(index, {
+                    id: itemId,
+                    outputIndex: index,
+                    type: "tool_use",
+                    text: "",
+                    toolId,
+                    toolName,
+                    toolInputJson: "",
+                    started: true,
+                });
+                writeSse(args.res, "response.output_item.added", {
+                    type: "response.output_item.added",
+                    output_index: index,
+                    item: {
+                        id: itemId,
+                        type: "function_call",
+                        status: "in_progress",
+                        call_id: toolId,
+                        ...responseName,
+                        arguments: "",
+                    },
+                });
+            }
+            return false;
+        }
+        if (type === "content_block_delta") {
+            const index = finiteNumber(parsed.index) ?? 0;
+            const block = blocks.get(index);
+            const delta = recordValue(parsed.delta);
+            if (!block || !delta) {
+                return false;
+            }
+            const deltaType = stringValue(delta.type);
+            if (block.type === "text" && deltaType === "text_delta") {
+                const chunk = textValue(delta.text) ?? "";
+                if (!chunk) {
+                    return false;
+                }
+                block.text += chunk;
+                writeSse(args.res, "response.output_text.delta", {
+                    type: "response.output_text.delta",
+                    item_id: block.id,
+                    output_index: block.outputIndex,
+                    content_index: 0,
+                    delta: chunk,
+                });
+            }
+            else if (block.type === "tool_use" && deltaType === "input_json_delta") {
+                const chunk = textValue(delta.partial_json) ?? "";
+                if (!chunk) {
+                    return false;
+                }
+                block.toolInputJson += chunk;
+                writeSse(args.res, "response.function_call_arguments.delta", {
+                    type: "response.function_call_arguments.delta",
+                    item_id: block.id,
+                    output_index: block.outputIndex,
+                    delta: chunk,
+                });
+            }
+            blocks.set(index, block);
+            return false;
+        }
+        if (type === "content_block_stop") {
+            const index = finiteNumber(parsed.index) ?? 0;
+            const block = blocks.get(index);
+            if (!block) {
+                return false;
+            }
+            if (block.type === "text") {
+                writeSse(args.res, "response.output_text.done", {
+                    type: "response.output_text.done",
+                    item_id: block.id,
+                    output_index: block.outputIndex,
+                    content_index: 0,
+                    text: block.text,
+                });
+                writeSse(args.res, "response.content_part.done", {
+                    type: "response.content_part.done",
+                    item_id: block.id,
+                    output_index: block.outputIndex,
+                    content_index: 0,
+                    part: { type: "output_text", text: block.text, annotations: [] },
+                });
+                const item = {
+                    id: block.id,
+                    type: "message",
+                    status: "completed",
+                    role: "assistant",
+                    content: [{ type: "output_text", text: block.text, annotations: [] }],
+                };
+                outputItems.push(item);
+                writeSse(args.res, "response.output_item.done", { type: "response.output_item.done", output_index: block.outputIndex, item });
+            }
+            else {
+                const responseName = responsesFunctionCallNameFromChatName(block.toolName);
+                const item = {
+                    id: block.id,
+                    type: "function_call",
+                    status: "completed",
+                    call_id: block.toolId,
+                    ...responseName,
+                    arguments: block.toolInputJson || "{}",
+                };
+                outputItems.push(item);
+                writeSse(args.res, "response.function_call_arguments.done", {
+                    type: "response.function_call_arguments.done",
+                    item_id: block.id,
+                    output_index: block.outputIndex,
+                    arguments: block.toolInputJson || "{}",
+                });
+                writeSse(args.res, "response.output_item.done", { type: "response.output_item.done", output_index: block.outputIndex, item });
+            }
+            return false;
+        }
+        if (type === "message_stop") {
+            upstreamDone = true;
+            return true;
+        }
+        return false;
+    };
+    try {
+        while (!upstreamDone) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split(/\r?\n/);
+            buffer = lines.pop() ?? "";
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed) {
+                    continue;
+                }
+                if (trimmed.startsWith("event:")) {
+                    currentEvent = trimmed.slice(6).trim();
+                    continue;
+                }
+                if (!trimmed.startsWith("data:")) {
+                    continue;
+                }
+                const data = trimmed.slice(5).trim();
+                if (processAnthropicEvent(currentEvent, data)) {
+                    await reader.cancel().catch(() => undefined);
+                    break;
+                }
+            }
+        }
+    }
+    catch (error) {
+        if (args.signal.aborted) {
+            return;
+        }
+        writeFailedSse({
+            errorMessage: `Anthropic Messages stream failed: ${error instanceof Error ? error.message : String(error)}`,
+            model,
+            res: args.res,
+            responseId,
+            responseMetadata,
+        });
+        args.res.end();
+        return;
+    }
+    if (streamFailed) {
+        return;
+    }
+    writeSse(args.res, "response.completed", { type: "response.completed", response: responseBase(responseId, model, outputItems, responseMetadata, streamUsage) });
+    args.res.end();
+}
 function requestAbortSignal(req, res) {
     const abortController = new AbortController();
     const abort = () => {
@@ -813,7 +1380,7 @@ function requestAbortSignal(req, res) {
 async function startResponsesBridge(args) {
     const targetBaseUrl = normalizeBaseUrl(args.targetBaseUrl);
     const expectedAuthorization = `Bearer ${args.localApiKey}`;
-    const upstreamAuthorization = `Bearer ${args.upstreamApiKey}`;
+    const upstreamHeaders = args.adapter.upstreamAuthHeaders(args.upstreamApiKey);
     const server = createServer(async (req, res) => {
         try {
             if (req.method !== "POST" || !req.url?.replace(/\?.*$/, "").endsWith("/responses")) {
@@ -829,11 +1396,33 @@ async function startResponsesBridge(args) {
             }
             const body = await readRequestJson(req);
             const signal = requestAbortSignal(req, res);
-            if (body.stream === true) {
-                await forwardStreaming({ body, res, signal, targetBaseUrl, upstreamAuthorization, onLog: args.onLog });
+            if (args.adapter.kind === "anthropic_messages") {
+                if (body.stream === true) {
+                    await forwardAnthropicStreaming({ body, res, signal, targetBaseUrl, upstreamHeaders, onLog: args.onLog });
+                }
+                else {
+                    await forwardAnthropicNonStreaming({ body, res, signal, targetBaseUrl, upstreamHeaders, onLog: args.onLog });
+                }
+            }
+            else if (body.stream === true) {
+                await forwardStreaming({
+                    body,
+                    res,
+                    signal,
+                    targetBaseUrl,
+                    upstreamAuthorization: upstreamHeaders.authorization ?? "",
+                    onLog: args.onLog,
+                });
             }
             else {
-                await forwardNonStreaming({ body, res, signal, targetBaseUrl, upstreamAuthorization, onLog: args.onLog });
+                await forwardNonStreaming({
+                    body,
+                    res,
+                    signal,
+                    targetBaseUrl,
+                    upstreamAuthorization: upstreamHeaders.authorization ?? "",
+                    onLog: args.onLog,
+                });
             }
         }
         catch (error) {
@@ -870,14 +1459,16 @@ export async function startCodexChatBridge(args) {
         throw new Error(`${providerName} API key is required to start the Codex chat bridge`);
     }
     const targetBaseUrl = resolveTargetBaseUrl({ providerId: args.providerId, targetBaseUrl: args.targetBaseUrl });
+    const adapter = resolveProviderAdapter(args.providerId);
     const apiKey = `sk-doer-chat-bridge-${randomUUID().replace(/-/g, "")}`;
     const bridge = await startResponsesBridge({
+        adapter,
         localApiKey: apiKey,
         targetBaseUrl,
         upstreamApiKey: providerApiKey,
         onLog: args.onLog,
     });
-    args.onLog?.(`Codex chat bridge listening baseUrl=${bridge.baseUrl} target=${targetBaseUrl} provider=${providerName}`);
+    args.onLog?.(`Codex provider gateway listening baseUrl=${bridge.baseUrl} target=${targetBaseUrl} provider=${providerName} adapter=${adapter.kind}`);
     return {
         baseUrl: bridge.baseUrl,
         envKey: CHAT_BRIDGE_ENV_KEY,

package/dist/codex-chat-bridge.test.js

@@ -2,7 +2,7 @@ import assert from "node:assert/strict";
 import { createServer } from "node:http";
 import { test } from "node:test";
 import { startCodexChatBridge } from "./codex-chat-bridge.js";
-async function startBridgeFixture(handler) {
+async function startBridgeFixture(handler, options) {
     const capturedBodies = [];
     const logs = [];
     const upstream = createServer(async (req, res) => {
@@ -20,7 +20,7 @@ async function startBridgeFixture(handler) {
     assert(address && typeof address !== "string");
     const bridge = await startCodexChatBridge({
         providerApiKey: "upstream-test-key",
-        providerId: "openai-compatible",
+        providerId: options?.providerId ?? "openai-compatible",
         providerName: "test upstream",
         targetBaseUrl: `http://127.0.0.1:${address.port}`,
         onLog: (message) => logs.push(message),
@@ -344,6 +344,142 @@ test("returns function_call output for non-streaming Chat tool calls", async ()
         await fixture.close();
     }
 });
+test("maps Responses create request fields to Anthropic Messages", async () => {
+    const fixture = await startBridgeFixture(({ req, res }) => {
+        assert.equal(req.url, "/messages");
+        assert.equal(req.headers["x-api-key"], "upstream-test-key");
+        assert.equal(req.headers["anthropic-version"], "2023-06-01");
+        writeChatJson(res, {
+            content: [
+                { type: "text", text: "claude mapped" },
+                { type: "tool_use", id: "toolu_123", name: "mcp__doer_daemon__daemon_list", input: { includeStopped: true } },
+            ],
+            usage: { input_tokens: 7, output_tokens: 3 },
+        });
+    }, { providerId: "anthropic" });
+    try {
+        const response = await responsesRequest({
+            bridge: fixture.bridge,
+            body: {
+                model: "claude-sonnet-4-6",
+                instructions: "system instruction",
+                input: [
+                    { role: "developer", content: [{ type: "input_text", text: "developer note" }] },
+                    {
+                        role: "user",
+                        content: [
+                            { type: "input_text", text: "look at this" },
+                            { type: "input_image", image_url: "data:image/png;base64,AA==", detail: "high" },
+                        ],
+                    },
+                    { type: "function_call", call_id: "call_123", name: "lookup", arguments: "{\"q\":\"doer\"}" },
+                    { type: "function_call_output", call_id: "call_123", output: "tool result" },
+                ],
+                tools: [{
+                        type: "namespace",
+                        name: "doer_daemon",
+                        tools: [{ name: "daemon_list", description: "List daemons", input_schema: { type: "object" } }],
+                    }],
+                tool_choice: "required",
+                max_output_tokens: 64,
+            },
+        });
+        assert.equal(response.status, 200);
+        const anthropic = fixture.capturedBodies[0];
+        assert.equal(anthropic.model, "claude-sonnet-4-6");
+        assert.equal(anthropic.stream, false);
+        assert.equal(anthropic.max_tokens, 64);
+        assert.equal(anthropic.system, "system instruction\n\ndeveloper note");
+        assert.deepEqual(anthropic.tool_choice, { type: "any" });
+        assert.deepEqual(anthropic.tools, [{
+                name: "mcp__doer_daemon__daemon_list",
+                description: "Namespace: mcp__doer_daemon__. Original tool: daemon_list. List daemons",
+                input_schema: { type: "object" },
+            }]);
+        assert.deepEqual(anthropic.messages, [
+            {
+                role: "user",
+                content: [
+                    { type: "text", text: "look at this" },
+                    { type: "image", source: { type: "base64", media_type: "image/png", data: "AA==" } },
+                ],
+            },
+            {
+                role: "assistant",
+                content: [{ type: "tool_use", id: "call_123", name: "lookup", input: { q: "doer" } }],
+            },
+            {
+                role: "user",
+                content: [{ type: "tool_result", tool_use_id: "call_123", content: "tool result" }],
+            },
+        ]);
+        const body = await response.json();
+        assert.deepEqual(body.usage, { input_tokens: 7, output_tokens: 3, total_tokens: 10 });
+        const output = body.output;
+        assert.equal(output[0]?.type, "message");
+        assert.deepEqual(output[1], {
+            type: "function_call",
+            id: "toolu_123",
+            call_id: "toolu_123",
+            namespace: "mcp__doer_daemon",
+            name: "daemon_list",
+            arguments: "{\"includeStopped\":true}",
+            status: "completed",
+        });
+    }
+    finally {
+        await fixture.close();
+    }
+});
+test("streams Anthropic Messages text and tool_use as Responses events", async () => {
+    const fixture = await startBridgeFixture(({ res }) => {
+        writeChatSse(res, [
+            { type: "message_start", message: { usage: { input_tokens: 5, output_tokens: 0 } } },
+            { type: "content_block_start", index: 0, content_block: { type: "text", text: "" } },
+            { type: "content_block_delta", index: 0, delta: { type: "text_delta", text: "hello" } },
+            { type: "content_block_stop", index: 0 },
+            { type: "content_block_start", index: 1, content_block: { type: "tool_use", id: "toolu_abc", name: "lookup", input: {} } },
+            { type: "content_block_delta", index: 1, delta: { type: "input_json_delta", partial_json: "{\"q\"" } },
+            { type: "content_block_delta", index: 1, delta: { type: "input_json_delta", partial_json: ":\"doer\"}" } },
+            { type: "content_block_stop", index: 1 },
+            { type: "message_delta", usage: { output_tokens: 4 } },
+            { type: "message_stop" },
+        ]);
+    }, { providerId: "anthropic" });
+    try {
+        const response = await responsesRequest({
+            bridge: fixture.bridge,
+            body: { model: "claude-sonnet-4-6", stream: true, input: "hello" },
+        });
+        const events = parseSse(await response.text());
+        assert.equal(response.status, 200);
+        assert.equal(fixture.capturedBodies[0]?.stream, true);
+        assert.equal(events.find((event) => event.event === "response.output_text.delta")?.data.delta, "hello");
+        assert.deepEqual(events.filter((event) => event.event === "response.function_call_arguments.delta").map((event) => event.data.delta), ["{\"q\"", ":\"doer\"}"]);
+        const completed = events.at(-1)?.data.response;
+        assert.deepEqual(completed.usage, { input_tokens: 5, output_tokens: 4, total_tokens: 9 });
+        assert.deepEqual(completed.output, [
+            {
+                id: completed.output[0]?.id,
+                type: "message",
+                status: "completed",
+                role: "assistant",
+                content: [{ type: "output_text", text: "hello", annotations: [] }],
+            },
+            {
+                id: "fc_toolu_abc",
+                type: "function_call",
+                status: "completed",
+                call_id: "toolu_abc",
+                name: "lookup",
+                arguments: "{\"q\":\"doer\"}",
+            },
+        ]);
+    }
+    finally {
+        await fixture.close();
+    }
+});
 test("normalizes upstream errors for non-streaming requests", async () => {
     const fixture = await startBridgeFixture(({ res }) => {
         writeChatJson(res, { error: { message: "bad upstream", code: "bad_request" } }, 400);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "doer-agent",
-  "version": "0.8.7",
+  "version": "0.8.8",
   "description": "Reverse-polling agent runtime for doer",
   "type": "module",
   "main": "dist/agent.js",