@pedrofariasx/qwenproxy 1.1.0

package/src/utils/json.ts

@@ -0,0 +1,114 @@
+/*
+ * File: json.ts
+ * Project: qwenproxy
+ * Robust JSON parsing utilities
+ */
+
+function sanitizeAndBalance(input: string): { result: string; openBraces: number; openBrackets: number } {
+  let out = '';
+  let openBraces = 0;
+  let openBrackets = 0;
+  let inString = false;
+  let escaped = false;
+
+  for (let i = 0; i < input.length; i++) {
+    const char = input[i];
+    if (escaped) {
+      const validEscapes = ['n', 'r', 't', 'u', '"', '\\', '/'];
+      if (validEscapes.includes(char)) {
+        if (char === 'u') {
+          const next4 = input.substring(i + 1, i + 5);
+          out += /^[0-9a-fA-F]{4}$/.test(next4) ? '\\' + char : '\\\\' + char;
+        } else if (['n', 'r', 't'].includes(char)) {
+          const isWinPath = /[a-zA-Z]:\\/i.test(input) || /[a-zA-Z]:\//i.test(input);
+          const nextChar = input[i + 1] || '';
+          out += (isWinPath && /^[a-zA-Z0-9]/.test(nextChar)) ? '\\\\' + char : '\\' + char;
+        } else {
+          out += '\\' + char;
+        }
+      } else {
+        out += '\\\\' + char;
+      }
+      escaped = false;
+      continue;
+    }
+    if (char === '\\') { escaped = true; continue; }
+    if (char === '"') { inString = !inString; out += char; continue; }
+    if (inString) {
+      if (char === '\n') out += '\\n';
+      else if (char === '\r') out += '\\r';
+      else if (char === '\t') out += '\\t';
+      else if (char.charCodeAt(0) < 32) out += '\\u' + char.charCodeAt(0).toString(16).padStart(4, '0');
+      else out += char;
+    } else {
+      out += char;
+      if (char === '{') openBraces++;
+      if (char === '}') openBraces--;
+      if (char === '[') openBrackets++;
+      if (char === ']') openBrackets--;
+    }
+  }
+  return { result: out, openBraces, openBrackets };
+}
+
+function closeBraces(input: string, openBraces: number, openBrackets: number): string {
+  let out = input;
+  if (openBrackets > 0) out += ']'.repeat(openBrackets);
+  if (openBraces > 0) out += '}'.repeat(openBraces);
+  return out;
+}
+
+export function robustParseJSON(str: string): any {
+  let sanitized = str.trim();
+  sanitized = sanitized.replace(/^```json\s*/, '').replace(/```$/, '').trim();
+
+  const firstBrace = sanitized.indexOf('{');
+  if (firstBrace === -1) return null;
+
+  let jsonPart = sanitized.substring(firstBrace);
+  try { return JSON.parse(jsonPart); } catch (e) { /* continue */ }
+
+  let currentJson = jsonPart.replace(/([{,]\s*)([a-zA-Z_][a-zA-Z0-9_]*)(\s*:)/g, '$1"$2"$3');
+  currentJson = currentJson.replace(/([{,]\s*)"([a-zA-Z0-9_]+)"\s*:\s*"\2"\s*:/g, '$1"$2":');
+  currentJson = currentJson.replace(/([{,]\s*)([a-zA-Z0-9_]+)\s*:\s*\2\s*:/g, '$1$2:');
+
+  try { return JSON.parse(currentJson); } catch (e) { /* continue */ }
+
+  let cleaned = currentJson.trim();
+  while (cleaned.length > 0 && !/[}\]"0-9a-z]/i.test(cleaned[cleaned.length - 1])) {
+    cleaned = cleaned.slice(0, -1).trim();
+  }
+
+  const { result: fixedJson, openBraces, openBrackets } = sanitizeAndBalance(cleaned);
+  let lastBalancedIndex = -1;
+
+  { let ob = 0, bk = 0, ins = false, esc = false;
+    for (let i = 0; i < fixedJson.length; i++) {
+      const c = fixedJson[i];
+      if (esc) { esc = false; continue; }
+      if (c === '\\') { esc = true; continue; }
+      if (c === '"') { ins = !ins; continue; }
+      if (!ins) {
+        if (c === '{') ob++; if (c === '}') ob--;
+        if (c === '[') bk++; if (c === ']') bk--;
+        if (ob === 0 && bk === 0) lastBalancedIndex = i;
+      }
+    }
+  }
+
+  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);
+  }
+
+  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 {
+    return null;
+  }
+}
+}

package/src/utils/qwen-stream-parser.ts

@@ -0,0 +1,286 @@
+/*
+ * File: qwen-stream-parser.ts
+ * Project: qwenproxy
+ * Author: Pedro Farias
+ * Created: 2026-06-02
+ *
+ * Shared SSE parser for Qwen stream responses.
+ * Eliminates duplication between streaming and non-streaming code paths.
+ */
+
+import { updateSessionParent } from '../services/qwen.js';
+import { getIncrementalDelta } from '../routes/chat.js';
+import { StreamingToolParser } from '../tools/parser.js';
+import type { FunctionToolDefinition } from '../tools/types.js';
+
+export interface QwenStreamDelta {
+  phase: string;
+  content?: string;
+  extra?: {
+    summary_thought?: {
+      content: string[];
+    };
+  };
+}
+
+export interface QwenStreamChunk {
+  'response.created'?: {
+    response_id: string;
+  };
+  response_id?: string;
+  usage?: {
+    input_tokens?: number;
+    output_tokens?: number;
+  };
+  choices?: Array<{
+    delta: QwenStreamDelta;
+  }>;
+}
+
+export interface ParsedChunkResult {
+  /** The extracted content string (delta for thinking or answer phase). Empty if none. */
+  content: string;
+  /** True if this chunk belongs to the thinking/reasoning phase. */
+  isThinking: boolean;
+}
+
+export interface StreamParserState {
+  targetResponseId: string | null;
+  currentThoughtIndex: number;
+  lastFullContent: string;
+  reasoningBuffer: string;
+  promptTokens: number;
+  completionTokens: number;
+}
+
+export interface QwenStreamParseOptions {
+  /** Tool definitions for the streaming tool parser. Pass [] or null to disable tool parsing. */
+  tools?: FunctionToolDefinition[];
+  /** Callback invoked when a response_id is discovered. */
+  onTargetResponseId?: (responseId: string, uiSessionId: string) => void;
+  /** Callback invoked for each parsed thinking content delta. */
+  onThinking?: (content: string) => void;
+  /** Callback invoked for each parsed answer content delta. */
+  onAnswer?: (content: string) => void;
+  /** Callback invoked for each tool call parsed from the answer stream. */
+  onToolCall?: (toolCall: {
+    id: string;
+    name: string;
+    arguments: Record<string, unknown>;
+  }) => void;
+}
+
+/**
+ * QwenStreamParser handles parsing of Qwen's SSE stream chunks for both
+ * streaming and non-streaming response modes.
+ *
+ * It extracts:
+ * - response_id for session tracking
+ * - usage statistics (input/output tokens)
+ * - thinking_summary content (reasoning)
+ * - answer content (final response text)
+ * - tool calls embedded in the answer stream
+ */
+export class QwenStreamParser {
+  private readonly uiSessionId: string;
+  private readonly options: Required<Pick<QwenStreamParseOptions, 'tools'>> & Omit<QwenStreamParseOptions, 'tools'>;
+
+  private _state: StreamParserState;
+  private toolParser: StreamingToolParser | null;
+  private readonly bufferAccumulator: string[] = [];
+
+  constructor(uiSessionId: string, options: QwenStreamParseOptions = {}) {
+    this.uiSessionId = uiSessionId;
+    this.options = {
+      tools: options.tools ?? [],
+      onTargetResponseId: options.onTargetResponseId,
+      onThinking: options.onThinking,
+      onAnswer: options.onAnswer,
+      onToolCall: options.onToolCall,
+    };
+
+    this._state = {
+      targetResponseId: null,
+      currentThoughtIndex: 0,
+      lastFullContent: '',
+      reasoningBuffer: '',
+      promptTokens: 0,
+      completionTokens: 0,
+    };
+
+    this.toolParser = this.options.tools && this.options.tools.length > 0
+      ? new StreamingToolParser(this.options.tools)
+      : null;
+  }
+
+  /** Get the current parser state (read-only). */
+  get state(): Readonly<StreamParserState> {
+    return this._state;
+  }
+
+  /** Get accumulated reasoning buffer. */
+  get reasoningBuffer(): string {
+    return this._state.reasoningBuffer;
+  }
+
+  /** Get accumulated answer content. */
+  get answerContent(): string {
+    return this._state.lastFullContent;
+  }
+
+  /** Get token usage statistics. */
+  get usage(): { promptTokens: number; completionTokens: number } {
+    return {
+      promptTokens: this._state.promptTokens,
+      completionTokens: this._state.completionTokens,
+    };
+  }
+
+  /**
+   * Process a single raw SSE line (the part after "data: ").
+   * Returns the parsed result, or null if the line should be skipped.
+   */
+  parseLine(rawData: string): ParsedChunkResult | null {
+    if (rawData === '[DONE]') return null;
+
+    let chunk: QwenStreamChunk;
+    try {
+      chunk = JSON.parse(rawData);
+    } catch {
+      return null; // Partial/malformed chunk, skip
+    }
+
+    // Track response_id for session continuity
+    this.updateResponseId(chunk);
+
+    // Track token usage
+    this.updateUsage(chunk);
+
+    // Extract content delta
+    const delta = this.extractDelta(chunk);
+    if (!delta) return null;
+
+    if (delta.content === 'FINISHED') return null;
+
+    if (delta.isThinking) {
+      this._state.reasoningBuffer += delta.content;
+      this.options.onThinking?.(delta.content);
+    } else {
+      // Update incremental content tracking
+      const deltaResult = getIncrementalDelta(this._state.lastFullContent, delta.content);
+      this._state.lastFullContent = deltaResult.matchedContent;
+
+      // Process through tool parser if enabled
+      if (this.toolParser) {
+        const { text, toolCalls } = this.toolParser.feed(delta.content);
+        // text is the lead-in before any tool_call tag.
+        // In non-streaming mode, the lead-in is preserved and recovered only if tool calls fail.
+        // In streaming mode, the caller decides whether to emit it.
+        for (const tc of toolCalls) {
+          this.options.onToolCall?.({
+            id: tc.id,
+            name: tc.name,
+            arguments: tc.arguments,
+          });
+        }
+        // Accumulate non-tool text
+        if (text) {
+          this._state.lastFullContent = this._state.lastFullContent.slice(0, this._state.lastFullContent.length - delta.content.length) + text + delta.content;
+        }
+      } else {
+        // Fast path: no tools, content already tracked in lastFullContent via getIncrementalDelta
+      }
+
+      this.options.onAnswer?.(delta.content);
+    }
+
+    return delta;
+  }
+
+  /**
+   * Feed accumulated buffer content and return any remaining text/tool calls
+   * that were not fully parsed (useful for flushing at end of stream).
+   */
+  flush(): { text: string; toolCalls: Array<{ id: string; name: string; arguments: Record<string, unknown> }> } {
+    if (this.toolParser) {
+      return this.toolParser.flush();
+    }
+    return { text: '', toolCalls: [] };
+  }
+
+  /**
+   * Reset the parser state for reuse with a new stream.
+   */
+  reset(): void {
+    this._state = {
+      targetResponseId: null,
+      currentThoughtIndex: 0,
+      lastFullContent: '',
+      reasoningBuffer: '',
+      promptTokens: this._state.promptTokens,
+      completionTokens: this._state.completionTokens,
+    };
+    this.toolParser = this.options.tools && this.options.tools.length > 0
+      ? new StreamingToolParser(this.options.tools)
+      : null;
+  }
+
+  // -- Private helpers --
+
+  private updateResponseId(chunk: QwenStreamChunk): void {
+    if (chunk['response.created'] && chunk['response.created'].response_id) {
+      if (!this._state.targetResponseId) {
+        this._state.targetResponseId = chunk['response.created'].response_id;
+      }
+      updateSessionParent(this.uiSessionId, chunk['response.created'].response_id);
+      this.options.onTargetResponseId?.(chunk['response.created'].response_id, this.uiSessionId);
+    } else if (chunk.response_id && !this._state.targetResponseId) {
+      this._state.targetResponseId = chunk.response_id;
+      updateSessionParent(this.uiSessionId, chunk.response_id);
+      this.options.onTargetResponseId?.(chunk.response_id, this.uiSessionId);
+    }
+  }
+
+  private updateUsage(chunk: QwenStreamChunk): void {
+    if (chunk.usage) {
+      if (chunk.usage.output_tokens) {
+        this._state.completionTokens = chunk.usage.output_tokens;
+      }
+      if (chunk.usage.input_tokens) {
+        this._state.promptTokens = chunk.usage.input_tokens;
+      }
+    }
+  }
+
+  private extractDelta(chunk: QwenStreamChunk): ParsedChunkResult | null {
+    if (!chunk.choices || !chunk.choices[0] || !chunk.choices[0].delta) {
+      return null;
+    }
+
+    // Filter by target response_id if one has been established
+    if (this._state.targetResponseId !== null && chunk.response_id !== this._state.targetResponseId) {
+      return null;
+    }
+
+    const delta = chunk.choices[0].delta;
+
+    if (delta.phase === 'thinking_summary') {
+      if (delta.extra?.summary_thought?.content) {
+        const thoughts = delta.extra.summary_thought.content;
+        if (thoughts.length > this._state.currentThoughtIndex) {
+          const content = thoughts.slice(this._state.currentThoughtIndex).join('\n');
+          this._state.currentThoughtIndex = thoughts.length;
+          return { content, isThinking: true };
+        }
+      }
+      return null;
+    }
+
+    if (delta.phase === 'answer') {
+      const content = delta.content ?? '';
+      return { content, isThinking: false };
+    }
+
+    return null;
+  }
+}

package/src/utils/types.ts

@@ -0,0 +1,101 @@
+/*
+ * File: types.ts
+ * Project: qwenproxy
+ * Author: Pedro Farias
+ * Created: 2026-05-09
+ * 
+ * Last Modified: Sat May 09 2026
+ * Modified By: Pedro Farias
+ */
+
+import type { JsonSchema, FunctionToolDefinition } from '../tools/types.ts';
+export type { JsonSchema, FunctionToolDefinition };
+
+/** Tool choice options */
+export type ToolChoice = 'auto' | 'none' | 'required' | {
+  type: 'function';
+  function: { name: string };
+};
+
+// --- Message Types ---
+
+export interface ToolCallFunction {
+  name: string;
+  arguments: string;
+}
+
+export interface MessageToolCall {
+  id: string;
+  type: 'function';
+  function: ToolCallFunction;
+}
+
+export interface Message {
+  role: string;
+  content: string | null;
+  /** Present on assistant messages that invoked tools */
+  tool_calls?: MessageToolCall[];
+  /** Present on tool/function response messages to link back to a call */
+  tool_call_id?: string;
+  /** Present on tool/function response messages */
+  name?: string;
+  /** Reasoning content for thinking models */
+  reasoning_content?: string;
+}
+
+// --- Request Types ---
+
+export interface OpenAIRequest {
+  model: string;
+  messages: Message[];
+  stream?: boolean;
+  tools?: FunctionToolDefinition[];
+  tool_choice?: ToolChoice;
+  stream_options?: {
+    include_usage?: boolean;
+  };
+}
+
+// --- Response Types ---
+
+export interface ToolCall {
+  index: number;
+  id?: string;
+  type: string;
+  function: {
+    name: string;
+    arguments: string;
+  };
+}
+
+export interface ChoiceDelta {
+  role?: string;
+  content?: string | null;
+  reasoning_content?: string | null;
+  tool_calls?: ToolCall[];
+}
+
+export interface Choice {
+  index: number;
+  delta?: ChoiceDelta;
+  message?: ChoiceDelta;
+  finish_reason: string | null;
+}
+
+export interface Usage {
+  prompt_tokens: number;
+  completion_tokens: number;
+  total_tokens: number;
+  prompt_tokens_details?: {
+    cached_tokens: number;
+  };
+}
+
+export interface ChatCompletionChunk {
+  id: string;
+  object: string;
+  created: number;
+  model: string;
+  choices: Choice[];
+  usage?: Usage;
+}