@offerpilot/axiomruntime 0.0.1

package/dist/core/models/model-discovery.js

@@ -0,0 +1,430 @@
+const RETRY_DELAYS_MS = [0, 200, 600];
+const RETRYABLE_STATUS_CODES = new Set([408, 409, 425, 429, 500, 502, 503, 504]);
+export async function checkProvider(provider) {
+    const checkedAt = new Date().toISOString();
+    const startedAt = Date.now();
+    const errors = [];
+    const retryErrors = [];
+    let attempts = 0;
+    try {
+        for (const url of buildModelUrlCandidates(provider.baseUrl)) {
+            const result = await fetchTextWithRetry(url, {
+                method: "GET",
+                headers: {
+                    Authorization: `Bearer ${provider.apiKey}`,
+                    Accept: "application/json"
+                }
+            });
+            attempts += result.attempts;
+            retryErrors.push(...result.retryErrors);
+            if (result.error || !result.response) {
+                errors.push(`GET ${url} failed: ${result.error ?? "empty response"}`);
+                continue;
+            }
+            const { response, text } = result;
+            if (!response.ok) {
+                errors.push(`GET ${url} failed with ${response.status} ${response.statusText}`);
+                continue;
+            }
+            const contentType = response.headers.get("content-type") ?? "";
+            if (!looksLikeJson(contentType, text)) {
+                errors.push(`GET ${url} returned ${contentType || "non-JSON response"}. Base URL may need /v1.`);
+                continue;
+            }
+            const models = extractModels(JSON.parse(text));
+            return {
+                status: "ok",
+                models,
+                checkedAt,
+                error: models.length ? null : "Provider responded but no models were found.",
+                attempts,
+                durationMs: Date.now() - startedAt,
+                retryErrors
+            };
+        }
+        return {
+            status: "error",
+            models: [],
+            checkedAt,
+            error: errors.join("; ") || "No model discovery endpoint worked.",
+            attempts,
+            durationMs: Date.now() - startedAt,
+            retryErrors
+        };
+    }
+    catch (error) {
+        return {
+            status: "error",
+            models: [],
+            checkedAt,
+            error: error instanceof Error ? error.message : String(error),
+            attempts,
+            durationMs: Date.now() - startedAt,
+            retryErrors
+        };
+    }
+}
+export async function runDeepCheck(provider, model) {
+    const checkedAt = new Date().toISOString();
+    const startedAt = Date.now();
+    try {
+        const url = buildChatCompletionsUrl(provider.baseUrl);
+        const result = await fetchTextWithRetry(url, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${provider.apiKey}`,
+                "Content-Type": "application/json",
+                Accept: "application/json"
+            },
+            body: JSON.stringify({
+                model,
+                messages: [{ role: "user", content: "ping" }],
+                max_tokens: 1,
+                temperature: 0
+            })
+        });
+        if (result.error || !result.response) {
+            return {
+                status: "error",
+                models: [],
+                checkedAt,
+                error: result.error ?? "empty response",
+                attempts: result.attempts,
+                durationMs: Date.now() - startedAt,
+                retryErrors: result.retryErrors
+            };
+        }
+        const { response, text } = result;
+        if (!response.ok) {
+            return {
+                status: "error",
+                models: [],
+                checkedAt,
+                error: `POST ${url} failed with ${response.status} ${response.statusText}`,
+                attempts: result.attempts,
+                durationMs: Date.now() - startedAt,
+                retryErrors: result.retryErrors
+            };
+        }
+        const json = looksLikeJson(response.headers.get("content-type") ?? "", text) ? JSON.parse(text) : {};
+        return {
+            status: "ok",
+            models: [model],
+            checkedAt,
+            error: null,
+            usage: extractTokenUsage(json),
+            attempts: result.attempts,
+            durationMs: Date.now() - startedAt,
+            retryErrors: result.retryErrors
+        };
+    }
+    catch (error) {
+        return {
+            status: "error",
+            models: [],
+            checkedAt,
+            error: error instanceof Error ? error.message : String(error),
+            attempts: 1,
+            durationMs: Date.now() - startedAt,
+            retryErrors: []
+        };
+    }
+}
+export async function checkCallableModels(provider, models) {
+    const uniqueModels = [...new Set(models.filter(Boolean))];
+    return mapWithConcurrency(uniqueModels, 3, (model) => checkCallableModel(provider, model));
+}
+async function checkCallableModel(provider, model) {
+    const lower = model.toLowerCase();
+    return lower.includes("claude")
+        ? checkAnthropicMessagesModel(provider, model)
+        : checkChatCompletionsModel(provider, model);
+}
+async function checkAnthropicMessagesModel(provider, model) {
+    const baseUrl = provider.baseUrl.replace(/\/+$/, "").replace(/\/v1$/i, "");
+    const url = `${baseUrl}/v1/messages`;
+    const payload = {
+        model,
+        max_tokens: 1,
+        messages: [{ role: "user", content: "." }]
+    };
+    const headers = {
+        "x-api-key": provider.apiKey,
+        "anthropic-version": "2023-06-01",
+        "Content-Type": "application/json",
+        Accept: "application/json"
+    };
+    return postModelProbe(url, headers, payload, model);
+}
+async function checkChatCompletionsModel(provider, model) {
+    const payload = {
+        model,
+        messages: [{ role: "user", content: "." }],
+        max_tokens: 1,
+        temperature: 0
+    };
+    const headers = {
+        Authorization: `Bearer ${provider.apiKey}`,
+        "Content-Type": "application/json",
+        Accept: "application/json"
+    };
+    let lastResult = null;
+    for (const url of buildChatCompletionsUrlCandidates(provider.baseUrl)) {
+        const result = await postModelProbe(url, headers, payload, model);
+        if (result.status === "ok")
+            return result;
+        lastResult = result;
+    }
+    return lastResult ?? { model, status: "error", error: "No chat completions endpoint worked." };
+}
+async function postModelProbe(url, headers, payload, model) {
+    try {
+        const result = await fetchTextWithRetry(url, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(payload)
+        });
+        if (result.error || !result.response) {
+            return {
+                model,
+                status: "error",
+                error: result.error ?? "empty response",
+                attempts: result.attempts,
+                durationMs: result.durationMs,
+                retryErrors: result.retryErrors
+            };
+        }
+        const { response, text } = result;
+        const json = looksLikeJson(response.headers.get("content-type") ?? "", text) ? JSON.parse(text) : {};
+        if (!response.ok) {
+            return {
+                model,
+                status: "error",
+                error: `POST ${url} failed with ${response.status} ${response.statusText}${extractErrorMessage(json)}`,
+                attempts: result.attempts,
+                durationMs: result.durationMs,
+                retryErrors: result.retryErrors
+            };
+        }
+        return {
+            model,
+            status: "ok",
+            error: null,
+            usage: extractTokenUsage(json),
+            attempts: result.attempts,
+            durationMs: result.durationMs,
+            retryErrors: result.retryErrors
+        };
+    }
+    catch (error) {
+        return {
+            model,
+            status: "error",
+            error: error instanceof Error ? error.message : String(error),
+            attempts: 1,
+            durationMs: 0,
+            retryErrors: []
+        };
+    }
+}
+export function extractTokenUsage(value) {
+    const usage = value?.usage;
+    if (!usage || typeof usage !== "object") {
+        return undefined;
+    }
+    const data = usage;
+    const rawInputTokens = readNumber(data, ["input_tokens", "prompt_tokens", "inputTokens", "promptTokens"]);
+    const outputTokens = readNumber(data, ["output_tokens", "completion_tokens", "outputTokens", "completionTokens"]);
+    const totalTokens = readNumber(data, ["total_tokens", "totalTokens"]);
+    const cacheReadInputTokens = readCacheReadInputTokens(data);
+    const cacheCreationInputTokens = readNumber(data, [
+        "cache_creation_input_tokens",
+        "cacheCreationInputTokens",
+        "cache_creation_tokens",
+        "cacheCreationTokens"
+    ]) ?? 0;
+    if (rawInputTokens === undefined
+        && outputTokens === undefined
+        && totalTokens === undefined
+        && cacheReadInputTokens === undefined) {
+        return undefined;
+    }
+    const input = normalizeInputTokens(data, rawInputTokens ?? 0, cacheReadInputTokens ?? 0, cacheCreationInputTokens);
+    const output = outputTokens ?? 0;
+    return {
+        inputTokens: input,
+        outputTokens: output,
+        totalTokens: totalTokens ?? input + output,
+        ...(cacheReadInputTokens !== undefined ? { cacheReadInputTokens } : {})
+    };
+}
+function normalizeInputTokens(data, rawInputTokens, cacheReadInputTokens, cacheCreationInputTokens) {
+    return hasNestedCachedTokens(data)
+        ? rawInputTokens
+        : rawInputTokens + cacheReadInputTokens + cacheCreationInputTokens;
+}
+function readCacheReadInputTokens(data) {
+    return readNumber(data, [
+        "cache_read_input_tokens",
+        "cacheReadInputTokens",
+        "cache_read_tokens",
+        "cacheReadTokens",
+        "cached_tokens",
+        "cachedTokens"
+    ])
+        ?? readNumberFromRecord(data.prompt_tokens_details, ["cached_tokens", "cachedTokens"])
+        ?? readNumberFromRecord(data.input_tokens_details, ["cached_tokens", "cachedTokens", "cache_read_tokens", "cacheReadTokens"]);
+}
+function hasNestedCachedTokens(data) {
+    return readNumberFromRecord(data.prompt_tokens_details, ["cached_tokens", "cachedTokens"]) !== undefined
+        || readNumberFromRecord(data.input_tokens_details, ["cached_tokens", "cachedTokens", "cache_read_tokens", "cacheReadTokens"]) !== undefined;
+}
+function readNumberFromRecord(value, keys) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    return readNumber(value, keys);
+}
+function readNumber(data, keys) {
+    for (const key of keys) {
+        const value = data[key];
+        if (typeof value === "number" && Number.isFinite(value)) {
+            return value;
+        }
+    }
+    return undefined;
+}
+function buildModelUrlCandidates(baseUrl) {
+    const normalized = baseUrl.replace(/\/+$/, "");
+    const candidates = [`${normalized}/models`];
+    if (!normalized.endsWith("/v1")) {
+        candidates.push(`${normalized}/v1/models`);
+    }
+    return candidates;
+}
+function buildChatCompletionsUrl(baseUrl) {
+    return `${baseUrl.replace(/\/+$/, "")}/chat/completions`;
+}
+function buildChatCompletionsUrlCandidates(baseUrl) {
+    const normalized = baseUrl.replace(/\/+$/, "");
+    const candidates = [`${normalized}/chat/completions`];
+    if (!normalized.endsWith("/v1")) {
+        candidates.push(`${normalized}/v1/chat/completions`);
+    }
+    return candidates;
+}
+async function fetchTextWithRetry(url, init) {
+    const startedAt = Date.now();
+    const retryErrors = [];
+    for (const [index, delayMs] of RETRY_DELAYS_MS.entries()) {
+        if (delayMs > 0) {
+            await sleep(delayMs);
+        }
+        const attempt = index + 1;
+        try {
+            const response = await fetchWithTimeout(url, init);
+            const text = await response.text();
+            if (!shouldRetryResponse(response) || attempt >= RETRY_DELAYS_MS.length) {
+                return {
+                    response,
+                    text,
+                    attempts: attempt,
+                    durationMs: Date.now() - startedAt,
+                    retryErrors
+                };
+            }
+            retryErrors.push(`attempt ${attempt}: ${response.status} ${response.statusText}`);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (attempt >= RETRY_DELAYS_MS.length) {
+                return {
+                    text: "",
+                    error: message,
+                    attempts: attempt,
+                    durationMs: Date.now() - startedAt,
+                    retryErrors
+                };
+            }
+            retryErrors.push(`attempt ${attempt}: ${message}`);
+        }
+    }
+    return {
+        text: "",
+        error: "Request failed after retries.",
+        attempts: RETRY_DELAYS_MS.length,
+        durationMs: Date.now() - startedAt,
+        retryErrors
+    };
+}
+function shouldRetryResponse(response) {
+    return RETRYABLE_STATUS_CODES.has(response.status);
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function fetchWithTimeout(url, init, timeoutMs = 12000) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        return await fetch(url, { ...init, signal: controller.signal });
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function looksLikeJson(contentType, text) {
+    const trimmed = text.trim();
+    return contentType.includes("application/json") || trimmed.startsWith("{") || trimmed.startsWith("[");
+}
+function extractModels(value) {
+    const payload = value;
+    const source = Array.isArray(payload.data)
+        ? payload.data
+        : Array.isArray(payload.models)
+            ? payload.models
+            : Array.isArray(value)
+                ? value
+                : [];
+    const models = source
+        .map((entry) => {
+        if (typeof entry === "string")
+            return entry;
+        if (entry && typeof entry === "object" && "id" in entry) {
+            return String(entry.id);
+        }
+        if (entry && typeof entry === "object" && "name" in entry) {
+            return String(entry.name);
+        }
+        return "";
+    })
+        .filter(Boolean);
+    return [...new Set(models)].sort((a, b) => a.localeCompare(b));
+}
+function extractErrorMessage(value) {
+    if (!value || typeof value !== "object")
+        return "";
+    const data = value;
+    const error = data.error;
+    if (typeof error === "string")
+        return `: ${error}`;
+    if (error && typeof error === "object") {
+        const message = error.message;
+        if (typeof message === "string")
+            return `: ${message}`;
+    }
+    const message = data.message;
+    return typeof message === "string" ? `: ${message}` : "";
+}
+async function mapWithConcurrency(items, limit, mapper) {
+    const results = new Array(items.length);
+    let nextIndex = 0;
+    const workers = Array.from({ length: Math.min(limit, items.length) }, async () => {
+        while (nextIndex < items.length) {
+            const currentIndex = nextIndex;
+            nextIndex += 1;
+            results[currentIndex] = await mapper(items[currentIndex]);
+        }
+    });
+    await Promise.all(workers);
+    return results;
+}

package/dist/core/models/model-filter.js

@@ -0,0 +1,13 @@
+export function isModelCompatible(tool, model) {
+    const value = model.toLowerCase();
+    if (tool === "claude") {
+        return value.includes("claude");
+    }
+    return value.includes("gpt") || value.includes("codex") || value.includes("grok") || /^o\d/.test(value) || value.includes("openai");
+}
+export function pickCompatibleModel(tool, preferredModel, models) {
+    if (preferredModel && isModelCompatible(tool, preferredModel)) {
+        return preferredModel;
+    }
+    return models.find((model) => isModelCompatible(tool, model)) ?? null;
+}

package/dist/core/providers/provider-service.js

@@ -0,0 +1,212 @@
+import { buildProviderHealthCache, deleteProviderCache, readCache, renameProviderCache, upsertProviderCache } from "../config/cache-store.js";
+import { appendUsageEvent } from "../config/usage-store.js";
+import { recordProviderChange } from "../integrations/integration-state.js";
+import { writeLog } from "../logs/log-service.js";
+import { readProviders, swapProviderLevel, updateProviders } from "../config/providers-store.js";
+import { checkCallableModels, checkProvider } from "../models/model-discovery.js";
+import { buildUsageEvent } from "../usage/usage-service.js";
+export async function listProviders() {
+    return readProviders();
+}
+export async function addProvider(input) {
+    const providers = await readProviders();
+    if (providers.some((provider) => provider.name === input.name.trim())) {
+        throw new Error(`Provider already exists: ${input.name}`);
+    }
+    const draft = {
+        name: input.name.trim(),
+        baseUrl: input.baseUrl.trim().replace(/\/+$/, ""),
+        apiKey: input.apiKey.trim(),
+        mode: input.mode ?? "auto",
+        level: providers.length + 1,
+        model: input.model?.trim() ?? ""
+    };
+    const result = await checkProvider(draft);
+    const model = draft.model || result.models[0] || "";
+    const normalizedProviders = await updateProviders((current) => {
+        if (current.some((provider) => provider.name === draft.name)) {
+            throw new Error(`Provider already exists: ${draft.name}`);
+        }
+        return [...current, { ...draft, level: current.length + 1, model }];
+    });
+    const provider = normalizedProviders.find((item) => item.name === draft.name);
+    if (!provider) {
+        throw new Error("Provider add failed.");
+    }
+    await upsertProviderCache(provider.name, buildProviderHealthCache(undefined, {
+        status: result.status,
+        models: result.models,
+        lastCheckedAt: result.checkedAt,
+        lastError: result.error
+    }));
+    await recordProviderChange({ type: "added", provider: provider.name });
+    return provider;
+}
+export async function updateProvider(providerName, patch) {
+    const targetName = patch.name?.trim() || providerName;
+    const normalizedProviders = await updateProviders((providers) => {
+        const current = providers.find((provider) => provider.name === providerName);
+        if (!current) {
+            throw new Error(`Provider not found: ${providerName}`);
+        }
+        if (targetName !== providerName && providers.some((provider) => provider.name === targetName)) {
+            throw new Error(`Provider already exists: ${targetName}`);
+        }
+        let nextProviders = providers.map((provider) => provider.name === providerName
+            ? {
+                ...provider,
+                ...patch,
+                name: targetName,
+                baseUrl: patch.baseUrl?.trim().replace(/\/+$/, "") || provider.baseUrl,
+                apiKey: patch.apiKey?.trim() || provider.apiKey,
+                model: patch.model?.trim() ?? provider.model
+            }
+            : provider);
+        if (patch.level) {
+            nextProviders = swapProviderLevel(nextProviders, targetName, patch.level);
+        }
+        return nextProviders;
+    });
+    const updated = normalizedProviders.find((provider) => provider.name === targetName);
+    if (!updated) {
+        throw new Error("Provider update failed.");
+    }
+    if (patch.name && patch.name !== providerName) {
+        await renameProviderCache(providerName, patch.name);
+    }
+    if (patch.name || patch.baseUrl || patch.apiKey) {
+        await refreshProvider(updated);
+    }
+    await recordProviderChange({
+        type: "updated",
+        provider: updated.name,
+        previousProvider: updated.name !== providerName ? providerName : undefined
+    });
+    return updated;
+}
+export async function deleteProvider(providerName) {
+    const deleted = {};
+    await updateProviders((providers) => {
+        deleted.value = providers.find((item) => item.name === providerName);
+        if (!deleted.value) {
+            throw new Error(`Provider not found: ${providerName}`);
+        }
+        return providers.filter((item) => item.name !== providerName);
+    });
+    if (!deleted.value) {
+        throw new Error(`Provider not found: ${providerName}`);
+    }
+    await deleteProviderCache(providerName);
+    await recordProviderChange({ type: "deleted", provider: deleted.value.name });
+    return deleted.value;
+}
+export async function refreshProvider(provider, options = {}) {
+    const result = await checkProvider(provider);
+    const callable = options.verifyCallableModels && result.models.length
+        ? await filterCallableModels(provider, result.models)
+        : { models: result.models, failed: 0, attempts: 0, durationMs: 0, retryErrors: [] };
+    const models = callable.models;
+    const status = result.status === "ok" && options.verifyCallableModels && !models.length ? "error" : result.status;
+    const lastError = status === "error" && options.verifyCallableModels && !models.length
+        ? `No callable models found. ${result.error ?? ""}`.trim()
+        : result.error;
+    const cache = await readCache();
+    await upsertProviderCache(provider.name, buildProviderHealthCache(cache.providers[provider.name], {
+        status,
+        models,
+        lastCheckedAt: result.checkedAt,
+        lastError
+    }));
+    await writeLog({
+        level: status === "ok" ? "info" : "error",
+        category: "provider",
+        action: "provider_health_check",
+        message: `${provider.name}: ${status}${lastError ? ` (${lastError})` : ""}`,
+        metadata: {
+            provider: provider.name,
+            status,
+            models: models.length,
+            discoveredModels: result.models.length,
+            failedCallableModels: callable.failed,
+            checkedAt: result.checkedAt,
+            verifyCallableModels: Boolean(options.verifyCallableModels),
+            attempts: (result.attempts ?? 0) + callable.attempts,
+            discoveryAttempts: result.attempts ?? null,
+            callableAttempts: callable.attempts,
+            durationMs: (result.durationMs ?? 0) + callable.durationMs,
+            discoveryDurationMs: result.durationMs ?? null,
+            callableDurationMs: callable.durationMs,
+            retryErrors: [...(result.retryErrors ?? []), ...callable.retryErrors].slice(-8)
+        }
+    });
+}
+export async function refreshAllProviders(options = {}) {
+    const providers = await readProviders();
+    if (options.verifyCallableModels) {
+        await mapWithConcurrency(providers, 2, (provider) => refreshProvider(provider, options));
+        return;
+    }
+    await Promise.all(providers.map((provider) => refreshProvider(provider, options)));
+}
+export async function getCachedModels(providerName) {
+    const cache = await readCache();
+    return cache.providers[providerName]?.models ?? [];
+}
+async function filterCallableModels(provider, models) {
+    const results = await checkCallableModels(provider, models);
+    for (const result of results) {
+        if (result.status === "ok" && result.usage) {
+            await recordModelProbeUsage(provider, result.model, result.usage);
+        }
+    }
+    const callableModels = results.filter((result) => result.status === "ok").map((result) => result.model);
+    const retryErrors = results.flatMap((result) => result.retryErrors ?? []);
+    await writeLog({
+        level: callableModels.length ? "info" : "warn",
+        category: "provider",
+        action: "provider_model_probe",
+        message: `${provider.name}: ${callableModels.length}/${models.length} callable model(s).`,
+        metadata: {
+            provider: provider.name,
+            callableModels,
+            failedModels: results.filter((result) => result.status === "error").map((result) => ({
+                model: result.model,
+                error: result.error,
+                attempts: result.attempts ?? null,
+                durationMs: result.durationMs ?? null
+            })),
+            attempts: results.reduce((sum, result) => sum + (result.attempts ?? 0), 0),
+            durationMs: results.reduce((sum, result) => sum + (result.durationMs ?? 0), 0),
+            retryErrors: retryErrors.slice(-8)
+        }
+    });
+    return {
+        models: callableModels,
+        failed: results.length - callableModels.length,
+        attempts: results.reduce((sum, result) => sum + (result.attempts ?? 0), 0),
+        durationMs: results.reduce((sum, result) => sum + (result.durationMs ?? 0), 0),
+        retryErrors
+    };
+}
+async function recordModelProbeUsage(provider, model, usage) {
+    await appendUsageEvent(buildUsageEvent({
+        provider: provider.name,
+        tool: "provider",
+        model,
+        source: "model_probe",
+        inputTokens: usage.inputTokens,
+        outputTokens: usage.outputTokens,
+        totalTokens: usage.totalTokens
+    }));
+}
+async function mapWithConcurrency(items, limit, mapper) {
+    let nextIndex = 0;
+    const workers = Array.from({ length: Math.min(limit, items.length) }, async () => {
+        while (nextIndex < items.length) {
+            const currentIndex = nextIndex;
+            nextIndex += 1;
+            await mapper(items[currentIndex]);
+        }
+    });
+    await Promise.all(workers);
+}