doer-agent 0.8.5 → 0.8.7

package/dist/litellm-responses-proxy.js

@@ -0,0 +1,685 @@
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { createServer } from "node:http";
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+const ZAI_CODING_BASE_URL = "https://api.z.ai/api/coding/paas/v4";
+const LITELLM_ENV_KEY = "LITELLM_API_KEY";
+function normalizeBaseUrl(value) {
+    return value.replace(/\/+$/, "");
+}
+function stringValue(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function yamlString(value) {
+    return JSON.stringify(value);
+}
+function readRequestJson(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on("data", (chunk) => chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)));
+        req.on("end", () => {
+            const raw = Buffer.concat(chunks).toString("utf8").trim();
+            if (!raw) {
+                resolve({});
+                return;
+            }
+            try {
+                const parsed = JSON.parse(raw);
+                resolve(parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {});
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+        req.on("error", reject);
+    });
+}
+function contentToText(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    if (!Array.isArray(value)) {
+        return "";
+    }
+    return value
+        .map((part) => {
+        if (typeof part === "string") {
+            return part;
+        }
+        if (!part || typeof part !== "object" || Array.isArray(part)) {
+            return "";
+        }
+        const record = part;
+        return stringValue(record.text) ?? stringValue(record.output_text) ?? "";
+    })
+        .filter(Boolean)
+        .join("\n");
+}
+function inputItemToMessages(item) {
+    if (!item || typeof item !== "object" || Array.isArray(item)) {
+        return [];
+    }
+    const record = item;
+    const type = stringValue(record.type);
+    const role = stringValue(record.role);
+    if (role === "user" || role === "assistant" || role === "system" || role === "developer") {
+        return [{
+                role: role === "developer" ? "system" : role,
+                content: contentToText(record.content),
+            }];
+    }
+    if (type === "message") {
+        const messageRole = stringValue(record.role) ?? "user";
+        return [{
+                role: messageRole === "developer" ? "system" : messageRole,
+                content: contentToText(record.content),
+            }];
+    }
+    if (type === "function_call") {
+        const name = stringValue(record.name);
+        const callId = stringValue(record.call_id) ?? stringValue(record.id) ?? `call_${randomUUID().replace(/-/g, "")}`;
+        if (!name) {
+            return [];
+        }
+        return [{
+                role: "assistant",
+                content: null,
+                tool_calls: [{
+                        id: callId,
+                        type: "function",
+                        function: {
+                            name,
+                            arguments: typeof record.arguments === "string" ? record.arguments : "",
+                        },
+                    }],
+            }];
+    }
+    if (type === "function_call_output") {
+        const callId = stringValue(record.call_id);
+        if (!callId) {
+            return [];
+        }
+        return [{
+                role: "tool",
+                tool_call_id: callId,
+                content: typeof record.output === "string" ? record.output : JSON.stringify(record.output ?? ""),
+            }];
+    }
+    return [];
+}
+function inputToMessages(input) {
+    if (typeof input === "string") {
+        return [{ role: "user", content: input }];
+    }
+    if (!Array.isArray(input)) {
+        return [];
+    }
+    return input.flatMap(inputItemToMessages);
+}
+function responsesToolToChatTool(tool) {
+    if (!tool || typeof tool !== "object" || Array.isArray(tool)) {
+        return null;
+    }
+    const record = tool;
+    const type = stringValue(record.type);
+    if (type !== "function") {
+        return null;
+    }
+    const name = stringValue(record.name);
+    if (!name) {
+        return null;
+    }
+    return {
+        type: "function",
+        function: {
+            name,
+            description: stringValue(record.description) ?? "",
+            parameters: record.parameters && typeof record.parameters === "object" ? record.parameters : { type: "object", properties: {} },
+        },
+    };
+}
+function buildChatRequest(body, stream) {
+    const messages = inputToMessages(body.input);
+    const instructions = stringValue(body.instructions);
+    if (instructions) {
+        messages.unshift({ role: "system", content: instructions });
+    }
+    const tools = Array.isArray(body.tools) ? body.tools.map(responsesToolToChatTool).filter(Boolean) : [];
+    return {
+        model: stringValue(body.model) ?? "glm-5.2",
+        messages,
+        stream,
+        ...(typeof body.temperature === "number" ? { temperature: body.temperature } : {}),
+        ...(typeof body.top_p === "number" ? { top_p: body.top_p } : {}),
+        ...(typeof body.max_output_tokens === "number" ? { max_tokens: body.max_output_tokens } : {}),
+        ...(tools.length > 0 ? { tools } : {}),
+    };
+}
+function writeSse(res, event, data) {
+    res.write(`event: ${event}\n`);
+    res.write(`data: ${JSON.stringify(data)}\n\n`);
+}
+function responseBase(responseId, model, output = []) {
+    return {
+        id: responseId,
+        object: "response",
+        created_at: Math.floor(Date.now() / 1000),
+        status: "completed",
+        error: null,
+        incomplete_details: null,
+        instructions: null,
+        max_output_tokens: null,
+        model,
+        output,
+        parallel_tool_calls: true,
+        previous_response_id: null,
+        reasoning: null,
+        store: false,
+        temperature: null,
+        text: { format: { type: "text" } },
+        tool_choice: "auto",
+        tools: [],
+        top_p: null,
+        truncation: "disabled",
+        usage: null,
+        user: null,
+        metadata: {},
+    };
+}
+function chatMessageToResponseOutput(message) {
+    const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : [];
+    if (toolCalls.length > 0) {
+        return toolCalls
+            .map((toolCall) => {
+            if (!toolCall || typeof toolCall !== "object" || Array.isArray(toolCall)) {
+                return null;
+            }
+            const record = toolCall;
+            const fn = record.function && typeof record.function === "object" && !Array.isArray(record.function)
+                ? record.function
+                : {};
+            const name = stringValue(fn.name);
+            if (!name) {
+                return null;
+            }
+            return {
+                type: "function_call",
+                id: stringValue(record.id) ?? `fc_${randomUUID().replace(/-/g, "")}`,
+                call_id: stringValue(record.id) ?? `call_${randomUUID().replace(/-/g, "")}`,
+                name,
+                arguments: typeof fn.arguments === "string" ? fn.arguments : "",
+                status: "completed",
+            };
+        })
+            .filter(Boolean);
+    }
+    return [{
+            id: `msg_${randomUUID().replace(/-/g, "")}`,
+            type: "message",
+            status: "completed",
+            role: "assistant",
+            content: [{ type: "output_text", text: contentToText(message.content), annotations: [] }],
+        }];
+}
+async function forwardNonStreaming(args) {
+    const chatRequest = buildChatRequest(args.body, false);
+    const upstream = await fetch(`${normalizeBaseUrl(args.targetBaseUrl)}/chat/completions`, {
+        method: "POST",
+        headers: {
+            authorization: args.authorization,
+            "content-type": "application/json",
+        },
+        body: JSON.stringify(chatRequest),
+    });
+    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(upstreamBody));
+        return;
+    }
+    const choices = Array.isArray(upstreamBody.choices) ? upstreamBody.choices : [];
+    const firstChoice = choices[0] && typeof choices[0] === "object" ? choices[0] : {};
+    const message = firstChoice.message && typeof firstChoice.message === "object" ? firstChoice.message : {};
+    if (!message.content && typeof message.reasoning_content === "string") {
+        message.content = message.reasoning_content;
+    }
+    const responseId = `resp_${randomUUID().replace(/-/g, "")}`;
+    args.res.writeHead(200, { "content-type": "application/json" });
+    args.res.end(JSON.stringify(responseBase(responseId, stringValue(chatRequest.model) ?? "glm-5.2", chatMessageToResponseOutput(message))));
+}
+function parseStreamingToolCalls(delta) {
+    const toolCalls = Array.isArray(delta.tool_calls) ? delta.tool_calls : [];
+    return toolCalls
+        .map((toolCall) => {
+        if (!toolCall || typeof toolCall !== "object" || Array.isArray(toolCall)) {
+            return null;
+        }
+        const record = toolCall;
+        const fn = record.function && typeof record.function === "object" && !Array.isArray(record.function)
+            ? record.function
+            : {};
+        const id = stringValue(record.id) ?? `call_${randomUUID().replace(/-/g, "")}`;
+        return {
+            id,
+            itemId: `fc_${id.replace(/[^a-zA-Z0-9_-]/g, "")}`,
+            name: stringValue(fn.name) ?? "",
+            arguments: typeof fn.arguments === "string" ? fn.arguments : "",
+            outputIndex: typeof record.index === "number" ? record.index : 0,
+            started: false,
+        };
+    })
+        .filter((item) => Boolean(item));
+}
+async function forwardStreaming(args) {
+    const chatRequest = buildChatRequest(args.body, true);
+    const model = stringValue(chatRequest.model) ?? "glm-5.2";
+    const responseId = `resp_${randomUUID().replace(/-/g, "")}`;
+    const messageId = `msg_${randomUUID().replace(/-/g, "")}`;
+    const outputItems = [];
+    let text = "";
+    let reasoningText = "";
+    let textStarted = false;
+    const tools = new Map();
+    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, []) });
+    writeSse(args.res, "response.in_progress", { type: "response.in_progress", response: { ...responseBase(responseId, model, []), status: "in_progress" } });
+    const upstream = await fetch(`${normalizeBaseUrl(args.targetBaseUrl)}/chat/completions`, {
+        method: "POST",
+        headers: {
+            authorization: args.authorization,
+            "content-type": "application/json",
+        },
+        body: JSON.stringify(chatRequest),
+    });
+    if (!upstream.ok || !upstream.body) {
+        const errorText = await upstream.text();
+        const message = `LiteLLM chat/completions failed: ${upstream.status} ${errorText}`;
+        writeSse(args.res, "response.failed", {
+            type: "response.failed",
+            response: { ...responseBase(responseId, model, []), status: "failed", error: { message, type: "server_error" } },
+        });
+        args.res.end();
+        return;
+    }
+    const reader = upstream.body.getReader();
+    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(/\r?\n/);
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed.startsWith("data:")) {
+                continue;
+            }
+            const data = trimmed.slice(5).trim();
+            if (!data || data === "[DONE]") {
+                continue;
+            }
+            const parsed = JSON.parse(data);
+            const choices = Array.isArray(parsed.choices) ? parsed.choices : [];
+            const firstChoice = choices[0] && typeof choices[0] === "object" ? choices[0] : {};
+            const delta = firstChoice.delta && typeof firstChoice.delta === "object" ? firstChoice.delta : {};
+            const reasoningChunk = stringValue(delta.reasoning_content) ?? "";
+            if (reasoningChunk) {
+                reasoningText += reasoningChunk;
+            }
+            const chunk = stringValue(delta.content) ?? "";
+            if (chunk) {
+                if (!textStarted) {
+                    textStarted = true;
+                    writeSse(args.res, "response.output_item.added", {
+                        type: "response.output_item.added",
+                        output_index: 0,
+                        item: { id: messageId, type: "message", status: "in_progress", role: "assistant", content: [] },
+                    });
+                    writeSse(args.res, "response.content_part.added", {
+                        type: "response.content_part.added",
+                        item_id: messageId,
+                        output_index: 0,
+                        content_index: 0,
+                        part: { type: "output_text", text: "", annotations: [] },
+                    });
+                }
+                text += chunk;
+                writeSse(args.res, "response.output_text.delta", {
+                    type: "response.output_text.delta",
+                    item_id: messageId,
+                    output_index: 0,
+                    content_index: 0,
+                    delta: chunk,
+                });
+            }
+            for (const partial of parseStreamingToolCalls(delta)) {
+                const existing = tools.get(partial.id) ?? partial;
+                existing.name = partial.name || existing.name;
+                existing.arguments += partial.arguments;
+                if (!existing.started && existing.name) {
+                    existing.started = true;
+                    const outputIndex = tools.size + (textStarted ? 1 : 0);
+                    existing.outputIndex = outputIndex;
+                    writeSse(args.res, "response.output_item.added", {
+                        type: "response.output_item.added",
+                        output_index: outputIndex,
+                        item: {
+                            id: existing.itemId,
+                            type: "function_call",
+                            status: "in_progress",
+                            call_id: existing.id,
+                            name: existing.name,
+                            arguments: "",
+                        },
+                    });
+                }
+                if (partial.arguments) {
+                    writeSse(args.res, "response.function_call_arguments.delta", {
+                        type: "response.function_call_arguments.delta",
+                        item_id: existing.itemId,
+                        output_index: existing.outputIndex,
+                        delta: partial.arguments,
+                    });
+                }
+                tools.set(partial.id, existing);
+            }
+        }
+    }
+    if (!textStarted && reasoningText) {
+        textStarted = true;
+        text = reasoningText;
+        writeSse(args.res, "response.output_item.added", {
+            type: "response.output_item.added",
+            output_index: 0,
+            item: { id: messageId, type: "message", status: "in_progress", role: "assistant", content: [] },
+        });
+        writeSse(args.res, "response.content_part.added", {
+            type: "response.content_part.added",
+            item_id: messageId,
+            output_index: 0,
+            content_index: 0,
+            part: { type: "output_text", text: "", annotations: [] },
+        });
+        writeSse(args.res, "response.output_text.delta", {
+            type: "response.output_text.delta",
+            item_id: messageId,
+            output_index: 0,
+            content_index: 0,
+            delta: text,
+        });
+    }
+    if (textStarted) {
+        writeSse(args.res, "response.output_text.done", {
+            type: "response.output_text.done",
+            item_id: messageId,
+            output_index: 0,
+            content_index: 0,
+            text,
+        });
+        writeSse(args.res, "response.content_part.done", {
+            type: "response.content_part.done",
+            item_id: messageId,
+            output_index: 0,
+            content_index: 0,
+            part: { type: "output_text", text, annotations: [] },
+        });
+        const item = {
+            id: messageId,
+            type: "message",
+            status: "completed",
+            role: "assistant",
+            content: [{ type: "output_text", text, annotations: [] }],
+        };
+        outputItems.push(item);
+        writeSse(args.res, "response.output_item.done", { type: "response.output_item.done", output_index: 0, item });
+    }
+    for (const tool of tools.values()) {
+        const item = {
+            id: tool.itemId,
+            type: "function_call",
+            status: "completed",
+            call_id: tool.id,
+            name: tool.name,
+            arguments: tool.arguments,
+        };
+        outputItems.push(item);
+        writeSse(args.res, "response.function_call_arguments.done", {
+            type: "response.function_call_arguments.done",
+            item_id: tool.itemId,
+            output_index: tool.outputIndex,
+            arguments: tool.arguments,
+        });
+        writeSse(args.res, "response.output_item.done", {
+            type: "response.output_item.done",
+            output_index: tool.outputIndex,
+            item,
+        });
+    }
+    writeSse(args.res, "response.completed", { type: "response.completed", response: responseBase(responseId, model, outputItems) });
+    args.res.end();
+}
+async function startResponsesBridge(args) {
+    const targetBaseUrl = normalizeBaseUrl(args.targetBaseUrl);
+    const server = createServer(async (req, res) => {
+        try {
+            if (req.method !== "POST" || !req.url?.replace(/\?.*$/, "").endsWith("/responses")) {
+                res.writeHead(404, { "content-type": "application/json" });
+                res.end(JSON.stringify({ error: { message: "Not Found" } }));
+                return;
+            }
+            const authorization = stringValue(req.headers.authorization) ?? "";
+            if (!authorization) {
+                res.writeHead(401, { "content-type": "application/json" });
+                res.end(JSON.stringify({ error: { message: "Missing Authorization header" } }));
+                return;
+            }
+            const body = await readRequestJson(req);
+            if (body.stream === false) {
+                await forwardNonStreaming({ authorization, body, res, targetBaseUrl });
+            }
+            else {
+                await forwardStreaming({ authorization, body, res, targetBaseUrl });
+            }
+        }
+        catch (error) {
+            args.onLog?.(`LiteLLM responses bridge failed: ${error instanceof Error ? error.message : String(error)}`);
+            if (!res.headersSent) {
+                res.writeHead(500, { "content-type": "application/json" });
+            }
+            res.end(JSON.stringify({ error: { message: error instanceof Error ? error.message : String(error) } }));
+        }
+    });
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(0, "127.0.0.1", () => {
+            server.off("error", reject);
+            resolve();
+        });
+    });
+    const address = server.address();
+    if (!address || typeof address === "string") {
+        throw new Error("Failed to start LiteLLM responses bridge");
+    }
+    return {
+        baseUrl: `http://127.0.0.1:${address.port}`,
+        stop: () => stopServer(server),
+    };
+}
+function resolveRuntimeDir(workspaceRoot) {
+    return path.resolve(workspaceRoot, ".doer-agent", "runtime", "litellm");
+}
+function buildLiteLlmConfig(model) {
+    return [
+        "model_list:",
+        "  - model_name: " + yamlString(model),
+        "    litellm_params:",
+        "      model: " + yamlString(`openai/${model}`),
+        "      api_base: " + yamlString(ZAI_CODING_BASE_URL),
+        "      api_key: os.environ/ZAI_API_KEY",
+        "      drop_params: true",
+        "litellm_settings:",
+        "  drop_params: true",
+        "general_settings:",
+        "  master_key: os.environ/LITELLM_MASTER_KEY",
+        "",
+    ].join("\n");
+}
+async function getFreePort() {
+    const server = createServer();
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(0, "127.0.0.1", () => {
+            server.off("error", reject);
+            resolve();
+        });
+    });
+    const address = server.address();
+    await stopServer(server);
+    if (!address || typeof address === "string") {
+        throw new Error("Failed to allocate local port");
+    }
+    return address.port;
+}
+async function waitForLiteLlm(port, child) {
+    const deadline = Date.now() + 45_000;
+    let lastError = "";
+    while (Date.now() < deadline) {
+        if (child.exitCode !== null) {
+            throw new Error(`LiteLLM exited before startup code=${child.exitCode}`);
+        }
+        try {
+            const response = await fetch(`http://127.0.0.1:${port}/health/readiness`);
+            if (response.ok) {
+                return;
+            }
+            lastError = `${response.status} ${await response.text().catch(() => "")}`;
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error.message : String(error);
+        }
+        await new Promise((resolve) => setTimeout(resolve, 500));
+    }
+    throw new Error(`Timed out waiting for LiteLLM startup${lastError ? `: ${lastError}` : ""}`);
+}
+function signalProcessGroup(pid, signal) {
+    if (!pid || process.platform === "win32") {
+        return false;
+    }
+    try {
+        process.kill(-pid, signal);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function stopChild(child) {
+    if (child.exitCode !== null || child.killed) {
+        return;
+    }
+    const pid = child.pid;
+    signalProcessGroup(pid, "SIGTERM") || child.kill("SIGTERM");
+    const exited = await new Promise((resolve) => {
+        const timer = setTimeout(() => resolve(false), 5_000);
+        child.once("exit", () => {
+            clearTimeout(timer);
+            resolve(true);
+        });
+    });
+    if (!exited) {
+        signalProcessGroup(pid, "SIGKILL") || child.kill("SIGKILL");
+    }
+}
+export async function startLitellmResponsesProxy(args) {
+    const model = args.model.trim() || "glm-5.2";
+    const zaiApiKey = args.zaiApiKey.trim();
+    if (!zaiApiKey) {
+        throw new Error("Z.AI API key is required to start LiteLLM");
+    }
+    const runtimeDir = resolveRuntimeDir(args.workspaceRoot);
+    await mkdir(runtimeDir, { recursive: true });
+    const instanceId = `${process.pid}-${randomUUID().slice(0, 8)}`;
+    const configPath = path.join(runtimeDir, `config-${instanceId}.yaml`);
+    await writeFile(configPath, buildLiteLlmConfig(model), "utf8");
+    const port = await getFreePort();
+    const apiKey = `sk-doer-litellm-${randomUUID().replace(/-/g, "")}`;
+    const child = spawn("uvx", [
+        "--from",
+        "litellm[proxy]",
+        "litellm",
+        "--config",
+        configPath,
+        "--host",
+        "127.0.0.1",
+        "--port",
+        String(port),
+    ], {
+        cwd: path.resolve(args.workspaceRoot),
+        detached: process.platform !== "win32",
+        env: {
+            ...process.env,
+            ZAI_API_KEY: zaiApiKey,
+            LITELLM_MASTER_KEY: apiKey,
+        },
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    child.stdout?.setEncoding("utf8");
+    child.stderr?.setEncoding("utf8");
+    child.stdout?.on("data", (chunk) => {
+        const message = chunk.trim();
+        if (message) {
+            args.onLog?.(`[litellm] ${message}`);
+        }
+    });
+    child.stderr?.on("data", (chunk) => {
+        const message = chunk.trim();
+        if (message) {
+            args.onLog?.(`[litellm] ${message}`);
+        }
+    });
+    try {
+        await waitForLiteLlm(port, child);
+    }
+    catch (error) {
+        await stopChild(child).catch(() => undefined);
+        await rm(configPath, { force: true }).catch(() => undefined);
+        throw error;
+    }
+    const bridge = await startResponsesBridge({
+        targetBaseUrl: `http://127.0.0.1:${port}/v1`,
+        onLog: args.onLog,
+    });
+    args.onLog?.(`LiteLLM responses bridge listening baseUrl=${bridge.baseUrl} litellm=http://127.0.0.1:${port}/v1 model=${model}`);
+    return {
+        baseUrl: bridge.baseUrl,
+        envKey: LITELLM_ENV_KEY,
+        apiKey,
+        stop: async () => {
+            await bridge.stop().catch((error) => {
+                args.onLog?.(`failed to stop LiteLLM responses bridge: ${error instanceof Error ? error.message : String(error)}`);
+            });
+            await stopChild(child).catch((error) => {
+                args.onLog?.(`failed to stop LiteLLM: ${error instanceof Error ? error.message : String(error)}`);
+            });
+            await rm(configPath, { force: true }).catch(() => undefined);
+        },
+    };
+}
+function stopServer(server) {
+    return new Promise((resolve, reject) => {
+        server.close((error) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve();
+        });
+    });
+}