@cetusai/sdk 0.2.0

package/dist/index.mjs

@@ -0,0 +1,880 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// node_modules/.pnpm/tsup@8.5.1_postcss@8.5.15_typescript@5.9.3/node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "node_modules/.pnpm/tsup@8.5.1_postcss@8.5.15_typescript@5.9.3/node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/errors.ts
+var errors_exports = {};
+__export(errors_exports, {
+  InvalidApiKeyError: () => InvalidApiKeyError,
+  InvalidConfigError: () => InvalidConfigError,
+  NetworkError: () => NetworkError,
+  PartialFailureError: () => PartialFailureError,
+  QueueOverflowError: () => QueueOverflowError,
+  RateLimitedError: () => RateLimitedError,
+  ServerError: () => ServerError,
+  SonglinesError: () => SonglinesError,
+  TimeoutError: () => TimeoutError
+});
+var SonglinesError, InvalidConfigError, InvalidApiKeyError, NetworkError, TimeoutError, RateLimitedError, ServerError, QueueOverflowError, PartialFailureError;
+var init_errors = __esm({
+  "src/errors.ts"() {
+    "use strict";
+    init_esm_shims();
+    SonglinesError = class extends Error {
+      code;
+      statusCode;
+      retryable;
+      constructor(message, code, options) {
+        super(message, { cause: options?.cause });
+        this.name = "SonglinesError";
+        this.code = code;
+        this.statusCode = options?.statusCode !== void 0 ? options.statusCode : void 0;
+        this.retryable = options?.retryable ?? false;
+      }
+    };
+    InvalidConfigError = class extends SonglinesError {
+      constructor(message) {
+        super(message, "INVALID_CONFIG", { retryable: false });
+        this.name = "InvalidConfigError";
+      }
+    };
+    InvalidApiKeyError = class extends SonglinesError {
+      constructor() {
+        super(
+          "Invalid or revoked API key. Check your SONGLINES_API_KEY environment variable.",
+          "INVALID_API_KEY",
+          { statusCode: 401, retryable: false }
+        );
+        this.name = "InvalidApiKeyError";
+      }
+    };
+    NetworkError = class extends SonglinesError {
+      constructor(message, cause) {
+        super(message, "NETWORK_ERROR", { retryable: true, cause });
+        this.name = "NetworkError";
+      }
+    };
+    TimeoutError = class extends SonglinesError {
+      constructor(timeoutMs) {
+        super(
+          `Request timed out after ${timeoutMs}ms`,
+          "TIMEOUT",
+          { retryable: true }
+        );
+        this.name = "TimeoutError";
+      }
+    };
+    RateLimitedError = class extends SonglinesError {
+      retryAfterMs;
+      constructor(retryAfterMs) {
+        super(
+          retryAfterMs ? `Rate limited. Retry after ${retryAfterMs}ms.` : "Rate limited by the Songlines API.",
+          "RATE_LIMITED",
+          { statusCode: 429, retryable: true }
+        );
+        this.name = "RateLimitedError";
+        this.retryAfterMs = retryAfterMs !== void 0 ? retryAfterMs : void 0;
+      }
+    };
+    ServerError = class extends SonglinesError {
+      constructor(statusCode, body) {
+        super(
+          `Songlines API returned ${statusCode}${body ? `: ${body}` : ""}`,
+          "SERVER_ERROR",
+          { statusCode, retryable: statusCode >= 500 }
+        );
+        this.name = "ServerError";
+      }
+    };
+    QueueOverflowError = class extends SonglinesError {
+      droppedCount;
+      constructor(droppedCount) {
+        super(
+          `Event queue is full. Dropped ${droppedCount} event(s). Check network connectivity.`,
+          "QUEUE_OVERFLOW",
+          { retryable: false }
+        );
+        this.name = "QueueOverflowError";
+        this.droppedCount = droppedCount;
+      }
+    };
+    PartialFailureError = class extends SonglinesError {
+      accepted;
+      failed;
+      failedIds;
+      constructor(accepted, failed, failedIds) {
+        super(
+          `Partial ingest failure: ${accepted} accepted, ${failed} failed.`,
+          "PARTIAL_FAILURE",
+          { retryable: false }
+        );
+        this.name = "PartialFailureError";
+        this.accepted = accepted;
+        this.failed = failed;
+        this.failedIds = failedIds;
+      }
+    };
+  }
+});
+
+// src/index.ts
+init_esm_shims();
+
+// src/client.ts
+init_esm_shims();
+init_errors();
+
+// src/utils/cost.ts
+init_esm_shims();
+var MODEL_RATES = {
+  // OpenAI
+  "gpt-4o-mini": { input: 0.15, output: 0.6 },
+  "gpt-4o": { input: 2.5, output: 10 },
+  "gpt-4-turbo": { input: 10, output: 30 },
+  "gpt-4": { input: 30, output: 60 },
+  "gpt-3.5-turbo": { input: 0.5, output: 1.5 },
+  "o1-mini": { input: 3, output: 12 },
+  "o1": { input: 15, output: 60 },
+  "o3-mini": { input: 1.1, output: 4.4 },
+  "o3": { input: 10, output: 40 },
+  "o4-mini": { input: 1.1, output: 4.4 },
+  // Anthropic
+  "claude-3-5-haiku": { input: 0.8, output: 4 },
+  "claude-3-5-sonnet": { input: 3, output: 15 },
+  "claude-3-7-sonnet": { input: 3, output: 15 },
+  "claude-3-opus": { input: 15, output: 75 },
+  "claude-3-haiku": { input: 0.25, output: 1.25 },
+  "claude-3-sonnet": { input: 3, output: 15 },
+  // Google
+  "gemini-2.0-flash": { input: 0.1, output: 0.4 },
+  "gemini-2.5-flash": { input: 0.15, output: 0.6 },
+  "gemini-2.5-pro": { input: 1.25, output: 10 },
+  "gemini-1.5-flash": { input: 0.075, output: 0.3 },
+  "gemini-1.5-pro": { input: 1.25, output: 5 },
+  // Mistral
+  "mistral-large": { input: 2, output: 6 },
+  "mistral-small": { input: 0.2, output: 0.6 },
+  "mistral-nemo": { input: 0.15, output: 0.15 },
+  "codestral": { input: 0.2, output: 0.6 },
+  // Meta (via Groq / Together / Bedrock)
+  "llama-3.3-70b": { input: 0.59, output: 0.79 },
+  "llama-3.1-405b": { input: 2.7, output: 2.7 },
+  "llama-3.1-70b": { input: 0.59, output: 0.79 },
+  "llama-3.1-8b": { input: 0.05, output: 0.08 },
+  // AWS Bedrock (Nova)
+  "amazon.nova-pro": { input: 0.8, output: 3.2 },
+  "amazon.nova-lite": { input: 0.06, output: 0.24 },
+  "amazon.nova-micro": { input: 0.035, output: 0.14 },
+  // Cohere
+  "command-r-plus": { input: 2.5, output: 10 },
+  "command-r": { input: 0.15, output: 0.6 },
+  // DeepSeek
+  "deepseek-chat": { input: 0.27, output: 1.1 },
+  "deepseek-reasoner": { input: 0.55, output: 2.19 }
+};
+var FALLBACK_RATES = { input: 1, output: 3 };
+function estimateCost({ model, inputTokens, outputTokens }) {
+  if (inputTokens === 0 && outputTokens === 0) return 0;
+  const normalised = model.toLowerCase().trim();
+  const rates = findRates(normalised);
+  const inputCost = inputTokens / 1e6 * rates.input;
+  const outputCost = outputTokens / 1e6 * rates.output;
+  return Math.round((inputCost + outputCost) * 1e8) / 1e8;
+}
+function findRates(normalisedModel) {
+  if (normalisedModel in MODEL_RATES) {
+    return MODEL_RATES[normalisedModel];
+  }
+  let bestMatch = "";
+  for (const key of Object.keys(MODEL_RATES)) {
+    if (normalisedModel.startsWith(key) && key.length > bestMatch.length) {
+      bestMatch = key;
+    }
+  }
+  return bestMatch ? MODEL_RATES[bestMatch] : FALLBACK_RATES;
+}
+function getModelRates() {
+  return MODEL_RATES;
+}
+
+// src/utils/id.ts
+init_esm_shims();
+function generateId() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+
+// src/utils/retry.ts
+init_esm_shims();
+init_errors();
+async function withRetry(fn, options = {}) {
+  const {
+    maxAttempts = 3,
+    baseDelayMs = 500,
+    maxDelayMs = 3e4,
+    jitter = 0.2,
+    onRetry
+  } = options;
+  let lastError;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err;
+      if (err instanceof SonglinesError && !err.retryable) {
+        throw err;
+      }
+      if (attempt === maxAttempts) {
+        break;
+      }
+      const delay = computeDelay(attempt, baseDelayMs, maxDelayMs, jitter);
+      onRetry?.(attempt, delay, err);
+      await sleep(delay);
+    }
+  }
+  throw lastError;
+}
+function computeDelay(attempt, baseDelayMs, maxDelayMs, jitter) {
+  const exponential = baseDelayMs * Math.pow(2, attempt - 1);
+  const capped = Math.min(exponential, maxDelayMs);
+  const jitterRange = capped * jitter;
+  const jitterOffset = (Math.random() * 2 - 1) * jitterRange;
+  return Math.max(0, Math.round(capped + jitterOffset));
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/utils/queue.ts
+init_esm_shims();
+init_errors();
+var BatchQueue = class {
+  queue = [];
+  flushTimer = null;
+  flushing = false;
+  opts;
+  constructor(opts) {
+    this.opts = opts;
+    this.scheduleFlush();
+  }
+  /**
+   * Pushes an event onto the queue. Triggers an immediate flush if the
+   * batch size threshold is reached.
+   */
+  push(event) {
+    if (this.queue.length >= this.opts.maxQueueSize) {
+      this.opts.onError(new QueueOverflowError(1));
+      this.log(`Queue overflow \u2014 dropped event ${event.request_id}`);
+      return;
+    }
+    this.queue.push(event);
+    this.log(`Queued event ${event.request_id} (queue size: ${this.queue.length})`);
+    if (this.queue.length >= this.opts.batchSize) {
+      this.log(`Batch size reached (${this.opts.batchSize}) \u2014 flushing immediately`);
+      void this.flushNow();
+    }
+  }
+  /**
+   * Flushes all queued events immediately.
+   * Safe to call multiple times concurrently — subsequent calls wait for the
+   * in-flight flush to complete before starting their own.
+   */
+  async flushNow() {
+    if (this.queue.length === 0) return;
+    const batch = this.queue.splice(0, this.queue.length);
+    this.log(`Flushing batch of ${batch.length} event(s)`);
+    try {
+      await this.opts.flush(batch);
+      this.log(`Flush successful \u2014 ${batch.length} event(s) accepted`);
+    } catch (err) {
+      this.log(`Flush failed \u2014 ${batch.length} event(s) dropped: ${String(err)}`);
+      if (err instanceof SonglinesError) {
+        this.opts.onError(err);
+      } else {
+        this.opts.onError(new NetworkError(String(err), err));
+      }
+    }
+  }
+  /**
+   * Cancels the periodic timer, flushes remaining events, and marks the queue
+   * as shut down. No further events should be pushed after calling this.
+   */
+  async shutdown() {
+    this.cancelTimer();
+    await this.flushNow();
+    this.log("Queue shut down");
+  }
+  // ── Private ─────────────────────────────────────────────────────────────────
+  scheduleFlush() {
+    this.cancelTimer();
+    this.flushTimer = setTimeout(() => {
+      void this.flushNow().finally(() => this.scheduleFlush());
+    }, this.opts.flushIntervalMs);
+    if (this.flushTimer.unref) {
+      this.flushTimer.unref();
+    }
+  }
+  cancelTimer() {
+    if (this.flushTimer !== null) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+  }
+  log(message) {
+    if (this.opts.debug) {
+      console.debug(`[Songlines SDK] ${message}`);
+    }
+  }
+  /** Exposed for testing only. */
+  get _queueLength() {
+    return this.queue.length;
+  }
+};
+
+// src/guardrail.ts
+init_esm_shims();
+var GuardrailBlockedError = class extends Error {
+  result;
+  constructor(result) {
+    const reasons = result.violations.map((v) => v.reason).join("; ");
+    super(`Guardrail blocked request: ${reasons}`);
+    this.name = "GuardrailBlockedError";
+    this.result = result;
+  }
+};
+var evaluateGuardrailImpl = async (params, config) => {
+  const { NetworkError: NetworkError2, ServerError: ServerError2, InvalidApiKeyError: InvalidApiKeyError2 } = await Promise.resolve().then(() => (init_errors(), errors_exports));
+  const url = `${config.baseUrl}/api/guardrail/evaluate`;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), config.timeout);
+  let response;
+  try {
+    response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${config.apiKey}`,
+        "User-Agent": "@songlines/sdk/0.2.0"
+      },
+      body: JSON.stringify({
+        prompt: params.prompt,
+        model: params.model,
+        workflow: params.workflow,
+        provider: params.provider
+      }),
+      signal: controller.signal
+    });
+  } catch (err) {
+    clearTimeout(timer);
+    if (err instanceof Error && err.name === "AbortError") {
+      const { TimeoutError: TimeoutError2 } = await Promise.resolve().then(() => (init_errors(), errors_exports));
+      throw new TimeoutError2(config.timeout);
+    }
+    throw new NetworkError2(`Failed to reach ${url}: ${String(err)}`, err);
+  } finally {
+    clearTimeout(timer);
+  }
+  if (response.status === 401) {
+    throw new InvalidApiKeyError2();
+  }
+  if (response.status >= 500) {
+    const text = await response.text().catch(() => "");
+    throw new ServerError2(response.status, text);
+  }
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new ServerError2(response.status, text);
+  }
+  const data = await response.json();
+  const result = {
+    decision: data.decision,
+    violations: data.violations.map((v) => ({
+      policyId: v.policy_id,
+      policyName: v.policy_name,
+      action: v.action,
+      reason: v.reason,
+      field: v.field
+    })),
+    latencyMs: data.latency_ms,
+    evaluationId: data.evaluation_id
+  };
+  if (data.modified_input !== void 0) {
+    result.modifiedInput = data.modified_input;
+  }
+  if (params.throwOnBlock && result.decision === "block") {
+    throw new GuardrailBlockedError(result);
+  }
+  return result;
+};
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://api.songlinesai.com";
+var DEFAULT_BATCH_SIZE = 10;
+var DEFAULT_FLUSH_INTERVAL_MS = 5e3;
+var DEFAULT_TIMEOUT_MS = 1e4;
+var DEFAULT_RETRIES = 3;
+var MAX_QUEUE_SIZE = 1e3;
+var SonglinesClient = class {
+  config;
+  queue;
+  constructor(config) {
+    if (!config.apiKey || typeof config.apiKey !== "string") {
+      throw new InvalidConfigError(
+        "apiKey is required. Set SONGLINES_API_KEY in your environment and pass it as apiKey."
+      );
+    }
+    if (config.apiKey.trim().length === 0) {
+      throw new InvalidConfigError("apiKey must not be empty.");
+    }
+    if (config.batchSize !== void 0 && (config.batchSize < 1 || config.batchSize > 100)) {
+      throw new InvalidConfigError("batchSize must be between 1 and 100.");
+    }
+    if (config.flushIntervalMs !== void 0 && config.flushIntervalMs < 100) {
+      throw new InvalidConfigError("flushIntervalMs must be at least 100ms.");
+    }
+    if (config.retries !== void 0 && (config.retries < 0 || config.retries > 10)) {
+      throw new InvalidConfigError("retries must be between 0 and 10.");
+    }
+    this.config = {
+      apiKey: config.apiKey.trim(),
+      baseUrl: (config.baseUrl ?? DEFAULT_BASE_URL).replace(/\/$/, ""),
+      environment: config.environment ?? "production",
+      batchSize: config.batchSize ?? DEFAULT_BATCH_SIZE,
+      flushIntervalMs: config.flushIntervalMs ?? DEFAULT_FLUSH_INTERVAL_MS,
+      timeout: config.timeout ?? DEFAULT_TIMEOUT_MS,
+      retries: config.retries ?? DEFAULT_RETRIES,
+      onError: config.onError ?? (() => {
+      }),
+      debug: config.debug ?? false
+    };
+    this.queue = new BatchQueue({
+      batchSize: this.config.batchSize,
+      flushIntervalMs: this.config.flushIntervalMs,
+      maxQueueSize: MAX_QUEUE_SIZE,
+      onError: this.config.onError,
+      flush: (events) => this.sendBatch(events),
+      debug: this.config.debug
+    });
+  }
+  // ── Public API ───────────────────────────────────────────────────────────────
+  /**
+   * Records an AI request event. The event is queued immediately and sent
+   * asynchronously — this method returns as soon as the event is enqueued.
+   *
+   * The returned Promise resolves when the event has been enqueued (not when
+   * it has been sent). Use `flush()` if you need confirmation of delivery.
+   */
+  async trackAIRequest(params) {
+    const event = this.buildEvent(params);
+    this.queue.push(event);
+  }
+  /**
+   * Forces an immediate flush of all queued events to the API.
+   * Resolves when the flush completes (successfully or not).
+   */
+  async flush() {
+    await this.queue.flushNow();
+  }
+  /**
+   * Flushes all remaining events and shuts down the background timer.
+   * Call this during graceful shutdown (e.g. in a `process.on("SIGTERM")` handler).
+   *
+   * @example
+   * ```typescript
+   * process.on("SIGTERM", async () => {
+   *   await songlines.shutdown();
+   *   process.exit(0);
+   * });
+   * ```
+   */
+  async shutdown() {
+    await this.queue.shutdown();
+  }
+  /**
+   * Evaluates a prompt against all active Songlines policies in real time.
+   *
+   * This method uses the **Songlines Gateway / Enforce** path, which is
+   * distinct from `trackAIRequest()`. Call it *before* sending the prompt
+   * to an LLM to enforce policies inline.
+   *
+   * @returns A `GuardrailResult` with `decision`, `violations`, and optionally
+   *   a `modifiedInput` (when a redaction policy fires).
+   *
+   * @example
+   * ```typescript
+   * const result = await songlines.evaluateGuardrail({
+   *   prompt: userMessage,
+   *   model: "gpt-4o",
+   *   workflow: "customer-support",
+   * });
+   *
+   * if (result.decision === "block") {
+   *   return { error: "Request blocked by policy", violations: result.violations };
+   * }
+   *
+   * const promptToSend = result.modifiedInput ?? userMessage;
+   * const response = await openai.chat.completions.create({ ... });
+   * ```
+   */
+  async evaluateGuardrail(params) {
+    return evaluateGuardrailImpl(params, {
+      baseUrl: this.config.baseUrl,
+      apiKey: this.config.apiKey,
+      timeout: this.config.timeout,
+      onError: this.config.onError
+    });
+  }
+  // ── Internal ─────────────────────────────────────────────────────────────────
+  /**
+   * Converts TrackAIRequestParams into the wire format expected by /api/ingest.
+   */
+  buildEvent(params) {
+    const requestId = params.requestId ?? generateId();
+    const cost = params.cost ?? estimateCost({
+      model: params.model,
+      inputTokens: params.inputTokens,
+      outputTokens: params.outputTokens
+    });
+    const event = {
+      request_id: requestId,
+      model: params.model,
+      input_tokens: params.inputTokens,
+      output_tokens: params.outputTokens,
+      environment: this.config.environment,
+      status: params.status ?? "success"
+    };
+    if (params.provider !== void 0) event.provider = params.provider;
+    if (params.workflow !== void 0) event.workflow = params.workflow;
+    if (params.step !== void 0) event.step = params.step;
+    if (params.agentId !== void 0) event.agent_id = params.agentId;
+    if (params.user !== void 0) event.user = params.user;
+    if (params.latencyMs !== void 0) event.latency_ms = params.latencyMs;
+    if (params.errorMessage !== void 0) event.error_message = params.errorMessage;
+    if (params.timestamp !== void 0) {
+      event.timestamp = params.timestamp.toISOString();
+    }
+    return event;
+  }
+  /**
+   * Sends a batch of events to POST /api/ingest.
+   * Called by the BatchQueue — never called directly.
+   */
+  async sendBatch(events) {
+    const url = `${this.config.baseUrl}/api/ingest`;
+    const body = events.length === 1 ? events[0] : { events };
+    await withRetry(
+      () => this.httpPost(url, body),
+      {
+        maxAttempts: this.config.retries + 1,
+        onRetry: (attempt, delayMs, error) => {
+          if (this.config.debug) {
+            console.debug(
+              `[Songlines SDK] Retry ${attempt} in ${delayMs}ms after: ${String(error)}`
+            );
+          }
+        }
+      }
+    );
+  }
+  /**
+   * Performs a single HTTP POST with timeout and error classification.
+   */
+  async httpPost(url, body) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.config.timeout);
+    let response;
+    try {
+      response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${this.config.apiKey}`,
+          "User-Agent": "@songlines/sdk/0.1.0"
+        },
+        body: JSON.stringify(body),
+        signal: controller.signal
+      });
+    } catch (err) {
+      clearTimeout(timer);
+      if (err instanceof Error && err.name === "AbortError") {
+        throw new TimeoutError(this.config.timeout);
+      }
+      throw new NetworkError(`Failed to reach ${url}: ${String(err)}`, err);
+    } finally {
+      clearTimeout(timer);
+    }
+    if (response.status === 401) {
+      throw new InvalidApiKeyError();
+    }
+    if (response.status === 429) {
+      const retryAfter = response.headers.get("Retry-After");
+      const retryAfterMs = retryAfter ? parseInt(retryAfter, 10) * 1e3 : void 0;
+      throw new RateLimitedError(retryAfterMs);
+    }
+    if (response.status >= 500) {
+      const text = await response.text().catch(() => "");
+      throw new ServerError(response.status, text);
+    }
+    if (!response.ok && response.status !== 207) {
+      const text = await response.text().catch(() => "");
+      throw new ServerError(response.status, text);
+    }
+    const data = await response.json();
+    if (data.failed > 0 && data.errors) {
+      const failedIds = data.errors.map((e) => e.request_id);
+      this.config.onError(new PartialFailureError(data.accepted, data.failed, failedIds));
+    }
+  }
+};
+
+// src/index.ts
+init_errors();
+
+// src/middleware/openai.ts
+init_esm_shims();
+function wrapOpenAI(client, songlines, defaults = {}) {
+  return new Proxy(client, {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (prop === "chat" && typeof value === "object" && value !== null) {
+        return wrapChat(value, songlines, defaults);
+      }
+      if (prop === "completions" && typeof value === "object" && value !== null) {
+        return wrapLegacyCompletions(value, songlines, defaults);
+      }
+      return value;
+    }
+  });
+}
+function wrapChat(chat, songlines, defaults) {
+  return new Proxy(chat, {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (prop === "completions" && typeof value === "object" && value !== null) {
+        return wrapChatCompletions(value, songlines, defaults);
+      }
+      return value;
+    }
+  });
+}
+function wrapChatCompletions(completions, songlines, defaults) {
+  return new Proxy(completions, {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (prop === "create") {
+        return async (params, options) => {
+          if (params.stream === true) {
+            const requestId2 = generateId();
+            const start2 = Date.now();
+            const stream = await value.call(target, params, options);
+            void songlines.trackAIRequest({
+              requestId: requestId2,
+              model: params.model,
+              provider: "openai",
+              inputTokens: 0,
+              outputTokens: 0,
+              latencyMs: Date.now() - start2,
+              status: "success",
+              metadata: { streaming: true },
+              ...defaults
+            });
+            return stream;
+          }
+          const requestId = generateId();
+          const start = Date.now();
+          let response;
+          let status = "success";
+          let errorMessage;
+          try {
+            response = await value.call(target, params, options);
+          } catch (err) {
+            status = "error";
+            errorMessage = err instanceof Error ? err.message : String(err);
+            void songlines.trackAIRequest({
+              requestId,
+              model: params.model,
+              provider: "openai",
+              inputTokens: 0,
+              outputTokens: 0,
+              latencyMs: Date.now() - start,
+              status: "error",
+              errorMessage,
+              ...defaults
+            });
+            throw err;
+          }
+          const latencyMs = Date.now() - start;
+          void songlines.trackAIRequest({
+            requestId,
+            model: params.model,
+            provider: "openai",
+            inputTokens: response.usage?.prompt_tokens ?? 0,
+            outputTokens: response.usage?.completion_tokens ?? 0,
+            latencyMs,
+            status,
+            ...defaults
+          });
+          return response;
+        };
+      }
+      return value;
+    }
+  });
+}
+function wrapLegacyCompletions(completions, songlines, defaults) {
+  return new Proxy(completions, {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (prop === "create") {
+        return async (params, options) => {
+          if (params.stream === true) {
+            return value.call(target, params, options);
+          }
+          const requestId = generateId();
+          const start = Date.now();
+          let response;
+          try {
+            response = await value.call(target, params, options);
+          } catch (err) {
+            void songlines.trackAIRequest({
+              requestId,
+              model: params.model,
+              provider: "openai",
+              inputTokens: 0,
+              outputTokens: 0,
+              latencyMs: Date.now() - start,
+              status: "error",
+              errorMessage: err instanceof Error ? err.message : String(err),
+              ...defaults
+            });
+            throw err;
+          }
+          void songlines.trackAIRequest({
+            requestId,
+            model: params.model,
+            provider: "openai",
+            inputTokens: response.usage?.prompt_tokens ?? 0,
+            outputTokens: response.usage?.completion_tokens ?? 0,
+            latencyMs: Date.now() - start,
+            status: "success",
+            ...defaults
+          });
+          return response;
+        };
+      }
+      return value;
+    }
+  });
+}
+
+// src/middleware/anthropic.ts
+init_esm_shims();
+function wrapAnthropic(client, songlines, defaults = {}) {
+  return new Proxy(client, {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (prop === "messages" && typeof value === "object" && value !== null) {
+        return wrapMessages(value, songlines, defaults);
+      }
+      return value;
+    }
+  });
+}
+function wrapMessages(messages, songlines, defaults) {
+  return new Proxy(messages, {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (prop === "create") {
+        return async (params, options) => {
+          if (params.stream === true) {
+            const requestId2 = generateId();
+            const start2 = Date.now();
+            const stream = await value.call(target, params, options);
+            void songlines.trackAIRequest({
+              requestId: requestId2,
+              model: params.model,
+              provider: "anthropic",
+              inputTokens: 0,
+              outputTokens: 0,
+              latencyMs: Date.now() - start2,
+              status: "success",
+              metadata: { streaming: true },
+              ...defaults
+            });
+            return stream;
+          }
+          const requestId = generateId();
+          const start = Date.now();
+          let response;
+          try {
+            response = await value.call(target, params, options);
+          } catch (err) {
+            void songlines.trackAIRequest({
+              requestId,
+              model: params.model,
+              provider: "anthropic",
+              inputTokens: 0,
+              outputTokens: 0,
+              latencyMs: Date.now() - start,
+              status: "error",
+              errorMessage: err instanceof Error ? err.message : String(err),
+              ...defaults
+            });
+            throw err;
+          }
+          void songlines.trackAIRequest({
+            requestId,
+            model: params.model,
+            provider: "anthropic",
+            inputTokens: response.usage?.input_tokens ?? 0,
+            outputTokens: response.usage?.output_tokens ?? 0,
+            latencyMs: Date.now() - start,
+            status: "success",
+            ...defaults
+          });
+          return response;
+        };
+      }
+      return value;
+    }
+  });
+}
+export {
+  GuardrailBlockedError,
+  InvalidApiKeyError,
+  InvalidConfigError,
+  NetworkError,
+  PartialFailureError,
+  QueueOverflowError,
+  RateLimitedError,
+  ServerError,
+  SonglinesClient,
+  SonglinesError,
+  TimeoutError,
+  estimateCost,
+  getModelRates,
+  wrapAnthropic,
+  wrapOpenAI
+};
+//# sourceMappingURL=index.mjs.map