@weckr/sdk 0.1.0

package/README.md

@@ -0,0 +1,72 @@
+# @weckr/sdk
+
+AI cost and margin intelligence for SaaS founders.
+
+See exactly which users cost more than they pay — per LLM call, zero added latency.
+
+## Install
+
+```bash
+npm install @weckr/sdk
+```
+
+## Usage
+
+```ts
+import { Weckr } from '@weckr/sdk';
+import OpenAI from 'openai';
+
+const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+
+const wk = new Weckr({
+  apiKey: 'wk_your_key_here',
+  plans: {
+    free: 0,
+    starter: 9,
+    pro: 29,
+    business: 99,
+  },
+});
+
+const result = await wk.chat(openai, {
+  model: 'gpt-4o',
+  messages: [{ role: 'user', content: prompt }],
+  userId: user.id,
+  feature: 'ai-summary',
+  plan: user.plan,
+});
+```
+
+The original LLM call runs unchanged and returns immediately. After it resolves, Weckr fires an async log to the Weckr API. The log call is fire-and-forget — if it fails or stalls, your request is unaffected.
+
+## Get your API key
+
+Sign up at [https://useweckr.com](https://useweckr.com).
+
+## Supported providers
+
+- **OpenAI** — `gpt-4o`, `gpt-4o-mini`, `gpt-3.5-turbo`
+- **Anthropic** — `claude-opus-4`, `claude-sonnet-4`, `claude-haiku-4`
+- **Gemini** — `gemini-2.5-flash`, `gemini-2.5-pro`
+
+## What gets logged
+
+```ts
+{
+  userId, feature, model, provider,
+  inputTokens, outputTokens,
+  costUsd, latencyMs,
+  planName, planRevenueUsd, marginUsd,
+  timestamp,
+}
+```
+
+Cost is computed from public per-token pricing. Margin is `planRevenueUsd - costUsd` (negative means you're losing money on that user).
+
+## Dashboard
+
+View cost and margin data at [https://useweckr.com/dashboard](https://useweckr.com/dashboard).
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,65 @@
+type Provider = 'openai' | 'anthropic' | 'gemini';
+interface WeckrConfig {
+    apiKey: string;
+    plans?: Record<string, number>;
+    endpoint?: string;
+    fetch?: typeof fetch;
+    onError?: (err: unknown) => void;
+}
+interface ChatOptions {
+    model: string;
+    messages: Array<{
+        role: string;
+        content: string;
+    }>;
+    userId?: string;
+    feature?: string;
+    plan?: string;
+    [key: string]: unknown;
+}
+interface NormalizedUsage {
+    inputTokens: number;
+    outputTokens: number;
+}
+interface LogPayload {
+    userId: string | null;
+    feature: string | null;
+    model: string;
+    provider: Provider;
+    inputTokens: number;
+    outputTokens: number;
+    costUsd: number;
+    latencyMs: number;
+    planName: string | null;
+    planRevenueUsd: number | null;
+    marginUsd: number | null;
+    timestamp: string;
+}
+interface ProviderAdapter<TClient = unknown, TResult = unknown> {
+    name: Provider;
+    matches(client: unknown): client is TClient;
+    call(client: TClient, options: ChatOptions): Promise<TResult>;
+    extractUsage(result: TResult): NormalizedUsage;
+}
+
+declare class Weckr {
+    private readonly apiKey;
+    private readonly plans;
+    private readonly log;
+    constructor(config: WeckrConfig);
+    chat<TClient, TResult = unknown>(client: TClient, options: ChatOptions): Promise<TResult>;
+}
+
+interface ModelPricing {
+    provider: Provider;
+    inputPerMillion: number;
+    outputPerMillion: number;
+}
+declare const PRICING: Record<string, ModelPricing>;
+declare function resolvePricing(model: string): ModelPricing | null;
+declare function calculateCost(model: string, inputTokens: number, outputTokens: number): {
+    costUsd: number;
+    provider: Provider | null;
+};
+
+export { type ChatOptions, type LogPayload, type NormalizedUsage, PRICING, type Provider, type ProviderAdapter, Weckr, type WeckrConfig, calculateCost, resolvePricing };

package/dist/index.d.ts

@@ -0,0 +1,65 @@
+type Provider = 'openai' | 'anthropic' | 'gemini';
+interface WeckrConfig {
+    apiKey: string;
+    plans?: Record<string, number>;
+    endpoint?: string;
+    fetch?: typeof fetch;
+    onError?: (err: unknown) => void;
+}
+interface ChatOptions {
+    model: string;
+    messages: Array<{
+        role: string;
+        content: string;
+    }>;
+    userId?: string;
+    feature?: string;
+    plan?: string;
+    [key: string]: unknown;
+}
+interface NormalizedUsage {
+    inputTokens: number;
+    outputTokens: number;
+}
+interface LogPayload {
+    userId: string | null;
+    feature: string | null;
+    model: string;
+    provider: Provider;
+    inputTokens: number;
+    outputTokens: number;
+    costUsd: number;
+    latencyMs: number;
+    planName: string | null;
+    planRevenueUsd: number | null;
+    marginUsd: number | null;
+    timestamp: string;
+}
+interface ProviderAdapter<TClient = unknown, TResult = unknown> {
+    name: Provider;
+    matches(client: unknown): client is TClient;
+    call(client: TClient, options: ChatOptions): Promise<TResult>;
+    extractUsage(result: TResult): NormalizedUsage;
+}
+
+declare class Weckr {
+    private readonly apiKey;
+    private readonly plans;
+    private readonly log;
+    constructor(config: WeckrConfig);
+    chat<TClient, TResult = unknown>(client: TClient, options: ChatOptions): Promise<TResult>;
+}
+
+interface ModelPricing {
+    provider: Provider;
+    inputPerMillion: number;
+    outputPerMillion: number;
+}
+declare const PRICING: Record<string, ModelPricing>;
+declare function resolvePricing(model: string): ModelPricing | null;
+declare function calculateCost(model: string, inputTokens: number, outputTokens: number): {
+    costUsd: number;
+    provider: Provider | null;
+};
+
+export { type ChatOptions, type LogPayload, type NormalizedUsage, PRICING, type Provider, type ProviderAdapter, Weckr, type WeckrConfig, calculateCost, resolvePricing };

package/dist/index.js

@@ -0,0 +1,237 @@
+"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, {
+  PRICING: () => PRICING,
+  Weckr: () => Weckr,
+  calculateCost: () => calculateCost,
+  resolvePricing: () => resolvePricing
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/pricing.ts
+var PRICING = {
+  "gpt-4o": { provider: "openai", inputPerMillion: 2.5, outputPerMillion: 10 },
+  "gpt-4o-mini": { provider: "openai", inputPerMillion: 0.15, outputPerMillion: 0.6 },
+  "gpt-3.5-turbo": { provider: "openai", inputPerMillion: 0.5, outputPerMillion: 1.5 },
+  "claude-opus-4": { provider: "anthropic", inputPerMillion: 15, outputPerMillion: 75 },
+  "claude-sonnet-4": { provider: "anthropic", inputPerMillion: 3, outputPerMillion: 15 },
+  "claude-haiku-4": { provider: "anthropic", inputPerMillion: 0.8, outputPerMillion: 4 },
+  "gemini-2.5-flash": { provider: "gemini", inputPerMillion: 0.15, outputPerMillion: 0.6 },
+  "gemini-2.5-pro": { provider: "gemini", inputPerMillion: 1.25, outputPerMillion: 10 }
+};
+function resolvePricing(model) {
+  if (PRICING[model]) return PRICING[model];
+  const lower = model.toLowerCase();
+  for (const key of Object.keys(PRICING)) {
+    if (lower.startsWith(key.toLowerCase())) return PRICING[key];
+  }
+  return null;
+}
+function calculateCost(model, inputTokens, outputTokens) {
+  const pricing = resolvePricing(model);
+  if (!pricing) return { costUsd: 0, provider: null };
+  const cost = inputTokens / 1e6 * pricing.inputPerMillion + outputTokens / 1e6 * pricing.outputPerMillion;
+  return { costUsd: round6(cost), provider: pricing.provider };
+}
+function round6(n) {
+  return Math.round(n * 1e6) / 1e6;
+}
+
+// src/providers.ts
+var openaiAdapter = {
+  name: "openai",
+  matches(client) {
+    return isObject(client) && isObject(client.chat) && isObject(client.chat.completions) && typeof client.chat.completions.create === "function";
+  },
+  async call(client, options) {
+    const { userId, feature, plan, ...rest } = options;
+    return client.chat.completions.create(rest);
+  },
+  extractUsage(result) {
+    const usage = result?.usage ?? {};
+    return {
+      inputTokens: toInt(usage.prompt_tokens ?? usage.input_tokens),
+      outputTokens: toInt(usage.completion_tokens ?? usage.output_tokens)
+    };
+  }
+};
+var anthropicAdapter = {
+  name: "anthropic",
+  matches(client) {
+    return isObject(client) && isObject(client.messages) && typeof client.messages.create === "function";
+  },
+  async call(client, options) {
+    const { userId, feature, plan, ...rest } = options;
+    return client.messages.create(rest);
+  },
+  extractUsage(result) {
+    const usage = result?.usage ?? {};
+    return {
+      inputTokens: toInt(usage.input_tokens),
+      outputTokens: toInt(usage.output_tokens)
+    };
+  }
+};
+var geminiAdapter = {
+  name: "gemini",
+  matches(client) {
+    return isObject(client) && isObject(client.models) && typeof client.models.generateContent === "function";
+  },
+  async call(client, options) {
+    const { userId, feature, plan, messages, ...rest } = options;
+    const contents = (messages ?? []).map((m) => ({
+      role: m.role === "assistant" ? "model" : "user",
+      parts: [{ text: m.content }]
+    }));
+    return client.models.generateContent({ ...rest, contents });
+  },
+  extractUsage(result) {
+    const meta = result?.usageMetadata ?? {};
+    return {
+      inputTokens: toInt(meta.promptTokenCount),
+      outputTokens: toInt(meta.candidatesTokenCount)
+    };
+  }
+};
+var adapters = [openaiAdapter, anthropicAdapter, geminiAdapter];
+function detectAdapter(client) {
+  for (const adapter of adapters) {
+    if (adapter.matches(client)) return adapter;
+  }
+  return null;
+}
+function isObject(v) {
+  return typeof v === "object" && v !== null;
+}
+function toInt(v) {
+  const n = typeof v === "number" ? v : Number(v);
+  return Number.isFinite(n) ? Math.max(0, Math.floor(n)) : 0;
+}
+
+// src/logger.ts
+function createLogger(opts) {
+  const f = opts.fetch ?? globalThis.fetch;
+  if (typeof f !== "function") {
+    throw new Error("Weckr: global fetch is unavailable. Pass a fetch implementation via config.fetch.");
+  }
+  return function log(payload) {
+    queueMicrotask(() => {
+      let promise;
+      try {
+        promise = f(opts.endpoint, {
+          method: "POST",
+          headers: {
+            "content-type": "application/json",
+            "x-api-key": opts.apiKey
+          },
+          body: JSON.stringify(payload),
+          keepalive: true
+        });
+      } catch (err) {
+        opts.onError?.(err);
+        return;
+      }
+      promise.then(async (res) => {
+        if (!res.ok) {
+          const body = await res.text().catch(() => "");
+          opts.onError?.(
+            new Error(`Weckr log failed: ${res.status} ${res.statusText} ${body}`.trim())
+          );
+        }
+      }).catch((err) => {
+        opts.onError?.(err);
+      });
+    });
+  };
+}
+
+// src/weckr.ts
+var DEFAULT_ENDPOINT = "https://useweckr.com/api/v1/log";
+var Weckr = class {
+  apiKey;
+  plans;
+  log;
+  constructor(config) {
+    if (!config?.apiKey) {
+      throw new Error("Weckr: apiKey is required.");
+    }
+    this.apiKey = config.apiKey;
+    this.plans = config.plans ?? {};
+    this.log = createLogger({
+      apiKey: config.apiKey,
+      endpoint: config.endpoint ?? DEFAULT_ENDPOINT,
+      fetch: config.fetch,
+      onError: config.onError
+    });
+  }
+  async chat(client, options) {
+    const adapter = detectAdapter(client);
+    if (!adapter) {
+      throw new Error(
+        "Weckr: could not detect provider. Pass an OpenAI, Anthropic, or Gemini client instance."
+      );
+    }
+    const startedAt = nowMs();
+    const result = await adapter.call(client, options);
+    const latencyMs = Math.round(nowMs() - startedAt);
+    try {
+      const usage = adapter.extractUsage(result);
+      const { costUsd } = calculateCost(options.model, usage.inputTokens, usage.outputTokens);
+      const planName = options.plan ?? null;
+      const planRevenueUsd = planName != null && Object.prototype.hasOwnProperty.call(this.plans, planName) ? this.plans[planName] : null;
+      const marginUsd = planRevenueUsd != null ? round2(planRevenueUsd - costUsd) : null;
+      const payload = {
+        userId: options.userId ?? null,
+        feature: options.feature ?? null,
+        model: options.model,
+        provider: adapter.name,
+        inputTokens: usage.inputTokens,
+        outputTokens: usage.outputTokens,
+        costUsd,
+        latencyMs,
+        planName,
+        planRevenueUsd,
+        marginUsd,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      this.log(payload);
+    } catch {
+    }
+    return result;
+  }
+};
+function nowMs() {
+  if (typeof performance !== "undefined" && typeof performance.now === "function") {
+    return performance.now();
+  }
+  return Date.now();
+}
+function round2(n) {
+  return Math.round(n * 100) / 100;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PRICING,
+  Weckr,
+  calculateCost,
+  resolvePricing
+});

package/dist/index.mjs

@@ -0,0 +1,207 @@
+// src/pricing.ts
+var PRICING = {
+  "gpt-4o": { provider: "openai", inputPerMillion: 2.5, outputPerMillion: 10 },
+  "gpt-4o-mini": { provider: "openai", inputPerMillion: 0.15, outputPerMillion: 0.6 },
+  "gpt-3.5-turbo": { provider: "openai", inputPerMillion: 0.5, outputPerMillion: 1.5 },
+  "claude-opus-4": { provider: "anthropic", inputPerMillion: 15, outputPerMillion: 75 },
+  "claude-sonnet-4": { provider: "anthropic", inputPerMillion: 3, outputPerMillion: 15 },
+  "claude-haiku-4": { provider: "anthropic", inputPerMillion: 0.8, outputPerMillion: 4 },
+  "gemini-2.5-flash": { provider: "gemini", inputPerMillion: 0.15, outputPerMillion: 0.6 },
+  "gemini-2.5-pro": { provider: "gemini", inputPerMillion: 1.25, outputPerMillion: 10 }
+};
+function resolvePricing(model) {
+  if (PRICING[model]) return PRICING[model];
+  const lower = model.toLowerCase();
+  for (const key of Object.keys(PRICING)) {
+    if (lower.startsWith(key.toLowerCase())) return PRICING[key];
+  }
+  return null;
+}
+function calculateCost(model, inputTokens, outputTokens) {
+  const pricing = resolvePricing(model);
+  if (!pricing) return { costUsd: 0, provider: null };
+  const cost = inputTokens / 1e6 * pricing.inputPerMillion + outputTokens / 1e6 * pricing.outputPerMillion;
+  return { costUsd: round6(cost), provider: pricing.provider };
+}
+function round6(n) {
+  return Math.round(n * 1e6) / 1e6;
+}
+
+// src/providers.ts
+var openaiAdapter = {
+  name: "openai",
+  matches(client) {
+    return isObject(client) && isObject(client.chat) && isObject(client.chat.completions) && typeof client.chat.completions.create === "function";
+  },
+  async call(client, options) {
+    const { userId, feature, plan, ...rest } = options;
+    return client.chat.completions.create(rest);
+  },
+  extractUsage(result) {
+    const usage = result?.usage ?? {};
+    return {
+      inputTokens: toInt(usage.prompt_tokens ?? usage.input_tokens),
+      outputTokens: toInt(usage.completion_tokens ?? usage.output_tokens)
+    };
+  }
+};
+var anthropicAdapter = {
+  name: "anthropic",
+  matches(client) {
+    return isObject(client) && isObject(client.messages) && typeof client.messages.create === "function";
+  },
+  async call(client, options) {
+    const { userId, feature, plan, ...rest } = options;
+    return client.messages.create(rest);
+  },
+  extractUsage(result) {
+    const usage = result?.usage ?? {};
+    return {
+      inputTokens: toInt(usage.input_tokens),
+      outputTokens: toInt(usage.output_tokens)
+    };
+  }
+};
+var geminiAdapter = {
+  name: "gemini",
+  matches(client) {
+    return isObject(client) && isObject(client.models) && typeof client.models.generateContent === "function";
+  },
+  async call(client, options) {
+    const { userId, feature, plan, messages, ...rest } = options;
+    const contents = (messages ?? []).map((m) => ({
+      role: m.role === "assistant" ? "model" : "user",
+      parts: [{ text: m.content }]
+    }));
+    return client.models.generateContent({ ...rest, contents });
+  },
+  extractUsage(result) {
+    const meta = result?.usageMetadata ?? {};
+    return {
+      inputTokens: toInt(meta.promptTokenCount),
+      outputTokens: toInt(meta.candidatesTokenCount)
+    };
+  }
+};
+var adapters = [openaiAdapter, anthropicAdapter, geminiAdapter];
+function detectAdapter(client) {
+  for (const adapter of adapters) {
+    if (adapter.matches(client)) return adapter;
+  }
+  return null;
+}
+function isObject(v) {
+  return typeof v === "object" && v !== null;
+}
+function toInt(v) {
+  const n = typeof v === "number" ? v : Number(v);
+  return Number.isFinite(n) ? Math.max(0, Math.floor(n)) : 0;
+}
+
+// src/logger.ts
+function createLogger(opts) {
+  const f = opts.fetch ?? globalThis.fetch;
+  if (typeof f !== "function") {
+    throw new Error("Weckr: global fetch is unavailable. Pass a fetch implementation via config.fetch.");
+  }
+  return function log(payload) {
+    queueMicrotask(() => {
+      let promise;
+      try {
+        promise = f(opts.endpoint, {
+          method: "POST",
+          headers: {
+            "content-type": "application/json",
+            "x-api-key": opts.apiKey
+          },
+          body: JSON.stringify(payload),
+          keepalive: true
+        });
+      } catch (err) {
+        opts.onError?.(err);
+        return;
+      }
+      promise.then(async (res) => {
+        if (!res.ok) {
+          const body = await res.text().catch(() => "");
+          opts.onError?.(
+            new Error(`Weckr log failed: ${res.status} ${res.statusText} ${body}`.trim())
+          );
+        }
+      }).catch((err) => {
+        opts.onError?.(err);
+      });
+    });
+  };
+}
+
+// src/weckr.ts
+var DEFAULT_ENDPOINT = "https://useweckr.com/api/v1/log";
+var Weckr = class {
+  apiKey;
+  plans;
+  log;
+  constructor(config) {
+    if (!config?.apiKey) {
+      throw new Error("Weckr: apiKey is required.");
+    }
+    this.apiKey = config.apiKey;
+    this.plans = config.plans ?? {};
+    this.log = createLogger({
+      apiKey: config.apiKey,
+      endpoint: config.endpoint ?? DEFAULT_ENDPOINT,
+      fetch: config.fetch,
+      onError: config.onError
+    });
+  }
+  async chat(client, options) {
+    const adapter = detectAdapter(client);
+    if (!adapter) {
+      throw new Error(
+        "Weckr: could not detect provider. Pass an OpenAI, Anthropic, or Gemini client instance."
+      );
+    }
+    const startedAt = nowMs();
+    const result = await adapter.call(client, options);
+    const latencyMs = Math.round(nowMs() - startedAt);
+    try {
+      const usage = adapter.extractUsage(result);
+      const { costUsd } = calculateCost(options.model, usage.inputTokens, usage.outputTokens);
+      const planName = options.plan ?? null;
+      const planRevenueUsd = planName != null && Object.prototype.hasOwnProperty.call(this.plans, planName) ? this.plans[planName] : null;
+      const marginUsd = planRevenueUsd != null ? round2(planRevenueUsd - costUsd) : null;
+      const payload = {
+        userId: options.userId ?? null,
+        feature: options.feature ?? null,
+        model: options.model,
+        provider: adapter.name,
+        inputTokens: usage.inputTokens,
+        outputTokens: usage.outputTokens,
+        costUsd,
+        latencyMs,
+        planName,
+        planRevenueUsd,
+        marginUsd,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      this.log(payload);
+    } catch {
+    }
+    return result;
+  }
+};
+function nowMs() {
+  if (typeof performance !== "undefined" && typeof performance.now === "function") {
+    return performance.now();
+  }
+  return Date.now();
+}
+function round2(n) {
+  return Math.round(n * 100) / 100;
+}
+export {
+  PRICING,
+  Weckr,
+  calculateCost,
+  resolvePricing
+};

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@weckr/sdk",
+  "version": "0.1.0",
+  "description": "AI cost and margin intelligence for SaaS founders",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts",
+    "dev": "tsup src/index.ts --format esm,cjs --dts --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "ai",
+    "llm",
+    "openai",
+    "anthropic",
+    "gemini",
+    "cost",
+    "monitoring",
+    "saas",
+    "finops"
+  ],
+  "author": "Weckr",
+  "license": "MIT",
+  "homepage": "https://useweckr.com",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Ghiles3232/weckr"
+  },
+  "peerDependencies": {
+    "openai": ">=4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "openai": { "optional": true },
+    "@anthropic-ai/sdk": { "optional": true },
+    "@google/generative-ai": { "optional": true }
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "openai": "^4.77.0",
+    "tsup": "^8.3.5",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.8"
+  }
+}