@pedrofariasx/qwenproxy 1.2.1 → 1.2.3

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
@@ -36,7 +31,7 @@ function truncateSemantically(content: string, maxChars: number): string {
 }
 
 export function truncateMessages(
-  messages: Array<{ role: string; content: string | null | any[] }>,
+  messages: Array<{ role: string; content: string | null | any[] | Record<string, unknown> }>,
   maxContextLength: number,
   systemPrompt: string = ''
 ): Array<{ role: string; content: string }> {

package/src/utils/json.ts

@@ -4,7 +4,7 @@
  * Robust JSON parsing utilities
  */
 
-function sanitizeAndBalance(input: string): { result: string; openBraces: number; openBrackets: number } {
+function sanitizeAndBalance(input: string): { result: string; openBraces: number; openBrackets: number; inString: boolean } {
   let out = '';
   let openBraces = 0;
   let openBrackets = 0;
@@ -48,11 +48,12 @@ function sanitizeAndBalance(input: string): { result: string; openBraces: number
       if (char === ']') openBrackets--;
     }
   }
-  return { result: out, openBraces, openBrackets };
+  return { result: out, openBraces, openBrackets, inString };
 }
 
-function closeBraces(input: string, openBraces: number, openBrackets: number): string {
+function closeBraces(input: string, openBraces: number, openBrackets: number, inString: boolean = false): string {
   let out = input;
+  if (inString) out += '"';
   if (openBrackets > 0) out += ']'.repeat(openBrackets);
   if (openBraces > 0) out += '}'.repeat(openBraces);
   return out;
@@ -79,7 +80,7 @@ export function robustParseJSON(str: string): any {
     cleaned = cleaned.slice(0, -1).trim();
   }
 
-  const { result: fixedJson, openBraces, openBrackets } = sanitizeAndBalance(cleaned);
+  const { result: fixedJson, openBraces, openBrackets, inString } = sanitizeAndBalance(cleaned);
   let lastBalancedIndex = -1;
 
   { let ob = 0, bk = 0, ins = false, esc = false;
@@ -99,15 +100,15 @@ export function robustParseJSON(str: string): any {
   let tempJson = fixedJson;
   if (lastBalancedIndex !== -1 && (openBraces !== 0 || openBrackets !== 0 || fixedJson.length > lastBalancedIndex + 1)) {
     tempJson = fixedJson.substring(0, lastBalancedIndex + 1);
-  } else if (openBraces > 0 || openBrackets > 0) {
-    tempJson = closeBraces(fixedJson, openBraces, openBrackets);
+  } else if (openBraces > 0 || openBrackets > 0 || inString) {
+    tempJson = closeBraces(fixedJson, openBraces, openBrackets, inString);
   }
 
   try { return JSON.parse(tempJson); } catch (e) {
     let aggressive = fixedJson.trim();
     if (aggressive.endsWith(',')) aggressive = aggressive.slice(0, -1);
-    const { result: aggFixed, openBraces: ob, openBrackets: bk } = sanitizeAndBalance(aggressive);
-  try { return JSON.parse(closeBraces(aggFixed, ob, bk)); } catch {
+    const { result: aggFixed, openBraces: ob, openBrackets: bk, inString: aggInString } = sanitizeAndBalance(aggressive);
+  try { return JSON.parse(closeBraces(aggFixed, ob, bk, aggInString)); } catch {
     return null;
   }
 }

package/src/utils/types.ts

@@ -8,7 +8,7 @@
  * Modified By: Pedro Farias
  */
 
-import type { JsonSchema, FunctionToolDefinition } from '../tools/types.ts';
+import type { JsonSchema, FunctionToolDefinition } from '../tools/types.js';
 export type { JsonSchema, FunctionToolDefinition };
 
 /** Tool choice options */

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}`)
-    }
-  }
-}