@offerpilot/axiomruntime 0.0.1

package/dist/core/runner/openai-usage-server.js

@@ -0,0 +1,319 @@
+import http from "node:http";
+import { Agent, fetch } from "undici";
+import { writeLog } from "../logs/log-service.js";
+import { buildUpstreamHeaders, buildUpstreamUrl, methodMayHaveBody, readRequestBody, streamResponse, writeResponseHead } from "./openai-usage-http.js";
+import { buildChatCompletionsResponsesSse, isResponsesStreamRequest, shouldFallbackResponsesToChat } from "./openai-usage-responses.js";
+import { extractRequestModel, recordUsageFromResponse } from "./openai-usage-recording.js";
+import { getToolBaseUrl } from "./tool-runner.js";
+const DEFAULT_UPSTREAM_HEADERS_TIMEOUT_MS = 45_000;
+const MAX_CONSECUTIVE_HEADERS_TIMEOUTS = 2;
+export async function startOpenAiUsageProxy(input) {
+    const upstreamBaseUrl = getToolBaseUrl("codex", input.provider);
+    const upstreamHeadersTimeoutMs = normalizePositiveTimeout(input.upstreamHeadersTimeoutMs, DEFAULT_UPSTREAM_HEADERS_TIMEOUT_MS);
+    // Codex already retries failed Responses requests. Give those retries fresh
+    // upstream connections so a stale gateway keep-alive socket cannot poison an
+    // entire turn with immediate fetch failures.
+    const upstreamDispatcher = new Agent({
+        connections: 4,
+        pipelining: 0,
+        headersTimeout: upstreamHeadersTimeoutMs,
+        bodyTimeout: 0
+    });
+    const records = [];
+    const metrics = createEmptyMetrics();
+    let consecutiveHeadersTimeouts = 0;
+    const server = http.createServer(async (req, res) => {
+        const startedAt = Date.now();
+        let requestModel = input.model;
+        let requestBytes = 0;
+        let requestShape = {};
+        let upstreamPath = new URL(req.url ?? "/", "http://127.0.0.1").pathname;
+        metrics.requestCount += 1;
+        let finalized = false;
+        const finalizeMetrics = (success, upstreamStatus) => {
+            if (finalized)
+                return;
+            finalized = true;
+            if (success) {
+                metrics.successCount += 1;
+            }
+            else {
+                metrics.failureCount += 1;
+            }
+            metrics.totalDurationMs += Date.now() - startedAt;
+            if (upstreamStatus !== undefined) {
+                incrementStatusCount(metrics, upstreamStatus);
+            }
+        };
+        try {
+            const requestBody = await readRequestBody(req);
+            requestModel = extractRequestModel(requestBody) ?? input.model;
+            requestBytes = requestBody.length;
+            requestShape = summarizeRequestShape(requestBody);
+            const responsesStream = isResponsesStreamRequest(req.url ?? "/", requestBody);
+            void writeLog({
+                category: "usage",
+                action: "openai_usage_proxy_request",
+                message: `Proxying ${input.tool} request for ${input.provider.name} / ${requestModel}`,
+                metadata: {
+                    tool: input.tool,
+                    provider: input.provider.name,
+                    model: requestModel,
+                    path: new URL(req.url ?? "/", "http://127.0.0.1").pathname
+                }
+            });
+            const upstreamUrl = buildUpstreamUrl(upstreamBaseUrl, req.url ?? "/");
+            upstreamPath = new URL(upstreamUrl).pathname;
+            if (consecutiveHeadersTimeouts >= MAX_CONSECUTIVE_HEADERS_TIMEOUTS) {
+                await writeLog({
+                    level: "warn",
+                    category: "usage",
+                    action: "openai_usage_proxy_timeout_short_circuit",
+                    message: `Skipping another stalled upstream attempt for ${input.provider.name} / ${requestModel}.`,
+                    metadata: {
+                        tool: input.tool,
+                        provider: input.provider.name,
+                        model: requestModel,
+                        upstreamPath,
+                        requestBytes,
+                        ...requestShape,
+                        timeoutMs: upstreamHeadersTimeoutMs,
+                        consecutiveTimeouts: consecutiveHeadersTimeouts
+                    }
+                });
+                sendProxyError(res, 504, "AI Gateway timed out waiting for provider response headers.");
+                finalizeMetrics(false, "headers_timeout_short_circuit");
+                return;
+            }
+            const upstreamResponse = await fetch(upstreamUrl, {
+                method: req.method,
+                headers: buildUpstreamHeaders(req.headers, input.provider.apiKey),
+                body: requestBody.length && methodMayHaveBody(req.method) ? requestBody : undefined,
+                dispatcher: upstreamDispatcher
+            });
+            consecutiveHeadersTimeouts = 0;
+            // Native Responses is attempted first. Only when the upstream cannot speak
+            // the Responses protocol do we translate the request through chat
+            // completions; transient/no-channel errors are passed through untouched so
+            // provider rotation can react to them.
+            if (responsesStream && !isUsableEventStream(upstreamResponse)) {
+                const nativeBody = await upstreamResponse.text().catch(() => "");
+                const outcome = {
+                    status: upstreamResponse.status,
+                    contentType: upstreamResponse.headers.get("content-type") ?? "",
+                    bodyText: nativeBody
+                };
+                if (shouldFallbackResponsesToChat(outcome)) {
+                    void writeLog({
+                        category: "usage",
+                        action: "openai_usage_proxy_responses_chat_fallback",
+                        message: `Responses protocol is unsupported for ${input.provider.name} / ${requestModel}; falling back to chat completions.`,
+                        metadata: {
+                            tool: input.tool,
+                            provider: input.provider.name,
+                            model: requestModel,
+                            status: outcome.status
+                        }
+                    });
+                    await sendChatCompletionsResponsesSse({
+                        upstreamBaseUrl,
+                        requestBody,
+                        apiKey: input.provider.apiKey,
+                        dispatcher: upstreamDispatcher,
+                        requestModel,
+                        provider: input.provider.name,
+                        tool: input.tool,
+                        records,
+                        onUsage: input.onUsage,
+                        metrics,
+                        res
+                    }).then((result) => finalizeMetrics(result.status >= 200 && result.status < 400, result.status));
+                    return;
+                }
+                // Not a protocol problem (e.g. 503 no-channel): pass the native error
+                // through so the caller and provider rotation see the real cause.
+                res.statusCode = outcome.status;
+                res.statusMessage = upstreamResponse.statusText;
+                res.setHeader("content-type", outcome.contentType || "application/json; charset=utf-8");
+                const recordedUsage = await recordUsageFromResponse({
+                    text: nativeBody,
+                    contentType: outcome.contentType,
+                    fallbackModel: requestModel,
+                    provider: input.provider.name,
+                    tool: input.tool,
+                    records,
+                    onUsage: input.onUsage
+                });
+                recordUsageMetric(metrics, recordedUsage);
+                res.end(nativeBody);
+                finalizeMetrics(outcome.status >= 200 && outcome.status < 400, outcome.status);
+                return;
+            }
+            writeResponseHead(res, upstreamResponse);
+            const captured = await streamResponse(upstreamResponse, res);
+            const recordedUsage = await recordUsageFromResponse({
+                text: captured.toString("utf8"),
+                contentType: upstreamResponse.headers.get("content-type") ?? "",
+                fallbackModel: requestModel,
+                provider: input.provider.name,
+                tool: input.tool,
+                records,
+                onUsage: input.onUsage
+            });
+            recordUsageMetric(metrics, recordedUsage);
+            res.end();
+            finalizeMetrics(upstreamResponse.status >= 200 && upstreamResponse.status < 400, upstreamResponse.status);
+        }
+        catch (error) {
+            const diagnostic = summarizeUpstreamError(error);
+            const headersTimedOut = diagnostic.code === "UND_ERR_HEADERS_TIMEOUT";
+            consecutiveHeadersTimeouts = headersTimedOut ? consecutiveHeadersTimeouts + 1 : 0;
+            await writeLog({
+                level: "error",
+                category: "usage",
+                action: "openai_usage_proxy_upstream_error",
+                message: `OpenAI upstream request failed for ${input.provider.name} / ${requestModel}: ${diagnostic.message}`,
+                metadata: {
+                    tool: input.tool,
+                    provider: input.provider.name,
+                    model: requestModel,
+                    upstreamPath,
+                    requestBytes,
+                    ...requestShape,
+                    errorName: diagnostic.name,
+                    errorCode: diagnostic.code,
+                    errorSyscall: diagnostic.syscall,
+                    timeoutMs: headersTimedOut ? upstreamHeadersTimeoutMs : null,
+                    consecutiveTimeouts: headersTimedOut ? consecutiveHeadersTimeouts : 0
+                }
+            });
+            const code = diagnostic.code ? ` (${diagnostic.code})` : "";
+            sendProxyError(res, headersTimedOut ? 504 : 502, `AI Gateway proxy failed: ${diagnostic.message}${code}`);
+            finalizeMetrics(false, headersTimedOut ? "headers_timeout" : "proxy_error");
+        }
+    });
+    await new Promise((resolve, reject) => {
+        const onListenError = (error) => {
+            void upstreamDispatcher.close();
+            reject(error);
+        };
+        server.once("error", onListenError);
+        server.listen(0, "127.0.0.1", () => {
+            server.off("error", onListenError);
+            resolve();
+        });
+    });
+    const address = server.address();
+    if (!address || typeof address === "string") {
+        throw new Error("Failed to start AI Gateway OpenAI proxy.");
+    }
+    return {
+        baseUrl: `http://127.0.0.1:${address.port}/v1`,
+        async close() {
+            const closeServer = server.listening
+                ? new Promise((resolve, reject) => {
+                    server.close((error) => error ? reject(error) : resolve());
+                })
+                : Promise.resolve();
+            await Promise.all([closeServer, upstreamDispatcher.close()]);
+        },
+        getRecords() {
+            return [...records];
+        },
+        getMetrics() {
+            return snapshotMetrics(metrics);
+        }
+    };
+}
+function normalizePositiveTimeout(value, fallback) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0
+        ? Math.floor(value)
+        : fallback;
+}
+function sendProxyError(res, status, message) {
+    res.statusCode = status;
+    res.setHeader("content-type", "application/json; charset=utf-8");
+    res.end(JSON.stringify({ error: { message } }));
+}
+function summarizeRequestShape(requestBody) {
+    try {
+        const body = JSON.parse(requestBody.toString("utf8"));
+        return {
+            stream: body.stream === true,
+            inputItems: Array.isArray(body.input) ? body.input.length : typeof body.input === "string" ? 1 : 0,
+            toolCount: Array.isArray(body.tools) ? body.tools.length : 0
+        };
+    }
+    catch {
+        return { stream: null, inputItems: null, toolCount: null };
+    }
+}
+function summarizeUpstreamError(error) {
+    const top = error instanceof Error ? error : new Error(String(error));
+    const cause = top.cause && typeof top.cause === "object" ? top.cause : null;
+    return {
+        name: cause && typeof cause.name === "string" ? cause.name : top.name,
+        message: cause && typeof cause.message === "string" ? cause.message : top.message,
+        code: cause && typeof cause.code === "string" ? cause.code : null,
+        syscall: cause && typeof cause.syscall === "string" ? cause.syscall : null
+    };
+}
+async function sendChatCompletionsResponsesSse(input) {
+    const response = await buildChatCompletionsResponsesSse({
+        upstreamBaseUrl: input.upstreamBaseUrl,
+        requestBody: input.requestBody,
+        apiKey: input.apiKey,
+        dispatcher: input.dispatcher
+    });
+    input.res.statusCode = response.status;
+    input.res.statusMessage = response.statusText;
+    input.res.setHeader("content-type", response.contentType);
+    const recordedUsage = await recordUsageFromResponse({
+        text: response.body.toString("utf8"),
+        contentType: response.contentType,
+        fallbackModel: input.requestModel,
+        provider: input.provider,
+        tool: input.tool,
+        records: input.records,
+        onUsage: input.onUsage
+    });
+    recordUsageMetric(input.metrics, recordedUsage);
+    input.res.end(response.body);
+    return { status: response.status };
+}
+function isUsableEventStream(response) {
+    if (!response.ok)
+        return false;
+    return (response.headers.get("content-type") ?? "").toLowerCase().includes("text/event-stream");
+}
+function createEmptyMetrics() {
+    return {
+        requestCount: 0,
+        successCount: 0,
+        failureCount: 0,
+        noUsageCount: 0,
+        usageRecordCount: 0,
+        totalDurationMs: 0,
+        averageDurationMs: 0,
+        upstreamStatusCounts: {}
+    };
+}
+function recordUsageMetric(metrics, recordedUsage) {
+    if (recordedUsage) {
+        metrics.usageRecordCount += 1;
+    }
+    else {
+        metrics.noUsageCount += 1;
+    }
+}
+function incrementStatusCount(metrics, status) {
+    const key = String(status);
+    metrics.upstreamStatusCounts[key] = (metrics.upstreamStatusCounts[key] ?? 0) + 1;
+}
+function snapshotMetrics(metrics) {
+    return {
+        ...metrics,
+        averageDurationMs: metrics.requestCount ? metrics.totalDurationMs / metrics.requestCount : 0,
+        upstreamStatusCounts: { ...metrics.upstreamStatusCounts }
+    };
+}

package/dist/core/runner/openai-usage-types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/runner/tool-runner.js

@@ -0,0 +1,138 @@
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { saveLastSelection } from "../config/cache-store.js";
+import { writeLog } from "../logs/log-service.js";
+import { isRecord } from "../utils/is-record.js";
+import { resolveToolCommand } from "./command-resolver.js";
+import { getRunnerEngine } from "./engine-registry.js";
+import { finishSession, startSession } from "../sessions/session-service.js";
+export async function runTool(tool, provider, model, options = {}) {
+    await saveLastSelection(tool, provider.name, model);
+    const command = resolveToolCommand(tool);
+    if (!command) {
+        throw new Error(`Failed to find ${tool} CLI. Run \`ai doctor\` to check local CLI installation.`);
+    }
+    const engine = getRunnerEngine(tool);
+    const env = buildRunnerEnv(tool, provider, model);
+    const temporaryFiles = [];
+    const claudeSettingsPath = engine.requiresSettingsFile ? writeTemporaryClaudeSettings(provider) : null;
+    if (claudeSettingsPath)
+        temporaryFiles.push(claudeSettingsPath);
+    const args = buildRunnerArgs(tool, provider, model, claudeSettingsPath);
+    const effectiveBaseUrl = getToolBaseUrl(tool, provider);
+    await writeLog({
+        category: "usage",
+        action: "tool_spawn",
+        message: `Spawning ${tool}: ${provider.name} / ${model}`,
+        metadata: {
+            tool,
+            provider: provider.name,
+            model,
+            mode: provider.mode,
+            baseUrl: effectiveBaseUrl,
+            configuredBaseUrl: provider.baseUrl,
+            apiKeyFingerprint: getSecretFingerprint(provider.apiKey),
+            command,
+            args,
+            authInjection: engine.authInjection
+        }
+    });
+    const session = await startSession({
+        tool,
+        provider,
+        model,
+        projectPath: process.cwd(),
+        fallbackFrom: options.fallbackFrom ?? null
+    });
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            stdio: "inherit",
+            env
+        });
+        child.on("error", (error) => {
+            cleanupTemporaryFiles(temporaryFiles);
+            void finishSession(session.id, 1);
+            reject(new Error(`Failed to start ${command}. Run \`ai doctor\` to check local CLI installation. ${error.message}`));
+        });
+        child.on("close", (code) => {
+            cleanupTemporaryFiles(temporaryFiles);
+            const exitCode = code ?? 0;
+            void finishSession(session.id, exitCode).finally(() => resolve(exitCode));
+        });
+    });
+}
+export function getSecretFingerprint(value) {
+    if (!value)
+        return "(empty)";
+    if (value.length <= 12)
+        return `len=${value.length}`;
+    return `${value.slice(0, 8)}...${value.slice(-6)} len=${value.length}`;
+}
+export function buildRunnerArgs(tool, provider, model, claudeSettingsPath) {
+    return getRunnerEngine(tool).buildArgs({ provider, model, settingsPath: claudeSettingsPath });
+}
+const AUTO_PERMISSIONS = {
+    defaultMode: "bypassPermissions",
+    allow: [
+        "Bash",
+        "Edit",
+        "Write",
+        "Read",
+        "Glob",
+        "Grep",
+        "WebFetch",
+        "WebSearch",
+        "MultiEdit",
+        "NotebookEdit"
+    ],
+    deny: []
+};
+const READ_ONLY_PERMISSIONS = {
+    defaultMode: "default",
+    allow: ["Read", "Glob", "Grep", "WebFetch", "WebSearch"],
+    deny: ["Bash", "Edit", "Write", "MultiEdit", "NotebookEdit"]
+};
+export function writeTemporaryClaudeSettings(provider, options = {}) {
+    const userSettingsPath = path.join(os.homedir(), ".claude", "settings.json");
+    const settings = readClaudeSettings(userSettingsPath);
+    const settingsEnv = isRecord(settings.env) ? settings.env : {};
+    const baseUrl = getToolBaseUrl("claude", provider);
+    settings.env = {
+        ...settingsEnv,
+        ANTHROPIC_API_KEY: provider.apiKey,
+        ANTHROPIC_BASE_URL: baseUrl
+    };
+    if (options.permissionMode === "readOnly") {
+        settings.permissions = { ...READ_ONLY_PERMISSIONS };
+    }
+    else if (provider.mode === "auto") {
+        settings.permissions = { ...AUTO_PERMISSIONS };
+    }
+    const settingsPath = path.join(os.tmpdir(), `ai-gateway-claude-settings-${process.pid}-${Date.now()}.json`);
+    fs.writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}\n`, { mode: 0o600 });
+    return settingsPath;
+}
+function readClaudeSettings(filePath) {
+    if (!fs.existsSync(filePath)) {
+        return {};
+    }
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+}
+export function cleanupTemporaryFiles(filePaths) {
+    for (const filePath of filePaths) {
+        try {
+            fs.unlinkSync(filePath);
+        }
+        catch {
+            // Best-effort cleanup for temporary launch settings.
+        }
+    }
+}
+export function buildRunnerEnv(tool, provider, model) {
+    return getRunnerEngine(tool).buildEnv(provider, model, process.env);
+}
+export function getToolBaseUrl(tool, provider) {
+    return getRunnerEngine(tool).normalizeBaseUrl(provider.baseUrl);
+}

package/dist/core/sessions/session-service.js

@@ -0,0 +1,47 @@
+import { randomBytes } from "node:crypto";
+import { addSession, clearSessions, readSessions, updateSession } from "../config/session-store.js";
+export async function startSession(input) {
+    const now = new Date();
+    const session = {
+        id: buildSessionId(now),
+        tool: input.tool,
+        provider: input.provider.name,
+        model: input.model,
+        mode: input.provider.mode,
+        projectPath: input.projectPath,
+        startedAt: now.toISOString(),
+        endedAt: null,
+        status: "running",
+        exitCode: null,
+        fallbackFrom: input.fallbackFrom ?? null
+    };
+    await addSession(session);
+    return session;
+}
+export async function finishSession(sessionId, exitCode) {
+    await updateSession(sessionId, {
+        endedAt: new Date().toISOString(),
+        status: exitCode === 0 ? "completed" : "failed",
+        exitCode
+    });
+}
+export async function listRecentSessions(limit = 20) {
+    const file = await readSessions();
+    return [...file.sessions]
+        .sort((a, b) => b.startedAt.localeCompare(a.startedAt))
+        .slice(0, limit);
+}
+export async function getSession(id) {
+    const file = await readSessions();
+    return file.sessions.find((session) => session.id === id) ?? null;
+}
+export async function getLastSession() {
+    return (await listRecentSessions(1))[0] ?? null;
+}
+export async function clearAllSessions() {
+    return clearSessions();
+}
+function buildSessionId(date) {
+    const stamp = date.toISOString().replace(/[-:]/g, "").replace(/\..+$/, "").replace("T", "_");
+    return `ses_${stamp}_${randomBytes(3).toString("hex")}`;
+}