the-token-company 0.1.0

package/README.md

@@ -0,0 +1,156 @@
+# The Token Company Node.js SDK
+
+Compress LLM prompts to reduce costs and latency. 100K tokens compressed in ~85ms.
+
+## Install
+
+```bash
+npm install the-token-company
+```
+
+## Quick start
+
+```ts
+import { TheTokenCompany } from "the-token-company";
+
+const client = new TheTokenCompany({ apiKey: "ttc-..." });
+const result = await client.compress("Your long prompt text here...", { model: "bear-2" });
+
+console.log(result.output);          // compressed text
+console.log(result.tokensSaved);     // tokens removed
+console.log(result.compressionRatio); // e.g. 1.8
+```
+
+## SDK wrappers
+
+Drop-in wrappers that auto-compress all non-assistant messages before sending to your LLM. Assistant messages pass through unchanged so the provider's KV cache stays warm.
+
+### OpenAI / OpenRouter
+
+```ts
+import OpenAI from "openai";
+import { withCompression } from "the-token-company/openai";
+
+const client = withCompression(new OpenAI(), { compressionApiKey: "ttc-..." });
+
+const response = await client.chat.completions.create({
+  model: "gpt-4o",
+  messages: [
+    { role: "system", content: "You are a helpful assistant..." },
+    { role: "user", content: "Summarize these results..." },
+  ],
+});
+```
+
+For OpenRouter, just set the base URL:
+
+```ts
+const client = withCompression(
+  new OpenAI({ baseURL: "https://openrouter.ai/api/v1", apiKey: "or-..." }),
+  { compressionApiKey: "ttc-..." }
+);
+```
+
+### Anthropic
+
+```ts
+import Anthropic from "@anthropic-ai/sdk";
+import { withCompression } from "the-token-company/anthropic";
+
+const client = withCompression(new Anthropic(), { compressionApiKey: "ttc-..." });
+
+const response = await client.messages.create({
+  model: "claude-sonnet-4-6",
+  max_tokens: 1024,
+  system: "You are a helpful assistant...",
+  messages: [{ role: "user", content: "Summarize these results..." }],
+});
+```
+
+Both `messages` and the `system` parameter are compressed.
+
+### Vercel AI SDK
+
+**`withCompression()` one-liner** — wraps any AI SDK model with automatic compression:
+
+```ts
+import { openai } from "@ai-sdk/openai";
+import { generateText } from "ai";
+import { withCompression } from "the-token-company/ai-sdk";
+
+const model = withCompression(openai("gpt-4o"), { compressionApiKey: "ttc-..." });
+
+const { text } = await generateText({
+  model,
+  messages: [{ role: "user", content: "Summarize these results..." }],
+});
+```
+
+Works with any provider (`@ai-sdk/openai`, `@ai-sdk/anthropic`, `@ai-sdk/google`, etc.).
+
+**`compressionMiddleware()` for composition** — use when combining with other middleware:
+
+```ts
+import { wrapLanguageModel, generateText } from "ai";
+import { openai } from "@ai-sdk/openai";
+import { compressionMiddleware } from "the-token-company/ai-sdk";
+
+const model = wrapLanguageModel({
+  model: openai("gpt-4o"),
+  middleware: compressionMiddleware({ compressionApiKey: "ttc-..." }),
+});
+```
+
+## Models
+
+| Model      | Description            |
+|------------|------------------------|
+| `bear-2`   | Latest, recommended    |
+| `bear-1.2` | Previous generation    |
+| `bear-1.1` | Legacy                 |
+| `bear-1`   | Legacy                 |
+
+## Aggressiveness
+
+Control compression intensity — a single number applies to all roles, or pass a per-role object:
+
+```ts
+// All roles at 0.5
+withCompression(client, { compressionApiKey: "ttc-...", aggressiveness: 0.5 });
+
+// Per-role — only listed roles are compressed
+withCompression(client, {
+  compressionApiKey: "ttc-...",
+  aggressiveness: { system: 0.1, user: 0.3, tool: 0.5 },
+});
+```
+
+| Role key   | OpenAI                          | Anthropic                      | AI SDK              |
+|------------|---------------------------------|--------------------------------|---------------------|
+| `user`     | `role: "user"` messages         | User text content              | User messages       |
+| `system`   | `role: "system"` messages       | `system` parameter             | System messages     |
+| `tool`     | `tool` + `function` messages    | `tool_result` content blocks   | Tool result parts   |
+
+## Gzip
+
+Gzip compression of request payloads is on by default. Disable with:
+
+```ts
+const client = new TheTokenCompany({ apiKey: "ttc-...", gzip: false });
+```
+
+## Response
+
+`CompressResult` fields:
+
+| Field              | Type     | Description                        |
+|--------------------|----------|------------------------------------|
+| `output`           | `string` | Compressed text                    |
+| `outputTokens`     | `number` | Token count after compression      |
+| `inputTokens`      | `number` | Token count before compression     |
+| `tokensSaved`      | `number` | Tokens removed                     |
+| `compressionRatio` | `number` | Ratio (e.g. 1.8x)                 |
+
+## License
+
+MIT

package/dist/ai-sdk.d.ts

@@ -0,0 +1,46 @@
+import type { LanguageModelMiddleware } from "ai";
+import type { LanguageModelV3 } from "@ai-sdk/provider";
+import type { WithCompressionOptions } from "./types.js";
+import { CompressionStats } from "./types.js";
+/**
+ * Create a Vercel AI SDK middleware that auto-compresses non-assistant messages.
+ *
+ * Use when composing with other middleware:
+ *
+ * ```ts
+ * import { wrapLanguageModel } from "ai";
+ * import { openai } from "@ai-sdk/openai";
+ * import { compressionMiddleware } from "the-token-company/ai-sdk";
+ *
+ * const { middleware, compression } = compressionMiddleware({ compressionApiKey: "ttc-..." });
+ * const model = wrapLanguageModel({ model: openai("gpt-4o"), middleware });
+ * // After calls: compression.totalTokensSaved
+ * ```
+ */
+export declare function compressionMiddleware(options: WithCompressionOptions): {
+    middleware: LanguageModelMiddleware;
+    compression: CompressionStats;
+};
+/**
+ * Wrap any Vercel AI SDK language model with automatic compression.
+ *
+ * ```ts
+ * import { openai } from "@ai-sdk/openai";
+ * import { generateText } from "ai";
+ * import { withCompression } from "the-token-company/ai-sdk";
+ *
+ * const { model, compression } = withCompression(openai("gpt-4o"), { compressionApiKey: "ttc-..." });
+ *
+ * const { text } = await generateText({
+ *   model,
+ *   messages: [{ role: "user", content: "Summarize these results..." }],
+ * });
+ * console.log(compression.totalTokensSaved);
+ * ```
+ *
+ * Works with any provider (`@ai-sdk/openai`, `@ai-sdk/anthropic`, `@ai-sdk/google`, etc.).
+ */
+export declare function withCompression(model: LanguageModelV3, options: WithCompressionOptions): {
+    model: LanguageModelV3;
+    compression: CompressionStats;
+};

package/dist/ai-sdk.js

@@ -0,0 +1,64 @@
+import { wrapLanguageModel } from "ai";
+import { TheTokenCompany } from "./client.js";
+import { AnalyticsTTC, compressAISDKPrompt, resolveAggressiveness } from "./compress.js";
+import { CompressionStats } from "./types.js";
+/**
+ * Create a Vercel AI SDK middleware that auto-compresses non-assistant messages.
+ *
+ * Use when composing with other middleware:
+ *
+ * ```ts
+ * import { wrapLanguageModel } from "ai";
+ * import { openai } from "@ai-sdk/openai";
+ * import { compressionMiddleware } from "the-token-company/ai-sdk";
+ *
+ * const { middleware, compression } = compressionMiddleware({ compressionApiKey: "ttc-..." });
+ * const model = wrapLanguageModel({ model: openai("gpt-4o"), middleware });
+ * // After calls: compression.totalTokensSaved
+ * ```
+ */
+export function compressionMiddleware(options) {
+    const stats = new CompressionStats();
+    const analytics = new AnalyticsTTC(new TheTokenCompany({ apiKey: options.compressionApiKey }), stats);
+    const compressionModel = options.model ?? "bear-2";
+    const roleAggr = resolveAggressiveness(options.aggressiveness ?? 0.2);
+    const middleware = {
+        specificationVersion: "v3",
+        transformParams: async ({ params }) => {
+            if (params.prompt) {
+                stats._startTurn();
+                const compressed = await compressAISDKPrompt(analytics, params.prompt, compressionModel, roleAggr);
+                stats._endTurn();
+                return { ...params, prompt: compressed };
+            }
+            return params;
+        },
+    };
+    return { middleware, compression: stats };
+}
+/**
+ * Wrap any Vercel AI SDK language model with automatic compression.
+ *
+ * ```ts
+ * import { openai } from "@ai-sdk/openai";
+ * import { generateText } from "ai";
+ * import { withCompression } from "the-token-company/ai-sdk";
+ *
+ * const { model, compression } = withCompression(openai("gpt-4o"), { compressionApiKey: "ttc-..." });
+ *
+ * const { text } = await generateText({
+ *   model,
+ *   messages: [{ role: "user", content: "Summarize these results..." }],
+ * });
+ * console.log(compression.totalTokensSaved);
+ * ```
+ *
+ * Works with any provider (`@ai-sdk/openai`, `@ai-sdk/anthropic`, `@ai-sdk/google`, etc.).
+ */
+export function withCompression(model, options) {
+    const { middleware, compression } = compressionMiddleware(options);
+    return {
+        model: wrapLanguageModel({ model, middleware }),
+        compression,
+    };
+}

package/dist/anthropic.d.ts

@@ -0,0 +1,30 @@
+import type { WithCompressionOptions } from "./types.js";
+import { CompressionStats } from "./types.js";
+/**
+ * Wrap an Anthropic client to auto-compress non-assistant messages.
+ *
+ * Compresses the `system` parameter and all non-assistant messages.
+ *
+ * ```ts
+ * import Anthropic from "@anthropic-ai/sdk";
+ * import { withCompression } from "the-token-company/anthropic";
+ *
+ * const client = withCompression(new Anthropic(), { compressionApiKey: "ttc-..." });
+ * const response = await client.messages.create({
+ *   model: "claude-sonnet-4-6",
+ *   max_tokens: 1024,
+ *   system: "You are a helpful assistant...",
+ *   messages: [{ role: "user", content: "..." }],
+ * });
+ * console.log(client.compression.totalTokensSaved);
+ * ```
+ *
+ * Assistant messages pass through unchanged to preserve the provider's KV cache.
+ */
+export declare function withCompression<T extends {
+    messages: {
+        create: Function;
+    };
+}>(client: T, options: WithCompressionOptions): T & {
+    compression: CompressionStats;
+};

package/dist/anthropic.js

@@ -0,0 +1,49 @@
+import { TheTokenCompany } from "./client.js";
+import { AnalyticsTTC, compressAnthropicMessages, resolveAggressiveness } from "./compress.js";
+import { CompressionStats } from "./types.js";
+/**
+ * Wrap an Anthropic client to auto-compress non-assistant messages.
+ *
+ * Compresses the `system` parameter and all non-assistant messages.
+ *
+ * ```ts
+ * import Anthropic from "@anthropic-ai/sdk";
+ * import { withCompression } from "the-token-company/anthropic";
+ *
+ * const client = withCompression(new Anthropic(), { compressionApiKey: "ttc-..." });
+ * const response = await client.messages.create({
+ *   model: "claude-sonnet-4-6",
+ *   max_tokens: 1024,
+ *   system: "You are a helpful assistant...",
+ *   messages: [{ role: "user", content: "..." }],
+ * });
+ * console.log(client.compression.totalTokensSaved);
+ * ```
+ *
+ * Assistant messages pass through unchanged to preserve the provider's KV cache.
+ */
+export function withCompression(client, options) {
+    const stats = new CompressionStats();
+    const analytics = new AnalyticsTTC(new TheTokenCompany({ apiKey: options.compressionApiKey }), stats);
+    const model = options.model ?? "bear-2";
+    const roleAggr = resolveAggressiveness(options.aggressiveness ?? 0.2);
+    const systemAggr = roleAggr["system"];
+    const originalCreate = client.messages.create.bind(client.messages);
+    client.messages.create = async function (params, ...rest) {
+        stats._startTurn();
+        if (params?.messages) {
+            params = {
+                ...params,
+                messages: await compressAnthropicMessages(analytics, params.messages, model, roleAggr),
+            };
+        }
+        if (systemAggr != null && typeof params?.system === "string" && params.system.trim()) {
+            const result = await analytics.compress(params.system, { model, aggressiveness: systemAggr });
+            params = { ...params, system: result.output };
+        }
+        stats._endTurn();
+        return originalCreate(params, ...rest);
+    };
+    client.compression = stats;
+    return client;
+}

package/dist/client.d.ts

@@ -0,0 +1,17 @@
+import type { CompressResult, TheTokenCompanyOptions } from "./types.js";
+export declare const BEAR_1 = "bear-1";
+export declare const BEAR_1_1 = "bear-1.1";
+export declare const BEAR_1_2 = "bear-1.2";
+export declare const BEAR_2 = "bear-2";
+export declare class TheTokenCompany {
+    private readonly baseUrl;
+    private readonly apiKey;
+    private readonly timeout;
+    private readonly gzip;
+    constructor(options: TheTokenCompanyOptions);
+    compress(text: string, options?: {
+        model?: string;
+        aggressiveness?: number;
+    }): Promise<CompressResult>;
+    private parseError;
+}

package/dist/client.js

@@ -0,0 +1,91 @@
+import { gzip } from "node:zlib";
+import { promisify } from "node:util";
+import { APIError, AuthenticationError, InvalidRequestError, PaymentRequiredError, RateLimitError, RequestTooLargeError, } from "./errors.js";
+const gzipAsync = promisify(gzip);
+const BASE_URL = "https://api.thetokencompany.com";
+const DEFAULT_TIMEOUT = 30_000;
+export const BEAR_1 = "bear-1";
+export const BEAR_1_1 = "bear-1.1";
+export const BEAR_1_2 = "bear-1.2";
+export const BEAR_2 = "bear-2";
+export class TheTokenCompany {
+    baseUrl;
+    apiKey;
+    timeout;
+    gzip;
+    constructor(options) {
+        this.apiKey = options.apiKey;
+        this.baseUrl = (options.baseUrl ?? BASE_URL).replace(/\/$/, "");
+        this.timeout = options.timeout ?? DEFAULT_TIMEOUT;
+        this.gzip = options.gzip ?? true;
+    }
+    async compress(text, options = {}) {
+        const { model = "bear-2", aggressiveness = 0.2 } = options;
+        if (!text || !text.trim()) {
+            throw new InvalidRequestError("text cannot be empty");
+        }
+        if (aggressiveness < 0 || aggressiveness > 1) {
+            throw new InvalidRequestError("aggressiveness must be between 0.0 and 1.0");
+        }
+        const payload = {
+            model,
+            input: text,
+            compression_settings: { aggressiveness },
+        };
+        const jsonBody = JSON.stringify(payload);
+        const headers = {
+            Authorization: `Bearer ${this.apiKey}`,
+            "Content-Type": "application/json",
+        };
+        let body;
+        if (this.gzip) {
+            headers["Content-Encoding"] = "gzip";
+            body = new Uint8Array(await gzipAsync(jsonBody));
+        }
+        else {
+            body = jsonBody;
+        }
+        const response = await fetch(`${this.baseUrl}/v1/compress`, {
+            method: "POST",
+            headers,
+            body: body,
+            signal: AbortSignal.timeout(this.timeout),
+        });
+        if (!response.ok) {
+            throw await this.parseError(response);
+        }
+        const data = (await response.json());
+        return {
+            output: data.output,
+            outputTokens: data.output_tokens,
+            inputTokens: data.original_input_tokens,
+            tokensSaved: data.original_input_tokens - data.output_tokens,
+            compressionRatio: data.output_tokens === 0 ? 0 : data.original_input_tokens / data.output_tokens,
+        };
+    }
+    async parseError(response) {
+        let msg;
+        try {
+            const body = (await response.json());
+            const detail = body.detail ?? "Unknown error";
+            msg = typeof detail === "object" ? (detail.message ?? JSON.stringify(detail)) : detail;
+        }
+        catch {
+            msg = (await response.text()) || "Unknown error";
+        }
+        switch (response.status) {
+            case 401:
+                return new AuthenticationError(msg);
+            case 402:
+                return new PaymentRequiredError(msg);
+            case 413:
+                return new RequestTooLargeError(msg);
+            case 429:
+                return new RateLimitError(msg);
+            case 400:
+                return new InvalidRequestError(msg);
+            default:
+                return new APIError(`API error (${response.status}): ${msg}`, response.status);
+        }
+    }
+}

package/dist/compress.d.ts

@@ -0,0 +1,68 @@
+import { TheTokenCompany } from "./client.js";
+import type { Aggressiveness, CompressResult } from "./types.js";
+import { CompressionStats } from "./types.js";
+export interface Compressor {
+    compress(text: string, options: {
+        model?: string;
+        aggressiveness?: number;
+    }): Promise<CompressResult>;
+}
+export declare class AnalyticsTTC implements Compressor {
+    private readonly inner;
+    readonly stats: CompressionStats;
+    constructor(inner: TheTokenCompany, stats: CompressionStats);
+    compress(text: string, options: {
+        model?: string;
+        aggressiveness?: number;
+    }): Promise<CompressResult>;
+}
+export declare function resolveAggressiveness(aggressiveness: Aggressiveness): Record<string, number>;
+interface OpenAIMessage {
+    role: string;
+    content?: string | Array<{
+        type: string;
+        text?: string;
+        [key: string]: unknown;
+    }> | null;
+    [key: string]: unknown;
+}
+export declare function compressOpenAIMessages(ttc: Compressor, messages: OpenAIMessage[], model: string, roleAggr: Record<string, number>): Promise<OpenAIMessage[]>;
+interface AnthropicBlock {
+    type: string;
+    text?: string;
+    content?: string | Array<{
+        type: string;
+        text?: string;
+        [key: string]: unknown;
+    }>;
+    [key: string]: unknown;
+}
+interface AnthropicMessage {
+    role: string;
+    content?: string | AnthropicBlock[] | null;
+    [key: string]: unknown;
+}
+export declare function compressAnthropicMessages(ttc: Compressor, messages: AnthropicMessage[], model: string, roleAggr: Record<string, number>): Promise<AnthropicMessage[]>;
+interface AISDKTextPart {
+    type: "text";
+    text: string;
+    [key: string]: unknown;
+}
+interface AISDKToolResultPart {
+    type: "tool-result";
+    toolCallId: string;
+    toolName: string;
+    result: unknown;
+    [key: string]: unknown;
+}
+type AISDKPart = AISDKTextPart | AISDKToolResultPart | {
+    type: string;
+    [key: string]: unknown;
+};
+interface AISDKMessage {
+    role: "system" | "user" | "assistant" | "tool";
+    content: string | AISDKPart[];
+    [key: string]: unknown;
+}
+export declare function compressAISDKPrompt(ttc: Compressor, prompt: AISDKMessage[], model: string, roleAggr: Record<string, number>): Promise<AISDKMessage[]>;
+export {};

package/dist/compress.js

@@ -0,0 +1,149 @@
+const DEFAULT_ROLES = ["user", "system", "tool"];
+export class AnalyticsTTC {
+    inner;
+    stats;
+    constructor(inner, stats) {
+        this.inner = inner;
+        this.stats = stats;
+    }
+    async compress(text, options) {
+        const result = await this.inner.compress(text, options);
+        this.stats._record(result);
+        return result;
+    }
+}
+export function resolveAggressiveness(aggressiveness) {
+    if (typeof aggressiveness === "number") {
+        return Object.fromEntries(DEFAULT_ROLES.map((r) => [r, aggressiveness]));
+    }
+    return aggressiveness;
+}
+const OPENAI_TOOL_ROLES = new Set(["tool", "function"]);
+function openaiAggr(role, roleAggr) {
+    if (OPENAI_TOOL_ROLES.has(role))
+        return roleAggr["tool"];
+    return roleAggr[role];
+}
+export async function compressOpenAIMessages(ttc, messages, model, roleAggr) {
+    return Promise.all(messages.map(async (msg) => {
+        const aggr = openaiAggr(msg.role, roleAggr);
+        if (aggr == null)
+            return msg;
+        if (typeof msg.content === "string" && msg.content.trim()) {
+            const result = await ttc.compress(msg.content, { model, aggressiveness: aggr });
+            return { ...msg, content: result.output };
+        }
+        if (Array.isArray(msg.content)) {
+            const blocks = await Promise.all(msg.content.map(async (block) => {
+                if (block.type === "text" && typeof block.text === "string" && block.text.trim()) {
+                    const result = await ttc.compress(block.text, { model, aggressiveness: aggr });
+                    return { ...block, text: result.output };
+                }
+                return block;
+            }));
+            return { ...msg, content: blocks };
+        }
+        return msg;
+    }));
+}
+export async function compressAnthropicMessages(ttc, messages, model, roleAggr) {
+    return Promise.all(messages.map(async (msg) => {
+        if (msg.role !== "user")
+            return msg;
+        const userAggr = roleAggr["user"];
+        const toolAggr = roleAggr["tool"];
+        if (userAggr == null && toolAggr == null)
+            return msg;
+        if (typeof msg.content === "string" && userAggr != null && msg.content.trim()) {
+            const result = await ttc.compress(msg.content, { model, aggressiveness: userAggr });
+            return { ...msg, content: result.output };
+        }
+        if (Array.isArray(msg.content)) {
+            const blocks = await compressAnthropicBlocks(ttc, msg.content, model, userAggr, toolAggr);
+            return { ...msg, content: blocks };
+        }
+        return msg;
+    }));
+}
+async function compressAnthropicBlocks(ttc, blocks, model, userAggr, toolAggr) {
+    return Promise.all(blocks.map(async (block) => {
+        if (block.type === "text" && userAggr != null && typeof block.text === "string" && block.text.trim()) {
+            const result = await ttc.compress(block.text, { model, aggressiveness: userAggr });
+            return { ...block, text: result.output };
+        }
+        if (block.type === "tool_result" && toolAggr != null) {
+            return compressToolResult(ttc, block, model, toolAggr);
+        }
+        return block;
+    }));
+}
+async function compressToolResult(ttc, block, model, aggressiveness) {
+    if (typeof block.content === "string" && block.content.trim()) {
+        const result = await ttc.compress(block.content, { model, aggressiveness });
+        return { ...block, content: result.output };
+    }
+    if (Array.isArray(block.content)) {
+        const compressed = await Promise.all(block.content.map(async (inner) => {
+            if (inner.type === "text" && typeof inner.text === "string" && inner.text.trim()) {
+                const result = await ttc.compress(inner.text, { model, aggressiveness });
+                return { ...inner, text: result.output };
+            }
+            return inner;
+        }));
+        return { ...block, content: compressed };
+    }
+    return block;
+}
+export async function compressAISDKPrompt(ttc, prompt, model, roleAggr) {
+    return Promise.all(prompt.map(async (msg) => {
+        if (msg.role === "assistant")
+            return msg;
+        if (msg.role === "system") {
+            const aggr = roleAggr["system"];
+            if (aggr == null)
+                return msg;
+            if (typeof msg.content === "string" && msg.content.trim()) {
+                const result = await ttc.compress(msg.content, { model, aggressiveness: aggr });
+                return { ...msg, content: result.output };
+            }
+            return msg;
+        }
+        if (msg.role === "user") {
+            const userAggr = roleAggr["user"];
+            if (userAggr == null)
+                return msg;
+            if (typeof msg.content === "string" && msg.content.trim()) {
+                const result = await ttc.compress(msg.content, { model, aggressiveness: userAggr });
+                return { ...msg, content: result.output };
+            }
+            if (Array.isArray(msg.content)) {
+                const parts = await Promise.all(msg.content.map(async (part) => {
+                    if (part.type === "text" && "text" in part && typeof part.text === "string" && part.text.trim()) {
+                        const result = await ttc.compress(part.text, { model, aggressiveness: userAggr });
+                        return { ...part, text: result.output };
+                    }
+                    return part;
+                }));
+                return { ...msg, content: parts };
+            }
+            return msg;
+        }
+        if (msg.role === "tool") {
+            const toolAggr = roleAggr["tool"];
+            if (toolAggr == null)
+                return msg;
+            if (Array.isArray(msg.content)) {
+                const parts = await Promise.all(msg.content.map(async (part) => {
+                    if (part.type === "tool-result" && "result" in part && typeof part.result === "string" && part.result.trim()) {
+                        const result = await ttc.compress(part.result, { model, aggressiveness: toolAggr });
+                        return { ...part, result: result.output };
+                    }
+                    return part;
+                }));
+                return { ...msg, content: parts };
+            }
+            return msg;
+        }
+        return msg;
+    }));
+}

package/dist/errors.d.ts

@@ -0,0 +1,22 @@
+export declare class TheTokenCompanyError extends Error {
+    constructor(message: string);
+}
+export declare class AuthenticationError extends TheTokenCompanyError {
+    constructor(message: string);
+}
+export declare class InvalidRequestError extends TheTokenCompanyError {
+    constructor(message: string);
+}
+export declare class PaymentRequiredError extends TheTokenCompanyError {
+    constructor(message: string);
+}
+export declare class RequestTooLargeError extends TheTokenCompanyError {
+    constructor(message: string);
+}
+export declare class RateLimitError extends TheTokenCompanyError {
+    constructor(message: string);
+}
+export declare class APIError extends TheTokenCompanyError {
+    statusCode: number | undefined;
+    constructor(message: string, statusCode?: number);
+}

package/dist/errors.js

@@ -0,0 +1,44 @@
+export class TheTokenCompanyError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "TheTokenCompanyError";
+    }
+}
+export class AuthenticationError extends TheTokenCompanyError {
+    constructor(message) {
+        super(message);
+        this.name = "AuthenticationError";
+    }
+}
+export class InvalidRequestError extends TheTokenCompanyError {
+    constructor(message) {
+        super(message);
+        this.name = "InvalidRequestError";
+    }
+}
+export class PaymentRequiredError extends TheTokenCompanyError {
+    constructor(message) {
+        super(message);
+        this.name = "PaymentRequiredError";
+    }
+}
+export class RequestTooLargeError extends TheTokenCompanyError {
+    constructor(message) {
+        super(message);
+        this.name = "RequestTooLargeError";
+    }
+}
+export class RateLimitError extends TheTokenCompanyError {
+    constructor(message) {
+        super(message);
+        this.name = "RateLimitError";
+    }
+}
+export class APIError extends TheTokenCompanyError {
+    statusCode;
+    constructor(message, statusCode) {
+        super(message);
+        this.name = "APIError";
+        this.statusCode = statusCode;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { TheTokenCompany, BEAR_1, BEAR_1_1, BEAR_1_2, BEAR_2 } from "./client.js";
+export { TheTokenCompanyError, AuthenticationError, InvalidRequestError, PaymentRequiredError, RequestTooLargeError, RateLimitError, APIError, } from "./errors.js";
+export { CompressionStats } from "./types.js";
+export type { CompressResult, TheTokenCompanyOptions, Aggressiveness, WithCompressionOptions, TurnStats, } from "./types.js";

package/dist/index.js

@@ -0,0 +1,3 @@
+export { TheTokenCompany, BEAR_1, BEAR_1_1, BEAR_1_2, BEAR_2 } from "./client.js";
+export { TheTokenCompanyError, AuthenticationError, InvalidRequestError, PaymentRequiredError, RequestTooLargeError, RateLimitError, APIError, } from "./errors.js";
+export { CompressionStats } from "./types.js";

package/dist/openai.d.ts

@@ -0,0 +1,30 @@
+import type { WithCompressionOptions } from "./types.js";
+import { CompressionStats } from "./types.js";
+/**
+ * Wrap an OpenAI-compatible client to auto-compress non-assistant messages.
+ *
+ * Works with `OpenAI`, OpenRouter, and any OpenAI-compatible client.
+ *
+ * ```ts
+ * import OpenAI from "openai";
+ * import { withCompression } from "the-token-company/openai";
+ *
+ * const client = withCompression(new OpenAI(), { compressionApiKey: "ttc-..." });
+ * const response = await client.chat.completions.create({
+ *   model: "gpt-4o",
+ *   messages: [{ role: "user", content: "..." }],
+ * });
+ * console.log(client.compression.totalTokensSaved);
+ * ```
+ *
+ * Assistant messages pass through unchanged to preserve the provider's KV cache.
+ */
+export declare function withCompression<T extends {
+    chat: {
+        completions: {
+            create: Function;
+        };
+    };
+}>(client: T, options: WithCompressionOptions): T & {
+    compression: CompressionStats;
+};

package/dist/openai.js

@@ -0,0 +1,42 @@
+import { TheTokenCompany } from "./client.js";
+import { AnalyticsTTC, compressOpenAIMessages, resolveAggressiveness } from "./compress.js";
+import { CompressionStats } from "./types.js";
+/**
+ * Wrap an OpenAI-compatible client to auto-compress non-assistant messages.
+ *
+ * Works with `OpenAI`, OpenRouter, and any OpenAI-compatible client.
+ *
+ * ```ts
+ * import OpenAI from "openai";
+ * import { withCompression } from "the-token-company/openai";
+ *
+ * const client = withCompression(new OpenAI(), { compressionApiKey: "ttc-..." });
+ * const response = await client.chat.completions.create({
+ *   model: "gpt-4o",
+ *   messages: [{ role: "user", content: "..." }],
+ * });
+ * console.log(client.compression.totalTokensSaved);
+ * ```
+ *
+ * Assistant messages pass through unchanged to preserve the provider's KV cache.
+ */
+export function withCompression(client, options) {
+    const stats = new CompressionStats();
+    const analytics = new AnalyticsTTC(new TheTokenCompany({ apiKey: options.compressionApiKey }), stats);
+    const model = options.model ?? "bear-2";
+    const roleAggr = resolveAggressiveness(options.aggressiveness ?? 0.2);
+    const originalCreate = client.chat.completions.create.bind(client.chat.completions);
+    client.chat.completions.create = async function (params, ...rest) {
+        if (params?.messages) {
+            stats._startTurn();
+            params = {
+                ...params,
+                messages: await compressOpenAIMessages(analytics, params.messages, model, roleAggr),
+            };
+            stats._endTurn();
+        }
+        return originalCreate(params, ...rest);
+    };
+    client.compression = stats;
+    return client;
+}

package/dist/types.d.ts

@@ -0,0 +1,51 @@
+export interface CompressRequest {
+    model: string;
+    input: string;
+    compression_settings: {
+        aggressiveness: number;
+    };
+}
+export interface CompressResponse {
+    output: string;
+    output_tokens: number;
+    original_input_tokens: number;
+}
+export interface CompressResult {
+    output: string;
+    outputTokens: number;
+    inputTokens: number;
+    tokensSaved: number;
+    compressionRatio: number;
+}
+export interface TheTokenCompanyOptions {
+    apiKey: string;
+    baseUrl?: string;
+    timeout?: number;
+    gzip?: boolean;
+}
+export type Aggressiveness = number | Record<string, number>;
+export interface WithCompressionOptions {
+    compressionApiKey: string;
+    model?: string;
+    aggressiveness?: Aggressiveness;
+}
+export interface TurnStats {
+    inputTokens: number;
+    outputTokens: number;
+    tokensSaved: number;
+    messagesCompressed: number;
+    ratio: number;
+    timestamp: number;
+}
+export declare class CompressionStats {
+    history: TurnStats[];
+    private _accumulator;
+    _startTurn(): void;
+    _record(result: CompressResult): void;
+    _endTurn(): void;
+    get totalInputTokens(): number;
+    get totalOutputTokens(): number;
+    get totalTokensSaved(): number;
+    get calls(): number;
+    get ratio(): number;
+}

package/dist/types.js

@@ -0,0 +1,40 @@
+export class CompressionStats {
+    history = [];
+    _accumulator = [];
+    _startTurn() {
+        this._accumulator = [];
+    }
+    _record(result) {
+        this._accumulator.push(result);
+    }
+    _endTurn() {
+        if (this._accumulator.length > 0) {
+            const inputTokens = this._accumulator.reduce((s, r) => s + r.inputTokens, 0);
+            const outputTokens = this._accumulator.reduce((s, r) => s + r.outputTokens, 0);
+            this.history.push({
+                inputTokens,
+                outputTokens,
+                tokensSaved: inputTokens - outputTokens,
+                messagesCompressed: this._accumulator.length,
+                ratio: outputTokens === 0 ? 0 : inputTokens / outputTokens,
+                timestamp: Date.now(),
+            });
+        }
+        this._accumulator = [];
+    }
+    get totalInputTokens() {
+        return this.history.reduce((s, t) => s + t.inputTokens, 0);
+    }
+    get totalOutputTokens() {
+        return this.history.reduce((s, t) => s + t.outputTokens, 0);
+    }
+    get totalTokensSaved() {
+        return this.history.reduce((s, t) => s + t.tokensSaved, 0);
+    }
+    get calls() {
+        return this.history.length;
+    }
+    get ratio() {
+        return this.totalOutputTokens === 0 ? 0 : this.totalInputTokens / this.totalOutputTokens;
+    }
+}

package/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "the-token-company",
+  "version": "0.1.0",
+  "description": "Node.js SDK for The Token Company — compress LLM prompts to reduce costs and latency",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./openai": {
+      "types": "./dist/openai.d.ts",
+      "import": "./dist/openai.js"
+    },
+    "./anthropic": {
+      "types": "./dist/anthropic.d.ts",
+      "import": "./dist/anthropic.js"
+    },
+    "./ai-sdk": {
+      "types": "./dist/ai-sdk.d.ts",
+      "import": "./dist/ai-sdk.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "tsc --noEmit"
+  },
+  "keywords": [
+    "llm",
+    "compression",
+    "tokens",
+    "ai",
+    "prompt-optimization",
+    "openai",
+    "anthropic",
+    "vercel-ai-sdk"
+  ],
+  "author": "The Token Company <support@thetokencompany.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/TheTokenCompany/the-token-company-node"
+  },
+  "homepage": "https://thetokencompany.com",
+  "devDependencies": {
+    "@ai-sdk/provider": "^3.0.10",
+    "@types/node": "^22",
+    "ai": "^6.0.195",
+    "typescript": "^5.7",
+    "vitest": "^3"
+  },
+  "peerDependencies": {
+    "@anthropic-ai/sdk": ">=0.30.0",
+    "ai": ">=4.0.0",
+    "openai": ">=4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "ai": {
+      "optional": true
+    },
+    "openai": {
+      "optional": true
+    },
+    "@anthropic-ai/sdk": {
+      "optional": true
+    }
+  }
+}