@pedrofariasx/qwenproxy 1.2.1 → 1.2.2

package/src/linter/structural-parser.ts

@@ -1,352 +0,0 @@
-/*
- * Layer 2: Structural AST Parser (Tolerant)
- * Builds partial AST from JSON-like structures without strict parsing
- */
-
-import type { PartialASTNode, ToolCallSource } from './types'
-
-export interface StructuralParseResult {
-  ast: PartialASTNode | null
-  confidence: number
-  errors: string[]
-  sourceHint: ToolCallSource
-}
-
-export class StructuralParser {
-  private pos = 0
-  private text = ''
-  private errors: string[] = []
-
-  parse(text: string, sourceHint: ToolCallSource = 'unknown'): StructuralParseResult {
-    this.pos = 0
-    this.text = text.trim()
-    this.errors = []
-
-    if (this.text.length === 0) {
-      return { ast: null, confidence: 0, errors: ['Empty input'], sourceHint }
-    }
-
-    const nodes: PartialASTNode[] = []
-
-    while (this.pos < this.text.length) {
-      this.skipWhitespace()
-      if (this.pos >= this.text.length) break
-      const node = this.parseValue()
-      if (node) nodes.push(node)
-    }
-
-    if (nodes.length === 0) {
-      return { ast: null, confidence: 0, errors: ['No parseable content'], sourceHint }
-    }
-
-    const root: PartialASTNode = {
-      type: 'object',
-      raw: this.text,
-      confidence: this.calculateConfidence(nodes),
-    }
-    if (nodes.length === 1 && nodes[0].type === 'object' && nodes[0].value !== undefined) {
-      root.value = nodes[0].value
-      root.children = nodes[0].children
-    } else {
-      root.children = nodes
-    }
-
-    return { ast: root, confidence: root.confidence, errors: this.errors, sourceHint }
-  }
-
-  private parseValue(): PartialASTNode | undefined {
-    const char = this.peek()
-    if (char === '{') return this.parseObject()
-    if (char === '[') return this.parseArray()
-    if (char === '"' || char === "'") return this.parseString()
-    if (this.isNull(char)) return this.parseNull()
-    if (this.isBoolean(char)) return this.parseBoolean()
-    if (this.isNumberStart(char)) return this.parseNumber()
-    if (this.isUnquotedKey(char)) return this.parseUnquotedValue()
-    if (this.isReActAction(char)) return this.parseReActBlock()
-    return undefined
-  }
-
-  private parseObject(): PartialASTNode {
-    const start = this.pos
-    this.expect('{')
-    const children: PartialASTNode[] = []
-
-    while (this.pos < this.text.length) {
-      this.skipWhitespace()
-      if (this.peek() === '}') { this.pos++; break }
-
-      const key = this.parseKey()
-      if (!key) { this.pos++; this.errors.push(`Expected key at position ${this.pos}`); continue }
-
-      this.skipWhitespace()
-      this.expectOptional(':')
-      this.skipWhitespace()
-
-      let value: PartialASTNode | undefined
-      const ch = this.peek()
-      if (ch === '"' || ch === "'") value = this.parseString()
-      else if (ch === '{') value = this.parseObject()
-      else if (ch === '[') value = this.parseArray()
-      else value = this.parseScalar()
-
-      if (value) {
-        children.push({
-          type: 'object',
-          value: value.value,
-          raw: this.text.slice(start, this.pos),
-          confidence: 1,
-          children: [key, value],
-        })
-      }
-
-      this.skipWhitespace()
-      if (this.expectOptional(',')) {
-        this.skipWhitespace()
-        if (this.peek() === '}') break
-      }
-    }
-
-    const value: Record<string, unknown> = {}
-    for (const child of children) {
-      if (child.children && child.children.length >= 2) {
-        const key = child.children[0].value
-        const val = child.children[1].value
-        if (key !== undefined) value[key as string] = val
-      }
-    }
-
-    return {
-      type: 'object',
-      value,
-      raw: this.text.slice(start, this.pos),
-      confidence: this.calculateObjectConfidence(children),
-      children,
-    }
-  }
-
-  private parseArray(): PartialASTNode {
-    const start = this.pos
-    this.expect('[')
-    const children: PartialASTNode[] = []
-
-    while (this.pos < this.text.length) {
-      this.skipWhitespace()
-      if (this.peek() === ']') { this.pos++; break }
-      const value = this.parseValue()
-      if (value) children.push(value)
-      this.skipWhitespace()
-      this.expectOptional(',')
-    }
-
-    return {
-      type: 'array',
-      raw: this.text.slice(start, this.pos),
-      confidence: children.length > 0 ? 0.9 : 0.5,
-      children,
-    }
-  }
-
-  private parseString(): PartialASTNode {
-    const start = this.pos
-    const quote = this.peek()
-    this.expect(quote as '"' | "'")
-    let value = ''
-    try {
-      value = this.readStringContent(quote)
-    } catch {
-      this.errors.push(`Unterminated string at position ${start}`)
-      const content = this.text.slice(start + 1)
-      const idx = content.split('').findIndex((c, i) => c === quote && (i === 0 || content[i - 1] !== '\\'))
-      value = idx === -1 ? content : content.slice(0, idx)
-      this.pos = this.text.length
-    }
-    return { type: 'string', value, raw: this.text.slice(start, this.pos), confidence: 0.95 }
-  }
-
-  private readStringContent(quote: string): string {
-    let value = ''
-    while (this.pos < this.text.length) {
-      const char = this.text[this.pos++]
-      if (char === '\\' && this.pos < this.text.length) {
-        const next = this.text[this.pos++]
-        value += this.resolveEscapeSequence(char, next)
-        continue
-      }
-      if (char === quote) break
-      value += char
-    }
-    return value
-  }
-
-  private resolveEscapeSequence(_backslash: string, char: string): string {
-    const map: Record<string, string> = { n: '\n', t: '\t', r: '\r', b: '\b', f: '\f', '"': '"', "'": "'", '\\': '\\', '0': '\0' }
-    return map[char] ?? _backslash + char
-  }
-
-  private parseKey(): PartialASTNode | undefined {
-    const start = this.pos
-    if (this.peek() === '"' || this.peek() === "'") {
-      const key = this.parseString()
-      return { type: 'string', value: key.value, raw: key.raw, confidence: 1 }
-    }
-
-    let key = ''
-    while (this.pos < this.text.length) {
-      const c = this.text[this.pos]
-      if (/[a-zA-Z0-9_\-]/.test(c)) { key += c; this.pos++ }
-      else break
-    }
-
-    if (key.length === 0) { this.pos = start; return undefined }
-  }
-
-  private parseScalar(): PartialASTNode | undefined {
-    const start = this.pos
-    let value = ''
-    while (this.pos < this.text.length) {
-      const c = this.text[this.pos]
-      if (c === ',' || c === '}' || c === ']' || c === '\n') break
-      value += c
-      this.pos++
-    }
-    value = value.trim()
-
-    if (value === 'true') return { type: 'boolean', value: true, raw: value, confidence: 1 }
-    if (value === 'false') return { type: 'boolean', value: false, raw: value, confidence: 1 }
-    if (value === 'null' || value === 'undefined') return { type: 'null', value: null, raw: value, confidence: 0.9 }
-    const num = Number(value)
-    if (!isNaN(num) && isFinite(num)) return { type: 'number', value: num, raw: value, confidence: 0.9 }
-    if (value.startsWith('"') && value.endsWith('"')) return { type: 'string', value: value.slice(1, -1), raw: value, confidence: 0.85 }
-    if (value.startsWith("'") && value.endsWith("'")) return { type: 'string', value: value.slice(1, -1), raw: value, confidence: 0.8 }
-    return { type: 'unknown', value, raw: value, confidence: 0.3 }
-  }
-
-  private parseUnquotedValue(): PartialASTNode | undefined {
-    const start = this.pos
-    let value = ''
-    while (this.pos < this.text.length) {
-      const c = this.text[this.pos]
-      if (/[a-zA-Z0-9_\- ]/.test(c)) { value += c; this.pos++ }
-      else break
-    }
-    if (value.length === 0) return undefined
-    return { type: 'unknown', value: value.trim(), raw: value, confidence: 0.5 }
-  }
-
-  private parseNull(): PartialASTNode | undefined {
-    if (this.text.slice(this.pos, this.pos + 4) === 'null') {
-      this.pos += 4
-      return { type: 'null', value: null, raw: 'null', confidence: 1 }
-    }
-    return undefined
-  }
-
-  private parseBoolean(): PartialASTNode | undefined {
-    if (this.text.slice(this.pos, this.pos + 4) === 'true') {
-      this.pos += 4
-      return { type: 'boolean', value: true, raw: 'true', confidence: 1 }
-    }
-    if (this.text.slice(this.pos, this.pos + 5) === 'false') {
-      this.pos += 5
-      return { type: 'boolean', value: false, raw: 'false', confidence: 1 }
-    }
-    return undefined
-  }
-
-  private parseNumber(): PartialASTNode | undefined {
-    const start = this.pos
-    let value = ''
-    while (this.pos < this.text.length) {
-      const c = this.text[this.pos]
-      if (/[0-9.\-eE+]/.test(c)) { value += c; this.pos++ }
-      else break
-    }
-    if (value.length === 0) return undefined
-    const num = Number(value)
-    if (!isNaN(num) && isFinite(num)) return { type: 'number', value: num, raw: value, confidence: 0.9 }
-    return { type: 'unknown', value, raw: value, confidence: 0.3 }
-  }
-
-  private parseReActBlock(): PartialASTNode | undefined {
-    const start = this.pos
-    let action = ''
-    let input = ''
-
-    const actionMatch = this.text.slice(this.pos).match(/^Action:\s*(\w+)/i)
-    if (!actionMatch) return undefined
-    action = actionMatch[1]
-    this.pos += actionMatch[0].length
-    this.skipWhitespace()
-
-    const inputMatch = this.text.slice(this.pos).match(/^Action Input:\s*(\{[\s\S]*)/i)
-    if (inputMatch) {
-      input = inputMatch[1].trim()
-      this.pos += inputMatch[0].length
-    }
-
-    return { type: 'object', value: { action, input }, raw: this.text.slice(start, this.pos), confidence: 0.85 }
-  }
-
-  private isReActAction(char: string): boolean {
-    return /^Action:|^thought|^Observation|^Final Answer/i.test(this.text.slice(this.pos))
-  }
-  private isNull(char: string): boolean { return this.text.slice(this.pos, this.pos + 4) === 'null' }
-  private isBoolean(char: string): boolean {
-    return this.text.slice(this.pos, this.pos + 4) === 'true' || this.text.slice(this.pos, this.pos + 5) === 'false'
-  }
-  private isNumberStart(char: string): boolean { return /[0-9.\-]/.test(char) }
-  private isUnquotedKey(char: string): boolean { return /[a-zA-Z_]/.test(char) && !this.isNull(char) && !this.isReActAction(char) }
-
-  private skipWhitespace(): void {
-    while (this.pos < this.text.length && /\s/.test(this.text[this.pos])) this.pos++
-  }
-  private peek(): string { return this.text[this.pos] ?? '' }
-  private expect(char: string): boolean {
-    if (this.peek() === char) { this.pos++; return true }
-    this.errors.push(`Expected '${char}' at position ${this.pos}, got '${this.peek()}'`)
-    return false
-  }
-  private expectOptional(char: string): boolean {
-    if (this.peek() === char) { this.pos++; return true }
-    return false
-  }
-
-  private calculateConfidence(nodes: PartialASTNode[]): number {
-    if (nodes.length === 0) return 0
-    const avg = nodes.reduce((a, n) => a + n.confidence, 0) / nodes.length
-    return Math.max(0, Math.min(1, avg - Math.min(this.errors.length * 0.1, 0.5)))
-  }
-
-  private calculateObjectConfidence(children: PartialASTNode[]): number {
-    if (children.length === 0) return 0.1
-    let confidence = 0.7
-    if (children.some(c => c.children && c.children[0]?.type === 'string')) confidence += 0.2
-    if (this.errors.length === 0) confidence += 0.1
-    if (children.length >= 2) confidence += 0.05
-    return Math.min(0.99, confidence)
-  }
-
-  static extractJsonFromText(text: string): string[] {
-    const results: string[] = []
-    let depth = 0, start = -1, inString = false, escape = false
-
-    for (let i = 0; i < text.length; i++) {
-      const char = text[i]
-      if (escape) { escape = false; continue }
-      if (char === '\\' && inString) { escape = true; continue }
-      if (char === '"' && !escape) { inString = !inString; continue }
-      if (inString) continue
-
-      if (char === '{' || char === '[') {
-        if (depth === 0) start = i
-        depth++
-      } else if (char === '}' || char === ']') {
-        depth--
-        if (depth === 0 && start !== -1) { results.push(text.slice(start, i + 1)); start = -1 }
-      }
-    }
-
-    return results
-  }
-}

package/src/linter/types.ts

@@ -1,74 +0,0 @@
-/*
- * File: types.ts
- * Project: qwenproxy
- * UltraToolCallLinter - Core type definitions
- */
-
-export type ToolCallSource = 'openai' | 'claude' | 'gemini' | 'react' | 'unknown'
-
-export interface CanonicalToolCall {
-  tool: string
-  input: Record<string, unknown>
-  meta?: {
-    source: ToolCallSource
-    confidence: number
-    repaired: boolean
-  }
-}
-
-export interface ParserState {
-  buffer: string
-  insideCodeBlock: boolean
-  braceDepth: number
-  bracketDepth: number
-  inString: boolean
-  escapeNext: boolean
-  potentialToolStart: boolean
-}
-
-export interface PartialASTNode {
-  type: 'object' | 'array' | 'string' | 'number' | 'boolean' | 'null' | 'unknown'
-  value?: unknown
-  raw: string
-  confidence: number
-  children?: PartialASTNode[]
-}
-
-export interface RawToolCandidate {
-  source: ToolCallSource
-  raw: Record<string, unknown>
-  rawString: string
-  confidence: number
-}
-
-export interface ParseResult {
-  text: string
-  toolCalls: CanonicalToolCall[]
-  errors: string[]
-  confidence: number
-}
-
-export interface SecurityViolation {
-  type: 'shell_injection' | 'filesystem_access' | 'ssrf' | 'prompt_injection' | 'encoded_payload'
-  field: string
-  value: string
-  detail: string
-}
-
-export interface ToolRegistry {
-  [name: string]: {
-    name: string
-    description: string
-    parameters: Record<string, unknown>
-    required?: string[]
-    strict?: boolean
-  }
-}
-
-export interface ToolDefinition {
-  name: string
-  description: string
-  parameters: Record<string, unknown>
-  required?: string[]
-  strict?: boolean
-}

package/src/tests/linter.test.ts

@@ -1,151 +0,0 @@
-/*
- * UltraToolCallLinter v1.0 - Edge Case Stress Tests
- * Tests required by spec
- */
-
-import { describe, it, beforeEach, afterEach } from 'node:test'
-import assert from 'node:assert'
-
-import { UltraToolCallLinter } from '../linter/index.js'
-import type { ParseResult, RawToolCandidate } from '../linter/types.js'
-
-// Helper functions to match the old bar.ts API using direct instantiation
-let globalLinter: UltraToolCallLinter | null = null
-
-function getGlobalLinter(): UltraToolCallLinter {
-  if (!globalLinter) globalLinter = new UltraToolCallLinter()
-  return globalLinter
-}
-
-function configure(config: { registry?: any; strictMode?: boolean; enableSecurityGate?: boolean; maxRecoveryAttempts?: number; minConfidenceThreshold?: number }): void {
-  globalLinter = new UltraToolCallLinter(config)
-}
-
-function parseText(input: string): ParseResult {
-  return getGlobalLinter().parseText(input)
-}
-
-function extract(input: string): RawToolCandidate[] {
-  return getGlobalLinter().extract(input)
-}
-
-function repair(input: string): string {
-  return getGlobalLinter().repair(input)
-}
-
-describe('UltraToolCallLinter Edge Cases', () => {
-  it('parses truncated JSON in the middle', () => {
-    configure({ minConfidenceThreshold: 0.1 })
-    const input = 'Here is the query: {"search": {"query": "test"}}'
-    const result = parseText(input)
-    assert.ok(result.toolCalls.length >= 1)
-    assert.equal(result.toolCalls[0].tool, 'search')
-  })
-
-  it('parses concatenated multiple JSONs', () => {
-    const input = '{"name":"search","arguments":{"query":"foo"}}{"name":"browser_open","arguments":{"url":"http://x"}}'
-    const candidates = extract(input)
-    assert.ok(candidates.length >= 1, 'Expected at least one candidate')
-  })
-
-  it('parses markdown-wrapped JSON', () => {
-    const input = '```json\n{"tool":"search","input":{"query":"beer"}}\n```'
-    const result = parseText(input)
-    assert.ok(result.toolCalls.length >= 1)
-    assert.equal(result.toolCalls[0].tool, 'search')
-  })
-
-  it('parses human text mixed with a tool call (ReAct)', () => {
-    const input =
-      'Sure, let me search that for you.\nAction: search\nAction Input: {"query": "breaking news"}'
-    const result = parseText(input)
-    assert.ok(result.toolCalls.length >= 1, 'Expected ReAct extraction')
-  })
-
-  it('recovers from broken escape sequences', () => {
-    const input = '{"tool":"search","input":{"query":"test\\\\n\\\\t\\\\"}}'
-    const result = parseText(input)
-    assert.ok(result.toolCalls.length >= 1)
-  })
-
-  it('recovers from unicode corruption', () => {
-    const input = '{"tool":"search","input":{"query":"caf\u0000\u001Fé"}}'
-    const result = parseText(input)
-    assert.ok(result.toolCalls.length >= 1)
-  })
-
-  it('handles streaming with repeated chunks', () => {
-    const linter = new UltraToolCallLinter({ minConfidenceThreshold: 0.1 })
-    const chunks = [
-      'S',
-      'Su',
-      'Sur',
-      'Sure! ',
-      'Here i',
-      'Here is ',
-      'Here is the ',
-      'Here is the result: ',
-      'Here is the result: {"tool":"search","input":{"query":"async"}}',
-    ]
-    for (const c of chunks) linter.push(c)
-    const result = linter.parse()
-    assert.ok(result.toolCalls.length >= 1)
-  })
-
-  it('extracts tool call inside a textual array', () => {
-    const input =
-      'Options:\n- `{"tool":"search","input":{"query":"foo"}}`\n- `{"tool":"search","input":{"query":"bar"}}`'
-    const candidates = extract(input)
-    assert.ok(candidates.length >= 1, 'Expected extraction from array-text format')
-  })
-
-  it('handles duplicate model output', () => {
-    const input =
-      '{"tool":"search","input":{"query":"dup"}}\n\n{"tool":"search","input":{"query":"dup"}}'
-    const result = parseText(input)
-    assert.ok(Array.isArray(result.toolCalls))
-  })
-
-  it('repair: single quotes to double quotes', () => {
-    const input = "{'tool': 'search', 'input': {'query': 'test'}}"
-    const repaired = repair(input)
-    assert.ok(repaired.includes('search'))
-  })
-
-  it('repair: trailing comma', () => {
-    const input = '{"tool": "search", "input": {"query": "test"},}'
-    const repaired = repair(input)
-    assert.ok(repaired.includes('search'))
-  })
-
-  it('repair: key without quotes', () => {
-    const input = '{tool: "search", input: {query: "test"}}'
-    const repaired = repair(input)
-    assert.ok(repaired.includes('search'))
-  })
-
-  it('security gate blocks destructive shell injection', () => {
-    configure({ minConfidenceThreshold: 0.0 })
-    const input = '{"tool":"search","input":{"query":"\'; rm -rf /; echo \'"}}'
-    const result = parseText(input)
-    const passed = result.toolCalls.some((call: any) => {
-      const val = (call.input.query ?? '') as string
-      return typeof val === 'string' && val.includes('rm -rf /')
-    })
-    assert.strictEqual(passed, false, 'Should not pass through destructive payload')
-  })
-
-  it('rejects empty string values per spec', () => {
-    configure({ minConfidenceThreshold: 0.0 })
-    const input = '{"tool":"search","input":{"query":""}}'
-    const result = parseText(input)
-    assert.ok(Array.isArray(result.toolCalls))
-  })
-
-  it('parseText returns canonical tool calls', () => {
-    configure({ minConfidenceThreshold: 0.1 })
-    const input = '{"tool":"search","input":{"query":"x"}}'
-    const result = parseText(input)
-    assert.ok(Array.isArray(result.toolCalls))
-  })
-})

package/src/tests/parallel.test.ts

@@ -1,42 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert';
-import { executeToolCalls } from '../tools/executor.ts';
-import { registry } from '../tools/registry.ts';
-import type { ToolContext } from '../tools/types.ts';
-
-test('executeToolCalls: parallel execution', async () => {
-  let activeCount = 0;
-  let maxParallel = 0;
-
-  registry.register(
-    'parallel_tool',
-    'A tool that waits to test parallelism',
-    { type: 'object', properties: {} },
-    async () => {
-      activeCount++;
-      maxParallel = Math.max(maxParallel, activeCount);
-      await new Promise(r => setTimeout(r, 100));
-      activeCount--;
-      return 'done';
-    }
-  );
-
-  const toolCalls = [
-    { id: '1', name: 'parallel_tool', arguments: {} },
-    { id: '2', name: 'parallel_tool', arguments: {} },
-    { id: '3', name: 'parallel_tool', arguments: {} },
-  ];
-
-  const context: ToolContext = {
-    messages: [],
-    turn: 0,
-    model: 'test'
-  };
-
-  const results = await executeToolCalls(toolCalls, context);
-  
-  assert.strictEqual(results.length, 3);
-  assert.ok(maxParallel > 1, `Max parallel should be > 1, got ${maxParallel}`);
-  
-  registry.unregister('parallel_tool');
-});