@loopers/client 0.4.8 → 1.2.0

package/README.md

@@ -74,6 +74,21 @@ const response = await client.messages.create({
 console.log(`Request Cost: $${(response as any).loopers_cost} USD`);
 ```
 
+### Other Providers (Groq, Mistral, DeepSeek, Together)
+
+Because these providers are OpenAI-compatible, they share the exact same interface as `LoopersOpenAI`. Simply substitute the class name:
+
+```typescript
+import { LoopersGroq } from '@loopers/client';
+
+// Example using Groq
+const client = new LoopersGroq({
+  loopersUrl: 'http://localhost:8080',
+  loopersKey: 'lp-xxx',
+  providerKey: 'gsk_xxx'
+});
+```
+
 ## License
 
 MIT

package/dist/client.d.ts

@@ -7,12 +7,35 @@ export interface LoopersClientOptions {
     sessionId?: string;
     sessionBudget?: number;
     maxSteps?: number;
+    sessionTtl?: number;
+    maxTools?: number;
+    maxServers?: number;
 }
 export declare class LoopersOpenAI extends OpenAI {
     constructor(options: LoopersClientOptions & {
         [key: string]: any;
     });
 }
+export declare class LoopersGroq extends LoopersOpenAI {
+    constructor(options: LoopersClientOptions & {
+        [key: string]: any;
+    });
+}
+export declare class LoopersMistral extends LoopersOpenAI {
+    constructor(options: LoopersClientOptions & {
+        [key: string]: any;
+    });
+}
+export declare class LoopersDeepSeek extends LoopersOpenAI {
+    constructor(options: LoopersClientOptions & {
+        [key: string]: any;
+    });
+}
+export declare class LoopersTogether extends LoopersOpenAI {
+    constructor(options: LoopersClientOptions & {
+        [key: string]: any;
+    });
+}
 export declare class LoopersAnthropic extends Anthropic {
     constructor(options: LoopersClientOptions & {
         [key: string]: any;

package/dist/client.js

@@ -3,10 +3,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LoopersAnthropic = exports.LoopersOpenAI = void 0;
+exports.LoopersAnthropic = exports.LoopersTogether = exports.LoopersDeepSeek = exports.LoopersMistral = exports.LoopersGroq = exports.LoopersOpenAI = void 0;
 const openai_1 = __importDefault(require("openai"));
 const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
-function createLoopersFetch(loopersKey, providerKey, sessionId, sessionBudget, maxSteps, customFetch) {
+function createLoopersFetch(loopersKey, providerKey, sessionId, sessionBudget, maxSteps, sessionTtl, maxTools, maxServers, customFetch) {
     const originalFetch = customFetch || (typeof fetch !== 'undefined' ? fetch : undefined);
     if (!originalFetch) {
         throw new Error('A global fetch function is not available. Please pass a custom fetch implementation (e.g. node-fetch) or use Node.js 18+.');
@@ -28,6 +28,15 @@ function createLoopersFetch(loopersKey, providerKey, sessionId, sessionBudget, m
         if (maxSteps !== undefined) {
             headers.set('X-Loopers-Session-Max-Steps', String(maxSteps));
         }
+        if (sessionTtl !== undefined) {
+            headers.set('X-Loopers-Session-TTL', String(sessionTtl));
+        }
+        if (maxTools !== undefined) {
+            headers.set('X-Loopers-Session-Max-Tools', String(maxTools));
+        }
+        if (maxServers !== undefined) {
+            headers.set('X-Loopers-Session-Max-Servers', String(maxServers));
+        }
         const modifiedInit = {
             ...init,
             headers,
@@ -78,23 +87,47 @@ function createLoopersFetch(loopersKey, providerKey, sessionId, sessionBudget, m
 }
 class LoopersOpenAI extends openai_1.default {
     constructor(options) {
-        const { loopersUrl, loopersKey, providerKey, sessionId, sessionBudget, maxSteps, ...openaiOptions } = options;
+        const { loopersUrl, loopersKey, providerKey, sessionId, sessionBudget, maxSteps, sessionTtl, maxTools, maxServers, _providerPath, ...openaiOptions } = options;
         const baseFetch = openaiOptions.fetch;
-        const loopersFetch = createLoopersFetch(loopersKey, providerKey, sessionId, sessionBudget, maxSteps, baseFetch);
+        const loopersFetch = createLoopersFetch(loopersKey, providerKey, sessionId, sessionBudget, maxSteps, sessionTtl, maxTools, maxServers, baseFetch);
         super({
             ...openaiOptions,
-            baseURL: `${loopersUrl.replace(/\/$/, '')}/openai/v1`,
+            baseURL: `${loopersUrl.replace(/\/$/, '')}/${_providerPath || 'openai/v1'}`,
             apiKey: loopersKey,
             fetch: loopersFetch,
         });
     }
 }
 exports.LoopersOpenAI = LoopersOpenAI;
+class LoopersGroq extends LoopersOpenAI {
+    constructor(options) {
+        super({ ...options, _providerPath: 'groq/v1' });
+    }
+}
+exports.LoopersGroq = LoopersGroq;
+class LoopersMistral extends LoopersOpenAI {
+    constructor(options) {
+        super({ ...options, _providerPath: 'mistral/v1' });
+    }
+}
+exports.LoopersMistral = LoopersMistral;
+class LoopersDeepSeek extends LoopersOpenAI {
+    constructor(options) {
+        super({ ...options, _providerPath: 'deepseek/v1' });
+    }
+}
+exports.LoopersDeepSeek = LoopersDeepSeek;
+class LoopersTogether extends LoopersOpenAI {
+    constructor(options) {
+        super({ ...options, _providerPath: 'together/v1' });
+    }
+}
+exports.LoopersTogether = LoopersTogether;
 class LoopersAnthropic extends sdk_1.default {
     constructor(options) {
-        const { loopersUrl, loopersKey, providerKey, sessionId, sessionBudget, maxSteps, ...anthropicOptions } = options;
+        const { loopersUrl, loopersKey, providerKey, sessionId, sessionBudget, maxSteps, sessionTtl, maxTools, maxServers, ...anthropicOptions } = options;
         const baseFetch = anthropicOptions.fetch;
-        const loopersFetch = createLoopersFetch(loopersKey, providerKey, sessionId, sessionBudget, maxSteps, baseFetch);
+        const loopersFetch = createLoopersFetch(loopersKey, providerKey, sessionId, sessionBudget, maxSteps, sessionTtl, maxTools, maxServers, baseFetch);
         super({
             ...anthropicOptions,
             baseURL: `${loopersUrl.replace(/\/$/, '')}/anthropic`,

package/dist/index.d.ts

@@ -1 +1 @@
-export { LoopersOpenAI, LoopersAnthropic, LoopersClientOptions } from './client';
+export { LoopersOpenAI, LoopersAnthropic, LoopersGroq, LoopersMistral, LoopersDeepSeek, LoopersTogether, LoopersClientOptions, } from './client';

package/dist/index.js

@@ -1,6 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LoopersAnthropic = exports.LoopersOpenAI = void 0;
+exports.LoopersTogether = exports.LoopersDeepSeek = exports.LoopersMistral = exports.LoopersGroq = exports.LoopersAnthropic = exports.LoopersOpenAI = void 0;
 var client_1 = require("./client");
 Object.defineProperty(exports, "LoopersOpenAI", { enumerable: true, get: function () { return client_1.LoopersOpenAI; } });
 Object.defineProperty(exports, "LoopersAnthropic", { enumerable: true, get: function () { return client_1.LoopersAnthropic; } });
+Object.defineProperty(exports, "LoopersGroq", { enumerable: true, get: function () { return client_1.LoopersGroq; } });
+Object.defineProperty(exports, "LoopersMistral", { enumerable: true, get: function () { return client_1.LoopersMistral; } });
+Object.defineProperty(exports, "LoopersDeepSeek", { enumerable: true, get: function () { return client_1.LoopersDeepSeek; } });
+Object.defineProperty(exports, "LoopersTogether", { enumerable: true, get: function () { return client_1.LoopersTogether; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loopers/client",
-  "version": "0.4.8",
+  "version": "1.2.0",
   "description": "A premium TypeScript client wrapper for the Loopers AI budget & rate-limit proxy.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/client.ts

@@ -8,6 +8,9 @@ export interface LoopersClientOptions {
   sessionId?: string;
   sessionBudget?: number;
   maxSteps?: number;
+  sessionTtl?: number;
+  maxTools?: number;
+  maxServers?: number;
 }
 
 function createLoopersFetch(
@@ -16,6 +19,9 @@ function createLoopersFetch(
   sessionId?: string,
   sessionBudget?: number,
   maxSteps?: number,
+  sessionTtl?: number,
+  maxTools?: number,
+  maxServers?: number,
   customFetch?: typeof fetch
 ) {
   const originalFetch = customFetch || (typeof fetch !== 'undefined' ? fetch : undefined);
@@ -41,6 +47,15 @@ function createLoopersFetch(
     if (maxSteps !== undefined) {
       headers.set('X-Loopers-Session-Max-Steps', String(maxSteps));
     }
+    if (sessionTtl !== undefined) {
+      headers.set('X-Loopers-Session-TTL', String(sessionTtl));
+    }
+    if (maxTools !== undefined) {
+      headers.set('X-Loopers-Session-Max-Tools', String(maxTools));
+    }
+    if (maxServers !== undefined) {
+      headers.set('X-Loopers-Session-Max-Servers', String(maxServers));
+    }
 
     const modifiedInit = {
       ...init,
@@ -108,6 +123,10 @@ export class LoopersOpenAI extends OpenAI {
       sessionId,
       sessionBudget,
       maxSteps,
+      sessionTtl,
+      maxTools,
+      maxServers,
+      _providerPath,
       ...openaiOptions
     } = options;
 
@@ -118,18 +137,45 @@ export class LoopersOpenAI extends OpenAI {
       sessionId,
       sessionBudget,
       maxSteps,
+      sessionTtl,
+      maxTools,
+      maxServers,
       baseFetch
     );
 
     super({
       ...openaiOptions,
-      baseURL: `${loopersUrl.replace(/\/$/, '')}/openai/v1`,
+      baseURL: `${loopersUrl.replace(/\/$/, '')}/${_providerPath || 'openai/v1'}`,
       apiKey: loopersKey,
       fetch: loopersFetch,
     });
   }
 }
 
+export class LoopersGroq extends LoopersOpenAI {
+  constructor(options: LoopersClientOptions & { [key: string]: any }) {
+    super({ ...options, _providerPath: 'groq/v1' });
+  }
+}
+
+export class LoopersMistral extends LoopersOpenAI {
+  constructor(options: LoopersClientOptions & { [key: string]: any }) {
+    super({ ...options, _providerPath: 'mistral/v1' });
+  }
+}
+
+export class LoopersDeepSeek extends LoopersOpenAI {
+  constructor(options: LoopersClientOptions & { [key: string]: any }) {
+    super({ ...options, _providerPath: 'deepseek/v1' });
+  }
+}
+
+export class LoopersTogether extends LoopersOpenAI {
+  constructor(options: LoopersClientOptions & { [key: string]: any }) {
+    super({ ...options, _providerPath: 'together/v1' });
+  }
+}
+
 export class LoopersAnthropic extends Anthropic {
   constructor(
     options: LoopersClientOptions & {
@@ -143,6 +189,9 @@ export class LoopersAnthropic extends Anthropic {
       sessionId,
       sessionBudget,
       maxSteps,
+      sessionTtl,
+      maxTools,
+      maxServers,
       ...anthropicOptions
     } = options;
 
@@ -153,6 +202,9 @@ export class LoopersAnthropic extends Anthropic {
       sessionId,
       sessionBudget,
       maxSteps,
+      sessionTtl,
+      maxTools,
+      maxServers,
       baseFetch
     );
 

package/src/index.ts

@@ -1 +1,9 @@
-export { LoopersOpenAI, LoopersAnthropic, LoopersClientOptions } from './client';
+export {
+  LoopersOpenAI,
+  LoopersAnthropic,
+  LoopersGroq,
+  LoopersMistral,
+  LoopersDeepSeek,
+  LoopersTogether,
+  LoopersClientOptions,
+} from './client';

package/test/client.test.ts

@@ -1,16 +1,40 @@
 import { describe, it, expect, vi } from 'vitest';
-import { LoopersOpenAI, LoopersAnthropic } from '../src/client';
+import { LoopersOpenAI, LoopersAnthropic, LoopersGroq } from '../src/client';
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeMockFetch(responseHeaders: Record<string, string> = {}) {
+  return vi.fn().mockResolvedValue({
+    json: async () => ({ id: 'chatcmpl-123', choices: [], object: 'chat.completion' }),
+    text: async () => JSON.stringify({ id: 'chatcmpl-123', choices: [], object: 'chat.completion' }),
+    headers: new Headers(responseHeaders),
+    ok: true,
+    status: 200,
+  });
+}
+
+// ---------------------------------------------------------------------------
+// LoopersOpenAI
+// ---------------------------------------------------------------------------
 
 describe('LoopersOpenAI', () => {
-  it('should override baseURL and inject headers', async () => {
-    const mockFetch = vi.fn().mockResolvedValue({
-      json: async () => ({ id: 'chatcmpl-123' }),
-      text: async () => JSON.stringify({ id: 'chatcmpl-123' }),
-      headers: new Headers(),
-      ok: true,
-      status: 200,
+  it('should route to the correct URL', async () => {
+    const mockFetch = makeMockFetch();
+    const client = new LoopersOpenAI({
+      loopersUrl: 'http://localhost:8080',
+      loopersKey: 'lp-123',
+      fetch: mockFetch as any,
     });
+    await client.chat.completions.create({ model: 'gpt-4', messages: [{ role: 'user', content: 'hi' }] });
 
+    const [url] = mockFetch.mock.calls[0];
+    expect(url.toString()).toBe('http://localhost:8080/openai/v1/chat/completions');
+  });
+
+  it('should inject all governance headers', async () => {
+    const mockFetch = makeMockFetch();
     const client = new LoopersOpenAI({
       loopersUrl: 'http://localhost:8080',
       loopersKey: 'lp-123',
@@ -18,60 +42,70 @@ describe('LoopersOpenAI', () => {
       sessionId: 'sess-1',
       sessionBudget: 5.0,
       maxSteps: 10,
+      sessionTtl: 3600,
+      maxTools: 5,
+      maxServers: 2,
       fetch: mockFetch as any,
     });
+    await client.chat.completions.create({ model: 'gpt-4', messages: [{ role: 'user', content: 'hi' }] });
 
-    await client.chat.completions.create({
-      model: 'gpt-4',
-      messages: [{ role: 'user', content: 'hi' }],
-    });
-
-    expect(mockFetch).toHaveBeenCalledTimes(1);
-    const [url, init] = mockFetch.mock.calls[0];
-    expect(url.toString()).toBe('http://localhost:8080/openai/v1/chat/completions');
-    
+    const [, init] = mockFetch.mock.calls[0];
     const headers = new Headers(init.headers);
     expect(headers.get('Authorization')).toBe('Bearer lp-123');
     expect(headers.get('X-Loopers-Provider-Key')).toBe('sk-openai');
     expect(headers.get('X-Loopers-Session-ID')).toBe('sess-1');
     expect(headers.get('X-Loopers-Session-Budget')).toBe('5');
     expect(headers.get('X-Loopers-Session-Max-Steps')).toBe('10');
+    expect(headers.get('X-Loopers-Session-TTL')).toBe('3600');
+    expect(headers.get('X-Loopers-Session-Max-Tools')).toBe('5');
+    expect(headers.get('X-Loopers-Session-Max-Servers')).toBe('2');
   });
 
-  // BUG: The TS SDK intercepts res.json() to attach metrics, but the underlying 
-  // OpenAI SDK uses res.text() and JSON.parse() internally. This means the metrics
-  // are never attached to the returned object. Skipping this test until the SDK is redesigned.
-  it.skip('should parse loopers metrics from headers', async () => {
-
-    const mockFetch = vi.fn().mockResolvedValue({
-      json: async () => ({ id: 'chatcmpl-123' }),
-      text: async () => JSON.stringify({ id: 'chatcmpl-123' }),
-      headers: mockHeaders,
-      ok: true,
-      status: 200,
-    });
-
+  it('should NOT send optional headers when they are not set', async () => {
+    const mockFetch = makeMockFetch();
     const client = new LoopersOpenAI({
       loopersUrl: 'http://localhost:8080',
       loopersKey: 'lp-123',
       fetch: mockFetch as any,
     });
+    await client.chat.completions.create({ model: 'gpt-4', messages: [{ role: 'user', content: 'hi' }] });
 
-    const res = await client.chat.completions.create({
-      model: 'gpt-4',
-      messages: [{ role: 'user', content: 'hi' }],
-    }) as any;
+    const [, init] = mockFetch.mock.calls[0];
+    const headers = new Headers(init.headers);
+    expect(headers.get('X-Loopers-Session-Budget')).toBeNull();
+    expect(headers.get('X-Loopers-Session-Max-Steps')).toBeNull();
+    expect(headers.get('X-Loopers-Session-TTL')).toBeNull();
+    expect(headers.get('X-Loopers-Session-Max-Tools')).toBeNull();
+    expect(headers.get('X-Loopers-Session-Max-Servers')).toBeNull();
+  });
 
+  // NOTE: The TS SDK intercepts res.json() but the underlying OpenAI SDK
+  // internally uses res.text() + JSON.parse(), so metrics are not attached
+  // to the returned typed object. This is a known limitation documented as
+  // a skipped test — the raw fetch response does expose the headers correctly.
+  it.skip('should parse loopers metrics from response headers', async () => {
+    const mockFetch = vi.fn().mockResolvedValue({
+      json: async () => ({ id: 'chatcmpl-123', choices: [], object: 'chat.completion' }),
+      text: async () => JSON.stringify({ id: 'chatcmpl-123', choices: [], object: 'chat.completion' }),
+      headers: new Headers({ 'X-Loopers-Request-Cost': '0.01', 'X-Loopers-Session-Spend': '0.05' }),
+      ok: true,
+      status: 200,
+    });
+    const client = new LoopersOpenAI({ loopersUrl: 'http://localhost:8080', loopersKey: 'lp-123', fetch: mockFetch as any });
+    const res = await client.chat.completions.create({ model: 'gpt-4', messages: [{ role: 'user', content: 'hi' }] }) as any;
     expect(res.loopers_cost).toBe(0.01);
-    expect(res.loopers_session_spend).toBe(0.05);
   });
 });
 
+// ---------------------------------------------------------------------------
+// LoopersAnthropic
+// ---------------------------------------------------------------------------
+
 describe('LoopersAnthropic', () => {
-  it('should override baseURL and inject headers', async () => {
+  it('should route to the correct URL and inject governance headers', async () => {
     const mockFetch = vi.fn().mockResolvedValue({
-      json: async () => ({ id: 'msg_123', type: 'message' }),
-      text: async () => JSON.stringify({ id: 'msg_123', type: 'message' }),
+      json: async () => ({ id: 'msg_123', type: 'message', role: 'assistant', content: [], model: 'claude-3', stop_reason: 'end_turn', usage: { input_tokens: 1, output_tokens: 1 } }),
+      text: async () => JSON.stringify({ id: 'msg_123', type: 'message', role: 'assistant', content: [], model: 'claude-3', stop_reason: 'end_turn', usage: { input_tokens: 1, output_tokens: 1 } }),
       headers: new Headers(),
       ok: true,
       status: 200,
@@ -81,6 +115,12 @@ describe('LoopersAnthropic', () => {
       loopersUrl: 'http://localhost:8080',
       loopersKey: 'lp-123',
       providerKey: 'sk-ant',
+      sessionId: 'sess-ant-1',
+      sessionBudget: 10.0,
+      maxSteps: 5,
+      sessionTtl: 1800,
+      maxTools: 3,
+      maxServers: 1,
       fetch: mockFetch as any,
     });
 
@@ -90,12 +130,43 @@ describe('LoopersAnthropic', () => {
       max_tokens: 10,
     });
 
-    expect(mockFetch).toHaveBeenCalledTimes(1);
     const [url, init] = mockFetch.mock.calls[0];
     expect(url.toString()).toBe('http://localhost:8080/anthropic/v1/messages');
-    
     const headers = new Headers(init.headers);
     expect(headers.get('Authorization')).toBe('Bearer lp-123');
     expect(headers.get('X-Loopers-Provider-Key')).toBe('sk-ant');
+    expect(headers.get('X-Loopers-Session-ID')).toBe('sess-ant-1');
+    expect(headers.get('X-Loopers-Session-Budget')).toBe('10');
+    expect(headers.get('X-Loopers-Session-Max-Steps')).toBe('5');
+    expect(headers.get('X-Loopers-Session-TTL')).toBe('1800');
+    expect(headers.get('X-Loopers-Session-Max-Tools')).toBe('3');
+    expect(headers.get('X-Loopers-Session-Max-Servers')).toBe('1');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Provider subclasses
+// ---------------------------------------------------------------------------
+
+describe('LoopersGroq', () => {
+  it('should route to groq/v1 path with all new headers', async () => {
+    const mockFetch = makeMockFetch();
+    const client = new LoopersGroq({
+      loopersUrl: 'http://localhost:8080',
+      loopersKey: 'lp-123',
+      providerKey: 'gsk_123',
+      sessionTtl: 600,
+      maxTools: 10,
+      maxServers: 3,
+      fetch: mockFetch as any,
+    });
+    await client.chat.completions.create({ model: 'llama-3', messages: [{ role: 'user', content: 'hi' }] });
+
+    const [url, init] = mockFetch.mock.calls[0];
+    expect(url.toString()).toBe('http://localhost:8080/groq/v1/chat/completions');
+    const headers = new Headers(init.headers);
+    expect(headers.get('X-Loopers-Session-TTL')).toBe('600');
+    expect(headers.get('X-Loopers-Session-Max-Tools')).toBe('10');
+    expect(headers.get('X-Loopers-Session-Max-Servers')).toBe('3');
   });
 });