@useautumn/gateway 0.0.1

package/dist/openrouter/index.js

@@ -0,0 +1,298 @@
+// 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;
+};
+export {
+  trackOpenRouterUsage,
+  trackingSettled,
+  withAutumn
+};

package/dist/track-C73uYSG_.d.cts

@@ -0,0 +1,47 @@
+/** Mutually exclusive token pools — each pool is priced at its own rate server-side. */
+type TokenPools = {
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens: number;
+    cacheWriteTokens: number;
+    reasoningTokens: number;
+    audioInputTokens?: number;
+    audioOutputTokens?: number;
+};
+
+type TrackTokensParams = TokenPools & {
+    customerId: string;
+    modelId: string;
+    featureId?: string;
+    entityId?: string;
+    properties?: Record<string, unknown>;
+};
+/** Tracking options every adapter shares. */
+type AutumnTrackingOptions = {
+    /**
+     * Autumn SDK client instance. When omitted, a minimal fetch client is
+     * created from AUTUMN_API_KEY (or AUTUMN_SECRET_KEY).
+     */
+    autumn?: AutumnClient;
+    /** The Autumn customer ID to attribute usage to. */
+    customerId: string;
+    /** Target a specific AI credit system feature. Auto-detected if omitted. */
+    featureId?: string;
+    /** Entity ID for entity-scoped balance tracking. */
+    entityId?: string;
+    /** Additional properties to attach to each usage event. */
+    properties?: Record<string, unknown>;
+};
+/**
+ * Structural view of the Autumn SDK client. @useautumn/sdk exposes
+ * trackTokens at the client root; balances.trackTokens is accepted for
+ * clients that namespace it. `balances` stays `unknown` so SDK namespace
+ * classes without trackTokens still satisfy the type. Older clients may
+ * ship neither shape.
+ */
+type AutumnClient = {
+    trackTokens?: (params: TrackTokensParams) => Promise<unknown>;
+    balances?: unknown;
+};
+
+export type { AutumnTrackingOptions as A, TokenPools as T, AutumnClient as a };

package/dist/track-C73uYSG_.d.ts

@@ -0,0 +1,47 @@
+/** Mutually exclusive token pools — each pool is priced at its own rate server-side. */
+type TokenPools = {
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens: number;
+    cacheWriteTokens: number;
+    reasoningTokens: number;
+    audioInputTokens?: number;
+    audioOutputTokens?: number;
+};
+
+type TrackTokensParams = TokenPools & {
+    customerId: string;
+    modelId: string;
+    featureId?: string;
+    entityId?: string;
+    properties?: Record<string, unknown>;
+};
+/** Tracking options every adapter shares. */
+type AutumnTrackingOptions = {
+    /**
+     * Autumn SDK client instance. When omitted, a minimal fetch client is
+     * created from AUTUMN_API_KEY (or AUTUMN_SECRET_KEY).
+     */
+    autumn?: AutumnClient;
+    /** The Autumn customer ID to attribute usage to. */
+    customerId: string;
+    /** Target a specific AI credit system feature. Auto-detected if omitted. */
+    featureId?: string;
+    /** Entity ID for entity-scoped balance tracking. */
+    entityId?: string;
+    /** Additional properties to attach to each usage event. */
+    properties?: Record<string, unknown>;
+};
+/**
+ * Structural view of the Autumn SDK client. @useautumn/sdk exposes
+ * trackTokens at the client root; balances.trackTokens is accepted for
+ * clients that namespace it. `balances` stays `unknown` so SDK namespace
+ * classes without trackTokens still satisfy the type. Older clients may
+ * ship neither shape.
+ */
+type AutumnClient = {
+    trackTokens?: (params: TrackTokensParams) => Promise<unknown>;
+    balances?: unknown;
+};
+
+export type { AutumnTrackingOptions as A, TokenPools as T, AutumnClient as a };

package/package.json

@@ -0,0 +1,64 @@
+{
+	"name": "@useautumn/gateway",
+	"version": "0.0.1",
+	"type": "module",
+	"description": "Autumn usage tracking adapters for AI SDKs and gateways (Vercel AI SDK, OpenRouter)",
+	"repository": "github:useautumn/autumn",
+	"homepage": "https://useautumn.com",
+	"license": "MIT",
+	"keywords": [
+		"autumn",
+		"billing",
+		"usage-based-billing",
+		"ai-sdk",
+		"openrouter",
+		"llm",
+		"token-tracking"
+	],
+	"sideEffects": false,
+	"files": [
+		"dist",
+		"README.md",
+		"LICENSE.md"
+	],
+	"exports": {
+		"./ai-sdk": {
+			"types": "./dist/ai-sdk/index.d.ts",
+			"require": "./dist/ai-sdk/index.cjs",
+			"import": "./dist/ai-sdk/index.js"
+		},
+		"./openrouter": {
+			"types": "./dist/openrouter/index.d.ts",
+			"require": "./dist/openrouter/index.cjs",
+			"import": "./dist/openrouter/index.js"
+		}
+	},
+	"scripts": {
+		"ts": "bunx tsgo --noEmit --skipLibCheck",
+		"test": "bun test tests/unit",
+		"build": "rm -rf dist && tsup",
+		"prepublishOnly": "bun run build"
+	},
+	"dependencies": {
+		"@ai-sdk/provider": "^3.0.0"
+	},
+	"peerDependencies": {
+		"@openrouter/sdk": "*",
+		"ai": "^6.0.116",
+		"autumn-js": "*"
+	},
+	"peerDependenciesMeta": {
+		"@openrouter/sdk": {
+			"optional": true
+		},
+		"ai": {
+			"optional": true
+		}
+	},
+	"devDependencies": {
+		"@types/node": "^24.9.1",
+		"@typescript/native-preview": "7.0.0-dev.20260220.1",
+		"tsup": "^8.4.0",
+		"typescript": "^5.8.3"
+	}
+}