@pedrofariasx/qwenproxy 1.2.0 → 1.2.2

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;
@@ -66,6 +68,9 @@ interface WarmPoolEntry {
 const warmPool: Map<string, WarmPoolEntry[]> = (globalThis as any)._warmPool || new Map();
 (globalThis as any)._warmPool = warmPool;
 
+const refillPromises: Map<string, Promise<void>> = (globalThis as any)._refillPromises || new Map();
+(globalThis as any)._refillPromises = refillPromises;
+
 const WARM_POOL_SIZE = 5;
 const WARM_POOL_TTL_MS = 10 * 60 * 1000;
 
@@ -79,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,
@@ -101,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({
@@ -128,15 +132,29 @@ async function refillPoolForAccount(accountId: string) {
   if (!pool) { pool = []; warmPool.set(accountId, pool); }
   cleanupStalePool(accountId);
   const need = Math.max(0, WARM_POOL_SIZE - pool.length);
-  for (let i = 0; i < need; i++) {
+  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);
-      pool.push({ chatId, headers, accountId, timestamp: Date.now() });
+      return { chatId, headers, accountId, timestamp: Date.now() };
     } catch (err) {
-      console.error(`[WarmPool] refill failed for ${accountId}:`, (err as Error).message);
-      break;
+      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);
   }
 }
 
@@ -146,7 +164,10 @@ export async function getWarmedChat(accountId?: string) {
   if (!pool) { pool = []; warmPool.set(key, pool); }
   cleanupStalePool(key);
   if (pool.length === 0) {
-    await refillPoolForAccount(key);
+    if (!refillPromises.has(key)) {
+      refillPromises.set(key, refillPoolForAccount(key).finally(() => refillPromises.delete(key)));
+    }
+    await refillPromises.get(key);
   }
   if (pool.length === 0) throw new Error(`Warm pool empty for ${key}`);
   return pool.shift()!;
@@ -240,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']
@@ -279,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'
     }
   });
@@ -385,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 = {
@@ -444,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,10 +1,33 @@
-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
+  // para textos mistos (português, código, caracteres especiais).
+  return Math.ceil(text.length / 2.5);
 }
 
-export function estimateTokenCount(text: string): number {
-  return Math.ceil(text.length / 3.5);
+function truncateSemantically(content: string, maxChars: number): string {
+  if (content.length <= maxChars) return content;
+  
+  const truncated = content.slice(0, maxChars);
+  
+  if (truncated.trimStart().startsWith('{') || truncated.trimStart().startsWith('[')) {
+    const lastBrace = Math.max(truncated.lastIndexOf('}'), truncated.lastIndexOf(']'));
+    if (lastBrace > maxChars * 0.7) {
+      return truncated.slice(0, lastBrace + 1) + ' /* truncated */';
+    }
+  }
+  
+  const lastNewline = truncated.lastIndexOf('\n');
+  if (lastNewline > maxChars * 0.8) {
+    return truncated.slice(0, lastNewline) + '\n[Truncated]';
+  }
+  
+  const lastSpace = truncated.lastIndexOf(' ');
+  if (lastSpace > maxChars * 0.9) {
+    return truncated.slice(0, lastSpace) + '... [Truncated]';
+  }
+  
+  return truncated + '... [Truncated]';
 }
 
 export function truncateMessages(
@@ -39,13 +62,14 @@ export function truncateMessages(
     const msgTokens = estimateTokenCount(msg.content);
     
     if (usedTokens + msgTokens <= availableTokens) {
-      result.unshift(msg);
+      result.push(msg);
       usedTokens += msgTokens;
     } else {
       const remainingTokens = availableTokens - usedTokens;
       if (remainingTokens > 100) {
-        const truncatedContent = msg.content.slice(0, remainingTokens * 3.5);
-        result.unshift({ role: msg.role, content: `[Truncated] ${truncatedContent}...` });
+        const maxChars = Math.floor(remainingTokens * 2.5);
+        const truncatedContent = truncateSemantically(msg.content, maxChars);
+        result.push({ role: msg.role, content: `[Truncated] ${truncatedContent}` });
       }
       break;
     }
@@ -53,9 +77,11 @@ export function truncateMessages(
   
   if (result.length === 0 && normalizedMessages.length > 0) {
     const lastMsg = normalizedMessages[normalizedMessages.length - 1];
-    const truncatedContent = lastMsg.content.slice(0, Math.max(200, availableTokens * 3.5));
-    result.push({ role: lastMsg.role, content: `[Truncated] ${truncatedContent}...` });
+    const maxChars = Math.max(200, Math.floor(availableTokens * 2.5));
+    const truncatedContent = truncateSemantically(lastMsg.content, maxChars);
+    result.push({ role: lastMsg.role, content: `[Truncated] ${truncatedContent}` });
   }
   
+  result.reverse();
   return result;
 }

package/src/linter/extraction-engine.ts

@@ -1,165 +0,0 @@
-/*
- * Layer 3: Tool Extraction Engine (Multi-Format)
- */
-
-import type { ToolCallSource, RawToolCandidate, SecurityViolation } from './types'
-import { StructuralParser } from './structural-parser'
-
-export interface ExtractionResult {
-  candidates: RawToolCandidate[]
-  sourceHint: ToolCallSource
-  extractionErrors: string[]
-}
-
-export class ToolExtractionEngine {
-  private parser: StructuralParser
-
-  constructor() {
-    this.parser = new StructuralParser()
-  }
-
-  extract(input: string): ExtractionResult {
-    const candidates: RawToolCandidate[] = []
-    const errors: string[] = []
-    let sourceHint: ToolCallSource = this.detectSourceHint(input)
-
-    const jsonCandidates = this.extractJsonObjects(input)
-    for (const candidate of jsonCandidates) {
-      const parsed = this.tryParseJson(candidate.raw)
-      if (parsed) {
-        candidates.push({
-          source: candidate.sourceHint,
-          raw: parsed,
-          rawString: candidate.raw,
-          confidence: this.calculateJsonConfidence(parsed, candidate.sourceHint),
-        })
-      }
-    }
-
-    if (candidates.length === 0) {
-      const reactCandidates = this.extractReAct(input)
-      candidates.push(
-        ...reactCandidates.map(c => ({
-          source: 'react' as ToolCallSource,
-          raw: c.raw,
-          rawString: c.rawString,
-          confidence: 0.8,
-        }))
-      )
-    }
-
-    if (candidates.length === 0) {
-      const gemini = this.extractGemini(input)
-      if (gemini) {
-        candidates.push({
-          source: 'gemini' as ToolCallSource,
-          raw: gemini,
-          rawString: JSON.stringify(gemini),
-          confidence: 0.85,
-        })
-      }
-    }
-
-    return { candidates, sourceHint, extractionErrors: errors }
-  }
-
-  private extractJsonObjects(text: string): Array<{ raw: string; sourceHint: ToolCallSource }> {
-    const results: Array<{ raw: string; sourceHint: ToolCallSource }> = []
-    const markupCleaned = this.stripMarkup(text)
-    const jsonSpans = StructuralParser.extractJsonFromText(markupCleaned)
-
-    for (const span of jsonSpans) {
-      const sourceHint = this.detectSourceHint(span)
-      results.push({ raw: span, sourceHint })
-    }
-
-    if (results.length === 0) {
-      const funcMatch = markupCleaned.match(/call_function\s*\(\s*'(\w+)'\s*,\s*(\{[\s\S]*\})\s*\)/i)
-      if (funcMatch) {
-        results.push({ raw: `{"name":"${funcMatch[1]}","arguments":${funcMatch[2]}}`, sourceHint: 'openai' })
-      }
-    }
-
-    return results
-  }
-
-  private extractReAct(text: string): Array<{ raw: Record<string, unknown>; rawString: string }> {
-    const results: Array<{ raw: Record<string, unknown>; rawString: string }> = []
-    const patterns = [
-      /Action:\s*(\w+)\s*\n?\s*Action Input:\s*(\{[\s\S]*?)(?=\n\s*\n|\n\s*Observation|\n\s*Final Answer|$)/i,
-      /Action:\s*(\w+)\s+Action Input:\s*(\{[\s\S]*)/i,
-      /\*\*Action\*\*:\s*(\w+)\s*\n?\s*\*\*Action Input\*\*:\s*(\{[\s\S]*?)(?=\n\s*\n|\n\s*Observation|\n\s*Final Answer|$)/i,
-    ]
-
-    for (const pattern of patterns) {
-      const match = text.match(pattern)
-      if (match) {
-        let actionInputStr = match[2].trim()
-        actionInputStr = actionInputStr.replace(/\n\s*Observation.*$/is, '').trim()
-        results.push({
-          raw: { name: match[1], arguments: this.safeParse(actionInputStr) || {} },
-          rawString: match[0],
-        })
-        break
-      }
-    }
-
-    return results
-  }
-
-  private extractGemini(text: string): Record<string, unknown> | null {
-    const patterns = [
-      /functionCall\s*[:=]\s*\{\s*name\s*[:=]\s*['"]([^'"]+)['"]\s*,\s*args\s*[:=]\s*(\{[\s\S]*\})\s*\}/i,
-      /"functionCall"\s*:\s*\{\s*"name"\s*:\s*"([^"]+)"\s*,\s*"args"\s*:\s*(\{[\s\S]*?\})\s*\}/i,
-    ]
-    for (const pattern of patterns) {
-      const match = text.match(pattern)
-      if (match) return { name: match[1], arguments: this.safeParse(match[2]) || {} }
-    }
-    return null
-  }
-
-  private stripMarkup(text: string): string {
-    return text
-      .replace(/```json\s*/gi, '')
-      .replace(/```\s*/gi, '')
-      .replace(/<function_calls>/gi, '')
-      .replace(/<\/function_calls>/gi, '')
-      .trim()
-  }
-
-  private detectSourceHint(text: string): ToolCallSource {
-    const t = this.stripMarkup(text)
-    if (/\btool_use\b/.test(t) || /type:\s*['"]?tool_use/i.test(t)) return 'claude'
-    if (/\bfunctionCall\b/.test(t) || /"functionCall"/.test(t)) return 'gemini'
-    if (/\barguments\b/.test(t) && /\bname\b/.test(t)) return 'openai'
-    if (/Action:\s*\w+\s*\n?Action Input:/i.test(t)) return 'react'
-    return 'unknown'
-  }
-
-  private tryParseJson(raw: string): Record<string, unknown> | null {
-    try { return JSON.parse(raw) } catch {
-      const result = this.parser.parse(raw, 'unknown')
-      return (result.ast?.value as Record<string, unknown>) ?? null
-    }
-  }
-
-  private safeParse(str: string): Record<string, unknown> | null {
-    try { return JSON.parse(str) } catch {
-      const result = this.parser.parse(str, 'unknown')
-      return (result.ast?.value as Record<string, unknown>) ?? null
-    }
-  }
-
-  private calculateJsonConfidence(parsed: Record<string, unknown>, source: ToolCallSource): number {
-    let conf = 0.5
-    if (parsed.name) conf += 0.15
-    if (parsed.arguments && typeof parsed.arguments === 'object') conf += 0.15
-    if (parsed.input && typeof parsed.input === 'object') conf += 0.1
-    if (parsed.tool) conf += 0.1
-    if (parsed.args && typeof parsed.args === 'object') conf += 0.1
-    if (typeof parsed.arguments === 'string') conf -= 0.2
-    if (typeof parsed.input === 'string') conf -= 0.2
-    return Math.min(0.95, Math.max(0.3, conf))
-  }
-}

package/src/linter/index.ts

@@ -1,258 +0,0 @@
-/*
- * UltraToolCallLinter v1.0
- * Main public API: composable 5-layer pipeline
- */
-
-import type {
-  CanonicalToolCall,
-  ParserState,
-  RawToolCandidate,
-  ParseResult,
-  ToolCallSource,
-  SecurityViolation,
-  ToolDefinition,
-  ToolRegistry,
-} from './types'
-
-import { StreamingStateMachine } from './streaming-state-machine'
-import { StructuralParser } from './structural-parser'
-import { ToolExtractionEngine } from './extraction-engine'
-import { GrammarRepairEngine, NormalizationEngine } from './repair-normalize'
-import { SafetyGate } from './safety-gate'
-
-export interface LinterConfig {
-  registry?: ToolRegistry
-  strictMode?: boolean
-  enableSecurityGate?: boolean
-  maxRecoveryAttempts?: number
-  minConfidenceThreshold?: number
-}
-
-export class UltraToolCallLinter {
-  private readonly streaming = new StreamingStateMachine()
-  private readonly extractor = new ToolExtractionEngine()
-  private readonly repairer = new GrammarRepairEngine()
-  private readonly normalizer = new NormalizationEngine()
-  private readonly gate = new SafetyGate()
-
-  private registry: ToolRegistry = {}
-  private strictMode: boolean = false
-  private enableSecurityGate: boolean = true
-  private maxRecoveryAttempts: number = 3
-  private minConfidenceThreshold: number = 0.3
-
-  constructor(config: LinterConfig = {}) {
-    if (config.registry) this.registry = config.registry
-    if (config.strictMode !== undefined) this.strictMode = config.strictMode
-    if (config.enableSecurityGate !== undefined) this.enableSecurityGate = config.enableSecurityGate
-    if (config.maxRecoveryAttempts !== undefined) this.maxRecoveryAttempts = config.maxRecoveryAttempts
-    if (config.minConfidenceThreshold !== undefined) this.minConfidenceThreshold = config.minConfidenceThreshold
-
-    if (this.registry) this.gate.registerRegistry(this.registry)
-  }
-
-  setRegistry(registry: ToolRegistry): void {
-    this.registry = registry
-    this.gate.registerRegistry(registry)
-  }
-
-  registerTool(name: string, def: ToolDefinition): void {
-    this.gate.registerTool(name, def)
-  }
-
-  push(chunk: string): void {
-    this.streaming.push(chunk)
-  }
-
-  parse(): ParseResult {
-    const buffer = this.streaming.getBuffer()
-    const errors: string[] = []
-
-    const { candidates, extractionErrors } = this.extractor.extract(buffer)
-    errors.push(...extractionErrors)
-
-    const toolCalls: CanonicalToolCall[] = []
-    let maxConfidence = 0
-
-    for (const candidate of candidates) {
-      const result = this.processCandidate(candidate, errors)
-      const tc: CanonicalToolCall = {
-        tool: result.tool,
-        input: result.input,
-        meta: result.meta ?? { source: candidate.source, confidence: 0, repaired: false },
-      }
-      if (tc.meta) {
-        tc.meta.confidence = result.meta?.confidence ?? 0
-        tc.meta.repaired = result.meta?.repaired ?? false
-      } else {
-        tc.meta = { source: candidate.source, confidence: result.meta?.confidence ?? 0, repaired: result.meta?.repaired ?? false }
-      }
-      toolCalls.push(tc)
-      maxConfidence = Math.max(maxConfidence, tc.meta.confidence)
-    }
-
-    this.streaming.reset()
-
-    return {
-      text: buffer,
-      toolCalls,
-      errors,
-      confidence: maxConfidence,
-    }
-  }
-
-  parseText(text: string): ParseResult {
-    this.streaming.reset()
-    this.streaming.push(text)
-    return this.parse()
-  }
-
-  parseObject(name: string, argumentsObj: Record<string, unknown>): ParseResult {
-    const candidate: RawToolCandidate = {
-      source: 'openai',
-      raw: { name, arguments: argumentsObj },
-      rawString: JSON.stringify({ name, arguments: argumentsObj }),
-      confidence: 1,
-    }
-
-    const errors: string[] = []
-    const processingResult = this.processCandidate(candidate, errors)
-
-    return {
-      text: '',
-      toolCalls: [processingResult],
-      errors,
-      confidence: processingResult.meta?.confidence ?? 0,
-    }
-  }
-
-  repair(input: string): string {
-    const result = this.repairer.repair(input)
-    if (!result.repaired) {
-      const structural = new StructuralParser()
-      const parsed = structural.parse(input, 'unknown')
-      if (parsed.ast?.value) return JSON.stringify(parsed.ast.value, null, 0)
-    }
-    return JSON.stringify(result.value ?? {}, null, 0)
-  }
-
-  extract(input: string): RawToolCandidate[] {
-    this.streaming.reset()
-    const { candidates } = this.extractor.extract(input)
-    return candidates
-  }
-
-  reset(): void {
-    this.streaming.reset()
-  }
-
-  getState(): ParserState {
-    return this.streaming.getState()
-  }
-
-  public processCandidate(
-    candidate: RawToolCandidate,
-    errors: string[]
-  ): CanonicalToolCall {
-    let confidence = candidate.confidence
-    let repaired = false
-    let currentRaw = { ...candidate.raw } as Record<string, unknown>
-
-    const args = currentRaw.arguments ?? currentRaw.input ?? currentRaw.args
-
-    if (typeof args === 'string' && args.trim().length > 0) {
-      const repairResult = this.repairer.repair(args)
-      if (repairResult.repaired) {
-        currentRaw = { ...currentRaw, arguments: repairResult.value }
-        repaired = true
-        confidence = Math.min(confidence + repairResult.confidence * 0.1, 0.95)
-        this.recoveryLog('string-args-repaired', candidate, repairResult.strategy)
-      }
-    }
-
-    if (!currentRaw.tool && !currentRaw.name && !currentRaw.functionCall && !currentRaw.type) {
-      const repairResult = this.repairer.repair(candidate.rawString)
-      if (repairResult.repaired) {
-        currentRaw = repairResult.value as Record<string, unknown>
-        repaired = true
-        confidence = Math.min(confidence + 0.05, 0.9)
-        this.recoveryLog('synthetic-construction', candidate, repairResult.strategy)
-      }
-    }
-
-    const { toolCall, warnings } = this.normalizer.normalize(
-      { source: candidate.source, raw: currentRaw, rawString: candidate.rawString, confidence },
-      repaired
-    )
-
-    if (warnings.length > 0) errors.push(...warnings)
-
-    if (!toolCall.meta) {
-      toolCall.meta = { source: candidate.source, confidence, repaired }
-    } else {
-      toolCall.meta.confidence = confidence
-      toolCall.meta.repaired = repaired
-    }
-
-    if (this.enableSecurityGate) {
-      const report = this.gate.validate(toolCall, candidate.source)
-      toolCall.meta.confidence = Math.min(toolCall.meta.confidence, report.confidence)
-
-      if (!report.isValid && !this.strictMode) {
-        const recoveryResult = this.attemptRecovery(candidate, report.violations, toolCall, errors)
-        if (recoveryResult) return recoveryResult
-      }
-
-      errors.push(...report.warnings)
-    }
-
-    return toolCall
-  }
-
-  private attemptRecovery(
-    candidate: RawToolCandidate,
-    violations: SecurityViolation[],
-    failedCall: CanonicalToolCall,
-    errors: string[]
-  ): CanonicalToolCall | null {
-    let attempt = 0
-    const currentCall: CanonicalToolCall = {
-      tool: failedCall.tool,
-      input: { ...failedCall.input },
-      meta: failedCall.meta ? { ...failedCall.meta } : undefined,
-    }
-
-    while (attempt < this.maxRecoveryAttempts) {
-      for (const v of violations) {
-        if (v.field === 'input') {
-          currentCall.input = {}
-          errors.push(`Recovered: cleared entire input`)
-          break
-        }
-        if (v.field in currentCall.input) {
-          delete currentCall.input[v.field]
-          errors.push(`Recovered: removed invalid field "${v.field}"`)
-        }
-      }
-
-      const report = this.gate.validate(currentCall, candidate.source)
-      if (report.isValid) {
-        if (currentCall.meta) {
-          currentCall.meta.repaired = true
-          currentCall.meta.confidence = Math.max(0.3, report.confidence)
-        }
-        return currentCall
-      }
-
-      attempt++
-    }
-
-    return null
-  }
-
-  private recoveryLog(event: string, candidate: RawToolCandidate, strategy: string): void {
-    if (process.env.DEBUG_ULTRA_LINTER === 'true') {
-      console.debug(`[UltraToolCallLinter] recovery ${event}: strategy=${strategy}, source=${candidate.source}`)
-    }
-  }
-}