@pedrofariasx/qwenproxy 1.2.1 → 1.2.2

package/README.md

@@ -39,7 +39,7 @@ graph TD
     Playwright --> Browser2[Browser - Conta 2]
     Playwright --> BrowserN[Browser - Conta N]
     Handler --> QwenAPI[chat.qwen.ai]
-    Handler --> Tools[Tool Executor]
+    Handler --> Tools[Tool Parser]
 
     subgraph "Persistência"
         Accounts
@@ -233,24 +233,14 @@ qwenproxy/
 │   │   ├── model-registry.ts    # Registro de modelos e context windows
 │   │   ├── stream-registry.ts   # Tracking de streams ativos
 │   │   └── watchdog.ts          # Health monitoring
-│   ├── linter/
-│   │   ├── bar.ts               # Facade
-│   │   ├── extraction-engine.ts # Extraction engine
-│   │   ├── foo.ts               # Exports
-│   │   ├── index.ts             # Main public API
-│   │   ├── repair-normalize.ts  # Repair and normalize
-│   │   ├── safety-gate.ts       # Safety gate
-│   │   ├── streaming-state-machine.ts # Streaming state machine
-│   │   ├── structural-parser.ts # Structural parser
-│   │   └── types.ts             # Types
 │   ├── routes/
-│   │   └── chat.ts              # Handler /v1/chat/completions
+│   │   ├── chat.ts              # Handler /v1/chat/completions
+│   │   └── upload.ts            # Handler /v1/upload (multimodal)
 │   ├── services/
 │   │   ├── playwright.ts        # Automação de navegador
 │   │   └── qwen.ts              # Integração com API do Qwen
 │   ├── tests/                   # Testes automatizados
 │   ├── tools/
-│   │   ├── executor.ts          # Execução de ferramentas
 │   │   ├── parser.ts            # Parser de <tool_call> tags
 │   │   ├── registry.ts          # Registro de tools
 │   │   ├── schema.ts            # Validação JSON Schema

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pedrofariasx/qwenproxy",
-  "version": "1.2.1",
+  "version": "1.2.2",
   "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

@@ -111,8 +111,6 @@ export async function startServer(): Promise<void> {
     await cache.close()
     const { closePlaywright } = await import('../services/playwright.js')
     await closePlaywright()
-    const { cleanupAllAccountMutexes } = await import('../routes/chat.js')
-    cleanupAllAccountMutexes()
     const { closeDatabase } = await import('../core/database.ts')
     closeDatabase()
     server?.close()

package/src/cache/memory-cache.ts

@@ -64,9 +64,10 @@ 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 = this.entryByteSize(fullKey, value)
+    const entrySize = Buffer.byteLength(fullKey) + valueBytes
     
     if (this.store.has(fullKey)) {
       const oldEntry = this.store.get(fullKey)
@@ -84,7 +85,7 @@ export class MemoryCache {
     this.totalBytes += entrySize
     
     metrics.increment('cache.set')
-    metrics.histogram('cache.value.size', Buffer.byteLength(serialized))
+    metrics.histogram('cache.value.size', valueBytes)
   }
 
   async get<T>(key: CacheKey): Promise<T | null> {

package/src/routes/chat.ts

@@ -10,7 +10,7 @@
 
 import { Context } from 'hono';
 import { stream as honoStream } from 'hono/streaming';
-import { v4 as uuidv4 } from 'uuid';
+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';
@@ -25,33 +25,71 @@ import { getNextAccount, getNextAvailableAccount, markAccountRateLimited, getAcc
 import { registerStream, removeStream, getStream } from '../core/stream-registry.ts';
 import { metrics } from '../core/metrics.js'
 
-export function cleanupAllAccountMutexes(): void {
-  // No-op - kept for backward compatibility
-}
-
 export interface DeltaResult {
   delta: string;
   matchedContent: string;
+  contentLength: number;
+  contentSuffix: string;
 }
 
-export function getIncrementalDelta(oldStr: string, newStr: string): DeltaResult {
+export function getIncrementalDelta(oldStr: string, newStr: string, prevLength: number = 0, prevSuffix: string = ''): DeltaResult {
   if (!oldStr) {
-    return { delta: newStr, matchedContent: newStr };
+    return { 
+      delta: newStr, 
+      matchedContent: newStr,
+      contentLength: newStr.length,
+      contentSuffix: newStr.slice(-64)
+    };
   }
   if (newStr === oldStr) {
-    return { delta: '', matchedContent: oldStr };
+    return { delta: '', matchedContent: oldStr, contentLength: prevLength, contentSuffix: prevSuffix };
+  }
+
+  // Ultra-fast path: use length tracking to avoid O(n) startsWith on large strings
+  if (newStr.length > prevLength && prevLength > 0) {
+    const delta = newStr.slice(prevLength);
+    const checkLen = Math.min(64, prevLength);
+    const expectedSuffix = prevSuffix.slice(-checkLen);
+    const actualSuffix = newStr.slice(prevLength - checkLen, prevLength);
+    
+    if (expectedSuffix === actualSuffix) {
+      if (delta.length <= 4 && oldStr.length > 2000) {
+        return { 
+          delta: newStr, 
+          matchedContent: oldStr + newStr,
+          contentLength: newStr.length,
+          contentSuffix: newStr.slice(-64)
+        };
+      }
+      return { 
+        delta, 
+        matchedContent: newStr,
+        contentLength: newStr.length,
+        contentSuffix: newStr.slice(-64)
+      };
+    }
   }
 
-  // Fast path: incremental SSE streams append to oldStr most of the time
+  // Fallback: startsWith check for edge cases
   if (newStr.startsWith(oldStr)) {
     const delta = newStr.slice(oldStr.length);
     if (delta.length <= 4 && oldStr.length > 2000) {
-      return { delta: newStr, matchedContent: oldStr + newStr };
+      return { 
+        delta: newStr, 
+        matchedContent: oldStr + newStr,
+        contentLength: newStr.length,
+        contentSuffix: newStr.slice(-64)
+      };
     }
-    return { delta, matchedContent: newStr };
+    return { 
+      delta, 
+      matchedContent: newStr,
+      contentLength: newStr.length,
+      contentSuffix: newStr.slice(-64)
+    };
   }
 
-  // Fallback: segment-based prefix matching
+  // Segment-based prefix matching (rare path)
   const scanWindow = Math.min(2000, oldStr.length);
   const maxLen = Math.min(scanWindow, newStr.length);
 
@@ -65,17 +103,27 @@ export function getIncrementalDelta(oldStr: string, newStr: string): DeltaResult
     commonPrefixLen += segmentLen;
   }
 
-  // Fine-grained scan within the mismatching segment
   while (commonPrefixLen < maxLen && oldStr[commonPrefixLen] === newStr[commonPrefixLen]) {
     commonPrefixLen++;
   }
 
   const threshold = Math.min(scanWindow, 4);
   if (commonPrefixLen >= threshold) {
-    return { delta: newStr.substring(commonPrefixLen), matchedContent: newStr };
+    return { 
+      delta: newStr.substring(commonPrefixLen), 
+      matchedContent: newStr,
+      contentLength: newStr.length,
+      contentSuffix: newStr.slice(-64)
+    };
   }
 
-  return { delta: newStr, matchedContent: oldStr + newStr };
+  const combined = oldStr + newStr;
+  return { 
+    delta: newStr, 
+    matchedContent: combined,
+    contentLength: combined.length,
+    contentSuffix: combined.slice(-64)
+  };
 }
 
 function parseQwenErrorPayload(raw: string): { message: string; status: number } | null {
@@ -119,29 +167,26 @@ export async function chatCompletions(c: Context) {
       const msg = messages[i];
       let contentStr = '';
       if (Array.isArray(msg.content)) {
-        // Handle multimodal content (text + images + videos + audio + files)
-        const multimodalParts = msg.content.filter(
-          (p: any) =>
+        // Single-pass: extract text and multimodal parts in one iteration
+        const textParts: string[] = [];
+        const multimodalParts: Array<{ type: string; text?: string; image_url?: { url: string }; video_url?: { url: string }; audio_url?: { url: string }; file_url?: { url: string } }> = [];
+        
+        for (const p of msg.content as any[]) {
+          if (p.type === "text" && p.text) {
+            textParts.push(p.text);
+          } else if (
             (p.type === "image_url" && p.image_url?.url) ||
             (p.type === "video_url" && p.video_url?.url) ||
             (p.type === "audio_url" && p.audio_url?.url) ||
-            (p.type === "file_url" && p.file_url?.url),
-        );
-
+            (p.type === "file_url" && p.file_url?.url)
+          ) {
+            multimodalParts.push(p);
+          }
+        }
+        
+        contentStr = textParts.join("\n");
         if (multimodalParts.length > 0) {
-          // Defer processing to after account selection to reuse cached headers
           pendingMultimodal.push(multimodalParts);
-          // Extract text parts for prompt building
-          contentStr = msg.content
-            .filter((p: any) => p.type === "text")
-            .map((p: any) => p.text)
-            .join("\n");
-        } else {
-          // No multimodal parts, just extract text
-          contentStr = msg.content
-            .filter((p: any) => p.type === "text")
-            .map((p: any) => p.text)
-            .join("\n");
         }
       } else if (typeof msg.content === 'object' && msg.content !== null) {
         contentStr = JSON.stringify(msg.content);
@@ -249,7 +294,7 @@ export async function chatCompletions(c: Context) {
 
     let stream: ReadableStream | undefined;
     let uiSessionId = '';
-    const completionId = 'chatcmpl-' + uuidv4();
+    const completionId = 'chatcmpl-' + crypto.randomUUID();
 
     while (account) {
       const accountId = account.id;
@@ -476,10 +521,30 @@ export async function chatCompletions(c: Context) {
           finish_reason: finishReason
         });
 
-        // Pre-compute timestamp once before the stream loop
         const createdTimestamp = Math.floor(Date.now() / 1000);
 
-        // Send initial chunk
+        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 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`);
+        };
+
         writeEvent({
           id: completionId,
           object: 'chat.completion.chunk',
@@ -493,6 +558,8 @@ export async function chatCompletions(c: Context) {
 
         let reasoningBuffer = '';
         let lastFullContent = '';
+        let contentLength = 0;
+        let contentSuffix = '';
         let targetResponseId: string | null = null;
         let targetResponseIdSet = false;
         let currentThoughtIndex = 0;
@@ -500,27 +567,27 @@ export async function chatCompletions(c: Context) {
         const toolParser = hasTools ? new StreamingToolParser(bodyAny.tools) : null;
 
         let buffer = '';
+        let bufferOffset = 0;
         let completionTokens = 0;
         let promptTokens = Math.ceil(finalPrompt.length / 3.5);
 
-        // Real-time flush: send each event immediately to minimize latency
-        let chunkCount = 0;
         while (true) {
           const { done, value } = await reader.read();
           if (done) break;
 
           buffer += decoder.decode(value, { stream: true });
 
-           let startIdx = 0;
-           let newlineIdx: number;
-           while ((newlineIdx = buffer.indexOf('\n', startIdx)) !== -1) {
-             const line = buffer.slice(startIdx, newlineIdx);
-             startIdx = newlineIdx + 1;
+          while (bufferOffset < buffer.length) {
+            const newlineIdx = buffer.indexOf('\n', bufferOffset);
+            if (newlineIdx === -1) break;
+            
+            const line = buffer.slice(bufferOffset, newlineIdx);
+            bufferOffset = newlineIdx + 1;
 
-             const trimmed = line.trim();
-             if (!trimmed || !trimmed.startsWith('data: ')) continue;
+            const trimmed = line.trim();
+            if (!trimmed || !trimmed.startsWith('data: ')) continue;
 
-             const dataStr = trimmed.slice(6);
+            const dataStr = trimmed.slice(6);
              if (dataStr === '[DONE]') {
                streamWriter.write('data: [DONE]\n\n');
                continue;
@@ -569,10 +636,12 @@ export async function chatCompletions(c: Context) {
                   isThinkingChunk = false;
                   if (delta.content !== undefined) {
                     const newContent = delta.content || '';
-                    const result = getIncrementalDelta(lastFullContent, newContent);
+                    const result = getIncrementalDelta(lastFullContent, newContent, contentLength, contentSuffix);
                     vStr = result.delta;
                     if (vStr) {
                       lastFullContent = result.matchedContent;
+                      contentLength = result.contentLength;
+                      contentSuffix = result.contentSuffix;
                       foundStr = true;
                     }
                   }
@@ -584,24 +653,12 @@ export async function chatCompletions(c: Context) {
 
                 if (isThinkingChunk) {
                   reasoningBuffer += vStr;
-                  streamWriter.write(`data: ${JSON.stringify({
-                    id: completionId,
-                    object: 'chat.completion.chunk',
-                    created: createdTimestamp,
-                    model: body.model,
-                    choices: [makeChoice({ reasoning_content: vStr })]
-                  })}\n\n`);
+                  fastWriteReasoning(vStr);
                 } else {
                   if (hasTools && toolParser) {
                     const { text, toolCalls } = toolParser.feed(vStr);
                     if (text) {
-                      streamWriter.write(`data: ${JSON.stringify({
-                        id: completionId,
-                        object: 'chat.completion.chunk',
-                        created: createdTimestamp,
-                        model: body.model,
-                        choices: [makeChoice({ content: text })]
-                      })}\n\n`);
+                      fastWriteContent(text);
                     }
                     for (const tc of toolCalls) {
                       streamWriter.write(`data: ${JSON.stringify({
@@ -624,13 +681,7 @@ export async function chatCompletions(c: Context) {
                     }
                   } else {
                     if (vStr) {
-                      streamWriter.write(`data: ${JSON.stringify({
-                        id: completionId,
-                        object: 'chat.completion.chunk',
-                        created: createdTimestamp,
-                        model: body.model,
-                        choices: [makeChoice({ content: vStr })]
-                      })}\n\n`);
+                      fastWriteContent(vStr);
                     }
                   }
                 }
@@ -640,16 +691,11 @@ export async function chatCompletions(c: Context) {
             }
           }
 
-          // Trim processed portion from buffer
-          if (startIdx > 0) {
-            buffer = buffer.slice(startIdx);
+          if (bufferOffset > 0) {
+            buffer = buffer.slice(bufferOffset);
+            bufferOffset = 0;
           }
 
-          // Periodic yielding to prevent event loop starvation
-          chunkCount++;
-          if (chunkCount % 100 === 0) {
-            await new Promise(r => setTimeout(r, 0));
-          }
         }
 
         const upstreamError = parseQwenErrorPayload(buffer);
@@ -782,7 +828,7 @@ export async function chatCompletionsStop(c: Context) {
         'Sec-Fetch-Mode': 'cors',
         'Sec-Fetch-Site': 'same-origin',
         'User-Agent': stream.headers['user-agent'],
-        'X-Request-Id': uuidv4(),
+        'X-Request-Id': crypto.randomUUID(),
         'bx-ua': stream.headers['bx-ua'],
         'bx-umidtoken': stream.headers['bx-umidtoken'],
         'bx-v': stream.headers['bx-v'],

package/src/routes/upload.ts

@@ -6,7 +6,7 @@
 
 import { Context } from "hono";
 import { getQwenHeaders } from "../services/playwright.ts";
-import { v4 as uuidv4 } from "uuid";
+import crypto from "crypto";
 
 interface STSResponse {
   success: boolean;
@@ -46,7 +46,7 @@ async function getSTSToken(
           Origin: "https://chat.qwen.ai",
           Referer: "https://chat.qwen.ai/",
           "User-Agent": headers["user-agent"],
-          "X-Request-Id": uuidv4(),
+          "X-Request-Id": crypto.randomUUID(),
           "bx-ua": headers["bx-ua"],
           "bx-umidtoken": headers["bx-umidtoken"],
           "bx-v": headers["bx-v"],
@@ -723,11 +723,11 @@ export async function processImagesForQwen(
           greenNet: "success",
           size: fileSize,
           error: "",
-          itemId: uuidv4(),
+          itemId: crypto.randomUUID(),
           file_type: typeInfo.mime,
           showType: typeInfo.showType,
           file_class: typeInfo.fileClass,
-          uploadTaskId: uuidv4(),
+          uploadTaskId: crypto.randomUUID(),
         });
       }
     }

package/src/services/playwright.ts

@@ -29,6 +29,7 @@ interface AccountHeaderCache {
 }
 
 const accountHeaderCaches = new Map<string, AccountHeaderCache>();
+const cachedUserAgents = new Map<string, string>();
 
 function getAccountHeaderCache(accountId: string): AccountHeaderCache {
   let cache = accountHeaderCaches.get(accountId);

package/src/services/qwen.ts

@@ -1,5 +1,7 @@
 import { getQwenHeaders, getBasicHeaders } from './playwright.ts';
-import { v4 as uuidv4 } from 'uuid';
+import crypto from 'crypto';
+
+const CACHED_TIMEZONE = new Date().toString().split(' (')[0];
 
 export class RetryableQwenStreamError extends Error {
   readonly retryAfterMs: number;
@@ -82,7 +84,6 @@ function cleanupStalePool(accountId: string) {
 }
 
 async function getBasicQwenHeaders(accountId?: string): Promise<Record<string, string>> {
-  const { getBasicHeaders } = await import('./playwright.ts');
   const { cookie, userAgent, bxV } = await getBasicHeaders(accountId);
   return {
     cookie,
@@ -104,7 +105,7 @@ async function createRealQwenChat(header: Record<string, string>): Promise<strin
       origin: 'https://chat.qwen.ai',
       referer: 'https://chat.qwen.ai/c/new-chat',
       'user-agent': header['user-agent'],
-      'x-request-id': uuidv4(),
+      'x-request-id': crypto.randomUUID(),
       'bx-v': header['bx-v'],
     },
     body: JSON.stringify({
@@ -131,18 +132,26 @@ async function refillPoolForAccount(accountId: string) {
   if (!pool) { pool = []; warmPool.set(accountId, pool); }
   cleanupStalePool(accountId);
   const need = Math.max(0, WARM_POOL_SIZE - pool.length);
-  
+  if (need === 0) return;
+
+  let headers: Record<string, string>;
+  try {
+    headers = await getBasicQwenHeaders(accountId === 'global' ? undefined : accountId);
+  } catch (err) {
+    console.error(`[WarmPool] header fetch failed for ${accountId}:`, (err as Error).message);
+    return;
+  }
+
   const creationPromises = Array.from({ length: need }, async () => {
     try {
-      const headers = await getBasicQwenHeaders(accountId === 'global' ? undefined : accountId);
       const chatId = await createRealQwenChat(headers);
       return { chatId, headers, accountId, timestamp: Date.now() };
     } catch (err) {
-      console.error(`[WarmPool] refill failed for ${accountId}:`, (err as Error).message);
+      console.error(`[WarmPool] chat creation failed for ${accountId}:`, (err as Error).message);
       return null;
     }
   });
-  
+
   const results = await Promise.all(creationPromises);
   for (const entry of results) {
     if (entry) pool.push(entry);
@@ -252,7 +261,7 @@ export async function disableNativeTools(accountId?: string): Promise<void> {
         'origin': 'https://chat.qwen.ai',
         'referer': 'https://chat.qwen.ai/',
         'user-agent': headers['user-agent'],
-        'x-request-id': uuidv4(),
+        'x-request-id': crypto.randomUUID(),
         'bx-ua': headers['bx-ua'],
         'bx-umidtoken': headers['bx-umidtoken'],
         'bx-v': headers['bx-v']
@@ -291,9 +300,9 @@ export async function fetchQwenModels(accountId?: string): Promise<any[]> {
       'cookie': cookie,
       'referer': 'https://chat.qwen.ai/',
       'user-agent': userAgent,
-      'x-request-id': uuidv4(),
+      'x-request-id': crypto.randomUUID(),
       'bx-v': bxV,
-      'timezone': new Date().toString(),
+      'timezone': CACHED_TIMEZONE,
       'source': 'web'
     }
   });
@@ -397,7 +406,7 @@ export async function createQwenStream(
   }
 
   const timestamp = Math.floor(Date.now() / 1000);
-  const fid = uuidv4();
+  const fid = crypto.randomUUID();
   const model = modelId.replace('-no-thinking', '');
 
   const payload: QwenPayload = {
@@ -456,10 +465,10 @@ export async function createQwenStream(
       'sec-fetch-dest': 'empty',
       'sec-fetch-mode': 'cors',
       'sec-fetch-site': 'same-origin',
-      'timezone': new Date().toString().split(' (')[0],
+      'timezone': CACHED_TIMEZONE,
       'user-agent': chatHeaders['user-agent'],
       'x-accel-buffering': 'no',
-      'x-request-id': uuidv4(),
+      'x-request-id': crypto.randomUUID(),
       'bx-v': chatHeaders['bx-v'],
     },
     body: JSON.stringify(payload),

package/src/tools/parser.ts

@@ -5,7 +5,7 @@
  * Supports both JSON and Hermes-style XML <parameter> formats.
  */
 
-import { v4 as uuidv4 } from 'uuid';
+import crypto from 'crypto';
 import { robustParseJSON } from '../utils/json.js';
 import { logger } from '../core/logger.js';
 import type { ParsedToolCall } from './types';
@@ -183,6 +183,11 @@ export class StreamingToolParser {
 
     while (this.buffer.length > 0) {
       if (!this.insideTool) {
+        if (this.buffer.indexOf('<') === -1) {
+          if (this.emittedToolCallCount === 0) result.text += this.buffer;
+          this.buffer = '';
+          break;
+        }
         const match = this.buffer.match(TOOL_OPEN_RE);
         if (match && match.index !== undefined) {
           // Text before the tool call tag
@@ -276,14 +281,6 @@ export class StreamingToolParser {
     return this.insideTool;
   }
 
-  /**
-   * Get any lead-in text that was captured before tool calls.
-   * Useful for fallback content when tool calls fail to parse.
-   */
-  getPendingLeadIn(): string {
-    return this.pendingLeadIn;
-  }
-
   // ─── Internal Methods ──────────────────────────────────────────────────────
 
   private processToolContent(content: string, result: ParserResult): void {
@@ -302,7 +299,7 @@ export class StreamingToolParser {
     const xmlParsed = parseXmlParameterToolCall(t, this.currentOpenTag, this.tools);
     if (xmlParsed) {
       result.toolCalls.push({
-        id: `call_${uuidv4()}`,
+        id: `call_${crypto.randomUUID()}`,
         name: xmlParsed.name,
         arguments: xmlParsed.arguments,
       });
@@ -365,7 +362,7 @@ export class StreamingToolParser {
     const xmlParsed = parseXmlParameterToolCall(block, this.currentOpenTag, this.tools);
     if (xmlParsed) {
       return {
-        id: `call_${uuidv4()}`,
+        id: `call_${crypto.randomUUID()}`,
         name: xmlParsed.name,
         arguments: xmlParsed.arguments,
       };
@@ -375,7 +372,7 @@ export class StreamingToolParser {
     const recovered = parseRecoverableXmlToolCall(block, this.currentOpenTag, this.tools);
     if (recovered) {
       return {
-        id: `call_${uuidv4()}`,
+        id: `call_${crypto.randomUUID()}`,
         name: recovered.name,
         arguments: recovered.arguments,
       };
@@ -438,7 +435,7 @@ export class StreamingToolParser {
     if (typeof args !== 'object' || args === null) args = {};
 
     return {
-      id: parsed.id || parsed.tool_call_id || `call_${uuidv4()}`,
+      id: parsed.id || parsed.tool_call_id || `call_${crypto.randomUUID()}`,
       name,
       arguments: args,
     };

package/src/utils/context-truncation.ts

@@ -1,8 +1,3 @@
-export interface TruncatedMessage {
-  role: string;
-  content: string;
-}
-
 export function estimateTokenCount(text: string): number {
   // Divisor conservador (2.5) para evitar estouro silencioso do context window.
   // Tokenizers modernos (como o do Qwen) usam ~1.5 a 2.5 caracteres por token