@offerpilot/axiomruntime 0.0.1

package/dist/core/status/doctor-service.js

@@ -0,0 +1,391 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { getCachePath, getConfigRoot, getProvidersPath, getSessionsPath, getUsagePath } from "../config/paths.js";
+import { readCache } from "../config/cache-store.js";
+import { writeJsonFile } from "../config/json-store.js";
+import { appendUsageEvent } from "../config/usage-store.js";
+import { readProviders } from "../config/providers-store.js";
+import { checkProvider, runDeepCheck } from "../models/model-discovery.js";
+import { writeLog } from "../logs/log-service.js";
+import { getKnownCandidates, resolveToolCommand } from "../runner/command-resolver.js";
+import { resolveProviderCandidatesForTool } from "../runner/fallback.js";
+import { buildUsageEvent } from "../usage/usage-service.js";
+const MIN_NODE_VERSION = "22.19.0";
+export async function runDoctor(options = {}) {
+    const items = [];
+    const fix = options.fix ?? false;
+    const checkProviders = options.checkProviders ?? true;
+    checkNodeVersion(items);
+    if (options.checkNativeDependencies ?? true) {
+        await checkNativeDependencies(items);
+    }
+    await checkConfigRoot(items, fix);
+    await checkRuntimeFiles(items, fix);
+    await checkProvidersAndModels(items, checkProviders);
+    checkCommand("Local CLIs", "claude", items);
+    checkCommand("Local CLIs", "codex", items);
+    return items;
+}
+export async function runDeepDoctor(tool = "codex", options = {}) {
+    const items = await runDoctor(options);
+    try {
+        const candidates = await resolveProviderCandidatesForTool(tool);
+        const success = await runDeepCandidates(tool, candidates, items);
+        if (!success) {
+            items.push({
+                group: "Deep",
+                status: "error",
+                message: "No provider passed deep diagnostics.",
+                suggestion: "Check the provider URL, API key, model, quota, and upstream service status."
+            });
+        }
+    }
+    catch (error) {
+        items.push({
+            group: "Deep",
+            status: "warn",
+            message: `No usable provider for the ${tool} deep check: ${formatError(error)}`,
+            suggestion: "Run `ai setup` to configure a provider, then retry the deep check."
+        });
+    }
+    return items;
+}
+function checkNodeVersion(items) {
+    const current = process.versions.node;
+    if (compareVersions(current, MIN_NODE_VERSION) >= 0) {
+        items.push({ group: "Installation", status: "ok", message: `Node.js ${current} (required: >=${MIN_NODE_VERSION}).` });
+        return;
+    }
+    items.push({
+        group: "Installation",
+        status: "error",
+        message: `Node.js ${current} is too old (required: >=${MIN_NODE_VERSION}).`,
+        suggestion: "Upgrade Node.js, then reinstall `@offerpilot/axiomruntime`."
+    });
+}
+async function checkNativeDependencies(items) {
+    try {
+        await import("better-sqlite3");
+        items.push({ group: "Installation", status: "ok", message: "Native SQLite dependency loaded successfully." });
+    }
+    catch (error) {
+        items.push({
+            group: "Installation",
+            status: "error",
+            message: `Native SQLite dependency failed to load: ${formatError(error)}`,
+            suggestion: "Reinstall with `npm install --global @offerpilot/axiomruntime`, then run `ai doctor` again."
+        });
+    }
+}
+async function checkConfigRoot(items, fix) {
+    const configRoot = getConfigRoot();
+    try {
+        await fs.access(configRoot, fs.constants.R_OK | fs.constants.W_OK);
+        items.push({ group: "Runtime Home", status: "ok", message: `${configRoot} is readable and writable.` });
+    }
+    catch (error) {
+        if (error.code === "ENOENT" && fix) {
+            try {
+                await fs.mkdir(configRoot, { recursive: true, mode: 0o700 });
+                items.push({ group: "Runtime Home", status: "ok", message: `Created ${configRoot}.`, fixed: true });
+                return;
+            }
+            catch (repairError) {
+                items.push({
+                    group: "Runtime Home",
+                    status: "error",
+                    message: `Could not create ${configRoot}: ${formatError(repairError)}`,
+                    suggestion: "Set `AI_GATEWAY_HOME` to a writable directory and retry."
+                });
+                return;
+            }
+        }
+        items.push({
+            group: "Runtime Home",
+            status: error.code === "ENOENT" ? "warn" : "error",
+            message: `${configRoot} is not ready: ${formatError(error)}`,
+            suggestion: fix
+                ? "Set `AI_GATEWAY_HOME` to a writable directory and retry."
+                : "Run `ai doctor --fix` or `ai setup` to create it."
+        });
+    }
+}
+async function checkRuntimeFiles(items, fix) {
+    const specs = [
+        {
+            group: "Providers",
+            filePath: getProvidersPath(),
+            defaultValue: [],
+            validate: Array.isArray,
+            repairInvalid: false
+        },
+        {
+            group: "Cache",
+            filePath: getCachePath(),
+            defaultValue: { providers: {} },
+            validate: (value) => isRecord(value) && isRecord(value.providers),
+            repairInvalid: true
+        },
+        {
+            group: "Usage",
+            filePath: getUsagePath(),
+            defaultValue: { events: [] },
+            validate: (value) => isRecord(value) && Array.isArray(value.events),
+            repairInvalid: true
+        },
+        {
+            group: "Sessions",
+            filePath: getSessionsPath(),
+            defaultValue: { sessions: [] },
+            validate: (value) => isRecord(value) && Array.isArray(value.sessions),
+            repairInvalid: true
+        }
+    ];
+    for (const spec of specs) {
+        await checkJsonFile(spec, items, fix);
+    }
+}
+async function checkJsonFile(spec, items, fix) {
+    try {
+        await fs.access(spec.filePath, fs.constants.R_OK | fs.constants.W_OK);
+        const raw = await fs.readFile(spec.filePath, "utf8");
+        const value = JSON.parse(raw);
+        if (!spec.validate(value)) {
+            throw new Error("unexpected JSON structure");
+        }
+        items.push({ group: spec.group, status: "ok", message: `${spec.filePath} is valid.` });
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ENOENT") {
+            if (fix) {
+                try {
+                    await writeJsonFile(spec.filePath, spec.defaultValue);
+                    items.push({ group: spec.group, status: "ok", message: `Created ${spec.filePath}.`, fixed: true });
+                }
+                catch (repairError) {
+                    items.push({
+                        group: spec.group,
+                        status: "error",
+                        message: `Could not create ${spec.filePath}: ${formatError(repairError)}`,
+                        suggestion: "Check the Runtime home directory permissions."
+                    });
+                }
+            }
+            else {
+                items.push({
+                    group: spec.group,
+                    status: "warn",
+                    message: `${spec.filePath} does not exist yet.`,
+                    suggestion: "Run `ai doctor --fix` or `ai setup` to create it."
+                });
+            }
+            return;
+        }
+        if (fix && spec.repairInvalid && isRepairableJsonError(error)) {
+            try {
+                const backupPath = await backupInvalidFile(spec.filePath);
+                await writeJsonFile(spec.filePath, spec.defaultValue);
+                items.push({
+                    group: spec.group,
+                    status: "ok",
+                    message: `Rebuilt ${spec.filePath}; invalid data was backed up to ${backupPath}.`,
+                    fixed: true
+                });
+                return;
+            }
+            catch (repairError) {
+                items.push({
+                    group: spec.group,
+                    status: "error",
+                    message: `Could not repair ${spec.filePath}: ${formatError(repairError)}`,
+                    suggestion: "Check file permissions and restore the latest valid backup."
+                });
+                return;
+            }
+        }
+        items.push({
+            group: spec.group,
+            status: "error",
+            message: `${spec.filePath} is invalid: ${formatError(error)}`,
+            suggestion: spec.repairInvalid
+                ? "Run `ai doctor --fix` to back up and rebuild this derived file."
+                : "Provider configuration is never overwritten automatically. Correct or restore providers.json, then retry."
+        });
+    }
+}
+async function checkProvidersAndModels(items, checkConnectivity) {
+    let providers;
+    try {
+        providers = await readProviders();
+    }
+    catch (error) {
+        items.push({
+            group: "Providers",
+            status: "error",
+            message: `Provider configuration could not be loaded: ${formatError(error)}`,
+            suggestion: "Correct or restore providers.json; `ai doctor` will not overwrite provider credentials."
+        });
+        return;
+    }
+    if (!providers.length) {
+        items.push({
+            group: "Providers",
+            status: "warn",
+            message: "No providers are configured.",
+            suggestion: "Run `ai setup` or `ai provider add` to configure the first provider."
+        });
+        return;
+    }
+    items.push({ group: "Providers", status: "ok", message: `${providers.length} provider(s) configured.` });
+    let cache = null;
+    try {
+        cache = await readCache();
+    }
+    catch (error) {
+        items.push({
+            group: "Cache",
+            status: "error",
+            message: `Provider cache could not be loaded: ${formatError(error)}`,
+            suggestion: "Run `ai doctor --fix` to back up and rebuild the cache."
+        });
+    }
+    for (const provider of providers) {
+        const cached = cache?.providers[provider.name];
+        if (provider.model && cached?.models?.length && !cached.models.includes(provider.model)) {
+            items.push({
+                group: "Models",
+                status: "warn",
+                message: `${provider.name} default model is not in the last discovered model list: ${provider.model}`,
+                suggestion: `Run \`ai status\` to refresh models, then edit ${provider.name} if necessary.`
+            });
+        }
+        if (!checkConnectivity)
+            continue;
+        const result = await checkProvider(provider);
+        const healthy = result.status === "ok" && result.models.length > 0;
+        items.push({
+            group: "Providers",
+            status: healthy ? "ok" : "error",
+            message: healthy
+                ? `${provider.name}: reachable; discovered ${result.models.length} model(s).`
+                : `${provider.name}: ${result.error ?? "provider returned no models"}`,
+            suggestion: healthy ? undefined : diagnoseProviderError(provider.name, result.error)
+        });
+    }
+}
+async function runDeepCandidates(tool, candidates, items) {
+    for (const candidate of candidates) {
+        const result = await runDeepCheck(candidate.provider, candidate.model);
+        if (result.status === "ok") {
+            if (result.usage) {
+                await recordDeepUsage(tool, candidate, result.usage);
+            }
+            items.push({
+                group: "Deep",
+                status: "ok",
+                message: `${candidate.provider.name}/${candidate.model}: ok${formatUsage(result)}`
+            });
+            return true;
+        }
+        items.push({
+            group: "Deep",
+            status: "warn",
+            message: `${candidate.provider.name}/${candidate.model}: failed, trying next provider (${result.error})`,
+            suggestion: diagnoseProviderError(candidate.provider.name, result.error)
+        });
+        await writeLog({
+            level: "warn",
+            category: "strategy",
+            action: "deep_fallback",
+            message: `${candidate.provider.name}/${candidate.model} failed deep check; trying next provider.`,
+            metadata: { provider: candidate.provider.name, model: candidate.model, tool, error: result.error }
+        });
+    }
+    return false;
+}
+async function recordDeepUsage(tool, candidate, usage) {
+    await appendUsageEvent(buildUsageEvent({
+        provider: candidate.provider.name,
+        tool,
+        model: candidate.model,
+        source: "doctor_deep",
+        inputTokens: usage.inputTokens,
+        outputTokens: usage.outputTokens,
+        totalTokens: usage.totalTokens
+    }));
+    await writeLog({
+        category: "usage",
+        action: "token_usage_recorded",
+        message: `Recorded ${usage.totalTokens} token(s) from doctor deep check.`,
+        metadata: {
+            provider: candidate.provider.name,
+            tool,
+            model: candidate.model,
+            source: "doctor_deep",
+            inputTokens: usage.inputTokens,
+            outputTokens: usage.outputTokens,
+            totalTokens: usage.totalTokens
+        }
+    });
+}
+function checkCommand(group, command, items) {
+    const resolved = resolveToolCommand(command);
+    if (resolved) {
+        items.push({ group, status: "ok", message: `${command}: ${resolved}` });
+        return;
+    }
+    const packageName = command === "claude" ? "@anthropic-ai/claude-code" : "@openai/codex";
+    items.push({
+        group,
+        status: "warn",
+        message: `${command} is not installed or failed its version check. Checked: ${getKnownCandidates(command).join(", ")}`,
+        suggestion: `Run \`ai setup\` or install it with \`npm install --global ${packageName}\`.`
+    });
+}
+function diagnoseProviderError(providerName, error) {
+    const message = (error ?? "").toLowerCase();
+    if (/401|403|unauthor|forbidden|api.?key|credential/.test(message)) {
+        return `Check the API key for ${providerName} with \`ai provider edit ${providerName}\`.`;
+    }
+    if (/404|not found|base url|non-json/.test(message)) {
+        return `Check the Base URL for ${providerName}; it may need or may already include /v1.`;
+    }
+    if (/429|quota|rate.?limit|credit|billing/.test(message)) {
+        return `Check quota, billing, and rate limits for ${providerName}.`;
+    }
+    if (/timeout|abort|network|fetch|enotfound|econn/.test(message)) {
+        return `Check network access, proxy settings, DNS, and the Base URL for ${providerName}.`;
+    }
+    return `Run \`ai provider edit ${providerName}\` to verify its URL, API key, and default model.`;
+}
+function formatUsage(result) {
+    if (!result.usage)
+        return " (usage not returned)";
+    return ` (${result.usage.totalTokens} tokens: ${result.usage.inputTokens} input, ${result.usage.outputTokens} output)`;
+}
+function compareVersions(left, right) {
+    const leftParts = left.split(".").map(Number);
+    const rightParts = right.split(".").map(Number);
+    for (let index = 0; index < Math.max(leftParts.length, rightParts.length); index += 1) {
+        const difference = (leftParts[index] ?? 0) - (rightParts[index] ?? 0);
+        if (difference !== 0)
+            return difference;
+    }
+    return 0;
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function isRepairableJsonError(error) {
+    return error instanceof SyntaxError || (error instanceof Error && error.message === "unexpected JSON structure");
+}
+async function backupInvalidFile(filePath) {
+    const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const backupPath = path.join(path.dirname(filePath), `${path.basename(filePath)}.invalid-${stamp}`);
+    await fs.rename(filePath, backupPath);
+    return backupPath;
+}
+function formatError(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/core/status/status-service.js

@@ -0,0 +1,60 @@
+import { readCache } from "../config/cache-store.js";
+import { readProviders } from "../config/providers-store.js";
+import { isModelCompatible, pickCompatibleModel } from "../models/model-filter.js";
+import { refreshAllProviders } from "../providers/provider-service.js";
+import { getToolBaseUrl } from "../runner/tool-runner.js";
+import { getUsageShare, getWeeklyTokenMap } from "../usage/usage-service.js";
+export async function getProviderStatuses(options = {}) {
+    if (options.refresh) {
+        await refreshAllProviders();
+    }
+    const [providers, cache, weeklyTokens] = await Promise.all([readProviders(), readCache(), getWeeklyTokenMap()]);
+    const allTokens = [...weeklyTokens.values()].reduce((sum, value) => sum + value, 0);
+    return providers.map((provider) => {
+        const cached = cache.providers[provider.name];
+        const tokens = weeklyTokens.get(provider.name) ?? 0;
+        return {
+            ...provider,
+            health: cached?.status ?? "unknown",
+            models: cached?.models ?? [],
+            lastCheckedAt: cached?.lastCheckedAt ?? null,
+            lastError: cached?.lastError ?? null,
+            weeklyTokens: tokens,
+            usageShare: getUsageShare(tokens, allTokens),
+            claude: buildToolStatus("claude", provider, cached?.status ?? "unknown", cached?.models ?? []),
+            codex: buildToolStatus("codex", provider, cached?.status ?? "unknown", cached?.models ?? [])
+        };
+    });
+}
+function buildToolStatus(tool, provider, health, models) {
+    const baseUrl = getToolBaseUrl(tool, provider);
+    if (health === "error") {
+        return {
+            state: "provider-error",
+            baseUrl,
+            model: null,
+            note: "provider health error"
+        };
+    }
+    const model = resolveToolModel(tool, provider.model, models);
+    if (!model) {
+        return {
+            state: "no-model",
+            baseUrl,
+            model: null,
+            note: "no compatible cached model"
+        };
+    }
+    return {
+        state: "ready",
+        baseUrl,
+        model,
+        note: models.includes(model) ? "model listed" : "default model not verified"
+    };
+}
+function resolveToolModel(tool, defaultModel, models) {
+    if (defaultModel && isModelCompatible(tool, defaultModel) && (!models.length || models.includes(defaultModel))) {
+        return defaultModel;
+    }
+    return pickCompatibleModel(tool, "", models);
+}

package/dist/core/types.js

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

package/dist/core/usage/pricing.js

@@ -0,0 +1,113 @@
+import { getModelPricingPath } from "../config/paths.js";
+import { readJsonFile, updateJsonFile } from "../config/json-store.js";
+import { isRecord } from "../utils/is-record.js";
+export async function readModelPricing() {
+    const raw = await readJsonFile(getModelPricingPath(), {});
+    return normalizePricingTable(raw);
+}
+export async function estimateTokenCostUsdFromConfig(providerName, model, usage) {
+    return estimateTokenCostUsd(providerName, model, usage, await readModelPricing());
+}
+export async function upsertModelPrice(providerName, model, price) {
+    const key = getProviderModelPricingKey(providerName, model);
+    return updateJsonFile(getModelPricingPath(), {}, (raw) => ({
+        ...normalizePricingTable(raw),
+        [key]: price
+    }));
+}
+export function getProviderModelPricingKey(providerName, model) {
+    return `${providerName.trim()}/${model.trim()}`;
+}
+export function estimateTokenCostUsd(providerName, model, usage, pricing) {
+    const price = resolveModelPrice(providerName, model, pricing);
+    if (!price)
+        return undefined;
+    const cacheReadInputTokens = usage.cacheReadInputTokens ?? 0;
+    const regularInputTokens = Math.max(0, usage.inputTokens - cacheReadInputTokens);
+    const cacheReadPrice = price.cacheReadPerMillionUsd ?? price.inputPerMillionUsd;
+    const cost = (regularInputTokens * price.inputPerMillionUsd
+        + cacheReadInputTokens * cacheReadPrice
+        + usage.outputTokens * price.outputPerMillionUsd) / 1_000_000;
+    return Number(cost.toFixed(8));
+}
+export function normalizePricingTable(value) {
+    const source = isRecord(value) && isRecord(value.models) ? value.models : value;
+    if (!isRecord(source))
+        return {};
+    const table = {};
+    for (const [key, rawPrice] of Object.entries(source)) {
+        const price = normalizeModelPrice(rawPrice);
+        if (key.trim() && price) {
+            table[key.trim()] = price;
+        }
+    }
+    return table;
+}
+function resolveModelPrice(providerName, model, pricing) {
+    const keys = [
+        `${providerName}/${model}`,
+        `${providerName}:${model}`,
+        model
+    ];
+    for (const key of keys) {
+        const exact = pricing[key];
+        if (exact)
+            return exact;
+        const lower = Object.entries(pricing).find(([candidate]) => candidate.toLowerCase() === key.toLowerCase());
+        if (lower)
+            return lower[1];
+    }
+    return undefined;
+}
+function normalizeModelPrice(value) {
+    if (!isRecord(value))
+        return null;
+    const inputPerMillionUsd = readFiniteNumber(value, [
+        "inputPerMillionUsd",
+        "input_per_million_usd",
+        "input",
+        "promptPerMillionUsd",
+        "prompt_per_million_usd"
+    ]);
+    const outputPerMillionUsd = readFiniteNumber(value, [
+        "outputPerMillionUsd",
+        "output_per_million_usd",
+        "output",
+        "completionPerMillionUsd",
+        "completion_per_million_usd"
+    ]);
+    if (inputPerMillionUsd === undefined || outputPerMillionUsd === undefined)
+        return null;
+    const cacheReadPerMillionUsd = readFiniteNumber(value, [
+        "cacheReadPerMillionUsd",
+        "cache_read_per_million_usd",
+        "cacheRead",
+        "cache_read",
+        "cachedInputPerMillionUsd",
+        "cached_input_per_million_usd",
+        "cachedInput",
+        "cached_input"
+    ]);
+    if (inputPerMillionUsd < 0 || outputPerMillionUsd < 0)
+        return null;
+    if (cacheReadPerMillionUsd !== undefined && cacheReadPerMillionUsd < 0)
+        return null;
+    return {
+        inputPerMillionUsd,
+        outputPerMillionUsd,
+        ...(cacheReadPerMillionUsd !== undefined ? { cacheReadPerMillionUsd } : {})
+    };
+}
+function readFiniteNumber(data, keys) {
+    for (const key of keys) {
+        const value = data[key];
+        if (typeof value === "number" && Number.isFinite(value))
+            return value;
+        if (typeof value === "string" && value.trim()) {
+            const numeric = Number(value);
+            if (Number.isFinite(numeric))
+                return numeric;
+        }
+    }
+    return undefined;
+}

package/dist/core/usage/usage-service.js

@@ -0,0 +1,30 @@
+import { readUsage } from "../config/usage-store.js";
+export async function getWeeklyTokenMap() {
+    const usage = await readUsage();
+    const start = getWeekStart(new Date());
+    const map = new Map();
+    for (const event of usage.events) {
+        if (new Date(event.createdAt) >= start) {
+            map.set(event.provider, (map.get(event.provider) ?? 0) + event.totalTokens);
+        }
+    }
+    return map;
+}
+export function getUsageShare(providerTokens, allTokens) {
+    if (!allTokens)
+        return 0;
+    return Number(((providerTokens / allTokens) * 100).toFixed(2));
+}
+export function buildUsageEvent(input) {
+    return {
+        ...input,
+        createdAt: new Date().toISOString()
+    };
+}
+function getWeekStart(date) {
+    const start = new Date(date);
+    const day = start.getDay() || 7;
+    start.setHours(0, 0, 0, 0);
+    start.setDate(start.getDate() - day + 1);
+    return start;
+}

package/dist/core/utils/is-record.js

@@ -0,0 +1,3 @@
+export function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/server/index.js

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import { startRuntimeServer } from "./runtime-server.js";
+function readToken() {
+    const inline = process.env.AI_GATEWAY_SERVER_TOKEN?.trim();
+    if (inline)
+        return inline;
+    const file = process.env.AI_GATEWAY_SERVER_TOKEN_FILE?.trim();
+    if (file)
+        return fs.readFileSync(file, "utf8").trim();
+    throw new Error("Set AI_GATEWAY_SERVER_TOKEN or AI_GATEWAY_SERVER_TOKEN_FILE.");
+}
+const server = await startRuntimeServer({
+    host: process.env.AI_GATEWAY_SERVER_HOST || "127.0.0.1",
+    port: Number(process.env.AI_GATEWAY_SERVER_PORT || "8080"),
+    token: readToken(),
+    maxRequestBytes: Number(process.env.AI_GATEWAY_MAX_REQUEST_BYTES || "16777216"),
+    upstreamHeadersTimeoutMs: Number(process.env.AI_GATEWAY_UPSTREAM_HEADERS_TIMEOUT_MS || "45000"),
+    agentWorkspaceRoot: process.env.AI_GATEWAY_AGENT_WORKSPACE_ROOT,
+    agentMaxConcurrentRuns: Number(process.env.AI_GATEWAY_AGENT_MAX_CONCURRENT_RUNS || "2"),
+    agentTimeoutMs: Number(process.env.AI_GATEWAY_AGENT_TIMEOUT_MS || "600000")
+});
+console.log(`AI Gateway runtime server listening on ${server.baseUrl}`);
+for (const signal of ["SIGINT", "SIGTERM"]) {
+    process.once(signal, () => {
+        void server.close().finally(() => process.exit(0));
+    });
+}