@pedrofariasx/qwenproxy 1.2.0 → 1.2.2

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');
-});

package/src/tests/structureVerification.test.ts

@@ -1,176 +0,0 @@
-/*
- * Structure Verification Tests
- * Verifies that the identified issues are correct and the logic works as expected.
- */
-
-import { describe, it, beforeEach } 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)
-}
-
-// Test 2: Verify CandidateSpan is defined but unused
-type TestCandidateSpan = {
-  startIndex: number
-  endIndex: number | null
-  rawContent: string
-  sourceHint: string
-  isComplete: boolean
-}
-
-// Test 3: Verify ParseResult structure
-
-describe('Structure Verification Tests', () => {
-  beforeEach(() => {
-    configure({ strictMode: false, minConfidenceThreshold: 0.1 })
-  })
-
-  describe('Direct import from index.js verification', () => {
-    it('should verify UltraToolCallLinter methods work correctly', () => {
-      const linter = new UltraToolCallLinter()
-      
-      assert.strictEqual(typeof linter.parse, 'function')
-      assert.strictEqual(typeof linter.push, 'function')
-      assert.strictEqual(typeof linter.extract, 'function')
-      assert.strictEqual(typeof linter.repair, 'function')
-      assert.strictEqual(typeof linter.parseText, 'function')
-    })
-
-    it('should verify parseText works through foo -> bar -> index chain', () => {
-      const input = '{"tool":"search","input":{"query":"test"}}'
-      const result = parseText(input)
-      
-      assert.ok(Array.isArray(result.toolCalls))
-      assert.ok(typeof result.confidence === 'number')
-    })
-
-    it('should verify extract works through foo -> bar -> index chain', () => {
-      const input = '{"tool":"search","input":{"query":"test"}}'
-      const candidates = extract(input)
-      
-      assert.ok(Array.isArray(candidates))
-    })
-
-    it('should verify repair works through foo -> bar -> index chain', () => {
-      const input = "{'tool': 'search'}"
-      const repaired = repair(input)
-      
-      assert.ok(typeof repaired === 'string')
-      assert.ok(repaired.includes('search'))
-    })
-  })
-
-  describe('Unused type: CandidateSpan verification', () => {
-    it('CandidateSpan type exists in types.ts but is not used anywhere', () => {
-      // This test documents that CandidateSpan is defined but unused
-      const exampleSpan: TestCandidateSpan = {
-        startIndex: 0,
-        endIndex: 10,
-        rawContent: '{"tool":"test"}',
-        sourceHint: 'json',
-        isComplete: true
-      }
-      
-      assert.ok(exampleSpan.startIndex === 0)
-      assert.ok(exampleSpan.isComplete === true)
-    })
-  })
-
-  describe('ParseResult structure verification', () => {
-    it('ParseResult has all required fields', () => {
-      const parseResult: ParseResult = {
-        text: 'test',
-        toolCalls: [],
-        errors: [],
-        confidence: 0.5
-      }
-      
-      assert.ok(Array.isArray(parseResult.toolCalls))
-      assert.ok(typeof parseResult.confidence === 'number')
-      assert.ok(Array.isArray(parseResult.errors))
-      assert.ok(typeof parseResult.text === 'string')
-    })
-
-    it('parseText returns ParseResult with all required fields', () => {
-      const input = '{"tool":"search","input":{"query":"test"}}'
-      const result = parseText(input)
-      
-      // Should have all ParserResult fields + confidence
-      assert.ok(typeof result.text === 'string')
-      assert.ok(Array.isArray(result.toolCalls))
-      assert.ok(Array.isArray(result.errors))
-      assert.ok(typeof result.confidence === 'number')
-    })
-  })
-
-  describe('src/tools/ directory isolation verification', () => {
-    it('tools/registry.ts has syntax error (Map initialization)', async () => {
-      // This test documents that tools/registry.ts has a bug:
-      // const toolRegistry: Map<string, ToolRegistration> = Map()
-      // Should be: new Map()
-      // The file is unused by the main codebase anyway
-      
-      const registryModule = await import('../tools/registry.js').catch(() => null)
-      
-      // If the module can't be imported due to syntax error, that confirms the issue
-      if (registryModule === null) {
-        assert.ok(true, 'Registry module has syntax error as expected')
-      }
-    })
-
-    it('tools/parser.ts StreamingToolParser is used by main codebase', async () => {
-      // This verifies that StreamingToolParser IS actually used
-      const { StreamingToolParser } = await import('../tools/parser.js')
-      
-      assert.ok(typeof StreamingToolParser === 'function')
-      
-      const parser = new StreamingToolParser()
-      assert.ok(typeof parser.feed === 'function')
-    })
-  })
-
-  describe('LinterConfig duplication verification', () => {
-    it('LinterConfig in index.ts duplicates constructor param type from bar.ts', () => {
-      // bar.ts defines inline config type:
-      // { registry?: ToolRegistry; strictMode?: boolean; ... }
-      // 
-      // index.ts defines LinterConfig interface:
-      // { registry?: ToolRegistry; strictMode?: boolean; ... }
-      //
-      // These are functionally identical but defined separately
-      
-      const linter = new UltraToolCallLinter({
-        strictMode: true,
-        enableSecurityGate: false,
-        maxRecoveryAttempts: 5,
-        minConfidenceThreshold: 0.5
-      })
-      
-      assert.ok(linter instanceof UltraToolCallLinter)
-    })
-  })
-})

package/src/tools/ast.ts

@@ -1,15 +0,0 @@
-import type { JsonSchema } from './types.js';
-
-export interface ToolCallAST {
-  id: string;
-  name: string;
-  arguments: unknown;
-  raw: string;
-  confidence: number;
-}
-
-export interface ToolDefinition {
-  name: string;
-  description?: string;
-  schema: JsonSchema;
-}

package/src/tools/coercion.ts

@@ -1,67 +0,0 @@
-import type { JsonSchema } from './types.js';
-
-export function coerceArguments(args: unknown, schema: JsonSchema): unknown {
-  if (typeof args !== 'object' || args === null || Array.isArray(args)) {
-    return args;
-  }
-
-  const coerced: Record<string, unknown> = {};
-  const properties = schema.properties || {};
-
-  for (const [key, value] of Object.entries(args as Record<string, unknown>)) {
-    const propSchema = properties[key];
-    if (propSchema && typeof propSchema === 'object') {
-      coerced[key] = coerceValue(value, propSchema);
-    } else {
-      coerced[key] = value;
-    }
-  }
-
-  return coerced;
-}
-
-function coerceValue(value: unknown, schema: JsonSchema): unknown {
-  if (typeof value !== 'string') {
-    if (Array.isArray(value) && schema.type === 'array' && schema.items) {
-      return value.map(item => coerceValue(item, schema.items!));
-    }
-    if (typeof value === 'object' && value !== null && schema.type === 'object' && schema.properties) {
-      return coerceArguments(value, { type: 'object', properties: schema.properties!, required: schema.required });
-    }
-    return value;
-  }
-
-  const trimmed = value.trim();
-
-  if (schema.type === 'boolean') {
-    if (trimmed.toLowerCase() === 'true') return true;
-    if (trimmed.toLowerCase() === 'false') return false;
-  }
-
-  if (schema.type === 'integer' || schema.type === 'number') {
-    if (/^-?\d+(\.\d+)?$/.test(trimmed)) {
-      const num = Number(trimmed);
-      if (!Number.isNaN(num)) {
-        return schema.type === 'integer' ? Math.trunc(num) : num;
-      }
-    }
-  }
-
-  if (schema.type === 'array' && trimmed.startsWith('[')) {
-    try {
-      return JSON.parse(trimmed);
-    } catch {
-      // fall through
-    }
-  }
-
-  if (schema.type === 'object' && trimmed.startsWith('{')) {
-    try {
-      return JSON.parse(trimmed);
-    } catch {
-      // fall through
-    }
-  }
-
-  return value;
-}

package/src/tools/confidence.ts

@@ -1,48 +0,0 @@
-import type { ToolCallAST, ToolDefinition } from './ast.js';
-
-export interface ConfidenceResult {
-  score: number;
-  reasons: string[];
-}
-
-export function calculateConfidence(ast: ToolCallAST, toolDef: ToolDefinition): ConfidenceResult {
-  let score = 0.0;
-  const reasons: string[] = [];
-
-  if (ast.name && toolDef.name === ast.name) {
-    score += 0.4;
-    reasons.push('Tool name matches registry');
-  }
-
-  if (ast.arguments && typeof ast.arguments === 'object' && !Array.isArray(ast.arguments)) {
-    score += 0.3;
-    reasons.push('Arguments are a valid object');
-  } else if (typeof ast.arguments === 'string') {
-    try {
-      JSON.parse(ast.arguments as string);
-      score += 0.15;
-      reasons.push('Arguments are a valid JSON string');
-    } catch {
-      reasons.push('Arguments are an invalid JSON string');
-    }
-  } else {
-    reasons.push('Arguments are missing or invalid type');
-  }
-
-  const schema = toolDef.schema as any;
-  if (schema && schema.required && Array.isArray(schema.required)) {
-    const args = (ast.arguments as Record<string, unknown>) || {};
-    const hasAllRequired = schema.required.every((field: string) => field in args);
-    if (hasAllRequired) {
-      score += 0.3;
-      reasons.push('All required fields are present');
-    } else {
-      reasons.push('Missing required fields');
-    }
-  } else {
-    score += 0.3;
-    reasons.push('No required fields to validate');
-  }
-
-  return { score: Math.min(score, 1.0), reasons };
-}

package/src/tools/detector.ts

@@ -1,40 +0,0 @@
-import { robustParseJSON } from '../utils/json.js';
-
-export interface DetectedTool {
-  raw: string;
-  extracted: Record<string, unknown>;
-}
-
-const TOOL_CALL_REGEX = /\b[^>]*>([\s\S]*?)<\/tool_call>/gi;
-
-export function detectToolCalls(text: string): DetectedTool[] {
-  const results: DetectedTool[] = [];
-
-  let match;
-  while ((match = TOOL_CALL_REGEX.exec(text)) !== null) {
-    const raw = match[0];
-    const content = match[1].trim();
-    const parsed = robustParseJSON(content);
-    if (parsed && typeof parsed === 'object') {
-      results.push({ raw, extracted: parsed });
-    } else {
-      results.push({ raw, extracted: { _rawContent: content } });
-    }
-  }
-
-  if (results.length === 0) {
-    const parsed = robustParseJSON(text);
-    if (parsed && typeof parsed === 'object') {
-      if (
-        'name' in parsed ||
-        'tool' in parsed ||
-        'function' in parsed ||
-        'function_call' in parsed
-      ) {
-        results.push({ raw: text.trim(), extracted: parsed });
-      }
-    }
-  }
-
-  return results;
-}