@sliday/tamp 0.1.1 → 0.2.1

package/README.md

@@ -1,6 +1,6 @@
 # Tamp
 
-**Token compression proxy for Claude Code.** 33.9% fewer input tokens, zero code changes. Sits between your client and the Anthropic API.
+**Token compression proxy for coding agents.** 33.9% fewer input tokens, zero code changes. Works with Claude Code, Aider, Cursor, Cline, Windsurf, and any OpenAI-compatible agent.
 
 ```
 npx @sliday/tamp
@@ -14,18 +14,28 @@ curl -fsSL https://tamp.dev/setup.sh | bash
 
 ## How It Works
 
-Tamp intercepts `POST /v1/messages` requests and compresses `tool_result` blocks before forwarding them upstream. Source code, error results, and non-JSON content pass through untouched.
+Tamp auto-detects your agent's API format and compresses tool result blocks before forwarding upstream. Source code, error results, and non-JSON content pass through untouched.
 
 ```
 Claude Code ──► Tamp (localhost:7778) ──► Anthropic API
-                  │
-                  ├─ JSON → minify whitespace
-                  ├─ Arrays → TOON columnar encoding
-                  ├─ Line-numbered → strip prefixes + minify
-                  ├─ Source code → passthrough
-                  └─ Errors → skip
+Aider/Cursor ──►          │          ──► OpenAI API
+Gemini CLI ────►          │          ──► Google AI API
+                          │
+                          ├─ JSON → minify whitespace
+                          ├─ Arrays → TOON columnar encoding
+                          ├─ Line-numbered → strip prefixes + minify
+                          ├─ Source code → passthrough
+                          └─ Errors → skip
 ```
 
+### Supported API Formats
+
+| Format | Endpoint | Agents |
+|--------|----------|--------|
+| Anthropic Messages | `POST /v1/messages` | Claude Code |
+| OpenAI Chat Completions | `POST /v1/chat/completions` | Aider, Cursor, Cline, Windsurf, OpenCode |
+| Google Gemini | `POST .../generateContent` | Gemini CLI |
+
 ### Compression Stages
 
 | Stage | What it does | When it applies |
@@ -45,24 +55,36 @@ npx @sliday/tamp
 ```
 
 ```
-  ┌─ Tamp ─────────────────────────────┐
-  │  Proxy: http://localhost:7778      │
-  │  Status: ● Ready                   │
-  │                                    │
-  │  In another terminal:              │
-  │  export ANTHROPIC_BASE_URL=http://localhost:7778
-  │  claude                            │
-  └────────────────────────────────────┘
+  ┌─ Tamp ─────────────────────────────────┐
+  │  Proxy: http://localhost:7778          │
+  │  Status: ● Ready                       │
+  │                                        │
+  │  Claude Code:                          │
+  │    ANTHROPIC_BASE_URL=http://localhost:7778
+  │                                        │
+  │  Aider / Cursor / Cline:              │
+  │    OPENAI_BASE_URL=http://localhost:7778
+  └────────────────────────────────────────┘
 ```
 
-### 2. Point Claude Code at the proxy
+### 2. Point your agent at the proxy
 
+**Claude Code:**
 ```bash
 export ANTHROPIC_BASE_URL=http://localhost:7778
 claude
 ```
 
-That's it. Use Claude Code as normal — Tamp compresses silently in the background.
+**Aider:**
+```bash
+export OPENAI_API_BASE=http://localhost:7778
+aider
+```
+
+**Cursor / Cline / Windsurf:**
+Set the API base URL to `http://localhost:7778` in your editor's settings.
+
+That's it. Use your agent as normal — Tamp compresses silently in the background.
 
 ## Configuration
 
@@ -71,7 +93,9 @@ All configuration via environment variables:
 | Variable | Default | Description |
 |----------|---------|-------------|
 | `TOONA_PORT` | `7778` | Proxy listen port |
-| `TOONA_UPSTREAM` | `https://api.anthropic.com` | Upstream API URL |
+| `TOONA_UPSTREAM` | `https://api.anthropic.com` | Default upstream API URL |
+| `TOONA_UPSTREAM_OPENAI` | `https://api.openai.com` | Upstream for OpenAI-format requests |
+| `TOONA_UPSTREAM_GEMINI` | `https://generativelanguage.googleapis.com` | Upstream for Gemini-format requests |
 | `TOONA_STAGES` | `minify` | Comma-separated compression stages |
 | `TOONA_MIN_SIZE` | `200` | Minimum content size (chars) to attempt compression |
 | `TOONA_LOG` | `true` | Enable request logging to stderr |
@@ -136,7 +160,8 @@ Tamp only compresses the **last user message** in each request (the most recent
 ```
 bin/tamp.js          CLI entry point
 index.js             HTTP proxy server
-compress.js          Compression pipeline (compressMessages, compressText)
+providers.js         API format adapters (Anthropic, OpenAI, Gemini) + auto-detection
+compress.js          Compression pipeline (compressRequest, compressText)
 detect.js            Content classification (classifyContent, tryParseJSON, stripLineNumbers)
 config.js            Environment-based configuration
 stats.js             Session statistics and request logging
@@ -145,11 +170,12 @@ setup.sh             One-line installer script
 
 ### How the proxy works
 
-1. Non-`/v1/messages` requests are piped through unmodified
-2. `POST /v1/messages` bodies are buffered and parsed as JSON
-3. The last user message's `tool_result` blocks are classified and compressed
-4. The modified body is forwarded upstream with updated `Content-Length`
-5. The upstream response is streamed back to the client unmodified
+1. `detectProvider()` auto-detects the API format from the request path
+2. Unrecognized requests are piped through unmodified
+3. Matched requests are buffered, parsed, and tool results are extracted via the provider adapter
+4. Extracted blocks are classified and compressed
+5. The modified body is forwarded to the correct upstream with updated `Content-Length`
+6. The upstream response is streamed back to the client unmodified
 
 Bodies exceeding `TOONA_MAX_BODY` are piped through without buffering.
 
@@ -183,7 +209,8 @@ node --test test/compress.test.js
 ### Test files
 
 ```
-test/compress.test.js    Compression pipeline tests
+test/compress.test.js    Compression pipeline tests (Anthropic + OpenAI formats)
+test/providers.test.js   Provider adapter + auto-detection tests
 test/detect.test.js      Content classification tests
 test/config.test.js      Configuration loading tests
 test/proxy.test.js       HTTP proxy integration tests

package/bin/tamp.js

@@ -4,17 +4,23 @@ import { createProxy } from '../index.js'
 const { config, server } = createProxy()
 
 server.listen(config.port, () => {
+  const url = `http://localhost:${config.port}`
   console.error('')
-  console.error('  ┌─ Tamp ─────────────────────────────┐')
-  console.error(`  │  Proxy: http://localhost:${config.port}      │`)
-  console.error('  │  Status: ● Ready                   │')
-  console.error('  │                                    │')
-  console.error('  │  In another terminal:              │')
-  console.error(`  │  export ANTHROPIC_BASE_URL=http://localhost:${config.port}`)
-  console.error('  │  claude                            │')
-  console.error('  └────────────────────────────────────┘')
+  console.error('  ┌─ Tamp ─────────────────────────────────┐')
+  console.error(`  │  Proxy: ${url}              │`)
+  console.error('  │  Status: ● Ready                       │')
+  console.error('  │                                        │')
+  console.error('  │  Claude Code:                          │')
+  console.error(`  │    ANTHROPIC_BASE_URL=${url}  │`)
+  console.error('  │                                        │')
+  console.error('  │  Aider / Cursor / Cline:               │')
+  console.error(`  │    OPENAI_BASE_URL=${url}     │`)
+  console.error('  └────────────────────────────────────────┘')
   console.error('')
-  console.error(`  Upstream: ${config.upstream}`)
+  console.error(`  Upstreams:`)
+  console.error(`    anthropic → ${config.upstreams.anthropic}`)
+  console.error(`    openai    → ${config.upstreams.openai}`)
+  console.error(`    gemini    → ${config.upstreams.gemini}`)
   console.error(`  Stages: ${config.stages.join(', ')}`)
   console.error('')
 })

package/compress.js

@@ -1,6 +1,7 @@
 import { encode } from '@toon-format/toon'
 import { countTokens } from '@anthropic-ai/tokenizer'
 import { tryParseJSON, classifyContent, stripLineNumbers } from './detect.js'
+import { anthropic } from './providers.js'
 
 export function compressText(text, config) {
   if (text.length < config.minSize) return null
@@ -62,54 +63,22 @@ async function compressBlock(text, config) {
   return sync
 }
 
-export async function compressMessages(body, config) {
+export async function compressRequest(body, config, provider) {
+  const targets = provider.extract(body)
   const stats = []
-  if (!body?.messages?.length) return { body, stats }
-
-  let lastUserIdx = -1
-  for (let i = body.messages.length - 1; i >= 0; i--) {
-    if (body.messages[i].role === 'user') { lastUserIdx = i; break }
-  }
-  if (lastUserIdx === -1) return { body, stats }
-
-  const msg = body.messages[lastUserIdx]
-  const debug = config.log
-
-  if (typeof msg.content === 'string') {
-    const result = await compressBlock(msg.content, config)
+  for (const target of targets) {
+    if (target.skip) { stats.push({ index: target.index, skipped: target.skip }); continue }
+    const result = await compressBlock(target.text, config)
     if (result) {
-      msg.content = result.text
-      stats.push({ index: lastUserIdx, ...result })
-    }
-  } else if (Array.isArray(msg.content)) {
-    for (let i = 0; i < msg.content.length; i++) {
-      const block = msg.content[i]
-      if (block.type !== 'tool_result') continue
-      if (block.is_error) { stats.push({ index: i, skipped: 'error' }); continue }
-
-      if (typeof block.content === 'string') {
-        if (debug) {
-          const cls = classifyContent(block.content)
-          const len = block.content.length
-          console.error(`[toona] debug block[${i}]: type=${cls} len=${len} tool_use_id=${block.tool_use_id || '?'}`)
-        }
-        const result = await compressBlock(block.content, config)
-        if (result) { block.content = result.text; stats.push({ index: i, ...result }) }
-      } else if (Array.isArray(block.content)) {
-        for (const sub of block.content) {
-          if (sub.type === 'text') {
-            if (debug) {
-              const cls = classifyContent(sub.text)
-              const len = sub.text.length
-              console.error(`[toona] debug sub-block: type=${cls} len=${len}`)
-            }
-            const result = await compressBlock(sub.text, config)
-            if (result) { sub.text = result.text; stats.push({ index: i, ...result }) }
-          }
-        }
-      }
+      target.compressed = result.text
+      stats.push({ index: target.index, ...result })
     }
   }
-
+  provider.apply(body, targets)
   return { body, stats }
 }
+
+export async function compressMessages(body, config) {
+  if (!body?.messages?.length) return { body, stats: [] }
+  return compressRequest(body, config, anthropic)
+}

package/config.js

@@ -3,6 +3,11 @@ export function loadConfig(env = process.env) {
   return Object.freeze({
     port: parseInt(env.TOONA_PORT, 10) || 7778,
     upstream: env.TOONA_UPSTREAM || 'https://api.anthropic.com',
+    upstreams: Object.freeze({
+      anthropic: env.TOONA_UPSTREAM || 'https://api.anthropic.com',
+      openai: env.TOONA_UPSTREAM_OPENAI || 'https://api.openai.com',
+      gemini: env.TOONA_UPSTREAM_GEMINI || 'https://generativelanguage.googleapis.com',
+    }),
     minSize: parseInt(env.TOONA_MIN_SIZE, 10) || 200,
     stages,
     log: env.TOONA_LOG !== 'false',

package/index.js

@@ -1,11 +1,16 @@
 import http from 'node:http'
 import https from 'node:https'
 import { loadConfig } from './config.js'
-import { compressMessages } from './compress.js'
+import { compressRequest } from './compress.js'
+import { detectProvider } from './providers.js'
 import { createSession, formatRequestLog } from './stats.js'
 
 export function createProxy(overrides = {}) {
-  const config = { ...loadConfig(), ...overrides }
+  const base = loadConfig()
+  const config = { ...base, ...overrides }
+  if (overrides.upstream && !overrides.upstreams) {
+    config.upstreams = { anthropic: overrides.upstream, openai: overrides.upstream, gemini: overrides.upstream }
+  }
   const session = createSession()
   return { config, session, server: _createServer(config, session) }
 }
@@ -81,13 +86,17 @@ function pipeRequest(req, res, upstreamUrl, prefixChunks) {
 
 return http.createServer(async (req, res) => {
   if (config.log) console.error(`[tamp] ${req.method} ${req.url}`)
-  const upstreamUrl = new URL(req.url, config.upstream)
-  const isMessages = req.method === 'POST' && req.url.startsWith('/v1/messages')
+  const provider = detectProvider(req.method, req.url)
 
-  if (!isMessages) {
+  if (!provider) {
+    const upstreamUrl = new URL(req.url, config.upstream)
     return pipeRequest(req, res, upstreamUrl)
   }
 
+  const upstream = config.upstreams?.[provider.name] || config.upstream
+  const reqUrl = provider.normalizeUrl ? provider.normalizeUrl(req.url) : req.url
+  const upstreamUrl = new URL(reqUrl, upstream)
+
   const chunks = []
   let size = 0
   let overflow = false
@@ -113,12 +122,12 @@ return http.createServer(async (req, res) => {
 
   try {
     const parsed = JSON.parse(rawBody.toString('utf-8'))
-    const { body, stats } = await compressMessages(parsed, config)
+    const { body, stats } = await compressRequest(parsed, config, provider)
     finalBody = Buffer.from(JSON.stringify(body), 'utf-8')
 
     if (config.log && stats.length) {
       session.record(stats)
-      console.error(formatRequestLog(stats, session))
+      console.error(formatRequestLog(stats, session, provider.name, req.url))
     }
   } catch (err) {
     if (config.log) console.error(`[tamp] passthrough (parse error): ${err.message}`)

package/package.json

@@ -6,10 +6,11 @@
     "compress.js",
     "config.js",
     "detect.js",
+    "providers.js",
     "stats.js"
   ],
-  "version": "0.1.1",
-  "description": "Token compression proxy for Claude Code. 50% fewer tokens, zero behavior change.",
+  "version": "0.2.1",
+  "description": "Token compression proxy for coding agents. Works with Claude Code, Aider, Cursor, Cline, Windsurf. 33.9% fewer input tokens.",
   "type": "module",
   "main": "index.js",
   "bin": {

package/providers.js

@@ -0,0 +1,151 @@
+const anthropic = {
+  name: 'anthropic',
+  match(method, url) {
+    return method === 'POST' && url.startsWith('/v1/messages')
+  },
+  extract(body) {
+    const targets = []
+    if (!body?.messages?.length) return targets
+
+    let lastUserIdx = -1
+    for (let i = body.messages.length - 1; i >= 0; i--) {
+      if (body.messages[i].role === 'user') { lastUserIdx = i; break }
+    }
+    if (lastUserIdx === -1) return targets
+
+    const msg = body.messages[lastUserIdx]
+
+    if (typeof msg.content === 'string') {
+      targets.push({ path: ['messages', lastUserIdx, 'content'], text: msg.content })
+    } else if (Array.isArray(msg.content)) {
+      for (let i = 0; i < msg.content.length; i++) {
+        const block = msg.content[i]
+        if (block.type !== 'tool_result') continue
+        if (block.is_error) { targets.push({ skip: 'error', index: i }); continue }
+
+        if (typeof block.content === 'string') {
+          targets.push({ path: ['messages', lastUserIdx, 'content', i, 'content'], text: block.content, index: i })
+        } else if (Array.isArray(block.content)) {
+          for (let j = 0; j < block.content.length; j++) {
+            const sub = block.content[j]
+            if (sub.type === 'text') {
+              targets.push({ path: ['messages', lastUserIdx, 'content', i, 'content', j, 'text'], text: sub.text, index: i })
+            }
+          }
+        }
+      }
+    }
+    return targets
+  },
+  apply(body, targets) {
+    for (const t of targets) {
+      if (t.skip || !t.compressed) continue
+      let obj = body
+      const path = t.path
+      for (let i = 0; i < path.length - 1; i++) obj = obj[path[i]]
+      obj[path[path.length - 1]] = t.compressed
+    }
+  },
+}
+
+const openai = {
+  name: 'openai',
+  match(method, url) {
+    return method === 'POST' && (url.startsWith('/v1/chat/completions') || url.startsWith('/chat/completions'))
+  },
+  normalizeUrl(url) {
+    if (url.startsWith('/chat/completions')) return '/v1' + url
+    return url
+  },
+  extract(body) {
+    const targets = []
+    if (!body?.messages?.length) return targets
+
+    // Find last assistant message with tool_calls
+    let lastAssistantIdx = -1
+    for (let i = body.messages.length - 1; i >= 0; i--) {
+      if (body.messages[i].role === 'assistant' && body.messages[i].tool_calls?.length) {
+        lastAssistantIdx = i
+        break
+      }
+    }
+    if (lastAssistantIdx === -1) return targets
+
+    // Collect all subsequent role:tool messages
+    for (let i = lastAssistantIdx + 1; i < body.messages.length; i++) {
+      const msg = body.messages[i]
+      if (msg.role !== 'tool') break
+      if (typeof msg.content === 'string') {
+        targets.push({ path: ['messages', i, 'content'], text: msg.content, index: i })
+      }
+    }
+    return targets
+  },
+  apply(body, targets) {
+    for (const t of targets) {
+      if (t.skip || !t.compressed) continue
+      let obj = body
+      const path = t.path
+      for (let i = 0; i < path.length - 1; i++) obj = obj[path[i]]
+      obj[path[path.length - 1]] = t.compressed
+    }
+  },
+}
+
+const gemini = {
+  name: 'gemini',
+  match(method, url) {
+    return method === 'POST' && url.includes('generateContent')
+  },
+  extract(body) {
+    const targets = []
+    if (!body?.contents?.length) return targets
+
+    // Find last content with functionResponse parts
+    for (let ci = body.contents.length - 1; ci >= 0; ci--) {
+      const content = body.contents[ci]
+      if (!content.parts?.length) continue
+      for (let pi = 0; pi < content.parts.length; pi++) {
+        const part = content.parts[pi]
+        if (!part.functionResponse?.response) continue
+        const resp = part.functionResponse.response
+        const text = typeof resp === 'string' ? resp : JSON.stringify(resp, null, 2)
+        targets.push({
+          path: ['contents', ci, 'parts', pi, 'functionResponse', 'response'],
+          text,
+          index: pi,
+          wasObject: typeof resp !== 'string',
+        })
+      }
+      if (targets.length) break
+    }
+    return targets
+  },
+  apply(body, targets) {
+    for (const t of targets) {
+      if (t.skip || !t.compressed) continue
+      let obj = body
+      const path = t.path
+      for (let i = 0; i < path.length - 1; i++) obj = obj[path[i]]
+      // If original was object, try to parse compressed back to object
+      if (t.wasObject) {
+        try {
+          obj[path[path.length - 1]] = JSON.parse(t.compressed)
+          continue
+        } catch { /* fall through to string */ }
+      }
+      obj[path[path.length - 1]] = t.compressed
+    }
+  },
+}
+
+const providers = [anthropic, openai, gemini]
+
+export function detectProvider(method, url) {
+  for (const p of providers) {
+    if (p.match(method, url)) return p
+  }
+  return null
+}
+
+export { anthropic, openai, gemini }

package/stats.js

@@ -1,7 +1,9 @@
-export function formatRequestLog(stats, session) {
+export function formatRequestLog(stats, session, providerName, url) {
   const compressed = stats.filter(s => s.method)
   const skipped = stats.filter(s => s.skipped)
-  const lines = [`[toona] POST /v1/messages — ${stats.length} blocks, ${compressed.length} compressed`]
+  const label = providerName || 'anthropic'
+  const path = url || '/v1/messages'
+  const lines = [`[toona] ${label} ${path} — ${stats.length} blocks, ${compressed.length} compressed`]
 
   for (const s of stats) {
     if (s.skipped) {