@axemere/gateway 0.1.6

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Axemere LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,49 @@
+# @axemere/gateway
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](../../LICENSE)
+
+Framework-independent TypeScript client for the [Axemere AI Gateway](https://axemere.ai).
+
+Use this package when you want explicit control over every request, or when you are not using OpenAI or Anthropic SDKs directly. If you are already using one of those SDKs, install the matching wrapper instead (`@axemere/gateway-openai`, `@axemere/gateway-anthropic`) — it requires no code changes beyond the import.
+
+## Install
+
+```bash
+npm install @axemere/gateway
+```
+
+## Usage
+
+```typescript
+import { AiGatewayClient, AiGatewayConfig } from "@axemere/gateway";
+
+const config = new AiGatewayConfig(); // reads AXEMERE_GATEWAY_URL + AXEMERE_GATEWAY_TOKEN
+const client = new AiGatewayClient(config);
+
+const result = await client.execute({
+  provider: "openai",
+  model: "gpt-4o-mini",
+  messages: [{ role: "user", content: "Hello" }],
+});
+console.log(result.content);
+console.log(result.metering?.cost_usd); // "0.000042"
+```
+
+## Configuration
+
+| Env var | Description |
+|---------|-------------|
+| `AXEMERE_GATEWAY_URL` | Gateway base URL, e.g. `http://localhost:7080` |
+| `AXEMERE_GATEWAY_TOKEN` | Gateway token issued by the gateway |
+| `AXEMERE_WORKLOAD_ID` | Workload identifier for attribution |
+| `AXEMERE_PROJECT_ID` | Project identifier for spend grouping |
+
+## Links
+
+- [Axemere AI Gateway](https://axemere.ai)
+- [Documentation](https://axemere.ai/docs)
+- [GitHub](https://github.com/Axemere-LLC/axemere-node)
+
+## License
+
+MIT

package/dist/client.d.ts

@@ -0,0 +1,48 @@
+import { AiGatewayConfig } from "./config";
+import { ExecuteParams, ExecuteResponse, StreamChunk } from "./types";
+/**
+ * Client for the Axemere AI Gateway explicit action API.
+ *
+ * Wraps the gateway's `/v1/actions:execute` endpoint, building the wire request
+ * from {@link ExecuteParams}, applying attribution and delegation, and normalizing
+ * provider responses (OpenAI- and Anthropic-style) into a uniform shape.
+ *
+ * @example
+ * ```ts
+ * const client = new AiGatewayClient(new AiGatewayConfig());
+ * const res = await client.execute({
+ *   provider: "openai",
+ *   model: "gpt-4o-mini",
+ *   messages: [{ role: "user", content: "Hello" }],
+ * });
+ * console.log(res.content);
+ * ```
+ */
+export declare class AiGatewayClient {
+    private readonly config;
+    constructor(config: AiGatewayConfig);
+    /**
+     * Executes a governed AI request through the gateway.
+     *
+     * Resolves provider/model and attribution from {@link ExecuteParams}, falling
+     * back to the {@link AiGatewayConfig} defaults. When `stream` is `true` the
+     * returned promise resolves to an async-iterable of {@link StreamChunk};
+     * otherwise it resolves to a single {@link ExecuteResponse}.
+     *
+     * @param params - Request parameters: messages plus optional provider, model,
+     *   attribution fields, delegation token, and provider-specific passthrough.
+     * @returns The completed response, or a stream of chunks when `stream: true`.
+     * @throws {GatewayError} On missing config (gateway_url/provider/model),
+     *   network failure, or non-OK gateway/provider status.
+     * @throws {PolicyDeniedError} When the gateway denies the request by policy.
+     * @throws {QuotaExceededError} When a spend/quota limit is exceeded (HTTP 429).
+     * @throws {GatewayTimeoutError} When the request times out (client or HTTP 504).
+     */
+    execute(params: ExecuteParams & {
+        stream?: false;
+    }): Promise<ExecuteResponse>;
+    execute(params: ExecuteParams & {
+        stream: true;
+    }): Promise<AsyncIterable<StreamChunk>>;
+    execute(params: ExecuteParams): Promise<ExecuteResponse | AsyncIterable<StreamChunk>>;
+}

package/dist/client.js

@@ -0,0 +1,297 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AiGatewayClient = void 0;
+const uuidv7_1 = require("uuidv7");
+const errors_1 = require("./errors");
+const providers_1 = require("./providers");
+/**
+ * Client for the Axemere AI Gateway explicit action API.
+ *
+ * Wraps the gateway's `/v1/actions:execute` endpoint, building the wire request
+ * from {@link ExecuteParams}, applying attribution and delegation, and normalizing
+ * provider responses (OpenAI- and Anthropic-style) into a uniform shape.
+ *
+ * @example
+ * ```ts
+ * const client = new AiGatewayClient(new AiGatewayConfig());
+ * const res = await client.execute({
+ *   provider: "openai",
+ *   model: "gpt-4o-mini",
+ *   messages: [{ role: "user", content: "Hello" }],
+ * });
+ * console.log(res.content);
+ * ```
+ */
+class AiGatewayClient {
+    constructor(config) {
+        this.config = config;
+    }
+    async execute(params) {
+        if (!this.config.gateway_url) {
+            throw new errors_1.GatewayError("gateway_url is required; set AXEMERE_GATEWAY_URL or pass it to AiGatewayConfig");
+        }
+        const provider = params.provider ?? this.config.default_provider;
+        const model = params.model ?? this.config.default_model;
+        if (!provider) {
+            throw new errors_1.GatewayError("provider is required");
+        }
+        if (!model) {
+            throw new errors_1.GatewayError("model is required");
+        }
+        const route = providers_1.PROVIDER_ROUTES[provider];
+        if (!route) {
+            throw new errors_1.GatewayError(`unknown provider: ${provider}`);
+        }
+        const workload_id = params.workload_id ?? this.config.workload_id;
+        const project_id = params.project_id ?? this.config.project_id;
+        const account_id = params.account_id ?? this.config.account_id;
+        const customer_id = params.customer_id ?? this.config.customer_id;
+        const labels = params.labels ?? this.config.labels;
+        const provider_api_key = params.provider_api_key ?? this.config.provider_api_key;
+        const target_path = route.path.replace("{model}", model);
+        // Build provider_params: strip known SDK fields, pass remaining through.
+        const { messages, provider: _p, model: _m, workload_id: _wl, project_id: _pi, account_id: _ai, customer_id: _ci, labels: _lb, provider_api_key: _pak, delegation_token, stream, ...extra_params } = params;
+        const provider_params = {
+            model,
+            messages,
+            ...extra_params,
+        };
+        if (stream) {
+            provider_params["stream"] = true;
+        }
+        // Build wire body.
+        const body = {
+            schema: "mvgc.action_request.v2",
+            request_id: (0, uuidv7_1.uuidv7)(),
+            org_id: "",
+            workload_id: workload_id ?? "",
+            ingress_mode: "explicit_action_request",
+            action: {
+                type: "llm_chat",
+                method: "POST",
+                target_host: route.host,
+                target_path,
+                params: provider_params,
+            },
+        };
+        // Attribution — omit if all fields are empty.
+        const attribution = {};
+        if (project_id)
+            attribution.project_id = project_id;
+        if (account_id)
+            attribution.account_id = account_id;
+        if (customer_id)
+            attribution.customer_id = customer_id;
+        if (labels && Object.keys(labels).length > 0)
+            attribution.labels = labels;
+        if (Object.keys(attribution).length > 0) {
+            body.attribution = attribution;
+        }
+        if (delegation_token) {
+            body.delegation_token = delegation_token;
+        }
+        if (provider_api_key) {
+            body.credential_hint = provider_api_key;
+        }
+        const headers = {
+            "Content-Type": "application/json",
+        };
+        if (this.config.gateway_token) {
+            headers["Authorization"] = `Bearer ${this.config.gateway_token}`;
+        }
+        const url = `${this.config.gateway_url}/v1/actions:execute`;
+        // Apply timeout to connection establishment for all requests.
+        // The timeout is cleared in the finally block once response headers arrive,
+        // so streaming payloads are not cut off by this timer.
+        const controller = new AbortController();
+        const timeoutMs = this.config.timeout * 1000;
+        const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+        let response;
+        try {
+            response = await fetch(url, {
+                method: "POST",
+                headers,
+                body: JSON.stringify(body),
+                signal: controller.signal,
+            });
+        }
+        catch (err) {
+            if (err instanceof Error && err.name === "AbortError") {
+                throw new errors_1.GatewayTimeoutError("Request timed out");
+            }
+            throw new errors_1.GatewayError(`Network error: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+        if (response.status === 504) {
+            throw new errors_1.GatewayTimeoutError("Gateway timeout (HTTP 504)");
+        }
+        if (stream) {
+            return parseStreamResponse(response, provider);
+        }
+        return parseResponse(response, provider);
+    }
+}
+exports.AiGatewayClient = AiGatewayClient;
+async function parseResponse(response, provider) {
+    let data;
+    try {
+        data = await response.json();
+    }
+    catch {
+        throw new errors_1.GatewayError(`Failed to parse JSON response: HTTP ${response.status}`);
+    }
+    const obj = data;
+    if (obj["decision"] === "deny") {
+        const err = new errors_1.PolicyDeniedError(`Request denied by policy: ${String(obj["reason"] ?? "unknown")}`);
+        err.status_code = response.status;
+        err.response_body = data;
+        err.reason = String(obj["reason"] ?? "");
+        err.trace = obj["trace"];
+        err.record_id = typeof obj["record_id"] === "string" ? obj["record_id"] : undefined;
+        throw err;
+    }
+    if (response.status === 429 && obj["error"] === "quota_exceeded") {
+        const err = new errors_1.QuotaExceededError("Quota exceeded");
+        err.status_code = 429;
+        err.response_body = data;
+        err.upgrade_url = typeof obj["upgrade_url"] === "string" ? obj["upgrade_url"] : undefined;
+        err.retry_after = typeof obj["retry_after"] === "number" ? obj["retry_after"] : undefined;
+        throw err;
+    }
+    if (!response.ok) {
+        const err = new errors_1.GatewayError(`HTTP ${response.status}`);
+        err.status_code = response.status;
+        err.response_body = data;
+        throw err;
+    }
+    const result = obj["result"];
+    if (result && typeof result["status_code"] === "number" && result["status_code"] >= 400) {
+        const err = new errors_1.GatewayError(`Provider error: HTTP ${result["status_code"]}`);
+        err.status_code = result["status_code"];
+        err.response_body = result["body"];
+        throw err;
+    }
+    const providerBody = result?.["body"];
+    let content = "";
+    if (providerBody) {
+        if (provider === "anthropic") {
+            // Anthropic returns an array of content blocks; concatenate every
+            // text block (tool_use / thinking blocks have no text and are skipped).
+            const contentArr = providerBody["content"];
+            const textBlocks = contentArr?.filter((b) => b.type === "text").map((b) => b.text ?? "") ?? [];
+            content = textBlocks.join("");
+        }
+        else {
+            // OpenAI-compatible format
+            const choices = providerBody["choices"];
+            content = choices?.[0]?.message?.content ?? "";
+        }
+    }
+    return {
+        content,
+        record_id: String(obj["record_id"] ?? ""),
+        metering: (obj["metering"] ?? {}),
+        provider,
+        model: String((providerBody?.["model"]) ?? (obj["model"]) ?? ""),
+        record_hash: typeof obj["record_hash"] === "string" ? obj["record_hash"] : undefined,
+        provider_response: providerBody,
+    };
+}
+function parseStreamResponse(response, provider) {
+    if (!response.ok) {
+        return {
+            [Symbol.asyncIterator]: async function* () {
+                let data;
+                try {
+                    data = await response.json();
+                }
+                catch {
+                    data = undefined;
+                }
+                const err = new errors_1.GatewayError(`HTTP ${response.status}`);
+                err.status_code = response.status;
+                err.response_body = data;
+                throw err;
+            },
+        };
+    }
+    const body = response.body;
+    if (!body) {
+        return {
+            [Symbol.asyncIterator]: async function* () {
+                throw new errors_1.GatewayError("Empty response body on streaming request");
+            },
+        };
+    }
+    return {
+        [Symbol.asyncIterator]: async function* () {
+            let recordId;
+            let metering;
+            const reader = body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = "";
+            try {
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    buffer += decoder.decode(value, { stream: true });
+                    // Split on newlines; keep any partial line in the buffer.
+                    const lines = buffer.split("\n");
+                    buffer = lines.pop() ?? "";
+                    for (const line of lines) {
+                        const trimmed = line.trim();
+                        if (!trimmed || trimmed.startsWith(":"))
+                            continue;
+                        if (!trimmed.startsWith("data: "))
+                            continue;
+                        const payload = trimmed.slice(6).trim();
+                        if (payload === "[DONE]") {
+                            yield { content: "", is_final: true, record_id: recordId, metering };
+                            return;
+                        }
+                        let chunk;
+                        try {
+                            chunk = JSON.parse(payload);
+                        }
+                        catch {
+                            continue; // skip malformed chunks
+                        }
+                        if (chunk["type"] === "mvgc_metering") {
+                            recordId = typeof chunk["record_id"] === "string"
+                                ? chunk["record_id"]
+                                : undefined;
+                            metering = chunk["metering"];
+                            continue;
+                        }
+                        if (provider === "anthropic") {
+                            // Anthropic delta format:
+                            //   {"type":"content_block_delta","delta":{"type":"text_delta","text":"hi"}}
+                            if (chunk["type"] === "content_block_delta") {
+                                const aDelta = chunk["delta"];
+                                const text = aDelta?.text;
+                                if (text) {
+                                    yield { content: text, is_final: false };
+                                }
+                            }
+                            continue;
+                        }
+                        // OpenAI-compatible delta format
+                        const choices = chunk["choices"];
+                        const delta = choices?.[0]?.delta?.content;
+                        if (delta) {
+                            yield { content: delta, is_final: false };
+                        }
+                    }
+                }
+            }
+            finally {
+                reader.releaseLock();
+            }
+            // Stream ended without [DONE] — emit final chunk.
+            yield { content: "", is_final: true, record_id: recordId, metering };
+        },
+    };
+}

package/dist/config.d.ts

@@ -0,0 +1,53 @@
+export interface AiGatewayOptions {
+    gateway_url?: string;
+    gateway_token?: string;
+    default_provider?: string;
+    default_model?: string;
+    workload_id?: string;
+    project_id?: string;
+    account_id?: string;
+    customer_id?: string;
+    labels?: Record<string, string>;
+    provider_api_key?: string;
+    timeout?: number;
+}
+/**
+ * Resolved configuration for talking to the Axemere AI Gateway.
+ *
+ * Each field is taken from the matching {@link AiGatewayOptions} value when
+ * provided, otherwise from its `AXEMERE_*` environment variable, otherwise a
+ * safe default. Values are read once at construction time. Also builds the
+ * proxy base URL used by the OpenAI/Anthropic drop-in wrappers.
+ *
+ * @example
+ * ```ts
+ * // From env (AXEMERE_GATEWAY_URL, AXEMERE_GATEWAY_TOKEN, ...)
+ * const config = new AiGatewayConfig();
+ * // Or explicit overrides
+ * const config2 = new AiGatewayConfig({ gateway_url: "http://localhost:7080" });
+ * ```
+ */
+export declare class AiGatewayConfig {
+    readonly gateway_url: string;
+    readonly gateway_token: string;
+    default_provider: string;
+    default_model: string;
+    readonly workload_id: string;
+    readonly project_id: string;
+    readonly account_id: string;
+    readonly customer_id: string;
+    readonly labels: Record<string, string>;
+    readonly provider_api_key: string;
+    readonly timeout: number;
+    constructor(opts?: AiGatewayOptions);
+    /**
+     * Builds the proxy base URL for a given provider.
+     * Format: {gateway_url}/proxy/{provider}[/k/{gateway_token}][/w/{workload_id}]
+     *         [/p/{project_id}][/a/{account_id}][/c/{customer_id}]/
+     */
+    proxyUrl(provider: string): string;
+    setDefaults(opts: {
+        provider?: string;
+        model?: string;
+    }): void;
+}

package/dist/config.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AiGatewayConfig = void 0;
+function parseLabelsEnv(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+            const result = {};
+            for (const [k, v] of Object.entries(parsed)) {
+                result[k] = String(v);
+            }
+            return result;
+        }
+    }
+    catch {
+        // Ignore parse errors — return empty
+    }
+    return {};
+}
+/**
+ * Resolved configuration for talking to the Axemere AI Gateway.
+ *
+ * Each field is taken from the matching {@link AiGatewayOptions} value when
+ * provided, otherwise from its `AXEMERE_*` environment variable, otherwise a
+ * safe default. Values are read once at construction time. Also builds the
+ * proxy base URL used by the OpenAI/Anthropic drop-in wrappers.
+ *
+ * @example
+ * ```ts
+ * // From env (AXEMERE_GATEWAY_URL, AXEMERE_GATEWAY_TOKEN, ...)
+ * const config = new AiGatewayConfig();
+ * // Or explicit overrides
+ * const config2 = new AiGatewayConfig({ gateway_url: "http://localhost:7080" });
+ * ```
+ */
+class AiGatewayConfig {
+    constructor(opts = {}) {
+        // Constructor args take precedence over env vars (read at construction time).
+        this.gateway_url =
+            opts.gateway_url ?? process.env["AXEMERE_GATEWAY_URL"] ?? "";
+        this.gateway_token =
+            opts.gateway_token ?? process.env["AXEMERE_GATEWAY_TOKEN"] ?? "";
+        this.default_provider =
+            opts.default_provider ?? process.env["AXEMERE_PROVIDER"] ?? "";
+        this.default_model =
+            opts.default_model ?? process.env["AXEMERE_MODEL"] ?? "";
+        this.workload_id =
+            opts.workload_id ?? process.env["AXEMERE_WORKLOAD_ID"] ?? "";
+        this.project_id =
+            opts.project_id ?? process.env["AXEMERE_PROJECT_ID"] ?? "";
+        this.account_id =
+            opts.account_id ?? process.env["AXEMERE_ACCOUNT_ID"] ?? "";
+        this.customer_id =
+            opts.customer_id ?? process.env["AXEMERE_CUSTOMER_ID"] ?? "";
+        this.provider_api_key =
+            opts.provider_api_key ?? process.env["AXEMERE_PROVIDER_API_KEY"] ?? "";
+        // Timeout in seconds; falls back to 120 on missing/invalid input so an
+        // unparseable env value can never produce a NaN AbortController delay.
+        const timeoutEnv = process.env["AXEMERE_TIMEOUT_SECONDS"];
+        const rawTimeout = opts.timeout ?? (timeoutEnv ? parseInt(timeoutEnv, 10) : undefined);
+        this.timeout =
+            rawTimeout === undefined || isNaN(rawTimeout) || rawTimeout <= 0
+                ? 120
+                : rawTimeout;
+        if (opts.labels !== undefined) {
+            this.labels = opts.labels;
+        }
+        else {
+            const labelsEnv = process.env["AXEMERE_LABELS"];
+            this.labels = labelsEnv ? parseLabelsEnv(labelsEnv) : {};
+        }
+    }
+    /**
+     * Builds the proxy base URL for a given provider.
+     * Format: {gateway_url}/proxy/{provider}[/k/{gateway_token}][/w/{workload_id}]
+     *         [/p/{project_id}][/a/{account_id}][/c/{customer_id}]/
+     */
+    proxyUrl(provider) {
+        let url = `${this.gateway_url}/proxy/${provider}`;
+        if (this.gateway_token)
+            url += `/k/${this.gateway_token}`;
+        if (this.workload_id)
+            url += `/w/${this.workload_id}`;
+        if (this.project_id)
+            url += `/p/${this.project_id}`;
+        if (this.account_id)
+            url += `/a/${this.account_id}`;
+        if (this.customer_id)
+            url += `/c/${this.customer_id}`;
+        url += "/";
+        return url;
+    }
+    setDefaults(opts) {
+        if (opts.provider !== undefined)
+            this.default_provider = opts.provider;
+        if (opts.model !== undefined)
+            this.default_model = opts.model;
+    }
+}
+exports.AiGatewayConfig = AiGatewayConfig;

package/dist/errors.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Base error for all gateway failures (config, network, and non-OK HTTP
+ * responses from the gateway or upstream provider). More specific subclasses
+ * are thrown for policy denials, quota limits, and timeouts.
+ *
+ * @property status_code - HTTP status of the failing response, when available.
+ * @property response_body - Parsed response body, when available.
+ */
+export declare class GatewayError extends Error {
+    status_code?: number;
+    response_body?: unknown;
+    constructor(message: string);
+}
+/**
+ * Thrown when the gateway denies a request by policy.
+ *
+ * @property reason - Human-readable denial reason from the gateway.
+ * @property trace - Optional policy-evaluation trace explaining the decision.
+ * @property record_id - Audit ledger record id for the denied request, if any.
+ */
+export declare class PolicyDeniedError extends GatewayError {
+    reason: string;
+    trace?: unknown;
+    record_id?: string;
+    constructor(message: string);
+}
+/**
+ * Thrown when a spend or quota limit is exceeded (HTTP 429).
+ *
+ * @property upgrade_url - URL to raise the limit / upgrade the plan, if provided.
+ * @property retry_after - Seconds to wait before retrying, if provided.
+ */
+export declare class QuotaExceededError extends GatewayError {
+    upgrade_url?: string;
+    retry_after?: number;
+    constructor(message: string);
+}
+/**
+ * Thrown when a request times out — either the client-side AbortController
+ * deadline (`AXEMERE_TIMEOUT_SECONDS`) or an HTTP 504 from the gateway.
+ */
+export declare class GatewayTimeoutError extends GatewayError {
+    constructor(message: string);
+}

package/dist/errors.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GatewayTimeoutError = exports.QuotaExceededError = exports.PolicyDeniedError = exports.GatewayError = void 0;
+/**
+ * Base error for all gateway failures (config, network, and non-OK HTTP
+ * responses from the gateway or upstream provider). More specific subclasses
+ * are thrown for policy denials, quota limits, and timeouts.
+ *
+ * @property status_code - HTTP status of the failing response, when available.
+ * @property response_body - Parsed response body, when available.
+ */
+class GatewayError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "GatewayError";
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.GatewayError = GatewayError;
+/**
+ * Thrown when the gateway denies a request by policy.
+ *
+ * @property reason - Human-readable denial reason from the gateway.
+ * @property trace - Optional policy-evaluation trace explaining the decision.
+ * @property record_id - Audit ledger record id for the denied request, if any.
+ */
+class PolicyDeniedError extends GatewayError {
+    constructor(message) {
+        super(message);
+        this.name = "PolicyDeniedError";
+        this.reason = "";
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.PolicyDeniedError = PolicyDeniedError;
+/**
+ * Thrown when a spend or quota limit is exceeded (HTTP 429).
+ *
+ * @property upgrade_url - URL to raise the limit / upgrade the plan, if provided.
+ * @property retry_after - Seconds to wait before retrying, if provided.
+ */
+class QuotaExceededError extends GatewayError {
+    constructor(message) {
+        super(message);
+        this.name = "QuotaExceededError";
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.QuotaExceededError = QuotaExceededError;
+/**
+ * Thrown when a request times out — either the client-side AbortController
+ * deadline (`AXEMERE_TIMEOUT_SECONDS`) or an HTTP 504 from the gateway.
+ */
+class GatewayTimeoutError extends GatewayError {
+    constructor(message) {
+        super(message);
+        this.name = "GatewayTimeoutError";
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.GatewayTimeoutError = GatewayTimeoutError;

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { AiGatewayConfig } from "./config";
+export type { AiGatewayOptions } from "./config";
+export { AiGatewayClient } from "./client";
+export { GatewayError, PolicyDeniedError, QuotaExceededError, GatewayTimeoutError } from "./errors";
+export { PROVIDER_ROUTES } from "./providers";
+export type { ProviderRoute } from "./providers";
+export type { Message, CostBreakdownItem, Metering, ExecuteResponse, StreamChunk, ExecuteParams, } from "./types";

package/dist/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROVIDER_ROUTES = exports.GatewayTimeoutError = exports.QuotaExceededError = exports.PolicyDeniedError = exports.GatewayError = exports.AiGatewayClient = exports.AiGatewayConfig = void 0;
+var config_1 = require("./config");
+Object.defineProperty(exports, "AiGatewayConfig", { enumerable: true, get: function () { return config_1.AiGatewayConfig; } });
+var client_1 = require("./client");
+Object.defineProperty(exports, "AiGatewayClient", { enumerable: true, get: function () { return client_1.AiGatewayClient; } });
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "GatewayError", { enumerable: true, get: function () { return errors_1.GatewayError; } });
+Object.defineProperty(exports, "PolicyDeniedError", { enumerable: true, get: function () { return errors_1.PolicyDeniedError; } });
+Object.defineProperty(exports, "QuotaExceededError", { enumerable: true, get: function () { return errors_1.QuotaExceededError; } });
+Object.defineProperty(exports, "GatewayTimeoutError", { enumerable: true, get: function () { return errors_1.GatewayTimeoutError; } });
+var providers_1 = require("./providers");
+Object.defineProperty(exports, "PROVIDER_ROUTES", { enumerable: true, get: function () { return providers_1.PROVIDER_ROUTES; } });

package/dist/providers.d.ts

@@ -0,0 +1,5 @@
+export interface ProviderRoute {
+    host: string;
+    path: string;
+}
+export declare const PROVIDER_ROUTES: Record<string, ProviderRoute>;

package/dist/providers.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROVIDER_ROUTES = void 0;
+exports.PROVIDER_ROUTES = {
+    openai: { host: "api.openai.com", path: "/v1/chat/completions" },
+    anthropic: { host: "api.anthropic.com", path: "/v1/messages" },
+    gemini: { host: "generativelanguage.googleapis.com", path: "/v1beta/models/{model}:generateContent" },
+    cohere: { host: "api.cohere.com", path: "/v2/chat" },
+    mistral: { host: "api.mistral.ai", path: "/v1/chat/completions" },
+    groq: { host: "api.groq.com", path: "/openai/v1/chat/completions" },
+    deepseek: { host: "api.deepseek.com", path: "/v1/chat/completions" },
+    together: { host: "api.together.ai", path: "/v1/chat/completions" },
+    minimax: { host: "api.minimax.chat", path: "/v1/text/chatcompletion_v2" },
+    moonshot: { host: "api.moonshot.ai", path: "/v1/chat/completions" },
+    zhipu: { host: "api.z.ai", path: "/api/paas/v4/chat/completions" },
+    xai: { host: "api.x.ai", path: "/v1/chat/completions" },
+    perplexity: { host: "api.perplexity.ai", path: "/chat/completions" },
+    openrouter: { host: "openrouter.ai", path: "/api/v1/chat/completions" },
+    "nvidia-nim": { host: "integrate.api.nvidia.com", path: "/v1/chat/completions" },
+    upstage: { host: "api.upstage.ai", path: "/v1/chat/completions" },
+    fireworks: { host: "api.fireworks.ai", path: "/inference/v1/chat/completions" },
+};

package/dist/types.d.ts

@@ -0,0 +1,54 @@
+export interface Message {
+    role: "system" | "user" | "assistant" | "tool";
+    content: string;
+}
+export interface CostBreakdownItem {
+    label: string;
+    tokens: number;
+    rate_per_million: string;
+    subtotal_usd: string;
+}
+export interface Metering {
+    cost_usd: string;
+    tokens_in: number;
+    tokens_out: number;
+    bytes_in?: number;
+    bytes_out?: number;
+    cache_hit_tokens?: number;
+    cache_miss_tokens?: number;
+    cache_creation_tokens?: number;
+    reasoning_tokens?: number;
+    pricing_config_version?: number;
+    org_pricing_config_version?: number;
+    markup_multiplier_applied?: string;
+    cost_breakdown?: CostBreakdownItem[];
+}
+export interface ExecuteResponse {
+    content: string;
+    record_id: string;
+    metering: Metering;
+    provider: string;
+    model: string;
+    record_hash?: string;
+    provider_response?: unknown;
+}
+export interface StreamChunk {
+    content: string;
+    is_final: boolean;
+    record_id?: string;
+    metering?: Metering;
+}
+export interface ExecuteParams {
+    messages: Message[];
+    provider?: string;
+    model?: string;
+    workload_id?: string;
+    project_id?: string;
+    account_id?: string;
+    customer_id?: string;
+    labels?: Record<string, string>;
+    provider_api_key?: string;
+    delegation_token?: string;
+    stream?: boolean;
+    [key: string]: unknown;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@axemere/gateway",
+  "version": "0.1.6",
+  "description": "Axemere AI Gateway SDK — core client, config, and proxy URL builder",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Axemere-LLC/axemere-node.git",
+    "directory": "packages/gateway"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "uuidv7": "^1.0.2"
+  },
+  "devDependencies": {
+    "typescript": "^5.4.0",
+    "@types/node": "^20.0.0",
+    "jest": "^29.0.0",
+    "@types/jest": "^29.0.0",
+    "ts-jest": "^29.0.0"
+  },
+  "jest": {
+    "preset": "ts-jest",
+    "testEnvironment": "node",
+    "extensionsToTreatAsEsm": [],
+    "transform": {
+      "^.+\\.tsx?$": [
+        "ts-jest",
+        {
+          "useESM": false
+        }
+      ]
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js"
+  }
+}