@useautumn/gateway 0.0.1

package/dist/openrouter/index.cjs

@@ -0,0 +1,327 @@
+"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/openrouter/index.ts
+var openrouter_exports = {};
+__export(openrouter_exports, {
+  trackOpenRouterUsage: () => trackOpenRouterUsage,
+  trackingSettled: () => trackingSettled,
+  withAutumn: () => withAutumn
+});
+module.exports = __toCommonJS(openrouter_exports);
+
+// src/shared/track.ts
+var WIRE_KEYS = {
+  customerId: "customer_id",
+  entityId: "entity_id",
+  featureId: "feature_id",
+  modelId: "model_id",
+  inputTokens: "input_tokens",
+  outputTokens: "output_tokens",
+  cacheReadTokens: "cache_read_tokens",
+  cacheWriteTokens: "cache_write_tokens",
+  audioInputTokens: "audio_input_tokens",
+  audioOutputTokens: "audio_output_tokens",
+  reasoningTokens: "reasoning_tokens"
+};
+var toWire = (params) => Object.fromEntries(
+  Object.entries(params).filter(([, value]) => value !== void 0).map(([key, value]) => [WIRE_KEYS[key] ?? key, value])
+);
+var envClient = () => {
+  const env = typeof process === "undefined" ? void 0 : process.env;
+  const secretKey = env?.AUTUMN_API_KEY ?? env?.AUTUMN_SECRET_KEY;
+  const baseUrl = env?.AUTUMN_BASE_URL ?? "https://api.useautumn.com";
+  return {
+    trackTokens: async (params) => {
+      if (!secretKey) {
+        throw new Error(
+          "[Autumn] No autumn client was passed and AUTUMN_API_KEY is not set."
+        );
+      }
+      const response = await fetch(`${baseUrl}/v1/balances.track_tokens`, {
+        method: "POST",
+        headers: {
+          authorization: `Bearer ${secretKey}`,
+          "content-type": "application/json"
+        },
+        body: JSON.stringify(toWire(params))
+      });
+      if (!response.ok) {
+        throw new Error(
+          `track_tokens failed (${response.status}): ${await response.text()}`
+        );
+      }
+      return response.json();
+    }
+  };
+};
+var createTracker = ({
+  autumn = envClient(),
+  customerId,
+  featureId,
+  entityId,
+  properties
+}) => (getEvent) => trackTokenUsage({
+  autumn,
+  getParams: () => {
+    const event = getEvent();
+    return {
+      ...event.pools,
+      customerId,
+      modelId: event.modelId,
+      featureId,
+      entityId,
+      properties: event.properties ?? properties
+    };
+  }
+});
+var trackTokenUsage = async ({
+  autumn,
+  getParams
+}) => {
+  try {
+    const balances = autumn.balances;
+    const trackTokens = balances?.trackTokens?.bind(balances) ?? autumn.trackTokens?.bind(autumn);
+    if (!trackTokens) {
+      throw new Error(
+        "Autumn client does not support trackTokens \u2014 upgrade @useautumn/sdk."
+      );
+    }
+    await trackTokens(getParams());
+  } catch (error) {
+    console.error("[Autumn Tracking] Failed to track usage:", error);
+  }
+};
+
+// src/shared/usage.ts
+var clamp = (value) => Math.max(0, value);
+var requiredCount = (value, label, modelName) => {
+  if (value == null) {
+    throw new Error(
+      `[Autumn] ${label} token usage was not returned by the model provider (${modelName}). This provider may not support usage tracking.`
+    );
+  }
+  return value;
+};
+var poolsFromParts = (parts, modelName) => {
+  const cacheRead = parts.cacheRead ?? 0;
+  const cacheWrite = parts.cacheWrite ?? 0;
+  const reasoning = parts.reasoning ?? 0;
+  const audioInput = parts.audioInput ?? 0;
+  const textInput = parts.textInput ?? (parts.totalInput != null ? parts.totalInput - cacheRead - cacheWrite - audioInput : void 0);
+  const textOutput = parts.textOutput ?? (parts.totalOutput != null ? parts.totalOutput - reasoning : void 0);
+  return {
+    inputTokens: clamp(requiredCount(textInput, "Input", modelName)),
+    outputTokens: clamp(requiredCount(textOutput, "Output", modelName)),
+    cacheReadTokens: clamp(cacheRead),
+    cacheWriteTokens: clamp(cacheWrite),
+    reasoningTokens: clamp(reasoning),
+    ...parts.audioInput !== void 0 && {
+      audioInputTokens: clamp(audioInput)
+    }
+  };
+};
+
+// src/openrouter/usage.ts
+var normalizeOpenRouterUsage = (usage, modelName) => {
+  const promptDetails = usage.promptTokensDetails ?? usage.prompt_tokens_details ?? usage.inputTokensDetails ?? usage.input_tokens_details;
+  const completionDetails = usage.completionTokensDetails ?? usage.completion_tokens_details ?? usage.outputTokensDetails ?? usage.output_tokens_details;
+  const promptTotal = usage.promptTokens ?? usage.prompt_tokens ?? usage.inputTokens ?? usage.input_tokens;
+  const completionTotal = usage.completionTokens ?? usage.completion_tokens ?? usage.outputTokens ?? usage.output_tokens;
+  return poolsFromParts(
+    {
+      totalInput: promptTotal,
+      totalOutput: completionTotal,
+      cacheRead: promptDetails?.cachedTokens ?? promptDetails?.cached_tokens ?? 0,
+      cacheWrite: promptDetails?.cacheWriteTokens ?? promptDetails?.cache_write_tokens ?? 0,
+      reasoning: completionDetails?.reasoningTokens ?? completionDetails?.reasoning_tokens ?? 0,
+      audioInput: promptDetails?.audioTokens ?? promptDetails?.audio_tokens ?? 0
+    },
+    modelName
+  );
+};
+
+// src/openrouter/index.ts
+var withCost = (properties, cost) => cost == null ? properties : { ...properties, openrouter_cost: cost };
+var HOOKED_OPERATIONS = /* @__PURE__ */ new Set(["createResponses"]);
+var pendingTracking = /* @__PURE__ */ new WeakMap();
+var trackingSettled = async (openRouter) => {
+  const pending = pendingTracking.get(openRouter);
+  while (pending && pending.size > 0) {
+    await Promise.allSettled([...pending]);
+  }
+};
+var findCarrier = (value) => {
+  if (value == null || typeof value !== "object") {
+    return;
+  }
+  const record = value;
+  if (record.usage && record.model) {
+    return record;
+  }
+  return findCarrier(record.response);
+};
+var lastCarrierFromSse = (body) => {
+  let carrier;
+  for (const line of body.split("\n")) {
+    if (!line.startsWith("data:")) {
+      continue;
+    }
+    try {
+      carrier = findCarrier(JSON.parse(line.slice(5).trim())) ?? carrier;
+    } catch {
+    }
+  }
+  return carrier;
+};
+var toModelId = (slug) => slug.startsWith("openrouter/") ? slug : `openrouter/${slug}`;
+var trackOpenRouterUsage = ({
+  usage,
+  model,
+  ...tracking
+}) => {
+  const modelId = toModelId(model);
+  return createTracker(tracking)(() => ({
+    pools: normalizeOpenRouterUsage(usage, modelId),
+    modelId,
+    properties: withCost(tracking.properties, usage.cost)
+  }));
+};
+var isAsyncIterable = (value) => value != null && typeof value === "object" && Symbol.asyncIterator in value && typeof value[Symbol.asyncIterator] === "function";
+var hasUsage = (value) => value != null && typeof value === "object" && "usage" in value && value.usage != null;
+var withAutumn = (options) => {
+  const { openRouter } = options;
+  const track = createTracker(options);
+  const trackCarrier = (carrier, requestModel) => track(() => {
+    const requested = requestModel?.endsWith("/auto") ? void 0 : requestModel;
+    const slug = requested ?? carrier.model ?? requestModel;
+    if (!slug) {
+      throw new Error(
+        "[Autumn] OpenRouter response did not include a model slug."
+      );
+    }
+    const modelId = toModelId(slug);
+    const usage = carrier.usage ?? {};
+    return {
+      pools: normalizeOpenRouterUsage(usage, modelId),
+      modelId,
+      properties: withCost(options.properties, usage.cost)
+    };
+  });
+  const wrapStream = (stream, requestModel) => {
+    let tracked = false;
+    async function* iterate() {
+      let finalCarrier;
+      try {
+        for await (const chunk of stream) {
+          if (hasUsage(chunk)) {
+            finalCarrier = chunk;
+          }
+          yield chunk;
+        }
+      } finally {
+        if (finalCarrier && !tracked) {
+          tracked = true;
+          await trackCarrier(finalCarrier, requestModel);
+        }
+      }
+    }
+    return new Proxy(stream, {
+      get(target, prop, receiver) {
+        if (prop === Symbol.asyncIterator) {
+          return () => iterate();
+        }
+        const value = Reflect.get(target, prop, receiver);
+        return typeof value === "function" ? value.bind(target) : value;
+      }
+    });
+  };
+  const send = async (request, ...rest) => {
+    const body = request.chatRequest ?? request;
+    const bodyWithUsage = {
+      ...body,
+      usage: { ...body.usage, include: true }
+    };
+    const requestWithUsage = request.chatRequest ? { ...request, chatRequest: bodyWithUsage } : bodyWithUsage;
+    const result = await openRouter.chat.send(requestWithUsage, ...rest);
+    if (isAsyncIterable(result)) {
+      return wrapStream(result, body.model);
+    }
+    await trackCarrier(result, body.model);
+    return result;
+  };
+  const captureHookedResponse = async (response, contentType) => {
+    let carrier;
+    if (contentType.includes("text/event-stream")) {
+      carrier = lastCarrierFromSse(await response.text());
+    } else if (contentType.includes("json")) {
+      carrier = findCarrier(await response.json());
+    }
+    if (carrier) {
+      await trackCarrier(carrier);
+    }
+  };
+  const pending = /* @__PURE__ */ new Set();
+  pendingTracking.set(openRouter, pending);
+  openRouter._options?.hooks?.registerAfterSuccessHook?.(
+    {
+      afterSuccess: (ctx, response) => {
+        if (!HOOKED_OPERATIONS.has(ctx.operationID)) {
+          return response;
+        }
+        const contentType = response.headers.get("content-type") ?? "";
+        const capture = captureHookedResponse(
+          response.clone(),
+          contentType
+        ).catch((error) => {
+          console.error("[Autumn Tracking] Failed to track usage:", error);
+        });
+        pending.add(capture);
+        capture.finally(() => pending.delete(capture));
+        return contentType.includes("text/event-stream") ? response : capture.then(() => response);
+      }
+    }
+  );
+  const wrappedChat = new Proxy(openRouter.chat, {
+    get(target, prop, receiver) {
+      if (prop === "send") {
+        return send;
+      }
+      const value = Reflect.get(target, prop, receiver);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+  const wrapped = new Proxy(openRouter, {
+    get(target, prop, receiver) {
+      if (prop === "chat") {
+        return wrappedChat;
+      }
+      const value = Reflect.get(target, prop, receiver);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+  pendingTracking.set(wrapped, pending);
+  return wrapped;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  trackOpenRouterUsage,
+  trackingSettled,
+  withAutumn
+});

package/dist/openrouter/index.d.cts

@@ -0,0 +1,69 @@
+import { A as AutumnTrackingOptions } from '../track-C73uYSG_.cjs';
+export { a as AutumnClient, T as TokenPools } from '../track-C73uYSG_.cjs';
+
+type PromptDetails = {
+    cachedTokens?: number | null;
+    cached_tokens?: number | null;
+    cacheWriteTokens?: number | null;
+    cache_write_tokens?: number | null;
+    audioTokens?: number | null;
+    audio_tokens?: number | null;
+};
+type CompletionDetails = {
+    reasoningTokens?: number | null;
+    reasoning_tokens?: number | null;
+};
+/**
+ * Lenient view over OpenRouter usage across all its surfaces: chat
+ * completions (prompt/completion naming) and the responses API
+ * (input/output naming), in SDK camelCase or raw snake_case.
+ */
+type OpenRouterUsageLike = {
+    promptTokens?: number | null;
+    prompt_tokens?: number | null;
+    inputTokens?: number | null;
+    input_tokens?: number | null;
+    completionTokens?: number | null;
+    completion_tokens?: number | null;
+    outputTokens?: number | null;
+    output_tokens?: number | null;
+    promptTokensDetails?: PromptDetails | null;
+    prompt_tokens_details?: PromptDetails | null;
+    inputTokensDetails?: PromptDetails | null;
+    input_tokens_details?: PromptDetails | null;
+    completionTokensDetails?: CompletionDetails | null;
+    completion_tokens_details?: CompletionDetails | null;
+    outputTokensDetails?: CompletionDetails | null;
+    output_tokens_details?: CompletionDetails | null;
+    /** OpenRouter's own charge in USD credits, present when usage accounting is enabled. */
+    cost?: number | null;
+};
+
+/**
+ * Resolves once all in-flight Autumn usage tracking for a wrapped client has
+ * settled. Streaming responses (including @openrouter/agent's callModel,
+ * which always streams internally) are tracked in the background — await
+ * this before reading balances that must reflect the calls just made.
+ */
+declare const trackingSettled: (openRouter: object) => Promise<void>;
+/** Structural view of the @openrouter/sdk client — only chat.send is intercepted. */
+type OpenRouterLike = {
+    chat: {
+        send: (request: any, ...rest: any[]) => Promise<unknown>;
+    };
+};
+type WithAutumnOptions<T extends OpenRouterLike> = AutumnTrackingOptions & {
+    /** The @openrouter/sdk client to wrap. */
+    openRouter: T;
+};
+type TrackOpenRouterUsageOptions = AutumnTrackingOptions & {
+    /** Usage object from an OpenRouter response (SDK model or raw API shape). */
+    usage: OpenRouterUsageLike;
+    /** OpenRouter model slug, e.g. "openai/gpt-4o". */
+    model: string;
+};
+/** Manual escape hatch for consumption patterns the wrapped client doesn't cover (e.g. callModel). */
+declare const trackOpenRouterUsage: ({ usage, model, ...tracking }: TrackOpenRouterUsageOptions) => Promise<void>;
+declare const withAutumn: <T extends OpenRouterLike>(options: WithAutumnOptions<T>) => T;
+
+export { AutumnTrackingOptions, type OpenRouterLike, type OpenRouterUsageLike, type TrackOpenRouterUsageOptions, type WithAutumnOptions, trackOpenRouterUsage, trackingSettled, withAutumn };

package/dist/openrouter/index.d.ts

@@ -0,0 +1,69 @@
+import { A as AutumnTrackingOptions } from '../track-C73uYSG_.js';
+export { a as AutumnClient, T as TokenPools } from '../track-C73uYSG_.js';
+
+type PromptDetails = {
+    cachedTokens?: number | null;
+    cached_tokens?: number | null;
+    cacheWriteTokens?: number | null;
+    cache_write_tokens?: number | null;
+    audioTokens?: number | null;
+    audio_tokens?: number | null;
+};
+type CompletionDetails = {
+    reasoningTokens?: number | null;
+    reasoning_tokens?: number | null;
+};
+/**
+ * Lenient view over OpenRouter usage across all its surfaces: chat
+ * completions (prompt/completion naming) and the responses API
+ * (input/output naming), in SDK camelCase or raw snake_case.
+ */
+type OpenRouterUsageLike = {
+    promptTokens?: number | null;
+    prompt_tokens?: number | null;
+    inputTokens?: number | null;
+    input_tokens?: number | null;
+    completionTokens?: number | null;
+    completion_tokens?: number | null;
+    outputTokens?: number | null;
+    output_tokens?: number | null;
+    promptTokensDetails?: PromptDetails | null;
+    prompt_tokens_details?: PromptDetails | null;
+    inputTokensDetails?: PromptDetails | null;
+    input_tokens_details?: PromptDetails | null;
+    completionTokensDetails?: CompletionDetails | null;
+    completion_tokens_details?: CompletionDetails | null;
+    outputTokensDetails?: CompletionDetails | null;
+    output_tokens_details?: CompletionDetails | null;
+    /** OpenRouter's own charge in USD credits, present when usage accounting is enabled. */
+    cost?: number | null;
+};
+
+/**
+ * Resolves once all in-flight Autumn usage tracking for a wrapped client has
+ * settled. Streaming responses (including @openrouter/agent's callModel,
+ * which always streams internally) are tracked in the background — await
+ * this before reading balances that must reflect the calls just made.
+ */
+declare const trackingSettled: (openRouter: object) => Promise<void>;
+/** Structural view of the @openrouter/sdk client — only chat.send is intercepted. */
+type OpenRouterLike = {
+    chat: {
+        send: (request: any, ...rest: any[]) => Promise<unknown>;
+    };
+};
+type WithAutumnOptions<T extends OpenRouterLike> = AutumnTrackingOptions & {
+    /** The @openrouter/sdk client to wrap. */
+    openRouter: T;
+};
+type TrackOpenRouterUsageOptions = AutumnTrackingOptions & {
+    /** Usage object from an OpenRouter response (SDK model or raw API shape). */
+    usage: OpenRouterUsageLike;
+    /** OpenRouter model slug, e.g. "openai/gpt-4o". */
+    model: string;
+};
+/** Manual escape hatch for consumption patterns the wrapped client doesn't cover (e.g. callModel). */
+declare const trackOpenRouterUsage: ({ usage, model, ...tracking }: TrackOpenRouterUsageOptions) => Promise<void>;
+declare const withAutumn: <T extends OpenRouterLike>(options: WithAutumnOptions<T>) => T;
+
+export { AutumnTrackingOptions, type OpenRouterLike, type OpenRouterUsageLike, type TrackOpenRouterUsageOptions, type WithAutumnOptions, trackOpenRouterUsage, trackingSettled, withAutumn };