@pedrofariasx/qwenproxy 1.2.2 → 1.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pedrofariasx/qwenproxy",
-  "version": "1.2.2",
+  "version": "1.2.3",
   "description": "Local OpenAI-compatible proxy API that routes requests to Qwen (chat.qwen.ai) via Playwright browser automation.",
   "main": "index.js",
   "scripts": {

package/src/api/server.ts

@@ -70,10 +70,10 @@ app.notFound((c) => c.json({ error: 'Not found' }, 404))
 export async function startServer(): Promise<void> {
   await cache.connect()
 
-  const { loadAccounts } = await import('../core/accounts.ts')
+  const { loadAccounts } = await import('../core/accounts.js')
   const accounts = loadAccounts()
 
-  const { initPlaywright, initPlaywrightForAccount, getQwenHeaders } = await import('../services/playwright.ts')
+  const { initPlaywright, initPlaywrightForAccount, getQwenHeaders } = await import('../services/playwright.js')
   
   await initPlaywright(config.browser.headless)
   
@@ -87,7 +87,7 @@ export async function startServer(): Promise<void> {
       )
     )
     console.log('[Server] Pre-fetching headers for all accounts in background...')
-    const { warmAllPools } = await import('../services/qwen.ts')
+    const { warmAllPools } = await import('../services/qwen.js')
     warmAllPools(accounts.map(a => a.id)).catch(() => {})
   }
 
@@ -111,7 +111,7 @@ export async function startServer(): Promise<void> {
     await cache.close()
     const { closePlaywright } = await import('../services/playwright.js')
     await closePlaywright()
-    const { closeDatabase } = await import('../core/database.ts')
+    const { closeDatabase } = await import('../core/database.js')
     closeDatabase()
     server?.close()
     process.exit(0)

package/src/cache/memory-cache.ts

@@ -21,6 +21,7 @@ export class MemoryCache {
   private cleanupInterval: NodeJS.Timeout | null
   private maxEntries: number
   private totalBytes: number
+  private scanRegexCache: Map<string, RegExp>
 
   constructor(options?: { prefix?: string; defaultTTL?: number; maxEntries?: number }) {
     this.prefix = options?.prefix || 'qwenproxy:'
@@ -29,12 +30,14 @@ export class MemoryCache {
     this.store = new Map()
     this.totalBytes = 0
     this.cleanupInterval = null
+    this.scanRegexCache = new Map()
 
     this.startCleanup()
   }
 
   private entryByteSize(key: string, value: any): number {
-    return Buffer.byteLength(key) + Buffer.byteLength(JSON.stringify(value))
+    const valueStr = typeof value === 'string' ? value : JSON.stringify(value)
+    return Buffer.byteLength(key) + Buffer.byteLength(valueStr || '')
   }
 
   private evictLRU(): void {
@@ -63,11 +66,9 @@ export class MemoryCache {
   }
 
   async set<T>(key: CacheKey, value: T, ttl?: number): Promise<void> {
-    const serialized = JSON.stringify(value)
-    const valueBytes = Buffer.byteLength(serialized)
     const effectiveTTL = ttl || this.defaultTTL
     const fullKey = this.prefix + key
-    const entrySize = Buffer.byteLength(fullKey) + valueBytes
+    const entrySize = this.entryByteSize(fullKey, value)
     
     if (this.store.has(fullKey)) {
       const oldEntry = this.store.get(fullKey)
@@ -85,7 +86,7 @@ export class MemoryCache {
     this.totalBytes += entrySize
     
     metrics.increment('cache.set')
-    metrics.histogram('cache.value.size', valueBytes)
+    metrics.histogram('cache.value.size', entrySize)
   }
 
   async get<T>(key: CacheKey): Promise<T | null> {

package/src/core/account-manager.ts

@@ -1,4 +1,4 @@
-import { QwenAccount, loadAccounts } from './accounts.ts'
+import { QwenAccount, loadAccounts } from './accounts.js'
 import { config } from './config.js'
 
 let currentIndex = 0

package/src/core/accounts.ts

@@ -1,5 +1,5 @@
 import crypto from 'crypto'
-import { getDatabase } from './database.ts'
+import { getDatabase } from './database.js'
 import { config } from './config.js'
 
 export interface QwenAccount {

package/src/login.ts

@@ -1,5 +1,5 @@
-import { addAccount, removeAccount, listAccounts, getAccountCredentials, QwenAccount } from './core/accounts.ts'
-import { initPlaywrightForAccount, closePlaywrightForAccount, BrowserType, launchManualLoginAccount, extractAccountInfoFromContext } from './services/playwright.ts'
+import { addAccount, removeAccount, listAccounts, getAccountCredentials, QwenAccount } from './core/accounts.js'
+import { initPlaywrightForAccount, closePlaywrightForAccount, BrowserType, launchManualLoginAccount, extractAccountInfoFromContext } from './services/playwright.js'
 import * as readline from 'readline'
 import * as dotenv from 'dotenv'
 

package/src/routes/chat.ts

@@ -11,18 +11,17 @@
 import { Context } from 'hono';
 import { stream as honoStream } from 'hono/streaming';
 import crypto from 'crypto';
-import { createQwenStream, updateSessionParent } from '../services/qwen.ts';
-import { OpenAIRequest, ChoiceDelta, Message } from '../utils/types.ts';
-import { registry } from '../tools/registry.ts';
-import type { FunctionToolDefinition } from '../tools/types.ts';
-import { robustParseJSON } from '../utils/json.ts';
-import { StreamingToolParser } from '../tools/parser.ts';
-import { QwenStreamParser, ParsedChunkResult } from '../utils/qwen-stream-parser.ts';
-import { RetryableQwenStreamError } from '../services/qwen.ts';
+import { createQwenStream, updateSessionParent, RetryableQwenStreamError } from '../services/qwen.js';
+import { OpenAIRequest, ChoiceDelta, Message } from '../utils/types.js';
+import { registry } from '../tools/registry.js';
+import type { FunctionToolDefinition } from '../tools/types.js';
+import { robustParseJSON } from '../utils/json.js';
+import { StreamingToolParser } from '../tools/parser.js';
+import { QwenStreamParser, ParsedChunkResult } from '../utils/qwen-stream-parser.js';
 import { getModelContextWindow } from '../core/model-registry.js'
-import { truncateMessages, estimateTokenCount } from '../utils/context-truncation.ts';
-import { getNextAccount, getNextAvailableAccount, markAccountRateLimited, getAccountCooldownInfo } from '../core/account-manager.ts';
-import { registerStream, removeStream, getStream } from '../core/stream-registry.ts';
+import { truncateMessages, estimateTokenCount } from '../utils/context-truncation.js';
+import { getNextAccount, getNextAvailableAccount, markAccountRateLimited, getAccountCooldownInfo } from '../core/account-manager.js';
+import { registerStream, removeStream, getStream } from '../core/stream-registry.js';
 import { metrics } from '../core/metrics.js'
 
 export interface DeltaResult {
@@ -289,7 +288,7 @@ export async function chatCompletions(c: Context) {
 
     // Account selection with fallback on rate-limit/failure
     let account = getNextAccount();
-    let triedAccountIds = new Set<string>();
+    const triedAccountIds = new Set<string>();
     let lastError: any = null;
 
     let stream: ReadableStream | undefined;
@@ -395,7 +394,6 @@ export async function chatCompletions(c: Context) {
 
       const toolCallsOut: any[] = [];
       let buffer = '';
-      const hasTools = Array.isArray(bodyAny.tools) && bodyAny.tools.length > 0;
 
       const qwenParser = new QwenStreamParser(uiSessionId, {
         tools: hasTools ? bodyAny.tools : [],
@@ -524,25 +522,13 @@ export async function chatCompletions(c: Context) {
         const createdTimestamp = Math.floor(Date.now() / 1000);
 
         const fastWriteContent = (content: string) => {
-          const chunk = JSON.stringify({
-            id: completionId,
-            object: 'chat.completion.chunk',
-            created: createdTimestamp,
-            model: body.model,
-            choices: [makeChoice({ content })]
-          });
-          streamWriter.write(`data: ${chunk}\n\n`);
+          const escaped = content.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n').replace(/\r/g, '\\r').replace(/\t/g, '\\t');
+          streamWriter.write(`data: {"id":"${completionId}","object":"chat.completion.chunk","created":${createdTimestamp},"model":"${body.model}","choices":[{"index":0,"delta":{"content":"${escaped}"},"logprobs":null,"finish_reason":null}]}\n\n`);
         };
 
         const fastWriteReasoning = (content: string) => {
-          const chunk = JSON.stringify({
-            id: completionId,
-            object: 'chat.completion.chunk',
-            created: createdTimestamp,
-            model: body.model,
-            choices: [makeChoice({ reasoning_content: content })]
-          });
-          streamWriter.write(`data: ${chunk}\n\n`);
+          const escaped = content.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n').replace(/\r/g, '\\r').replace(/\t/g, '\\t');
+          streamWriter.write(`data: {"id":"${completionId}","object":"chat.completion.chunk","created":${createdTimestamp},"model":"${body.model}","choices":[{"index":0,"delta":{"reasoning_content":"${escaped}"},"logprobs":null,"finish_reason":null}]}\n\n`);
         };
 
         writeEvent({
@@ -563,7 +549,6 @@ export async function chatCompletions(c: Context) {
         let targetResponseId: string | null = null;
         let targetResponseIdSet = false;
         let currentThoughtIndex = 0;
-        const hasTools = Array.isArray(bodyAny.tools) && bodyAny.tools.length > 0;
         const toolParser = hasTools ? new StreamingToolParser(bodyAny.tools) : null;
 
         let buffer = '';

package/src/routes/upload.ts

@@ -5,7 +5,7 @@
  */
 
 import { Context } from "hono";
-import { getQwenHeaders } from "../services/playwright.ts";
+import { getQwenHeaders } from "../services/playwright.js";
 import crypto from "crypto";
 
 interface STSResponse {

package/src/services/playwright.ts

@@ -11,11 +11,27 @@
 import { chromium, firefox, webkit, BrowserContext, Page } from 'playwright';
 import path from 'path';
 import crypto from 'crypto';
-import { QwenAccount } from '../core/accounts.ts';
-import { config } from '../core/config.ts';
+import { QwenAccount } from '../core/accounts.js';
+import { config } from '../core/config.js';
 
 export type BrowserType = 'chromium' | 'firefox' | 'webkit' | 'chrome' | 'edge';
 
+interface BrowserEngineConfig {
+  engine: typeof chromium | typeof firefox | typeof webkit;
+  channel?: string;
+}
+
+function resolveBrowserEngine(browserType: BrowserType): BrowserEngineConfig {
+  switch (browserType) {
+    case 'firefox': return { engine: firefox };
+    case 'webkit': return { engine: webkit };
+    case 'chrome': return { engine: chromium, channel: 'chrome' };
+    case 'edge': return { engine: chromium, channel: 'msedge' };
+    case 'chromium':
+    default: return { engine: chromium };
+  }
+}
+
 let context: BrowserContext | null = null;
 export let activePage: Page | null = null;
 const accountContexts = new Map<string, BrowserContext>();
@@ -120,9 +136,14 @@ export async function getBasicHeaders(accountId?: string): Promise<{ cookie: str
   if (!page) throw new Error('Playwright not initialized');
   
   const cookie = await getCookies(accountId);
-  const userAgent = await page.evaluate(() => navigator.userAgent);
-  
   const cacheKey = accountId || 'global';
+  
+  let userAgent = cachedUserAgents.get(cacheKey);
+  if (!userAgent) {
+    userAgent = await page.evaluate(() => navigator.userAgent);
+    cachedUserAgents.set(cacheKey, userAgent);
+  }
+  
   const cache = getAccountHeaderCache(cacheKey);
   const bxV = cache.currentHeaders['bx-v'] || '2.5.36';
   const bxUa = cache.currentHeaders['bx-ua'];
@@ -138,34 +159,11 @@ export async function initPlaywright(headless = true, browserType: BrowserType =
   }
 
   const profilePath = path.resolve('qwen_profiles', '_default');
-  
-  let browserEngine;
-  let channel: string | undefined;
-
-  switch (browserType) {
-    case 'firefox':
-      browserEngine = firefox;
-      break;
-    case 'webkit':
-      browserEngine = webkit;
-      break;
-    case 'chrome':
-      browserEngine = chromium;
-      channel = 'chrome';
-      break;
-    case 'edge':
-      browserEngine = chromium;
-      channel = 'msedge';
-      break;
-    case 'chromium':
-    default:
-      browserEngine = chromium;
-      break;
-  }
+  const { engine, channel } = resolveBrowserEngine(browserType);
 
   console.log(`[Playwright] Launching ${browserType}...`);
 
-  context = await browserEngine.launchPersistentContext(profilePath, {
+  context = await engine.launchPersistentContext(profilePath, {
     headless,
     channel,
     userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36',
@@ -249,45 +247,8 @@ export async function closePlaywright() {
 
 export async function loginToQwen(email: string, password: string): Promise<boolean> {
   if (!activePage) throw new Error('Playwright not initialized');
-
   console.log(`[Playwright] Attempting API login for ${email}...`);
-  
-  await activePage.goto('https://chat.qwen.ai/auth', { waitUntil: 'domcontentloaded' });
-
-  const hashedPassword = crypto.createHash('sha256').update(password).digest('hex');
-
-  const result = await activePage.evaluate(async ({ email, password }) => {
-    try {
-      const response = await fetch("https://chat.qwen.ai/api/v2/auths/signin", {
-        method: "POST",
-        headers: {
-          "accept": "application/json, text/plain, */*",
-          "content-type": "application/json",
-          "source": "web",
-          "timezone": new Date().toString().split(' (')[0],
-          "x-request-id": crypto.randomUUID()
-        },
-        body: JSON.stringify({ email, password, login_type: "email" })
-      });
-      const data = await response.json();
-      return { ok: response.ok, data };
-    } catch (e: any) {
-      return { ok: false, error: e.message };
-    }
-  }, { email, password: hashedPassword });
-
-  if (result.ok) {
-    console.log('[Playwright] API login request successful.');
-    await activePage.goto('https://chat.qwen.ai/', { waitUntil: 'domcontentloaded' });
-    const isLogged = !(activePage.url().includes('auth') || activePage.url().includes('login'));
-    if (isLogged) {
-       console.log('[Playwright] Login confirmed.');
-       return true;
-    }
-  }
-
-  console.error('[Playwright] Login failed:', result.data || result.error);
-  return false;
+  return loginToQwenWithContext(activePage.context(), activePage, email, password);
 }
 
 async function loginToQwenUI(email: string, password: string): Promise<boolean> {
@@ -374,7 +335,11 @@ async function tryLightweightCookieRefresh(accountId?: string): Promise<{ header
   try {
     const cookies = await page.context().cookies();
     const cookieStr = cookies.map(c => `${c.name}=${c.value}`).join('; ');
-    const userAgent = await page.evaluate(() => navigator.userAgent);
+    let userAgent = cachedUserAgents.get(cacheKey);
+    if (!userAgent) {
+      userAgent = await page.evaluate(() => navigator.userAgent);
+      cachedUserAgents.set(cacheKey, userAgent);
+    }
 
     const now = Date.now();
     cookieCaches.set(cacheKey, { cookie: cookieStr, timestamp: now });
@@ -473,7 +438,7 @@ async function _getQwenHeadersInternal(forceNew = false, accountId?: string): Pr
         console.warn('[Playwright] Detected login page but QWEN_EMAIL/PASSWORD not provided in .env');
       }
     } else {
-      const { getAccountCredentials } = await import('../core/accounts.ts');
+      const { getAccountCredentials } = await import('../core/accounts.js');
       const creds = getAccountCredentials(accountId);
       if (creds && creds.email && creds.password) {
         console.log(`[Playwright] Detected login page for account ${creds.email}. Attempting login...`);
@@ -548,7 +513,7 @@ async function _getQwenHeadersInternal(forceNew = false, accountId?: string): Pr
       cache.lastHeadersTime = Date.now();
       cache.refreshInProgress = false;
 
-      import('./qwen.ts').then(m => m.disableNativeTools(accountId).catch(() => {}));
+      import('./qwen.js').then(m => m.disableNativeTools(accountId).catch(() => {}));
 
       await route.abort('aborted');
 
@@ -609,34 +574,11 @@ async function _getQwenHeadersInternal(forceNew = false, accountId?: string): Pr
 
 export async function initPlaywrightForAccount(account: QwenAccount, headless = true, browserType: BrowserType = 'chromium') {
   const profilePath = path.resolve('qwen_profiles', account.id);
-  
-  let browserEngine;
-  let channel: string | undefined;
-
-  switch (browserType) {
-    case 'firefox':
-      browserEngine = firefox;
-      break;
-    case 'webkit':
-      browserEngine = webkit;
-      break;
-    case 'chrome':
-      browserEngine = chromium;
-      channel = 'chrome';
-      break;
-    case 'edge':
-      browserEngine = chromium;
-      channel = 'msedge';
-      break;
-    case 'chromium':
-    default:
-      browserEngine = chromium;
-      break;
-  }
+  const { engine, channel } = resolveBrowserEngine(browserType);
 
   console.log(`[Playwright] Launching ${browserType} for account ${account.email}...`);
 
-  const acctContext = await browserEngine.launchPersistentContext(profilePath, {
+  const acctContext = await engine.launchPersistentContext(profilePath, {
     headless,
     channel,
     userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36',
@@ -666,32 +608,9 @@ export async function initPlaywrightForAccount(account: QwenAccount, headless =
 
 export async function launchManualLoginAccount(accountId: string, browserType: BrowserType = 'chromium'): Promise<{ context: BrowserContext, page: Page }> {
   const profilePath = path.resolve('qwen_profiles', accountId);
-  
-  let browserEngine;
-  let channel: string | undefined;
-
-  switch (browserType) {
-    case 'firefox':
-      browserEngine = firefox;
-      break;
-    case 'webkit':
-      browserEngine = webkit;
-      break;
-    case 'chrome':
-      browserEngine = chromium;
-      channel = 'chrome';
-      break;
-    case 'edge':
-      browserEngine = chromium;
-      channel = 'msedge';
-      break;
-    case 'chromium':
-    default:
-      browserEngine = chromium;
-      break;
-  }
+  const { engine, channel } = resolveBrowserEngine(browserType);
 
-  const acctContext = await browserEngine.launchPersistentContext(profilePath, {
+  const acctContext = await engine.launchPersistentContext(profilePath, {
     headless: false,
     channel,
     userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36',

package/src/services/qwen.ts

@@ -1,4 +1,4 @@
-import { getQwenHeaders, getBasicHeaders } from './playwright.ts';
+import { getQwenHeaders, getBasicHeaders } from './playwright.js';
 import crypto from 'crypto';
 
 const CACHED_TIMEZONE = new Date().toString().split(' (')[0];
@@ -28,8 +28,7 @@ interface SessionEntry {
   timestamp: number;
 }
 
-const sessionStates: Map<string, SessionEntry> = (globalThis as any)._sessionStates || new Map();
-(globalThis as any)._sessionStates = sessionStates;
+const sessionStates: Map<string, SessionEntry> = new Map();
 const SESSION_TTL_MS = 24 * 60 * 60 * 1000;
 
 function cleanupStaleSessions() {
@@ -65,11 +64,9 @@ interface WarmPoolEntry {
   timestamp: number;
 }
 
-const warmPool: Map<string, WarmPoolEntry[]> = (globalThis as any)._warmPool || new Map();
-(globalThis as any)._warmPool = warmPool;
+const warmPool: Map<string, WarmPoolEntry[]> = new Map();
 
-const refillPromises: Map<string, Promise<void>> = (globalThis as any)._refillPromises || new Map();
-(globalThis as any)._refillPromises = refillPromises;
+const refillPromises: Map<string, Promise<void>> = new Map();
 
 const WARM_POOL_SIZE = 5;
 const WARM_POOL_TTL_MS = 10 * 60 * 1000;
@@ -78,9 +75,8 @@ function cleanupStalePool(accountId: string) {
   const pool = warmPool.get(accountId);
   if (!pool) return;
   const now = Date.now();
-  for (let i = pool.length - 1; i >= 0; i--) {
-    if (now - pool[i].timestamp > WARM_POOL_TTL_MS) pool.splice(i, 1);
-  }
+  const filtered = pool.filter(e => now - e.timestamp <= WARM_POOL_TTL_MS);
+  if (filtered.length !== pool.length) warmPool.set(accountId, filtered);
 }
 
 async function getBasicQwenHeaders(accountId?: string): Promise<Record<string, string>> {
@@ -93,8 +89,6 @@ async function getBasicQwenHeaders(accountId?: string): Promise<Record<string, s
 }
 
 async function createRealQwenChat(header: Record<string, string>): Promise<string> {
-  const controller = new AbortController();
-  const timeoutId = setTimeout(() => controller.abort(), 30000);
   const response = await fetch('https://chat.qwen.ai/api/v2/chats/new', {
     method: 'POST',
     headers: {
@@ -116,9 +110,8 @@ async function createRealQwenChat(header: Record<string, string>): Promise<strin
       timestamp: Date.now(),
       project_id: '',
     }),
-    signal: controller.signal,
+    signal: AbortSignal.timeout(30000),
   });
-  clearTimeout(timeoutId);
 
   if (!response.ok) throw new Error(`Failed to create chat: ${response.status}`);
   const json = await response.json();

package/src/tests/concurrency.test.ts

@@ -4,7 +4,7 @@ import assert from 'node:assert';
 process.env.TEST_MOCK_PLAYWRIGHT = 'true';
 
 import { app } from '../api/server.js';
-import { initPlaywright, closePlaywright } from '../services/playwright.ts';
+import { initPlaywright, closePlaywright } from '../services/playwright.js';
 
 test('Concurrent requests are serialized by mutex', async () => {
   const originalFetch = globalThis.fetch;

package/src/tests/concurrentChat.test.ts

@@ -3,7 +3,7 @@ import assert from 'node:assert';
 import net from 'node:net';
 import { serve } from '@hono/node-server';
 import { app } from '../api/server.js';
-import { initPlaywright, closePlaywright } from '../services/playwright.ts';
+import { initPlaywright, closePlaywright } from '../services/playwright.js';
 
 function isPortAvailable(port: number): Promise<boolean> {
   return new Promise((resolve) => {

package/src/tests/contextTruncation.test.ts

@@ -0,0 +1,142 @@
+import { test } from 'node:test';
+import assert from 'node:assert';
+import { estimateTokenCount, truncateMessages } from '../utils/context-truncation.js';
+
+test('estimateTokenCount: returns 0 for empty string', () => {
+  assert.strictEqual(estimateTokenCount(''), 0);
+});
+
+test('estimateTokenCount: estimates tokens conservatively using 2.5 divisor', () => {
+  assert.strictEqual(estimateTokenCount('hello'), 2);
+  assert.strictEqual(estimateTokenCount('a'.repeat(100)), 40);
+  assert.strictEqual(estimateTokenCount('a'.repeat(250)), 100);
+  assert.strictEqual(estimateTokenCount('a'.repeat(2500)), 1000);
+});
+
+test('estimateTokenCount: handles single character', () => {
+  assert.strictEqual(estimateTokenCount('x'), 1);
+});
+
+test('estimateTokenCount: rounds up for non-multiples of 2.5', () => {
+  assert.strictEqual(estimateTokenCount('ab'), 1);
+  assert.strictEqual(estimateTokenCount('abc'), 2);
+  assert.strictEqual(estimateTokenCount('abcd'), 2);
+});
+
+test('truncateMessages: returns all messages when within context window', () => {
+  const messages = [
+    { role: 'system', content: 'You are helpful.' },
+    { role: 'user', content: 'Hello' },
+    { role: 'assistant', content: 'Hi there!' },
+  ];
+  const result = truncateMessages(messages, 100000);
+  assert.strictEqual(result.length, 3);
+  assert.strictEqual(result[0].content, 'You are helpful.');
+  assert.strictEqual(result[1].content, 'Hello');
+  assert.strictEqual(result[2].content, 'Hi there!');
+});
+
+test('truncateMessages: preserves chronological order', () => {
+  const messages = [
+    { role: 'user', content: 'first' },
+    { role: 'assistant', content: 'second' },
+    { role: 'user', content: 'third' },
+  ];
+  const result = truncateMessages(messages, 100000);
+  assert.strictEqual(result[0].role, 'user');
+  assert.strictEqual(result[0].content, 'first');
+  assert.strictEqual(result[1].role, 'assistant');
+  assert.strictEqual(result[2].role, 'user');
+  assert.strictEqual(result[2].content, 'third');
+});
+
+test('truncateMessages: drops oldest messages first when exceeding context', () => {
+  const largeContent = 'x'.repeat(5000);
+  const messages = [
+    { role: 'user', content: largeContent },
+    { role: 'assistant', content: largeContent },
+    { role: 'user', content: 'latest message' },
+  ];
+  const result = truncateMessages(messages, 2000);
+  const lastMsg = result[result.length - 1];
+  assert.ok(lastMsg.content.includes('latest message') || lastMsg.content.includes('[Truncated]'));
+});
+
+test('truncateMessages: returns system prompt as fallback when context is extremely small', () => {
+  const messages = [
+    { role: 'user', content: 'some content' },
+  ];
+  const systemPrompt = 'system instructions';
+  const result = truncateMessages(messages, 10, systemPrompt);
+  assert.strictEqual(result.length, 1);
+  assert.strictEqual(result[0].role, 'user');
+  assert.strictEqual(result[0].content, systemPrompt);
+});
+
+test('truncateMessages: handles array content in messages', () => {
+  const messages = [
+    {
+      role: 'user',
+      content: [
+        { type: 'text', text: 'hello' },
+        { type: 'image_url', image_url: { url: 'data:image/png;base64,...' } },
+      ],
+    },
+  ];
+  const result = truncateMessages(messages, 100000);
+  assert.strictEqual(result.length, 1);
+  assert.ok(result[0].content.includes('hello'));
+});
+
+test('truncateMessages: handles null content', () => {
+  const messages = [
+    { role: 'user', content: null },
+    { role: 'assistant', content: 'response' },
+  ];
+  const result = truncateMessages(messages, 100000);
+  assert.strictEqual(result.length, 2);
+  assert.strictEqual(result[0].content, '');
+  assert.strictEqual(result[1].content, 'response');
+});
+
+test('truncateMessages: handles object content', () => {
+  const messages = [
+    { role: 'user', content: { structured: 'data', value: 42 } },
+  ];
+  const result = truncateMessages(messages, 100000);
+  assert.strictEqual(result.length, 1);
+  assert.ok(result[0].content.includes('structured'));
+});
+
+test('truncateMessages: truncates partially fitting message with marker', () => {
+  const messages = [
+    { role: 'user', content: 'a'.repeat(10000) },
+  ];
+  const result = truncateMessages(messages, 1000);
+  assert.strictEqual(result.length, 1);
+  assert.ok(
+    result[0].content.includes('[Truncated]') || result[0].content.length < 10000,
+    'Should truncate or mark as truncated'
+  );
+});
+
+test('truncateMessages: accounts for system prompt in available tokens', () => {
+  const systemPrompt = 'x'.repeat(2000);
+  const messages = [
+    { role: 'user', content: 'short' },
+  ];
+  const withSystem = truncateMessages(messages, 2000, systemPrompt);
+  const withoutSystem = truncateMessages(messages, 2000);
+  assert.ok(withSystem.length <= withoutSystem.length);
+});
+
+test('truncateMessages: handles empty messages array', () => {
+  const result = truncateMessages([], 100000);
+  assert.strictEqual(result.length, 0);
+});
+
+test('truncateMessages: handles empty messages with system prompt fallback', () => {
+  const result = truncateMessages([], 5, 'fallback');
+  assert.strictEqual(result.length, 1);
+  assert.strictEqual(result[0].content, 'fallback');
+});