@modelrelay/sdk 0.2.0

package/dist/index.cjs

@@ -0,0 +1,960 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ApiKeysClient: () => ApiKeysClient,
+  AuthClient: () => AuthClient,
+  BillingClient: () => BillingClient,
+  ChatClient: () => ChatClient,
+  ChatCompletionsStream: () => ChatCompletionsStream,
+  DEFAULT_BASE_URL: () => DEFAULT_BASE_URL,
+  DEFAULT_CLIENT_HEADER: () => DEFAULT_CLIENT_HEADER,
+  DEFAULT_REQUEST_TIMEOUT_MS: () => DEFAULT_REQUEST_TIMEOUT_MS,
+  ModelRelay: () => ModelRelay,
+  ModelRelayError: () => ModelRelayError,
+  SANDBOX_BASE_URL: () => SANDBOX_BASE_URL,
+  SDK_VERSION: () => SDK_VERSION,
+  STAGING_BASE_URL: () => STAGING_BASE_URL,
+  isPublishableKey: () => isPublishableKey
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var ModelRelayError = class extends Error {
+  constructor(message, opts) {
+    super(message);
+    this.name = "ModelRelayError";
+    this.status = opts.status;
+    this.code = opts.code;
+    this.requestId = opts.requestId;
+    this.fields = opts.fields;
+    this.data = opts.data;
+  }
+};
+async function parseErrorResponse(response) {
+  const requestId = response.headers.get("X-ModelRelay-Chat-Request-Id") || response.headers.get("X-Request-Id") || void 0;
+  const fallbackMessage = response.statusText || "Request failed";
+  const status = response.status || 500;
+  let bodyText = "";
+  try {
+    bodyText = await response.text();
+  } catch {
+  }
+  if (!bodyText) {
+    return new ModelRelayError(fallbackMessage, { status, requestId });
+  }
+  try {
+    const parsed = JSON.parse(bodyText);
+    const parsedObj = typeof parsed === "object" && parsed !== null ? parsed : null;
+    if (parsedObj?.error) {
+      const errPayload = typeof parsedObj.error === "object" && parsedObj.error !== null ? parsedObj.error : null;
+      const message = errPayload?.message || fallbackMessage;
+      const code = errPayload?.code || void 0;
+      const fields = Array.isArray(errPayload?.fields) ? errPayload?.fields : void 0;
+      const parsedStatus = typeof errPayload?.status === "number" ? errPayload.status : status;
+      return new ModelRelayError(message, {
+        status: parsedStatus,
+        code,
+        fields,
+        requestId: parsedObj?.request_id || parsedObj?.requestId || requestId,
+        data: parsed
+      });
+    }
+    if (parsedObj?.message || parsedObj?.code) {
+      const message = parsedObj.message || fallbackMessage;
+      return new ModelRelayError(message, {
+        status,
+        code: parsedObj.code,
+        fields: parsedObj.fields,
+        requestId: parsedObj?.request_id || parsedObj?.requestId || requestId,
+        data: parsed
+      });
+    }
+    return new ModelRelayError(fallbackMessage, {
+      status,
+      requestId,
+      data: parsed
+    });
+  } catch {
+    return new ModelRelayError(bodyText, { status, requestId });
+  }
+}
+
+// src/auth.ts
+var AuthClient = class {
+  constructor(http, cfg) {
+    this.cachedFrontend = /* @__PURE__ */ new Map();
+    this.http = http;
+    this.apiKey = cfg.apiKey;
+    this.accessToken = cfg.accessToken;
+    this.endUser = cfg.endUser;
+  }
+  /**
+   * Exchange a publishable key for a short-lived frontend token.
+   * Tokens are cached until they are close to expiry.
+   */
+  async frontendToken(request) {
+    const publishableKey = request?.publishableKey || (isPublishableKey(this.apiKey) ? this.apiKey : void 0);
+    if (!publishableKey) {
+      throw new ModelRelayError(
+        "publishable key required to issue frontend tokens",
+        { status: 400 }
+      );
+    }
+    const userId = request?.userId || this.endUser?.id;
+    if (!userId) {
+      throw new ModelRelayError(
+        "endUserId is required to mint a frontend token",
+        { status: 400 }
+      );
+    }
+    const deviceId = request?.deviceId || this.endUser?.deviceId;
+    const ttlSeconds = request?.ttlSeconds ?? this.endUser?.ttlSeconds;
+    const cacheKey = `${publishableKey}:${userId}:${deviceId || ""}`;
+    const cached = this.cachedFrontend.get(cacheKey);
+    if (cached && isTokenReusable(cached)) {
+      return cached;
+    }
+    const payload = {
+      publishable_key: publishableKey,
+      user_id: userId
+    };
+    if (deviceId) {
+      payload.device_id = deviceId;
+    }
+    if (typeof ttlSeconds === "number" && ttlSeconds > 0) {
+      payload.ttl_seconds = ttlSeconds;
+    }
+    const response = await this.http.json(
+      "/auth/frontend-token",
+      {
+        method: "POST",
+        body: payload
+      }
+    );
+    const token = normalizeFrontendToken(response, {
+      publishableKey,
+      userId,
+      deviceId
+    });
+    this.cachedFrontend.set(cacheKey, token);
+    return token;
+  }
+  /**
+   * Determine the correct auth headers for chat completions.
+   * Publishable keys are automatically exchanged for frontend tokens.
+   */
+  async authForChat(endUserId, overrides) {
+    if (this.accessToken) {
+      return { accessToken: this.accessToken };
+    }
+    if (!this.apiKey) {
+      throw new ModelRelayError("API key or token is required", {
+        status: 401
+      });
+    }
+    if (isPublishableKey(this.apiKey)) {
+      const token = await this.frontendToken({
+        userId: endUserId || overrides?.id,
+        deviceId: overrides?.deviceId,
+        ttlSeconds: overrides?.ttlSeconds
+      });
+      return { accessToken: token.token };
+    }
+    return { apiKey: this.apiKey };
+  }
+  /**
+   * Billing calls accept either bearer tokens or API keys (including publishable keys).
+   */
+  authForBilling() {
+    if (this.accessToken) {
+      return { accessToken: this.accessToken };
+    }
+    if (!this.apiKey) {
+      throw new ModelRelayError("API key or token is required", {
+        status: 401
+      });
+    }
+    return { apiKey: this.apiKey };
+  }
+};
+function isPublishableKey(value) {
+  if (!value) {
+    return false;
+  }
+  return value.trim().toLowerCase().startsWith("mr_pk_");
+}
+function normalizeFrontendToken(payload, meta) {
+  const expiresAt = payload.expires_at || payload.expiresAt;
+  return {
+    token: payload.token,
+    expiresAt: expiresAt ? new Date(expiresAt) : void 0,
+    expiresIn: payload.expires_in ?? payload.expiresIn,
+    tokenType: payload.token_type ?? payload.tokenType,
+    keyId: payload.key_id ?? payload.keyId,
+    sessionId: payload.session_id ?? payload.sessionId,
+    tokenScope: payload.token_scope ?? payload.tokenScope,
+    tokenSource: payload.token_source ?? payload.tokenSource,
+    endUserId: meta.userId,
+    publishableKey: meta.publishableKey,
+    deviceId: meta.deviceId
+  };
+}
+function isTokenReusable(token) {
+  if (!token.token) {
+    return false;
+  }
+  if (!token.expiresAt) {
+    return true;
+  }
+  return token.expiresAt.getTime() - Date.now() > 6e4;
+}
+
+// src/api-keys.ts
+var ApiKeysClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async list() {
+    const payload = await this.http.json("/api-keys", {
+      method: "GET"
+    });
+    const items = payload.api_keys || payload.apiKeys || [];
+    return items.map(normalizeApiKey).filter(Boolean);
+  }
+  async create(req) {
+    if (!req?.label?.trim()) {
+      throw new ModelRelayError("label is required", { status: 400 });
+    }
+    const body = {
+      label: req.label
+    };
+    if (req.kind) body.kind = req.kind;
+    if (req.expiresAt instanceof Date) {
+      body.expires_at = req.expiresAt.toISOString();
+    }
+    const payload = await this.http.json("/api-keys", {
+      method: "POST",
+      body
+    });
+    const record = payload.api_key || payload.apiKey;
+    if (!record) {
+      throw new ModelRelayError("missing api_key in response", {
+        status: 500
+      });
+    }
+    return normalizeApiKey(record);
+  }
+  async delete(id) {
+    if (!id?.trim()) {
+      throw new ModelRelayError("id is required", { status: 400 });
+    }
+    await this.http.request(`/api-keys/${encodeURIComponent(id)}`, {
+      method: "DELETE"
+    });
+  }
+};
+function normalizeApiKey(record) {
+  const created = record?.created_at || record?.createdAt || "";
+  const expires = record?.expires_at ?? record?.expiresAt ?? void 0;
+  const lastUsed = record?.last_used_at ?? record?.lastUsedAt ?? void 0;
+  return {
+    id: record?.id || "",
+    label: record?.label || "",
+    kind: record?.kind || "",
+    createdAt: created ? new Date(created) : /* @__PURE__ */ new Date(),
+    expiresAt: expires ? new Date(expires) : void 0,
+    lastUsedAt: lastUsed ? new Date(lastUsed) : void 0,
+    redactedKey: record?.redacted_key || record?.redactedKey || "",
+    secretKey: record?.secret_key ?? record?.secretKey ?? void 0
+  };
+}
+
+// src/billing.ts
+var BillingClient = class {
+  constructor(http, auth) {
+    this.http = http;
+    this.auth = auth;
+  }
+  /**
+   * Initiate a Stripe Checkout session for an end user.
+   */
+  async checkout(params) {
+    if (!params?.endUserId?.trim()) {
+      throw new ModelRelayError("endUserId is required", { status: 400 });
+    }
+    if (!params.successUrl?.trim() || !params.cancelUrl?.trim()) {
+      throw new ModelRelayError("successUrl and cancelUrl are required", {
+        status: 400
+      });
+    }
+    const authHeaders = this.auth.authForBilling();
+    const body = {
+      end_user_id: params.endUserId,
+      success_url: params.successUrl,
+      cancel_url: params.cancelUrl
+    };
+    if (params.deviceId) body.device_id = params.deviceId;
+    if (params.planId) body.plan_id = params.planId;
+    if (params.plan) body.plan = params.plan;
+    const response = await this.http.json(
+      "/end-users/checkout",
+      {
+        method: "POST",
+        body,
+        apiKey: authHeaders.apiKey,
+        accessToken: authHeaders.accessToken
+      }
+    );
+    return normalizeCheckoutResponse(response);
+  }
+};
+function normalizeCheckoutResponse(payload) {
+  const endUser = {
+    id: payload.end_user?.id || "",
+    externalId: payload.end_user?.external_id || "",
+    ownerId: payload.end_user?.owner_id || ""
+  };
+  const session = {
+    id: payload.session?.id || "",
+    plan: payload.session?.plan || "",
+    status: payload.session?.status || "",
+    url: payload.session?.url || "",
+    expiresAt: payload.session?.expires_at ? new Date(payload.session.expires_at) : void 0,
+    completedAt: payload.session?.completed_at ? new Date(payload.session.completed_at) : void 0
+  };
+  return { endUser, session };
+}
+
+// src/chat.ts
+var REQUEST_ID_HEADER = "X-ModelRelay-Chat-Request-Id";
+var ChatClient = class {
+  constructor(http, auth, cfg = {}) {
+    this.completions = new ChatCompletionsClient(
+      http,
+      auth,
+      cfg.defaultMetadata
+    );
+  }
+};
+var ChatCompletionsClient = class {
+  constructor(http, auth, defaultMetadata) {
+    this.http = http;
+    this.auth = auth;
+    this.defaultMetadata = defaultMetadata;
+  }
+  async create(params, options = {}) {
+    const stream = options.stream ?? params.stream ?? true;
+    if (!params?.model?.trim()) {
+      throw new ModelRelayError("model is required", { status: 400 });
+    }
+    if (!params?.messages?.length) {
+      throw new ModelRelayError("at least one message is required", {
+        status: 400
+      });
+    }
+    if (!hasUserMessage(params.messages)) {
+      throw new ModelRelayError(
+        "at least one user message is required",
+        { status: 400 }
+      );
+    }
+    const authHeaders = await this.auth.authForChat(params.endUserId);
+    const body = buildProxyBody(
+      params,
+      mergeMetadata(this.defaultMetadata, params.metadata, options.metadata)
+    );
+    const requestId = params.requestId || options.requestId;
+    const headers = { ...options.headers || {} };
+    if (requestId) {
+      headers[REQUEST_ID_HEADER] = requestId;
+    }
+    const response = await this.http.request("/llm/proxy", {
+      method: "POST",
+      body,
+      headers,
+      apiKey: authHeaders.apiKey,
+      accessToken: authHeaders.accessToken,
+      accept: stream ? "text/event-stream" : "application/json",
+      raw: true,
+      signal: options.signal,
+      timeoutMs: options.timeoutMs ?? (stream ? 0 : void 0),
+      useDefaultTimeout: !stream,
+      retry: options.retry
+    });
+    const resolvedRequestId = requestIdFromHeaders(response.headers) || requestId || void 0;
+    if (!response.ok) {
+      throw await parseErrorResponse(response);
+    }
+    if (!stream) {
+      const payload = await response.json();
+      return normalizeChatResponse(payload, resolvedRequestId);
+    }
+    return new ChatCompletionsStream(response, resolvedRequestId);
+  }
+};
+var ChatCompletionsStream = class {
+  constructor(response, requestId) {
+    this.closed = false;
+    if (!response.body) {
+      throw new ModelRelayError("streaming response is missing a body", {
+        status: 500
+      });
+    }
+    this.response = response;
+    this.requestId = requestId;
+  }
+  async cancel(reason) {
+    this.closed = true;
+    try {
+      await this.response.body?.cancel(reason);
+    } catch {
+    }
+  }
+  async *[Symbol.asyncIterator]() {
+    if (this.closed) {
+      return;
+    }
+    const body = this.response.body;
+    if (!body) {
+      throw new ModelRelayError("streaming response is missing a body", {
+        status: 500
+      });
+    }
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+      while (true) {
+        if (this.closed) {
+          await reader.cancel();
+          return;
+        }
+        const { value, done } = await reader.read();
+        if (done) {
+          const { events: events2 } = consumeSSEBuffer(buffer, true);
+          for (const evt of events2) {
+            const parsed = mapChatEvent(evt, this.requestId);
+            if (parsed) {
+              yield parsed;
+            }
+          }
+          return;
+        }
+        buffer += decoder.decode(value, { stream: true });
+        const { events, remainder } = consumeSSEBuffer(buffer);
+        buffer = remainder;
+        for (const evt of events) {
+          const parsed = mapChatEvent(evt, this.requestId);
+          if (parsed) {
+            yield parsed;
+          }
+        }
+      }
+    } finally {
+      this.closed = true;
+      reader.releaseLock();
+    }
+  }
+};
+function consumeSSEBuffer(buffer, flush = false) {
+  const events = [];
+  let eventName = "";
+  let dataLines = [];
+  let remainder = "";
+  const lines = buffer.split(/\r?\n/);
+  const lastIndex = lines.length - 1;
+  const limit = flush ? lines.length : Math.max(0, lastIndex);
+  const pushEvent = () => {
+    if (!eventName && dataLines.length === 0) {
+      return;
+    }
+    events.push({
+      event: eventName || "message",
+      data: dataLines.join("\n")
+    });
+    eventName = "";
+    dataLines = [];
+  };
+  for (let i = 0; i < limit; i++) {
+    const line = lines[i];
+    if (line === "") {
+      pushEvent();
+      continue;
+    }
+    if (line.startsWith(":")) {
+      continue;
+    }
+    if (line.startsWith("event:")) {
+      eventName = line.slice(6).trim();
+    } else if (line.startsWith("data:")) {
+      dataLines.push(line.slice(5).trimStart());
+    }
+  }
+  if (flush) {
+    pushEvent();
+    remainder = "";
+  } else {
+    remainder = lines[lastIndex] ?? "";
+  }
+  return { events, remainder };
+}
+function mapChatEvent(raw, requestId) {
+  let parsed = raw.data;
+  if (raw.data) {
+    try {
+      parsed = JSON.parse(raw.data);
+    } catch {
+      parsed = raw.data;
+    }
+  }
+  const payload = typeof parsed === "object" && parsed !== null ? parsed : {};
+  const p = payload;
+  const type = normalizeEventType(raw.event, p);
+  const usage = normalizeUsage(p.usage);
+  const responseId = p.response_id || p.responseId || p.id || p?.message?.id;
+  const model = p.model || p?.message?.model;
+  const stopReason = p.stop_reason || p.stopReason;
+  const textDelta = extractTextDelta(p);
+  return {
+    type,
+    event: raw.event || type,
+    data: p,
+    textDelta,
+    responseId,
+    model,
+    stopReason,
+    usage,
+    requestId,
+    raw: raw.data || ""
+  };
+}
+function normalizeEventType(eventName, payload) {
+  const hint = String(
+    payload?.type || payload?.event || eventName || ""
+  ).trim();
+  switch (hint) {
+    case "message_start":
+      return "message_start";
+    case "message_delta":
+      return "message_delta";
+    case "message_stop":
+      return "message_stop";
+    case "ping":
+      return "ping";
+    default:
+      return "custom";
+  }
+}
+function extractTextDelta(payload) {
+  if (!payload || typeof payload !== "object") {
+    return void 0;
+  }
+  if (typeof payload.delta === "string") {
+    return payload.delta;
+  }
+  if (payload.delta && typeof payload.delta === "object") {
+    if (typeof payload.delta.text === "string") {
+      return payload.delta.text;
+    }
+    if (typeof payload.delta.content === "string") {
+      return payload.delta.content;
+    }
+  }
+  return void 0;
+}
+function normalizeChatResponse(payload, requestId) {
+  const p = payload;
+  return {
+    id: p?.id,
+    provider: p?.provider,
+    content: Array.isArray(p?.content) ? p.content : p?.content ? [String(p.content)] : [],
+    stopReason: p?.stop_reason ?? p?.stopReason,
+    model: p?.model,
+    usage: normalizeUsage(p?.usage),
+    requestId
+  };
+}
+function normalizeUsage(payload) {
+  if (!payload) {
+    return { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+  }
+  return {
+    inputTokens: Number(payload.input_tokens ?? payload.inputTokens ?? 0),
+    outputTokens: Number(payload.output_tokens ?? payload.outputTokens ?? 0),
+    totalTokens: Number(payload.total_tokens ?? payload.totalTokens ?? 0)
+  };
+}
+function buildProxyBody(params, metadata) {
+  const body = {
+    model: params.model,
+    messages: normalizeMessages(params.messages)
+  };
+  if (typeof params.maxTokens === "number") body.max_tokens = params.maxTokens;
+  if (params.provider) body.provider = params.provider;
+  if (typeof params.temperature === "number")
+    body.temperature = params.temperature;
+  if (metadata && Object.keys(metadata).length > 0) body.metadata = metadata;
+  if (params.stop?.length) body.stop = params.stop;
+  if (params.stopSequences?.length) body.stop_sequences = params.stopSequences;
+  return body;
+}
+function normalizeMessages(messages) {
+  return messages.map((msg) => ({
+    role: msg.role || "user",
+    content: msg.content
+  }));
+}
+function requestIdFromHeaders(headers) {
+  return headers.get(REQUEST_ID_HEADER) || headers.get("X-Request-Id") || void 0;
+}
+function mergeMetadata(...sources) {
+  const merged = {};
+  for (const src of sources) {
+    if (!src) continue;
+    for (const [key, value] of Object.entries(src)) {
+      const k = key?.trim();
+      const v = value?.trim();
+      if (!k || !v) continue;
+      merged[k] = v;
+    }
+  }
+  return Object.keys(merged).length ? merged : void 0;
+}
+function hasUserMessage(messages) {
+  return messages.some(
+    (msg) => msg.role?.toLowerCase?.() === "user" && !!msg.content
+  );
+}
+
+// package.json
+var package_default = {
+  name: "@modelrelay/sdk",
+  version: "0.2.0",
+  description: "TypeScript SDK for the ModelRelay API",
+  type: "module",
+  main: "dist/index.cjs",
+  module: "dist/index.js",
+  types: "dist/index.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js",
+      require: "./dist/index.cjs"
+    }
+  },
+  publishConfig: { access: "public" },
+  files: [
+    "dist"
+  ],
+  scripts: {
+    build: "tsup src/index.ts --format esm,cjs --dts",
+    dev: "tsup src/index.ts --format esm,cjs --dts --watch",
+    lint: "tsc --noEmit",
+    test: "vitest run"
+  },
+  keywords: [
+    "modelrelay",
+    "llm",
+    "sdk",
+    "typescript"
+  ],
+  author: "Shane Vitarana",
+  license: "Apache-2.0",
+  devDependencies: {
+    tsup: "^8.2.4",
+    typescript: "^5.6.3",
+    vitest: "^2.1.4"
+  }
+};
+
+// src/types.ts
+var SDK_VERSION = package_default.version || "0.0.0";
+var DEFAULT_BASE_URL = "https://api.modelrelay.ai/api/v1";
+var STAGING_BASE_URL = "https://api-stg.modelrelay.ai/api/v1";
+var SANDBOX_BASE_URL = "https://api.sandbox.modelrelay.ai/api/v1";
+var DEFAULT_CLIENT_HEADER = `modelrelay-ts/${SDK_VERSION}`;
+var DEFAULT_REQUEST_TIMEOUT_MS = 6e4;
+
+// src/http.ts
+var HTTPClient = class {
+  constructor(cfg) {
+    const baseFromEnv = baseUrlForEnvironment(cfg.environment);
+    this.baseUrl = normalizeBaseUrl(cfg.baseUrl || baseFromEnv || DEFAULT_BASE_URL);
+    this.apiKey = cfg.apiKey?.trim();
+    this.accessToken = cfg.accessToken?.trim();
+    this.fetchImpl = cfg.fetchImpl;
+    this.clientHeader = cfg.clientHeader?.trim() || DEFAULT_CLIENT_HEADER;
+    this.defaultTimeoutMs = cfg.timeoutMs === void 0 ? DEFAULT_REQUEST_TIMEOUT_MS : Math.max(0, cfg.timeoutMs);
+    this.retry = normalizeRetryConfig(cfg.retry);
+    this.defaultHeaders = normalizeHeaders(cfg.defaultHeaders);
+  }
+  async request(path, options = {}) {
+    const fetchFn = this.fetchImpl ?? globalThis.fetch;
+    if (!fetchFn) {
+      throw new ModelRelayError(
+        "fetch is not available; provide a fetch implementation",
+        { status: 500 }
+      );
+    }
+    const method = options.method || "GET";
+    const url = buildUrl(this.baseUrl, path);
+    const headers = new Headers({
+      ...this.defaultHeaders,
+      ...options.headers || {}
+    });
+    const accepts = options.accept || (options.raw ? void 0 : "application/json");
+    if (accepts && !headers.has("Accept")) {
+      headers.set("Accept", accepts);
+    }
+    const body = options.body;
+    const shouldEncodeJSON = body !== void 0 && body !== null && typeof body === "object" && !(body instanceof FormData) && !(body instanceof Blob);
+    const payload = shouldEncodeJSON ? JSON.stringify(body) : body;
+    if (shouldEncodeJSON && !headers.has("Content-Type")) {
+      headers.set("Content-Type", "application/json");
+    }
+    const accessToken = options.accessToken ?? this.accessToken;
+    if (accessToken) {
+      const bearer = accessToken.toLowerCase().startsWith("bearer ") ? accessToken : `Bearer ${accessToken}`;
+      headers.set("Authorization", bearer);
+    }
+    const apiKey = options.apiKey ?? this.apiKey;
+    if (apiKey) {
+      headers.set("X-ModelRelay-Api-Key", apiKey);
+    }
+    if (this.clientHeader && !headers.has("X-ModelRelay-Client")) {
+      headers.set("X-ModelRelay-Client", this.clientHeader);
+    }
+    const timeoutMs = options.useDefaultTimeout === false ? options.timeoutMs : options.timeoutMs ?? this.defaultTimeoutMs;
+    const retryCfg = normalizeRetryConfig(
+      options.retry === void 0 ? this.retry : options.retry
+    );
+    const attempts = retryCfg ? Math.max(1, retryCfg.maxAttempts) : 1;
+    let lastError;
+    for (let attempt = 1; attempt <= attempts; attempt++) {
+      const controller = timeoutMs && timeoutMs > 0 ? new AbortController() : void 0;
+      const signal = mergeSignals(options.signal, controller?.signal);
+      const timer = controller && setTimeout(() => controller.abort(new DOMException("timeout", "AbortError")), timeoutMs);
+      try {
+        const response = await fetchFn(url, {
+          method,
+          headers,
+          body: payload,
+          signal
+        });
+        if (!response.ok) {
+          const shouldRetry = retryCfg && shouldRetryStatus(
+            response.status,
+            method,
+            retryCfg.retryPost
+          ) && attempt < attempts;
+          if (shouldRetry) {
+            await backoff(attempt, retryCfg);
+            continue;
+          }
+          if (!options.raw) {
+            throw await parseErrorResponse(response);
+          }
+        }
+        return response;
+      } catch (err) {
+        if (options.signal?.aborted) {
+          throw err;
+        }
+        const shouldRetry = retryCfg && isRetryableError(err) && (method !== "POST" || retryCfg.retryPost) && attempt < attempts;
+        if (!shouldRetry) {
+          throw err;
+        }
+        lastError = err;
+        await backoff(attempt, retryCfg);
+      } finally {
+        if (timer) {
+          clearTimeout(timer);
+        }
+      }
+    }
+    throw lastError instanceof Error ? lastError : new ModelRelayError("request failed", { status: 500 });
+  }
+  async json(path, options = {}) {
+    const response = await this.request(path, {
+      ...options,
+      raw: true,
+      accept: options.accept || "application/json"
+    });
+    if (!response.ok) {
+      throw await parseErrorResponse(response);
+    }
+    if (response.status === 204) {
+      return void 0;
+    }
+    try {
+      return await response.json();
+    } catch (err) {
+      throw new ModelRelayError("failed to parse response JSON", {
+        status: response.status,
+        data: err
+      });
+    }
+  }
+};
+function buildUrl(baseUrl, path) {
+  if (/^https?:\/\//i.test(path)) {
+    return path;
+  }
+  if (!path.startsWith("/")) {
+    path = `/${path}`;
+  }
+  return `${baseUrl}${path}`;
+}
+function normalizeBaseUrl(value) {
+  const trimmed = value.trim();
+  if (trimmed.endsWith("/")) {
+    return trimmed.slice(0, -1);
+  }
+  return trimmed;
+}
+function baseUrlForEnvironment(env) {
+  if (!env || env === "production") return void 0;
+  if (env === "staging") return STAGING_BASE_URL;
+  if (env === "sandbox") return SANDBOX_BASE_URL;
+  return void 0;
+}
+function normalizeRetryConfig(retry) {
+  if (retry === false) return void 0;
+  const cfg = retry || {};
+  return {
+    maxAttempts: Math.max(1, cfg.maxAttempts ?? 3),
+    baseBackoffMs: Math.max(0, cfg.baseBackoffMs ?? 300),
+    maxBackoffMs: Math.max(0, cfg.maxBackoffMs ?? 5e3),
+    retryPost: cfg.retryPost ?? true
+  };
+}
+function shouldRetryStatus(status, method, retryPost) {
+  if (status === 408 || status === 429) {
+    return method !== "POST" || retryPost;
+  }
+  if (status >= 500 && status < 600) {
+    return method !== "POST" || retryPost;
+  }
+  return false;
+}
+function isRetryableError(err) {
+  if (!err) return false;
+  return err instanceof DOMException && err.name === "AbortError" || err instanceof TypeError;
+}
+function backoff(attempt, cfg) {
+  const exp = Math.max(0, attempt - 1);
+  const base = cfg.baseBackoffMs * Math.pow(2, Math.min(exp, 10));
+  const capped = Math.min(base, cfg.maxBackoffMs);
+  const jitter = 0.5 + Math.random();
+  const delay = Math.min(cfg.maxBackoffMs, capped * jitter);
+  if (delay <= 0) return Promise.resolve();
+  return new Promise((resolve) => setTimeout(resolve, delay));
+}
+function mergeSignals(user, timeoutSignal) {
+  if (!user && !timeoutSignal) return void 0;
+  if (user && !timeoutSignal) return user;
+  if (!user && timeoutSignal) return timeoutSignal;
+  const controller = new AbortController();
+  const propagate = (source) => {
+    if (source.aborted) {
+      controller.abort(source.reason);
+    } else {
+      source.addEventListener(
+        "abort",
+        () => controller.abort(source.reason),
+        { once: true }
+      );
+    }
+  };
+  if (user) propagate(user);
+  if (timeoutSignal) propagate(timeoutSignal);
+  return controller.signal;
+}
+function normalizeHeaders(headers) {
+  if (!headers) return {};
+  const normalized = {};
+  for (const [key, value] of Object.entries(headers)) {
+    if (!key || !value) continue;
+    const k = key.trim();
+    const v = value.trim();
+    if (k && v) {
+      normalized[k] = v;
+    }
+  }
+  return normalized;
+}
+
+// src/index.ts
+var ModelRelay = class {
+  constructor(options) {
+    const cfg = options || {};
+    if (!cfg.key && !cfg.token) {
+      throw new ModelRelayError("Provide an API key or access token", {
+        status: 400
+      });
+    }
+    this.baseUrl = resolveBaseUrl(cfg.environment, cfg.baseUrl);
+    const http = new HTTPClient({
+      baseUrl: this.baseUrl,
+      apiKey: cfg.key,
+      accessToken: cfg.token,
+      fetchImpl: cfg.fetch,
+      clientHeader: cfg.clientHeader || DEFAULT_CLIENT_HEADER,
+      timeoutMs: cfg.timeoutMs,
+      retry: cfg.retry,
+      defaultHeaders: cfg.defaultHeaders,
+      environment: cfg.environment
+    });
+    const auth = new AuthClient(http, {
+      apiKey: cfg.key,
+      accessToken: cfg.token,
+      endUser: cfg.endUser
+    });
+    this.auth = auth;
+    this.billing = new BillingClient(http, auth);
+    this.chat = new ChatClient(http, auth, {
+      defaultMetadata: cfg.defaultMetadata
+    });
+    this.apiKeys = new ApiKeysClient(http);
+  }
+};
+function resolveBaseUrl(env, override) {
+  const base = override || (env === "staging" ? STAGING_BASE_URL : env === "sandbox" ? SANDBOX_BASE_URL : DEFAULT_BASE_URL);
+  return base.replace(/\/+$/, "");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApiKeysClient,
+  AuthClient,
+  BillingClient,
+  ChatClient,
+  ChatCompletionsStream,
+  DEFAULT_BASE_URL,
+  DEFAULT_CLIENT_HEADER,
+  DEFAULT_REQUEST_TIMEOUT_MS,
+  ModelRelay,
+  ModelRelayError,
+  SANDBOX_BASE_URL,
+  SDK_VERSION,
+  STAGING_BASE_URL,
+  isPublishableKey
+});