gavio 0.1.0

package/dist/cjs/interceptors/pii/scanners/index.js

@@ -0,0 +1,45 @@
+"use strict";
+/** Built-in tier-1 (regex) PII scanners. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ssnScanner = exports.secretScanner = exports.phoneScanner = exports.ipAddressScanner = exports.validIban = exports.ibanScanner = exports.emailScanner = exports.luhnValid = exports.creditCardScanner = exports.validBsn = exports.bsnScanner = void 0;
+exports.defaultScanners = defaultScanners;
+const bsn_js_1 = require("./bsn.js");
+const credit_card_js_1 = require("./credit-card.js");
+const email_js_1 = require("./email.js");
+const iban_js_1 = require("./iban.js");
+const ip_address_js_1 = require("./ip-address.js");
+const phone_js_1 = require("./phone.js");
+const secret_js_1 = require("./secret.js");
+const ssn_js_1 = require("./ssn.js");
+var bsn_js_2 = require("./bsn.js");
+Object.defineProperty(exports, "bsnScanner", { enumerable: true, get: function () { return bsn_js_2.bsnScanner; } });
+Object.defineProperty(exports, "validBsn", { enumerable: true, get: function () { return bsn_js_2.validBsn; } });
+var credit_card_js_2 = require("./credit-card.js");
+Object.defineProperty(exports, "creditCardScanner", { enumerable: true, get: function () { return credit_card_js_2.creditCardScanner; } });
+Object.defineProperty(exports, "luhnValid", { enumerable: true, get: function () { return credit_card_js_2.luhnValid; } });
+var email_js_2 = require("./email.js");
+Object.defineProperty(exports, "emailScanner", { enumerable: true, get: function () { return email_js_2.emailScanner; } });
+var iban_js_2 = require("./iban.js");
+Object.defineProperty(exports, "ibanScanner", { enumerable: true, get: function () { return iban_js_2.ibanScanner; } });
+Object.defineProperty(exports, "validIban", { enumerable: true, get: function () { return iban_js_2.validIban; } });
+var ip_address_js_2 = require("./ip-address.js");
+Object.defineProperty(exports, "ipAddressScanner", { enumerable: true, get: function () { return ip_address_js_2.ipAddressScanner; } });
+var phone_js_2 = require("./phone.js");
+Object.defineProperty(exports, "phoneScanner", { enumerable: true, get: function () { return phone_js_2.phoneScanner; } });
+var secret_js_2 = require("./secret.js");
+Object.defineProperty(exports, "secretScanner", { enumerable: true, get: function () { return secret_js_2.secretScanner; } });
+var ssn_js_2 = require("./ssn.js");
+Object.defineProperty(exports, "ssnScanner", { enumerable: true, get: function () { return ssn_js_2.ssnScanner; } });
+/** The default scanner set wired into PiiGuard when none is supplied. */
+function defaultScanners() {
+    return [
+        (0, secret_js_1.secretScanner)(),
+        (0, email_js_1.emailScanner)(),
+        (0, iban_js_1.ibanScanner)(),
+        (0, bsn_js_1.bsnScanner)(),
+        (0, credit_card_js_1.creditCardScanner)(),
+        (0, ssn_js_1.ssnScanner)(),
+        (0, phone_js_1.phoneScanner)(),
+        (0, ip_address_js_1.ipAddressScanner)(),
+    ];
+}

package/dist/cjs/interceptors/pii/scanners/ip-address.js

@@ -0,0 +1,36 @@
+"use strict";
+/** IP address scanner — IPv4 and IPv6, validated via node:net isIP. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ipAddressScanner = ipAddressScanner;
+const node_net_1 = require("node:net");
+const match_js_1 = require("../match.js");
+const IPV4 = String.raw `(?:\d{1,3}\.){3}\d{1,3}`;
+// Permissive IPv6 candidate — allows empty groups for "::" compression. False
+// positives are filtered by isIP validation below.
+const IPV6 = String.raw `(?:[A-Fa-f0-9]{0,4}:){2,7}[A-Fa-f0-9]{0,4}`;
+const IP = new RegExp(String.raw `(?<![\w.])(?:${IPV6}|${IPV4})(?![\w.])`, 'g');
+function validIp(candidate) {
+    return (0, node_net_1.isIP)(candidate) !== 0;
+}
+function ipAddressScanner() {
+    return {
+        entityType: 'IP_ADDRESS',
+        tier: 1,
+        scan(text, ctx) {
+            const out = [];
+            for (const m of text.matchAll(IP)) {
+                if (!validIp(m[0]))
+                    continue;
+                const idx = ctx.nextIndex('IP_ADDRESS');
+                out.push((0, match_js_1.makeMatch)({
+                    entityType: 'IP_ADDRESS',
+                    start: m.index,
+                    end: m.index + m[0].length,
+                    value: m[0],
+                    replacement: `[IP_ADDRESS_${idx}]`,
+                }));
+            }
+            return out;
+        },
+    };
+}

package/dist/cjs/interceptors/pii/scanners/phone.js

@@ -0,0 +1,37 @@
+"use strict";
+/** Phone number scanner — E.164 and common national formats. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.phoneScanner = phoneScanner;
+const match_js_1 = require("../match.js");
+// E.164 (+CC...) or national groupings with separators. A digit-count filter
+// (7–15) below avoids matching short numbers / years.
+const PHONE = /(?<![\w.])(?:\+?\d{1,3}[ .-]?)?(?:\(\d{1,4}\)[ .-]?)?\d{2,4}(?:[ .-]?\d{2,4}){2,4}(?![\w])/g;
+function phoneScanner(options = {}) {
+    const locales = options.locales ?? ['NL', 'DE', 'GB', 'US'];
+    return {
+        entityType: 'PHONE',
+        tier: 1,
+        confidence: 0.85,
+        scan(text, ctx) {
+            const out = [];
+            for (const m of text.matchAll(PHONE)) {
+                const digitCount = (m[0].match(/\d/g) ?? []).length;
+                if (digitCount < 7 || digitCount > 15)
+                    continue;
+                const idx = ctx.nextIndex('PHONE');
+                out.push((0, match_js_1.makeMatch)({
+                    entityType: 'PHONE',
+                    start: m.index,
+                    end: m.index + m[0].length,
+                    value: m[0],
+                    confidence: 0.85,
+                    replacement: `[PHONE_${idx}]`,
+                }));
+            }
+            return out;
+        },
+        supportsLocale(locale) {
+            return locales.includes(locale.toUpperCase());
+        },
+    };
+}

package/dist/cjs/interceptors/pii/scanners/secret.js

@@ -0,0 +1,46 @@
+"use strict";
+/**
+ * Secret / credential scanner (F-SEC-04).
+ *
+ * Detects API keys, tokens, JWTs, PEM private keys, and database connection
+ * strings. These must never leave the device, so SecretScanner is tier 1 and
+ * runs by default.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.secretScanner = secretScanner;
+const match_js_1 = require("../match.js");
+// [label, pattern] — ordered most-specific first. All patterns are global.
+const PATTERNS = [
+    ['ANTHROPIC_KEY', /\bsk-ant-[A-Za-z0-9_-]{20,}\b/g],
+    ['OPENAI_KEY', /\bsk-(?:proj-)?[A-Za-z0-9_-]{20,}\b/g],
+    ['AWS_ACCESS_KEY', /\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/g],
+    ['GITHUB_TOKEN', /\bgh[pousr]_[A-Za-z0-9]{36,}\b/g],
+    ['JWT', /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/g],
+    ['PRIVATE_KEY', /-----BEGIN (?:RSA |EC |OPENSSH |PGP )?PRIVATE KEY-----/g],
+    [
+        'DB_CONNECTION_STRING',
+        /\b(?:postgres(?:ql)?|mysql|mongodb(?:\+srv)?|redis):\/\/[^\s"']+/g,
+    ],
+];
+function secretScanner() {
+    return {
+        entityType: 'SECRET',
+        tier: 1,
+        scan(text, ctx) {
+            const out = [];
+            for (const [, pattern] of PATTERNS) {
+                for (const m of text.matchAll(pattern)) {
+                    const idx = ctx.nextIndex('SECRET');
+                    out.push((0, match_js_1.makeMatch)({
+                        entityType: 'SECRET',
+                        start: m.index,
+                        end: m.index + m[0].length,
+                        value: m[0],
+                        replacement: `[SECRET_${idx}]`,
+                    }));
+                }
+            }
+            return out;
+        },
+    };
+}

package/dist/cjs/interceptors/pii/scanners/ssn.js

@@ -0,0 +1,28 @@
+"use strict";
+/** US Social Security Number scanner. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ssnScanner = ssnScanner;
+const match_js_1 = require("../match.js");
+// AAA-GG-SSSS with hyphens or spaces. Requires a separator to avoid colliding
+// with bare 9-digit numbers (handled by the BSN scanner / others).
+const SSN = /\b(?!000|666|9\d\d)\d{3}[ -](?!00)\d{2}[ -](?!0000)\d{4}\b/g;
+function ssnScanner() {
+    return {
+        entityType: 'SSN',
+        tier: 1,
+        scan(text, ctx) {
+            const out = [];
+            for (const m of text.matchAll(SSN)) {
+                const idx = ctx.nextIndex('SSN');
+                out.push((0, match_js_1.makeMatch)({
+                    entityType: 'SSN',
+                    start: m.index,
+                    end: m.index + m[0].length,
+                    value: m[0],
+                    replacement: `[SSN_${idx}]`,
+                }));
+            }
+            return out;
+        },
+    };
+}

package/dist/cjs/interceptors/reliability/fallback.js

@@ -0,0 +1,53 @@
+"use strict";
+/** fallbackChain (F-REL-02) — route to a secondary provider on failure. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fallbackChain = fallbackChain;
+const errors_js_1 = require("../../errors.js");
+const types_js_1 = require("../../types.js");
+/**
+ * Try the primary executor; on a provider error, try fallback adapters.
+ *
+ * Each fallback is a provider adapter (anything with an async `complete`). The
+ * request's provider/model are rewritten per fallback so the audit record
+ * reflects which provider actually answered.
+ */
+class FallbackChain {
+    name = 'fallback';
+    isExecutorPolicy = true;
+    dryRunSafe = true;
+    fallbacks;
+    constructor(options) {
+        if (!options.fallbacks || options.fallbacks.length === 0) {
+            throw new Error('fallbackChain requires at least one fallback adapter');
+        }
+        this.fallbacks = options.fallbacks;
+    }
+    async around(request, ctx, callNext) {
+        ctx.markFired(this.name);
+        try {
+            return await callNext(request);
+        }
+        catch (primaryError) {
+            if (!(primaryError instanceof errors_js_1.ProviderError))
+                throw primaryError;
+            let lastError = primaryError;
+            for (const adapter of this.fallbacks) {
+                try {
+                    const rerouted = request.copyWithMessages(request.messages);
+                    rerouted.provider = (0, types_js_1.coerceProvider)(adapter.providerName);
+                    return await adapter.complete(rerouted);
+                }
+                catch (error) {
+                    if (!(error instanceof errors_js_1.ProviderError))
+                        throw error;
+                    lastError = error;
+                }
+            }
+            throw lastError;
+        }
+    }
+}
+/** Factory: build a fallback policy. */
+function fallbackChain(options) {
+    return new FallbackChain(options);
+}

package/dist/cjs/interceptors/reliability/index.js

@@ -0,0 +1,11 @@
+"use strict";
+/** Reliability policies (F-REL-01, F-REL-02, F-REL-07). */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fallbackChain = exports.timeout = exports.timeoutPolicy = exports.retryInterceptor = void 0;
+var retry_js_1 = require("./retry.js");
+Object.defineProperty(exports, "retryInterceptor", { enumerable: true, get: function () { return retry_js_1.retryInterceptor; } });
+var timeout_js_1 = require("./timeout.js");
+Object.defineProperty(exports, "timeoutPolicy", { enumerable: true, get: function () { return timeout_js_1.timeoutPolicy; } });
+Object.defineProperty(exports, "timeout", { enumerable: true, get: function () { return timeout_js_1.timeout; } });
+var fallback_js_1 = require("./fallback.js");
+Object.defineProperty(exports, "fallbackChain", { enumerable: true, get: function () { return fallback_js_1.fallbackChain; } });

package/dist/cjs/interceptors/reliability/retry.js

@@ -0,0 +1,69 @@
+"use strict";
+/** retryInterceptor (F-REL-01) — exponential backoff with jitter. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retryInterceptor = retryInterceptor;
+const node_crypto_1 = require("node:crypto");
+const errors_js_1 = require("../../errors.js");
+/** Default predicate: retry transient provider errors. */
+function defaultRetryable(error) {
+    return (error instanceof errors_js_1.RateLimitError ||
+        error instanceof errors_js_1.TimeoutError ||
+        error instanceof errors_js_1.ServerError ||
+        error instanceof errors_js_1.ProviderUnavailableError);
+}
+const defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+class RetryInterceptor {
+    name = 'retry';
+    isExecutorPolicy = true;
+    dryRunSafe = true;
+    maxAttempts;
+    baseDelayMs;
+    maxDelayMs;
+    jitter;
+    retryOn;
+    sleep;
+    constructor(options = {}) {
+        const maxAttempts = options.maxAttempts ?? 3;
+        if (maxAttempts < 1)
+            throw new Error('maxAttempts must be >= 1');
+        this.maxAttempts = maxAttempts;
+        this.baseDelayMs = options.baseDelayMs ?? 500;
+        this.maxDelayMs = options.maxDelayMs ?? 10_000;
+        this.jitter = options.jitter ?? true;
+        this.retryOn = options.retryOn ?? defaultRetryable;
+        this.sleep = options.sleep ?? defaultSleep;
+    }
+    async around(request, ctx, callNext) {
+        ctx.markFired(this.name);
+        let lastError;
+        for (let attempt = 1; attempt <= this.maxAttempts; attempt++) {
+            try {
+                return await callNext(request);
+            }
+            catch (error) {
+                if (!this.retryOn(error))
+                    throw error;
+                lastError = error;
+                if (attempt >= this.maxAttempts)
+                    break;
+                await this.sleep(this.delayMs(attempt));
+            }
+        }
+        throw lastError;
+    }
+    delayMs(attempt) {
+        // Exponential: base * 2^(attempt-1), capped, with optional full jitter.
+        const raw = this.baseDelayMs * 2 ** (attempt - 1);
+        let capped = Math.min(raw, this.maxDelayMs);
+        if (this.jitter) {
+            // full jitter in [0, capped] using crypto bytes (no global RNG state)
+            const frac = (0, node_crypto_1.randomBytes)(2).readUInt16BE(0) / 0xffff;
+            capped *= frac;
+        }
+        return capped;
+    }
+}
+/** Factory: build a retry policy. */
+function retryInterceptor(options = {}) {
+    return new RetryInterceptor(options);
+}

package/dist/cjs/interceptors/reliability/timeout.js

@@ -0,0 +1,41 @@
+"use strict";
+/** timeoutPolicy (F-REL-07) — per-request timeout enforcement. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.timeout = void 0;
+exports.timeoutPolicy = timeoutPolicy;
+const errors_js_1 = require("../../errors.js");
+class TimeoutPolicy {
+    name = 'timeout';
+    isExecutorPolicy = true;
+    dryRunSafe = true;
+    timeoutSeconds;
+    constructor(options = {}) {
+        const timeoutSeconds = options.timeoutSeconds ?? 30.0;
+        if (timeoutSeconds <= 0)
+            throw new Error('timeoutSeconds must be > 0');
+        this.timeoutSeconds = timeoutSeconds;
+    }
+    async around(request, ctx, callNext) {
+        ctx.markFired(this.name);
+        const ms = this.timeoutSeconds * 1000;
+        let timer;
+        const timeout = new Promise((_, reject) => {
+            timer = setTimeout(() => {
+                reject(new errors_js_1.TimeoutError(`Request exceeded ${this.timeoutSeconds}s timeout`));
+            }, ms);
+        });
+        try {
+            return await Promise.race([callNext(request), timeout]);
+        }
+        finally {
+            if (timer !== undefined)
+                clearTimeout(timer);
+        }
+    }
+}
+/** Factory: build a timeout policy. */
+function timeoutPolicy(options = {}) {
+    return new TimeoutPolicy(options);
+}
+/** Alias matching the SDK plan naming (`timeout`). */
+exports.timeout = timeoutPolicy;

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/cjs/pricing.js

@@ -0,0 +1,70 @@
+"use strict";
+/**
+ * Token cost tracking (F-GOV-01).
+ *
+ * Prices are USD per 1,000 tokens, sourced from public provider pricing and
+ * overridable. Unknown models price at zero (warned once) rather than guessing.
+ * Prices are intentionally data, not code — update the table, not the estimator.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PricingProvider = void 0;
+exports.estimateTokens = estimateTokens;
+/** model -> [inputPer1kUsd, outputPer1kUsd] */
+const DEFAULT_PRICES = {
+    // OpenAI
+    'gpt-4o': [0.0025, 0.01],
+    'gpt-4o-mini': [0.00015, 0.0006],
+    o1: [0.015, 0.06],
+    'o1-mini': [0.0011, 0.0044],
+    // Anthropic
+    'claude-sonnet-4-6': [0.003, 0.015],
+    'claude-sonnet-4-20250514': [0.003, 0.015],
+    'claude-haiku-4-5': [0.0008, 0.004],
+    'claude-opus-4-1': [0.015, 0.075],
+    // Local / mock are free.
+    mock: [0.0, 0.0],
+};
+/** Estimates request cost from token usage and a model price table. */
+class PricingProvider {
+    prices;
+    warned = new Set();
+    constructor(prices) {
+        this.prices = { ...DEFAULT_PRICES, ...(prices ?? {}) };
+    }
+    setPrice(model, inputPer1k, outputPer1k) {
+        this.prices[model] = [inputPer1k, outputPer1k];
+    }
+    rates(model) {
+        const rate = this.prices[model];
+        if (rate !== undefined)
+            return rate;
+        // try a prefix match (e.g. "gpt-4o-2024-..." -> "gpt-4o")
+        for (const [known, value] of Object.entries(this.prices)) {
+            if (model.startsWith(known))
+                return value;
+        }
+        if (!this.warned.has(model)) {
+            // eslint-disable-next-line no-console
+            console.warn(`[gavio:pricing] no pricing for model '${model}'; treating as free`);
+            this.warned.add(model);
+        }
+        return [0.0, 0.0];
+    }
+    estimate(model, usage) {
+        const [inRate, outRate] = this.rates(model);
+        let cost = (usage.promptTokens / 1000.0) * inRate;
+        cost += (usage.completionTokens / 1000.0) * outRate;
+        return roundTo(cost, 8);
+    }
+}
+exports.PricingProvider = PricingProvider;
+function roundTo(value, decimals) {
+    const factor = 10 ** decimals;
+    return Math.round(value * factor) / factor;
+}
+/** Rough token estimate (~4 chars/token) for providers without a tokenizer. */
+function estimateTokens(text) {
+    if (!text)
+        return 0;
+    return Math.max(1, Math.floor(text.length / 4));
+}

package/dist/cjs/providers/anthropic.js

@@ -0,0 +1,80 @@
+"use strict";
+/** anthropicAdapter — Messages API (Claude Sonnet, Haiku, Opus). */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.anthropicAdapter = anthropicAdapter;
+const errors_js_1 = require("../errors.js");
+const types_js_1 = require("../types.js");
+const base_js_1 = require("./base.js");
+const http_js_1 = require("./http.js");
+const DEFAULT_BASE_URL = 'https://api.anthropic.com/v1';
+const API_VERSION = '2023-06-01';
+/**
+ * Talks to the Anthropic Messages endpoint. Anthropic splits the system prompt
+ * from the message list, so any `role === "system"` messages are extracted into
+ * the `system` field.
+ */
+class AnthropicAdapter extends base_js_1.BaseProviderAdapter {
+    apiKey;
+    baseUrl;
+    timeoutSeconds;
+    constructor(options = {}) {
+        super(options.pricing);
+        this.apiKey = options.apiKey ?? process.env['ANTHROPIC_API_KEY'];
+        this.baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, '');
+        this.timeoutSeconds = (options.timeoutMs ?? 30_000) / 1000;
+    }
+    get providerName() {
+        return 'anthropic';
+    }
+    headers() {
+        if (!this.apiKey) {
+            throw new errors_js_1.ConfigurationError('ANTHROPIC_API_KEY not set (pass apiKey or set the env var)');
+        }
+        return {
+            'x-api-key': this.apiKey,
+            'anthropic-version': API_VERSION,
+        };
+    }
+    static splitSystem(messages) {
+        const systemParts = messages
+            .filter((m) => m.role === 'system')
+            .map((m) => m.content);
+        const chat = messages.filter((m) => m.role !== 'system');
+        const system = systemParts.length > 0 ? systemParts.join('\n') : null;
+        return [system, chat];
+    }
+    async complete(request) {
+        const started = performance.now();
+        const [system, chat] = AnthropicAdapter.splitSystem(request.messages);
+        const payload = {
+            model: request.model,
+            messages: chat,
+            max_tokens: request.maxTokens,
+            temperature: request.temperature,
+        };
+        if (system)
+            payload['system'] = system;
+        const data = await (0, http_js_1.postJson)(`${this.baseUrl}/messages`, payload, this.headers(), this.timeoutSeconds);
+        const blocks = data['content'] ?? [];
+        const content = blocks
+            .filter((b) => b['type'] === 'text')
+            .map((b) => b['text'] ?? '')
+            .join('');
+        const usageData = data['usage'] ?? {};
+        const usage = new types_js_1.TokenUsage(usageData['input_tokens'] ?? 0, usageData['output_tokens'] ?? 0);
+        return this.buildResponse(request, content, usage, data['model'] ?? request.model, started);
+    }
+    async healthCheck() {
+        try {
+            this.headers();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+/** Factory: build an Anthropic provider adapter. */
+function anthropicAdapter(options = {}) {
+    return new AnthropicAdapter(options);
+}

package/dist/cjs/providers/base.js

@@ -0,0 +1,30 @@
+"use strict";
+/** ProviderAdapter interface and shared response-building helpers. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseProviderAdapter = void 0;
+const pricing_js_1 = require("../pricing.js");
+const response_js_1 = require("../response.js");
+/** Base class with a shared pricing provider and response builder. */
+class BaseProviderAdapter {
+    pricing;
+    constructor(pricing) {
+        this.pricing = pricing ?? new pricing_js_1.PricingProvider();
+    }
+    get reportedModelVersion() {
+        return null;
+    }
+    buildResponse(request, content, usage, modelVersion, startedAt) {
+        const latencyMs = Math.floor(performance.now() - startedAt);
+        return new response_js_1.GavioResponse({
+            traceId: request.traceId,
+            content,
+            model: request.model,
+            provider: this.providerName,
+            modelVersion: modelVersion || request.model,
+            usage,
+            costUsd: this.pricing.estimate(request.model, usage),
+            latencyMs,
+        });
+    }
+}
+exports.BaseProviderAdapter = BaseProviderAdapter;

package/dist/cjs/providers/http.js

@@ -0,0 +1,42 @@
+"use strict";
+/** Tiny JSON-over-HTTP helper built on native fetch (keeps core dependency-free). */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.postJson = postJson;
+const errors_js_1 = require("../errors.js");
+/**
+ * POST `payload` as JSON and return the parsed response.
+ *
+ * Maps HTTP status families onto Gavio's transient error types so the
+ * retry/fallback policies can react.
+ */
+async function postJson(url, payload, headers, timeoutSeconds = 30.0) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutSeconds * 1000);
+    let resp;
+    try {
+        resp = await fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', ...headers },
+            body: JSON.stringify(payload),
+            signal: controller.signal,
+        });
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new errors_js_1.ProviderUnavailableError(`network error: ${reason}`);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+    if (!resp.ok) {
+        const body = (await resp.text().catch(() => '')).slice(0, 200);
+        if (resp.status === 429) {
+            throw new errors_js_1.RateLimitError(`429 from provider: ${body}`);
+        }
+        if (resp.status >= 500) {
+            throw new errors_js_1.ServerError(`${resp.status} from provider: ${body}`);
+        }
+        throw new errors_js_1.ProviderUnavailableError(`${resp.status} from provider: ${body}`);
+    }
+    return (await resp.json());
+}

package/dist/cjs/providers/index.js

@@ -0,0 +1,34 @@
+"use strict";
+/** Provider adapters and the provider registry. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Provider = exports.anthropicAdapter = exports.openaiAdapter = exports.mockProvider = exports.BaseProviderAdapter = void 0;
+exports.buildAdapter = buildAdapter;
+const errors_js_1 = require("../errors.js");
+const types_js_1 = require("../types.js");
+const anthropic_js_1 = require("./anthropic.js");
+const mock_js_1 = require("./mock.js");
+const openai_js_1 = require("./openai.js");
+var base_js_1 = require("./base.js");
+Object.defineProperty(exports, "BaseProviderAdapter", { enumerable: true, get: function () { return base_js_1.BaseProviderAdapter; } });
+var mock_js_2 = require("./mock.js");
+Object.defineProperty(exports, "mockProvider", { enumerable: true, get: function () { return mock_js_2.mockProvider; } });
+var openai_js_2 = require("./openai.js");
+Object.defineProperty(exports, "openaiAdapter", { enumerable: true, get: function () { return openai_js_2.openaiAdapter; } });
+var anthropic_js_2 = require("./anthropic.js");
+Object.defineProperty(exports, "anthropicAdapter", { enumerable: true, get: function () { return anthropic_js_2.anthropicAdapter; } });
+var types_js_2 = require("../types.js");
+Object.defineProperty(exports, "Provider", { enumerable: true, get: function () { return types_js_2.Provider; } });
+/** Instantiate the default adapter for a provider id. v0.1.0: OpenAI, Anthropic, Mock. */
+function buildAdapter(provider, pricing) {
+    const p = (0, types_js_1.coerceProvider)(provider);
+    switch (p) {
+        case types_js_1.Provider.OPENAI:
+            return (0, openai_js_1.openaiAdapter)(pricing ? { pricing } : {});
+        case types_js_1.Provider.ANTHROPIC:
+            return (0, anthropic_js_1.anthropicAdapter)(pricing ? { pricing } : {});
+        case types_js_1.Provider.MOCK:
+            return (0, mock_js_1.mockProvider)(pricing ? { pricing } : {});
+        default:
+            throw new errors_js_1.ConfigurationError(`Provider '${p}' is not available in v0.1.0 (available: openai, anthropic, mock)`);
+    }
+}