@pedrofariasx/qwenproxy 1.2.1 → 1.2.3

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

package/src/tools/registry-runtime.ts

@@ -1,34 +0,0 @@
-import type { ToolDefinition } from './ast.js';
-
-export class RequestToolRegistry {
-  private registry: Map<string, ToolDefinition>;
-
-  constructor(requestTools: unknown[] = []) {
-    this.registry = new Map();
-    for (const tool of requestTools) {
-      if (tool && typeof tool === 'object') {
-        const t = tool as any;
-        if (t.type === 'function' && t.function && typeof t.function === 'object') {
-          const fn = t.function;
-          this.registry.set(fn.name, {
-            name: fn.name,
-            description: fn.description,
-            schema: fn.parameters || {},
-          });
-        }
-      }
-    }
-  }
-
-  has(name: string): boolean {
-    return this.registry.has(name);
-  }
-
-  get(name: string): ToolDefinition | undefined {
-    return this.registry.get(name);
-  }
-
-  list(): ToolDefinition[] {
-    return Array.from(this.registry.values());
-  }
-}

package/src/tools/repair.ts

@@ -1,42 +0,0 @@
-export interface RepairedTool {
-  name: string;
-  arguments: unknown;
-}
-
-export function repairToolCall(extracted: Record<string, unknown>): RepairedTool | null {
-  if ('tool' in extracted && !('name' in extracted)) {
-    return {
-      name: String(extracted.tool),
-      arguments: extracted.arguments || {},
-    };
-  }
-
-  if ('function' in extracted && typeof extracted.function === 'object' && extracted.function !== null) {
-    const fn = extracted.function as Record<string, unknown>;
-    if ('name' in fn) {
-      return {
-        name: String(fn.name),
-        arguments: fn.arguments || {},
-      };
-    }
-  }
-
-  if ('function_call' in extracted && typeof extracted.function_call === 'object' && extracted.function_call !== null) {
-    const fn = extracted.function_call as Record<string, unknown>;
-    if ('name' in fn) {
-      return {
-        name: String(fn.name),
-        arguments: fn.arguments || {},
-      };
-    }
-  }
-
-  if ('name' in extracted) {
-    return {
-      name: String(extracted.name),
-      arguments: extracted.arguments || {},
-    };
-  }
-
-  return null;
-}

package/src/tools/validator.ts

@@ -1,33 +0,0 @@
-import Ajv from 'ajv';
-import type { ToolCallAST, ToolDefinition } from './ast.js';
-
-const ajv = new Ajv({ allErrors: true, strict: false });
-
-export interface ValidationResult {
-  valid: boolean;
-  errors: any[] | null;
-  missingFields: string[];
-}
-
-export function validateToolCall(ast: ToolCallAST, toolDef: ToolDefinition): ValidationResult {
-  const validate = ajv.compile(toolDef.schema);
-  const valid = validate(ast.arguments);
-
-  const missingFields: string[] = [];
-  if (toolDef.schema && typeof toolDef.schema === 'object' && 'required' in toolDef.schema) {
-    const required = (toolDef.schema as any).required;
-    if (Array.isArray(required)) {
-      for (const field of required) {
-        if (!(ast.arguments && typeof ast.arguments === 'object' && field in (ast.arguments as Record<string, unknown>))) {
-          missingFields.push(field);
-        }
-      }
-    }
-  }
-
-  return {
-    valid,
-    errors: validate.errors ?? null,
-    missingFields,
-  };
-}