@pedrofariasx/qwenproxy 1.2.1 → 1.2.2

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

package/src/tools/executor.ts

@@ -1,236 +0,0 @@
-/*
- * File: executor.ts
- * Project: qwenproxy
- * Execution loop for tool calling - agentic loop that handles
- * send -> tool calls -> execute -> re-send until completion
- */
-
-import { v4 as uuidv4 } from 'uuid';
-import type { ParsedToolCall, ToolCallResult, ToolContext } from './types';
-import { SchemaValidationError } from './schema.js';
-import { registry } from './registry';
-import { robustParseJSON } from '../utils/json.js';
-
-export interface ExecutionLoopConfig {
-  maxTurns?: number;
-  debug?: boolean;
-}
-
-export interface LoopTurnResult {
-  toolCalls: ParsedToolCall[];
-  toolResults: ToolCallResult[];
-  content: string | null;
-  finishReason: string | null;
-  turn: number;
-}
-
-export type LLMSendFunction = (
-  messages: unknown[],
-  tools: unknown[] | undefined,
-  model: string
-) => Promise<LLMResponse>;
-
-export interface LLMResponse {
-  content: string | null;
-  toolCalls: ParsedToolCall[];
-  finishReason: string;
-}
-
-const TOOL_START_TAG = '<' + 'tool_call>';
-const TOOL_END_TAG = '</' + 'tool_call>';
-
-export function parseToolCallsFromContent(content: string): {
-  textContent: string;
-  toolCalls: ParsedToolCall[];
-} {
-  const toolCalls: ParsedToolCall[] = [];
-  let remaining = content;
-  let textContent = '';
-
-  while (true) {
-    const startIdx = remaining.indexOf(TOOL_START_TAG);
-    if (startIdx === -1) {
-      textContent += remaining;
-      break;
-    }
-
-    textContent += remaining.substring(0, startIdx);
-
-    const endIdx = remaining.indexOf(TOOL_END_TAG, startIdx + TOOL_START_TAG.length);
-    if (endIdx === -1) {
-      textContent += remaining.substring(startIdx);
-      break;
-    }
-
-    const jsonStr = remaining
-      .substring(startIdx + TOOL_START_TAG.length, endIdx)
-      .trim();
-
-    try {
-      const parsed = robustParseJSON(jsonStr);
-      if (!parsed) throw new Error('Failed to parse JSON');
-      
-      toolCalls.push({
-        id: 'call_' + uuidv4(),
-        name: parsed.name || '',
-        arguments: parsed.arguments 
-          ? (typeof parsed.arguments === 'string' ? JSON.parse(parsed.arguments) : parsed.arguments)
-          : (() => {
-              const { name, ...rest } = parsed;
-              return rest;
-            })(),
-      });
-    } catch (e) {
-      textContent += TOOL_START_TAG + jsonStr + TOOL_END_TAG;
-    }
-
-    remaining = remaining.substring(endIdx + TOOL_END_TAG.length);
-  }
-
-  return { textContent: textContent.trim(), toolCalls };
-}
-
-export async function executeToolCalls(
-  toolCalls: ParsedToolCall[],
-  context: ToolContext
-): Promise<ToolCallResult[]> {
-  return await Promise.all(
-    toolCalls.map(async (tc) => {
-      try {
-        if (!registry.has(tc.name)) {
-          return {
-            toolCallId: tc.id,
-            name: tc.name,
-            result: JSON.stringify({ error: `Unknown tool: '${tc.name}'` }),
-            isError: true,
-          };
-        }
-
-        const result = await registry.execute(tc.name, tc.arguments, context);
-        return {
-          toolCallId: tc.id,
-          name: tc.name,
-          result,
-          isError: false,
-        };
-      } catch (err: unknown) {
-        const message = err instanceof Error ? err.message : String(err);
-        const isValidation = err instanceof SchemaValidationError;
-        return {
-          toolCallId: tc.id,
-          name: tc.name,
-          result: JSON.stringify({
-            error: isValidation ? 'Schema validation failed' : 'Tool execution error',
-            details: message,
-            ...(isValidation ? { path: (err as SchemaValidationError).path } : {}),
-          }),
-          isError: true,
-        };
-      }
-    })
-  );
-}
-
-function buildToolMessage(result: ToolCallResult): Record<string, unknown> {
-  return {
-    role: 'tool',
-    tool_call_id: result.toolCallId,
-    content: result.result,
-  };
-}
-
-function buildAssistantToolCallMessage(
-  content: string | null,
-  toolCalls: ParsedToolCall[]
-): Record<string, unknown> {
-  return {
-    role: 'assistant',
-    content: content || null,
-    tool_calls: toolCalls.map((tc) => ({
-      id: tc.id,
-      type: 'function',
-      function: {
-        name: tc.name,
-        arguments: typeof tc.arguments === 'string'
-          ? tc.arguments
-          : JSON.stringify(tc.arguments),
-      },
-    })),
-  };
-}
-
-export async function runExecutionLoop(
-  sendToLLM: LLMSendFunction,
-  messages: unknown[],
-  model: string,
-  config: ExecutionLoopConfig = {}
-): Promise<string> {
-  const maxTurns = config.maxTurns ?? 10;
-  const debug = config.debug ?? false;
-
-  const tools = registry.listNames().length > 0
-    ? registry.toOpenAITools()
-    : undefined;
-
-  for (let turn = 0; turn < maxTurns; turn++) {
-    if (debug) {
-      console.log(`[executor] Turn ${turn + 1}/${maxTurns}, messages: ${messages.length}`);
-    }
-
-    const response = await sendToLLM(messages, tools, model);
-
-    const hasStructuredToolCalls = response.toolCalls && response.toolCalls.length > 0;
-    let parsedFromContent: { textContent: string; toolCalls: ParsedToolCall[] } | null = null;
-
-    if (!hasStructuredToolCalls && response.content) {
-      parsedFromContent = parseToolCallsFromContent(response.content);
-    }
-
-    const effectiveToolCalls = hasStructuredToolCalls
-      ? response.toolCalls
-      : parsedFromContent?.toolCalls || [];
-
-    const effectiveContent = parsedFromContent
-      ? parsedFromContent.textContent
-      : response.content;
-
-    if (effectiveToolCalls.length === 0) {
-      if (debug) {
-        console.log('[executor] No tool calls, loop complete');
-      }
-      return effectiveContent || '';
-    }
-
-    const context: ToolContext = {
-      messages,
-      turn,
-      model,
-    };
-
-    if (debug) {
-      console.log(
-        `[executor] Executing ${effectiveToolCalls.length} tool calls:`,
-        effectiveToolCalls.map((tc) => tc.name)
-      );
-    }
-
-    const toolResults = await executeToolCalls(effectiveToolCalls, context);
-
-    messages.push(buildAssistantToolCallMessage(effectiveContent, effectiveToolCalls));
-
-    for (const result of toolResults) {
-      messages.push(buildToolMessage(result));
-    }
-
-    if (debug) {
-      console.log(
-        `[executor] Tool results:`,
-        toolResults.map((r) => ({ name: r.name, isError: r.isError }))
-      );
-    }
-  }
-
-  throw new Error(
-    `Execution loop exceeded maximum turns (${maxTurns}). The agent may be stuck in a cycle.`
-  );
-}

package/src/tools/pipeline.ts

@@ -1,122 +0,0 @@
-import type { ToolCallAST, ToolDefinition } from './ast.js';
-import { detectToolCalls } from './detector.js';
-import { repairToolCall } from './repair.js';
-import { RequestToolRegistry } from './registry-runtime.js';
-import { coerceArguments } from './coercion.js';
-import { validateToolCall, type ValidationResult } from './validator.js';
-import { calculateConfidence } from './confidence.js';
-import { v4 as uuidv4 } from 'uuid';
-
-export interface PipelineResult {
-  textContent: string;
-  toolCalls: ToolCallAST[];
-  errors: Array<{
-    toolName?: string;
-    code: string;
-    message: string;
-    details?: any;
-  }>;
-}
-
-const CONFIDENCE_THRESHOLD = 0.7;
-
-export function processToolCalls(
-  text: string,
-  requestTools: unknown[]
-): PipelineResult {
-  const registry = new RequestToolRegistry(requestTools);
-  const detected = detectToolCalls(text);
-  
-  const toolCalls: ToolCallAST[] = [];
-  const errors: PipelineResult['errors'] = [];
-  let textContent = text;
-
-  for (const det of detected) {
-    while (textContent.includes(det.raw)) {
-      textContent = textContent.replace(det.raw, '').trim();
-    }
-  }
-
-  for (const det of detected) {
-    const repaired = repairToolCall(det.extracted);
-    if (!repaired) {
-      errors.push({
-        code: 'MALFORMED_TOOL_CALL',
-        message: 'Could not repair or identify tool call structure',
-        details: det.extracted,
-      });
-      continue;
-    }
-
-    if (!registry.has(repaired.name)) {
-      errors.push({
-        toolName: repaired.name,
-        code: 'UNKNOWN_TOOL',
-        message: `Tool '${repaired.name}' is not registered or provided in the request`,
-      });
-      continue;
-    }
-
-    const toolDef = registry.get(repaired.name)!;
-    const coercedArgs = coerceArguments(repaired.arguments, toolDef.schema);
-
-    const ast: ToolCallAST = {
-      id: `call_${uuidv4()}`,
-      name: repaired.name,
-      arguments: coercedArgs,
-      raw: det.raw,
-      confidence: 0.0,
-    };
-
-    const validation: ValidationResult = validateToolCall(ast, toolDef);
-    const confidenceResult = calculateConfidence(ast, toolDef);
-    ast.confidence = confidenceResult.score;
-
-    if (!validation.valid) {
-      if (validation.missingFields.length > 0) {
-        errors.push({
-          toolName: ast.name,
-          code: 'MISSING_REQUIRED_FIELD',
-          message: `Missing required fields: ${validation.missingFields.join(', ')}`,
-          details: validation.errors,
-        });
-      } else {
-        errors.push({
-          toolName: ast.name,
-          code: 'SCHEMA_VALIDATION_FAILED',
-          message: 'Arguments do not match the tool schema',
-          details: validation.errors,
-        });
-      }
-      continue;
-    }
-
-    if (ast.confidence >= CONFIDENCE_THRESHOLD) {
-      toolCalls.push(ast);
-    } else {
-      errors.push({
-        toolName: ast.name,
-        code: 'LOW_CONFIDENCE',
-        message: `Tool call confidence ${ast.confidence} is below threshold ${CONFIDENCE_THRESHOLD}`,
-        details: confidenceResult.reasons,
-      });
-    }
-  }
-
-  return {
-    textContent,
-    toolCalls,
-    errors,
-  };
-}
-
-export function formatOpenAIToolCalls(toolCalls: ToolCallAST[]): any[] {
-  return toolCalls.map(tc => ({
-    id: tc.id,
-    type: 'function',
-    function: {
-      name: tc.name,
-      arguments: JSON.stringify(tc.arguments),
-    },
-  }));
-}