@offerpilot/axiomruntime 0.0.1

package/dist/core/reports/report-service.js

@@ -0,0 +1,166 @@
+import fs from "node:fs/promises";
+import { readCache } from "../config/cache-store.js";
+import { readProviders } from "../config/providers-store.js";
+import { getReportPath, getReportsDir } from "../config/paths.js";
+import { readUsage } from "../config/usage-store.js";
+import { generateProjectContext } from "../context/context-service.js";
+import { writeLog } from "../logs/log-service.js";
+import { getSession } from "../sessions/session-service.js";
+export async function generateSessionReport(sessionId) {
+    const session = await getSession(sessionId);
+    if (!session) {
+        throw new Error(`Session not found: ${sessionId}`);
+    }
+    const [providers, cache, usage] = await Promise.all([
+        readProviders(),
+        readCache(),
+        readUsage()
+    ]);
+    const provider = providers.find((item) => item.name === session.provider) ?? null;
+    const providerCache = cache.providers[session.provider] ?? null;
+    const tokenSummary = summarizeSessionUsage(session, usage.events);
+    const projectContext = await buildProjectContext(session);
+    const content = renderReport({
+        session,
+        provider,
+        providerHealth: providerCache?.status ?? "unknown",
+        providerLastCheckedAt: providerCache?.lastCheckedAt ?? null,
+        providerModelCount: providerCache?.models.length ?? 0,
+        tokenSummary,
+        projectContext
+    });
+    const filePath = getReportPath(session.id);
+    await fs.mkdir(getReportsDir(), { recursive: true });
+    await fs.writeFile(filePath, content, "utf8");
+    await writeLog({
+        category: "usage",
+        action: "report_generated",
+        message: `Generated session report: ${filePath}`,
+        metadata: { sessionId: session.id, provider: session.provider, model: session.model }
+    });
+    return { filePath, content };
+}
+function summarizeSessionUsage(session, events) {
+    const startedAt = new Date(session.startedAt).getTime();
+    const endedAt = session.endedAt ? new Date(session.endedAt).getTime() : Date.now();
+    const matched = events.filter((event) => {
+        const createdAt = new Date(event.createdAt).getTime();
+        return event.provider === session.provider
+            && event.tool === session.tool
+            && event.model === session.model
+            && createdAt >= startedAt
+            && createdAt <= endedAt;
+    });
+    return matched.reduce((summary, event) => ({
+        inputTokens: summary.inputTokens + event.inputTokens,
+        outputTokens: summary.outputTokens + event.outputTokens,
+        totalTokens: summary.totalTokens + event.totalTokens,
+        eventCount: summary.eventCount + 1
+    }), { inputTokens: 0, outputTokens: 0, totalTokens: 0, eventCount: 0 });
+}
+async function buildProjectContext(session) {
+    try {
+        const context = await generateProjectContext(session.projectPath);
+        return context.content.trim();
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return [
+            "# Project Context",
+            "",
+            `Project context could not be generated for ${session.projectPath}.`,
+            "",
+            `Error: ${message}`
+        ].join("\n");
+    }
+}
+function renderReport(input) {
+    const duration = getDuration(input.session);
+    const providerLevel = input.provider ? String(input.provider.level) : "(provider removed)";
+    const defaultModel = input.provider?.model ?? "(provider removed)";
+    return `${[
+        "# AI Gateway Session Report",
+        "",
+        "This report is generated for agent handoff. It intentionally excludes API keys and does not estimate token usage.",
+        "",
+        "## Session Summary",
+        "",
+        `- Session ID: ${input.session.id}`,
+        `- Tool: ${input.session.tool}`,
+        `- Provider: ${input.session.provider}`,
+        `- Model: ${input.session.model}`,
+        `- Provider priority level: ${providerLevel}`,
+        `- Provider default model: ${defaultModel}`,
+        `- Permission mode: ${input.session.mode}`,
+        `- Project path: ${input.session.projectPath}`,
+        `- Status: ${input.session.status}`,
+        `- Exit code: ${input.session.exitCode ?? "(running)"}`,
+        `- Started at: ${input.session.startedAt}`,
+        `- Ended at: ${input.session.endedAt ?? "(running)"}`,
+        `- Duration: ${duration}`,
+        `- Fallback: ${input.session.fallbackFrom ? `${input.session.fallbackFrom} -> ${input.session.provider}` : "none"}`,
+        "",
+        "## Token Usage",
+        "",
+        `- Usage events matched to this session: ${input.tokenSummary.eventCount}`,
+        `- Input tokens: ${input.tokenSummary.inputTokens}`,
+        `- Output tokens: ${input.tokenSummary.outputTokens}`,
+        `- Total tokens: ${input.tokenSummary.totalTokens}`,
+        "",
+        "Token usage is counted only from structured provider usage events recorded by AI Gateway.",
+        "",
+        "## Provider Snapshot",
+        "",
+        `- Health: ${input.providerHealth}`,
+        `- Last checked at: ${input.providerLastCheckedAt ?? "(never)"}`,
+        `- Discovered model count: ${input.providerModelCount}`,
+        "",
+        "## Current Session Profile",
+        "",
+        renderSessionProfile(input.session),
+        "",
+        "## User Profile",
+        "",
+        renderUserProfile(),
+        "",
+        "## Session Context",
+        "",
+        input.projectContext
+    ].join("\n")}\n`;
+}
+function renderSessionProfile(session) {
+    const lines = [
+        `- This session launched ${session.tool} through AI Gateway with provider ${session.provider}.`,
+        `- The selected model was ${session.model}.`,
+        `- The working project was ${session.projectPath}.`
+    ];
+    if (session.fallbackFrom) {
+        lines.push(`- The session used fallback from ${session.fallbackFrom} to ${session.provider}.`);
+    }
+    if (session.status === "running") {
+        lines.push("- The session was still marked as running when the report was generated.");
+    }
+    return lines.join("\n");
+}
+function renderUserProfile() {
+    return [
+        "- User-facing documentation should be concise and written in Chinese.",
+        "- Agent-facing project/context documents can be written in English.",
+        "- The user prefers practical interactive workflows that reduce command memorization.",
+        "- Documentation should be updated whenever CLI behavior, configuration, or architecture changes.",
+        "- Provider secrets must be masked in logs, terminal output, and reports."
+    ].join("\n");
+}
+function getDuration(session) {
+    const startedAt = new Date(session.startedAt).getTime();
+    const endedAt = session.endedAt ? new Date(session.endedAt).getTime() : Date.now();
+    if (!Number.isFinite(startedAt) || !Number.isFinite(endedAt) || endedAt < startedAt) {
+        return "(unknown)";
+    }
+    const seconds = Math.round((endedAt - startedAt) / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const remainingSeconds = seconds % 60;
+    if (minutes <= 0)
+        return `${remainingSeconds}s`;
+    return `${minutes}m ${remainingSeconds}s`;
+}

package/dist/core/runner/command-resolver.js

@@ -0,0 +1,60 @@
+import fs from "node:fs";
+import { spawnSync } from "node:child_process";
+import os from "node:os";
+import path from "node:path";
+export function resolveToolCommand(tool) {
+    return resolveToolCommandWithOptions(tool);
+}
+export function resolveToolCommandWithOptions(tool, options = {}) {
+    const command = tool === "claude" ? "claude" : "codex";
+    const runner = options.runner ?? isRunnableCommand;
+    const fromPath = (options.pathResolver ?? resolveFromPath)(command);
+    if (fromPath && runner(fromPath))
+        return fromPath;
+    for (const candidate of options.candidates ?? getKnownCandidates(tool)) {
+        if (runner(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+export function getKnownCandidates(tool) {
+    if (tool === "claude") {
+        return [
+            path.join(os.homedir(), ".local/bin/claude"),
+            "/opt/homebrew/bin/claude",
+            "/usr/local/bin/claude"
+        ];
+    }
+    return [
+        "/Applications/Codex.app/Contents/Resources/codex",
+        "/opt/homebrew/bin/codex",
+        "/usr/local/bin/codex"
+    ];
+}
+function resolveFromPath(command) {
+    const result = spawnSync("which", [command], { encoding: "utf8" });
+    if (result.status === 0) {
+        return result.stdout.trim();
+    }
+    return null;
+}
+function isExecutable(filePath) {
+    try {
+        fs.accessSync(filePath, fs.constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function isRunnableCommand(command) {
+    if (!isExecutable(command))
+        return false;
+    const result = spawnSync(command, ["--version"], {
+        encoding: "utf8",
+        timeout: 5000,
+        stdio: ["ignore", "pipe", "pipe"]
+    });
+    return result.status === 0;
+}

package/dist/core/runner/engine-registry.js

@@ -0,0 +1,93 @@
+const runnerEngines = new Map();
+export function registerRunnerEngine(descriptor) {
+    runnerEngines.set(descriptor.name, descriptor);
+}
+export function getRunnerEngine(tool) {
+    const descriptor = runnerEngines.get(tool);
+    if (!descriptor) {
+        throw new Error(`Unknown runner engine: ${tool}`);
+    }
+    return descriptor;
+}
+export function listRunnerEngines() {
+    return [...runnerEngines.values()];
+}
+registerRunnerEngine({
+    name: "claude",
+    requiresSettingsFile: true,
+    authInjection: "temporary Claude settings env + process env",
+    normalizeBaseUrl: (baseUrl) => baseUrl.replace(/\/+$/, "").replace(/\/v1$/i, ""),
+    buildEnv: (provider, model, baseEnv) => {
+        const baseUrl = getRunnerEngine("claude").normalizeBaseUrl(provider.baseUrl);
+        return {
+            ...baseEnv,
+            AI_GATEWAY_PROVIDER: provider.name,
+            AI_GATEWAY_MODEL: model,
+            AI_GATEWAY_MODE: provider.mode,
+            AI_GATEWAY_BASE_URL: baseUrl,
+            ANTHROPIC_API_KEY: provider.apiKey,
+            ANTHROPIC_BASE_URL: baseUrl,
+            ANTHROPIC_MODEL: model
+        };
+    },
+    buildArgs: ({ provider, model, settingsPath }) => {
+        const args = ["--model", model];
+        if (settingsPath) {
+            args.push("--settings", settingsPath);
+        }
+        if (provider.mode === "auto") {
+            args.push("--permission-mode", "bypassPermissions");
+            args.push("--dangerously-skip-permissions");
+        }
+        return args;
+    }
+});
+registerRunnerEngine({
+    name: "codex",
+    authInjection: "process env + process-scoped Codex provider override",
+    normalizeBaseUrl: (baseUrl) => {
+        const normalized = baseUrl.replace(/\/+$/, "");
+        return normalized.endsWith("/v1") ? normalized : `${normalized}/v1`;
+    },
+    buildEnv: (provider, model, baseEnv) => {
+        const baseUrl = getRunnerEngine("codex").normalizeBaseUrl(provider.baseUrl);
+        return {
+            ...baseEnv,
+            AI_GATEWAY_PROVIDER: provider.name,
+            AI_GATEWAY_MODEL: model,
+            AI_GATEWAY_MODE: provider.mode,
+            AI_GATEWAY_BASE_URL: baseUrl,
+            OPENAI_API_KEY: provider.apiKey,
+            OPENAI_BASE_URL: baseUrl,
+            OPENAI_MODEL: model,
+            CODEX_MODEL: model
+        };
+    },
+    buildArgs: ({ provider, model }) => {
+        const providerId = "ai_gateway_selected";
+        const baseUrl = getRunnerEngine("codex").normalizeBaseUrl(provider.baseUrl);
+        const args = [
+            "-c",
+            `model_provider=${tomlString(providerId)}`,
+            "-c",
+            `model_providers.${providerId}.name=${tomlString(`AI Gateway (${provider.name})`)}`,
+            "-c",
+            `model_providers.${providerId}.base_url=${tomlString(baseUrl)}`,
+            "-c",
+            `model_providers.${providerId}.env_key=${tomlString("OPENAI_API_KEY")}`,
+            "-c",
+            `model_providers.${providerId}.requires_openai_auth=true`,
+            "-c",
+            `model_providers.${providerId}.wire_api=${tomlString("responses")}`,
+            "--model",
+            model
+        ];
+        if (provider.mode === "auto") {
+            args.push("--dangerously-bypass-approvals-and-sandbox");
+        }
+        return args;
+    }
+});
+function tomlString(value) {
+    return JSON.stringify(value);
+}

package/dist/core/runner/fallback.js

@@ -0,0 +1,114 @@
+import { isProviderCircuitOpen, readCache } from "../config/cache-store.js";
+import { readProviders } from "../config/providers-store.js";
+import { writeLog } from "../logs/log-service.js";
+import { isModelCompatible, pickCompatibleModel } from "../models/model-filter.js";
+export async function resolveProviderForTool(tool, providerName, modelName) {
+    const candidates = await resolveProviderCandidatesForTool(tool, providerName, modelName);
+    const resolved = candidates[0];
+    if (!resolved) {
+        throw new Error("No usable provider/model found. Run `ai status` or `ai doctor`.");
+    }
+    await writeLog({
+        category: "strategy",
+        action: "provider_resolved",
+        message: `Resolved provider ${resolved.provider.name} with model ${resolved.model}.`,
+        metadata: { provider: resolved.provider.name, tool, model: resolved.model, requestedProvider: providerName ?? null, requestedModel: modelName ?? null }
+    });
+    return resolved;
+}
+export async function resolveExactProviderForTool(tool, providerName, modelName) {
+    const providers = await readProviders();
+    const provider = providers.find((candidate) => candidate.name === providerName);
+    if (!provider) {
+        throw new Error(`Provider not found: ${providerName}`);
+    }
+    const cache = await readCache();
+    const models = cache.providers[provider.name]?.models ?? [];
+    const model = resolveModel(tool, provider.model, models, modelName);
+    if (!model) {
+        throw new Error(`Provider ${providerName} does not offer a compatible ${tool} model.`);
+    }
+    await writeLog({
+        category: "strategy",
+        action: "provider_resolved_exact",
+        message: `Resolved exact provider ${provider.name} with model ${model}.`,
+        metadata: { provider: provider.name, tool, model, requestedProvider: providerName, requestedModel: modelName ?? null }
+    });
+    return { provider, model };
+}
+export async function resolveProviderCandidatesForTool(tool, providerName, modelName) {
+    const providers = await readProviders();
+    if (!providers.length) {
+        throw new Error("No providers configured. Run `ai add` first.");
+    }
+    const cache = await readCache();
+    const candidates = providerName
+        ? [...providers.filter((provider) => provider.name === providerName), ...providers.filter((provider) => provider.name !== providerName)]
+        : providers;
+    if (providerName && candidates[0]?.name !== providerName) {
+        throw new Error(`Provider not found: ${providerName}`);
+    }
+    const resolved = [];
+    for (const provider of candidates) {
+        const cached = cache.providers[provider.name];
+        if (isProviderCircuitOpen(cached)) {
+            await writeLog({
+                level: "warn",
+                category: "strategy",
+                action: "fallback_skip_provider",
+                message: `Skipped provider ${provider.name} because circuit breaker is open.`,
+                metadata: { provider: provider.name, tool, reason: "circuit_open", circuitOpenUntil: cached?.circuitOpenUntil ?? null }
+            });
+            continue;
+        }
+        // Runtime-opened circuits become half-open after their cooldown. A stale
+        // status=error must not keep a provider disabled forever after the timer.
+        if (cached?.status === "error" && !cached.circuitOpenUntil) {
+            await writeLog({
+                level: "warn",
+                category: "strategy",
+                action: "fallback_skip_provider",
+                message: `Skipped provider ${provider.name} because health is error.`,
+                metadata: { provider: provider.name, tool, reason: cached.lastError }
+            });
+            continue;
+        }
+        const models = cached?.models ?? [];
+        const model = resolveModel(tool, provider.model, models, modelName);
+        if (!model) {
+            await writeLog({
+                level: "warn",
+                category: "strategy",
+                action: "fallback_skip_provider",
+                message: `Skipped provider ${provider.name} because no compatible model is available.`,
+                metadata: { provider: provider.name, tool, defaultModel: provider.model, cachedModels: models.length }
+            });
+            continue;
+        }
+        resolved.push({
+            provider,
+            model,
+            fallbackFrom: providerName && provider.name !== providerName ? providerName : undefined
+        });
+    }
+    return resolved;
+}
+function resolveModel(tool, defaultModel, cachedModels, requestedModel) {
+    if (requestedModel) {
+        // Only offer the requested model when the provider's known catalog serves
+        // it; otherwise drop this provider from the rotation instead of guaranteeing
+        // an upstream model_not_found. An unknown/never-probed catalog is allowed
+        // through optimistically so newly added providers still get a chance.
+        if (cachedModels.length && !cachedModels.includes(requestedModel)) {
+            return null;
+        }
+        return requestedModel;
+    }
+    if (defaultModel && isModelCompatible(tool, defaultModel)) {
+        return defaultModel;
+    }
+    if (cachedModels.length) {
+        return pickCompatibleModel(tool, "", cachedModels);
+    }
+    return defaultModel || null;
+}

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

@@ -0,0 +1,82 @@
+const MAX_USAGE_CAPTURE_BYTES = 8 * 1024 * 1024;
+export const HOP_BY_HOP_HEADERS = new Set([
+    "connection",
+    "keep-alive",
+    "proxy-authenticate",
+    "proxy-authorization",
+    "te",
+    "trailer",
+    "transfer-encoding",
+    "upgrade"
+]);
+const RESPONSE_HEADERS_TO_DROP = new Set([
+    ...HOP_BY_HOP_HEADERS,
+    "content-encoding",
+    "content-length"
+]);
+export function buildUpstreamUrl(upstreamBaseUrl, incomingUrl) {
+    const local = new URL(incomingUrl, "http://127.0.0.1");
+    let suffix = local.pathname;
+    if (suffix === "/v1") {
+        suffix = "";
+    }
+    else if (suffix.startsWith("/v1/")) {
+        suffix = suffix.slice(3);
+    }
+    const upstream = new URL(`${upstreamBaseUrl.replace(/\/+$/, "")}${suffix}`);
+    upstream.search = local.search;
+    return upstream.toString();
+}
+export function buildUpstreamHeaders(headers, apiKey) {
+    const next = {};
+    for (const [key, value] of Object.entries(headers)) {
+        const normalized = key.toLowerCase();
+        if (HOP_BY_HOP_HEADERS.has(normalized) || normalized === "host" || normalized === "content-length")
+            continue;
+        if (Array.isArray(value)) {
+            next[key] = value.join(", ");
+        }
+        else if (typeof value === "string") {
+            next[key] = value;
+        }
+    }
+    next.authorization = `Bearer ${apiKey}`;
+    next["accept-encoding"] = "identity";
+    return next;
+}
+export function writeResponseHead(res, response) {
+    res.statusCode = response.status;
+    res.statusMessage = response.statusText;
+    for (const [key, value] of response.headers.entries()) {
+        if (!RESPONSE_HEADERS_TO_DROP.has(key.toLowerCase())) {
+            res.setHeader(key, value);
+        }
+    }
+}
+export async function streamResponse(response, res) {
+    const chunks = [];
+    let capturedBytes = 0;
+    if (!response.body)
+        return Buffer.alloc(0);
+    for await (const chunk of response.body) {
+        const buffer = Buffer.from(chunk);
+        if (capturedBytes < MAX_USAGE_CAPTURE_BYTES) {
+            const remaining = MAX_USAGE_CAPTURE_BYTES - capturedBytes;
+            chunks.push(buffer.length > remaining ? buffer.subarray(0, remaining) : buffer);
+            capturedBytes += Math.min(buffer.length, remaining);
+        }
+        res.write(buffer);
+    }
+    return Buffer.concat(chunks);
+}
+export async function readRequestBody(req) {
+    const chunks = [];
+    for await (const chunk of req) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks);
+}
+export function methodMayHaveBody(method) {
+    const normalized = (method ?? "GET").toUpperCase();
+    return normalized !== "GET" && normalized !== "HEAD";
+}

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

@@ -0,0 +1 @@
+export { startOpenAiUsageProxy } from "./openai-usage-server.js";

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

@@ -0,0 +1,172 @@
+import { appendUsageEvent } from "../config/usage-store.js";
+import { writeLog } from "../logs/log-service.js";
+import { extractTokenUsage } from "../models/model-discovery.js";
+import { estimateTokenCostUsdFromConfig } from "../usage/pricing.js";
+import { buildUsageEvent } from "../usage/usage-service.js";
+export async function recordUsageFromResponse(input) {
+    const candidate = extractBestUsageCandidate(input.text, input.contentType, input.fallbackModel);
+    if (!candidate) {
+        await writeLog({
+            category: "usage",
+            action: "openai_usage_proxy_no_usage",
+            message: `Provider response did not include usage for ${input.provider} / ${input.fallbackModel}.`,
+            metadata: {
+                tool: input.tool,
+                provider: input.provider,
+                model: input.fallbackModel,
+                contentType: input.contentType
+            }
+        });
+        return false;
+    }
+    const pricedCost = candidate.costUsd ?? await estimateTokenCostUsdFromConfig(input.provider, candidate.model, candidate.usage);
+    const record = {
+        provider: input.provider,
+        model: candidate.model,
+        usage: candidate.usage,
+        costUsd: pricedCost,
+        costSource: candidate.costUsd !== undefined ? "provider" : pricedCost !== undefined ? "pricing" : "unknown"
+    };
+    input.records.push(record);
+    await appendUsageEvent(buildUsageEvent({
+        provider: input.provider,
+        tool: input.tool,
+        model: record.model,
+        source: "proxy",
+        inputTokens: record.usage.inputTokens,
+        outputTokens: record.usage.outputTokens,
+        totalTokens: record.usage.totalTokens,
+        cacheReadInputTokens: record.usage.cacheReadInputTokens
+    })).catch(() => undefined);
+    await writeLog({
+        category: "usage",
+        action: "openai_usage_proxy_recorded",
+        message: `Recorded proxied usage for ${record.provider} / ${record.model}.`,
+        metadata: {
+            tool: input.tool,
+            provider: record.provider,
+            model: record.model,
+            inputTokens: record.usage.inputTokens,
+            outputTokens: record.usage.outputTokens,
+            totalTokens: record.usage.totalTokens,
+            cacheReadInputTokens: record.usage.cacheReadInputTokens,
+            costUsd: record.costUsd,
+            costSource: record.costSource
+        }
+    });
+    await Promise.resolve(input.onUsage?.(record)).catch(() => undefined);
+    return true;
+}
+function extractBestUsageCandidate(text, contentType, fallbackModel) {
+    const values = contentType.includes("text/event-stream") ? parseSseValues(text) : parseJsonValues(text);
+    let best = null;
+    for (const value of values) {
+        for (const candidate of collectUsageCandidates(value, fallbackModel)) {
+            if (!best || candidate.usage.totalTokens >= best.usage.totalTokens) {
+                best = candidate;
+            }
+        }
+    }
+    return best;
+}
+function parseJsonValues(text) {
+    const trimmed = text.trim();
+    if (!trimmed || !/^[\[{]/.test(trimmed))
+        return [];
+    try {
+        return [JSON.parse(trimmed)];
+    }
+    catch {
+        return [];
+    }
+}
+function parseSseValues(text) {
+    const values = [];
+    let data = "";
+    for (const line of text.split(/\r?\n/)) {
+        if (!line.trim()) {
+            pushSseData(values, data);
+            data = "";
+            continue;
+        }
+        if (line.startsWith("data:")) {
+            data += `${line.slice(5).trimStart()}\n`;
+        }
+    }
+    pushSseData(values, data);
+    return values;
+}
+function pushSseData(values, data) {
+    const trimmed = data.trim();
+    if (!trimmed || trimmed === "[DONE]")
+        return;
+    try {
+        values.push(JSON.parse(trimmed));
+    }
+    catch {
+        // Ignore non-JSON SSE frames.
+    }
+}
+function collectUsageCandidates(value, fallbackModel, depth = 0) {
+    if (depth > 6 || !value || typeof value !== "object")
+        return [];
+    const candidates = [];
+    const usage = extractTokenUsage(value);
+    if (usage) {
+        candidates.push({
+            model: extractModel(value) ?? fallbackModel,
+            usage,
+            costUsd: extractCostUsd(value)
+        });
+    }
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            candidates.push(...collectUsageCandidates(item, fallbackModel, depth + 1));
+        }
+        return candidates;
+    }
+    const record = value;
+    for (const nested of Object.values(record)) {
+        candidates.push(...collectUsageCandidates(nested, extractModel(record) ?? fallbackModel, depth + 1));
+    }
+    return candidates;
+}
+export function extractRequestModel(body) {
+    const text = body.toString("utf8").trim();
+    if (!text || !text.startsWith("{"))
+        return undefined;
+    try {
+        return extractModel(JSON.parse(text));
+    }
+    catch {
+        return undefined;
+    }
+}
+function extractModel(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const model = value.model;
+    return typeof model === "string" && model.trim() ? model.trim() : undefined;
+}
+function extractCostUsd(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const record = value;
+    for (const key of ["total_cost_usd", "cost_usd", "costUsd", "totalCostUsd", "total_cost", "cost"]) {
+        const cost = readCostValue(record[key]);
+        if (cost !== undefined)
+            return cost;
+    }
+    return undefined;
+}
+function readCostValue(value) {
+    if (typeof value === "number" && Number.isFinite(value) && value >= 0)
+        return value;
+    if (typeof value === "string" && value.trim()) {
+        const normalized = value.trim().replace(/^\$/, "");
+        const numeric = Number(normalized);
+        if (Number.isFinite(numeric) && numeric >= 0)
+            return numeric;
+    }
+    return undefined;
+}