@pedrofariasx/qwenproxy 1.1.0

package/src/tests/concurrentChat.test.ts

@@ -0,0 +1,71 @@
+import test from 'node:test';
+import assert from 'node:assert';
+import net from 'node:net';
+import { serve } from '@hono/node-server';
+import { app } from '../api/server.js';
+import { initPlaywright, closePlaywright } from '../services/playwright.ts';
+
+function isPortAvailable(port: number): Promise<boolean> {
+  return new Promise((resolve) => {
+    const server = net.createServer();
+    server.once('error', () => resolve(false));
+    server.once('listening', () => {
+      server.close(() => resolve(true));
+    });
+    server.listen(port);
+  });
+}
+
+async function getFreePort(startPort: number): Promise<number> {
+  let port = startPort;
+  while (true) {
+    const available = await isPortAvailable(port);
+    if (available) return port;
+    port++;
+  }
+}
+
+test('Concurrent chat requests check for "chat is in progress"', { skip: process.env.CI ? 'Requires real accounts - skipped in CI' : false }, async () => {
+  const port = await getFreePort(3100);
+  const server = serve({ fetch: app.fetch, port });
+  console.log(`[ConcurrentTest] Server started on port ${port}`);
+
+  await initPlaywright(true);
+
+  try {
+    const requestPayload = {
+      model: 'qwen3.6-plus',
+      messages: [{ role: 'user', content: 'Say "hello" and nothing else.' }],
+      stream: false
+    };
+
+    console.log('[ConcurrentTest] Sending 2 requests concurrently...');
+    
+    const p1 = fetch(`http://localhost:${port}/v1/chat/completions`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(requestPayload)
+    });
+
+    const p2 = fetch(`http://localhost:${port}/v1/chat/completions`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(requestPayload)
+    });
+
+    const [res1, res2] = await Promise.all([p1, p2]);
+
+    const data1 = await res1.json();
+    const data2 = await res2.json();
+
+    console.log('[ConcurrentTest] Result 1:', res1.status, JSON.stringify(data1).substring(0, 200));
+    console.log('[ConcurrentTest] Result 2:', res2.status, JSON.stringify(data2).substring(0, 200));
+
+    assert.strictEqual(res1.status, 200, `Request 1 failed: ${JSON.stringify(data1)}`);
+    assert.strictEqual(res2.status, 200, `Request 2 failed: ${JSON.stringify(data2)}`);
+
+  } finally {
+    await closePlaywright();
+    server.close();
+  }
+});

package/src/tests/delta.test.ts

@@ -0,0 +1,63 @@
+import { test } from 'node:test';
+import assert from 'node:assert';
+import { getIncrementalDelta } from '../routes/chat.ts';
+
+test('getIncrementalDelta: handles strictly cumulative stream correctly', () => {
+  let accumulated = '';
+  
+  // Step 1
+  let chunk1 = 'const x = 1;';
+  let res1 = getIncrementalDelta(accumulated, chunk1);
+  assert.strictEqual(res1.delta, 'const x = 1;');
+  accumulated = res1.matchedContent;
+  
+  // Step 2
+  let chunk2 = 'const x = 1;\nconst y = 2;';
+  let res2 = getIncrementalDelta(accumulated, chunk2);
+  assert.strictEqual(res2.delta, '\nconst y = 2;');
+  accumulated = res2.matchedContent;
+
+  // Step 3
+  let chunk3 = 'const x = 1;\nconst y = 2;\nconst z = 3;';
+  let res3 = getIncrementalDelta(accumulated, chunk3);
+  assert.strictEqual(res3.delta, '\nconst z = 3;');
+  accumulated = res3.matchedContent;
+  
+  assert.strictEqual(accumulated, 'const x = 1;\nconst y = 2;\nconst z = 3;');
+});
+
+test('getIncrementalDelta: handles strictly incremental stream correctly', () => {
+  let accumulated = '';
+  
+  // Step 1
+  let chunk1 = 'const x = 1;';
+  let res1 = getIncrementalDelta(accumulated, chunk1);
+  assert.strictEqual(res1.delta, 'const x = 1;');
+  accumulated = res1.matchedContent;
+  
+  // Step 2
+  let chunk2 = '\nconst y = 2;';
+  let res2 = getIncrementalDelta(accumulated, chunk2);
+  assert.strictEqual(res2.delta, '\nconst y = 2;');
+  accumulated = res2.matchedContent;
+
+  // Step 3
+  let chunk3 = '\nconst z = 3;';
+  let res3 = getIncrementalDelta(accumulated, chunk3);
+  assert.strictEqual(res3.delta, '\nconst z = 3;');
+  accumulated = res3.matchedContent;
+  
+  assert.strictEqual(accumulated, 'const x = 1;\nconst y = 2;\nconst z = 3;');
+});
+
+test('getIncrementalDelta: does not suffer from false-positive repetitive word overlap bugs', () => {
+  // Previously, if oldStr ended in a common keyword and newStr started/contained the same keyword,
+  // it would incorrectly match them and strip them. Let's verify this is fixed.
+  let accumulated = 'import { useState } from \'react\';\nimport {';
+  let nextChunk = ' Button } from \'@/components/ui/button\';';
+  
+  let res = getIncrementalDelta(accumulated, nextChunk);
+  // It should treat the next chunk as strictly incremental and return it unchanged.
+  assert.strictEqual(res.delta, ' Button } from \'@/components/ui/button\';');
+  assert.strictEqual(res.matchedContent, 'import { useState } from \'react\';\nimport { Button } from \'@/components/ui/button\';');
+});

package/src/tests/index.test.ts

@@ -0,0 +1,356 @@
+import test from 'node:test';
+import assert from 'node:assert';
+
+process.env.TEST_MOCK_PLAYWRIGHT = 'true';
+// Ensure API_KEY is empty by default for existing tests
+process.env.API_KEY = '';
+
+import { app } from '../api/server.js';
+import { initPlaywright, closePlaywright } from '../services/playwright.ts';
+
+test('Health check endpoint returns 200', async () => {
+  const req = new Request('http://localhost/health');
+  const res = await app.fetch(req);
+  
+  assert.strictEqual(res.status, 200);
+  
+  const body = await res.json();
+  assert.ok(body.status === 'ok' || body.status === 'unknown');
+  assert.ok(body.timestamp);
+});
+
+test('Models endpoint returns qwen3.6-plus and qwen3.6-plus-no-thinking', async () => {
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = async (input: any) => {
+    const url = typeof input === 'string' ? input : input.url;
+    if (url.includes('/api/models')) {
+      return new Response(JSON.stringify({ data: [{ id: 'qwen3.6-plus', owned_by: 'qwen' }] }), { status: 200 });
+    }
+    return originalFetch(input);
+  };
+
+  try {
+    const req = new Request('http://localhost/v1/models');
+    const res = await app.fetch(req);
+    
+    assert.strictEqual(res.status, 200);
+    
+    const body = await res.json();
+    assert.strictEqual(body.object, 'list');
+    assert.ok(Array.isArray(body.data));
+    assert.ok(body.data.some((m: any) => m.id === 'qwen3.6-plus'));
+    assert.ok(body.data.some((m: any) => m.id === 'qwen3.6-plus-no-thinking'));
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test('Chat Completions endpoint with qwen3.6-plus (thinking enabled)', async () => {
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = async (input: any) => {
+    const url = typeof input === 'string' ? input : input.url;
+    if (url.includes('/api/models')) {
+      return new Response(JSON.stringify({ data: [{ id: 'qwen3.6-plus', owned_by: 'qwen' }] }), { status: 200 });
+    }
+    if (url.includes('/api/v2/chat/completions')) {
+      const stream = new ReadableStream({
+        start(c) {
+          c.enqueue(new TextEncoder().encode('data: {"choices": [{"delta": {"phase": "thinking_summary", "extra": {"summary_thought": {"content": ["Thinking..."]}}}}]}\n\n'));
+          c.enqueue(new TextEncoder().encode('data: {"choices": [{"delta": {"phase": "answer", "content": "Hello"}}]}\n\n'));
+          c.enqueue(new TextEncoder().encode('data: [DONE]\n\n'));
+          c.close();
+        }
+      });
+      return new Response(stream, { status: 200 });
+    }
+    return originalFetch(input);
+  };
+
+  // Initialize playwright for this test
+  await initPlaywright(false);
+
+  try {
+    const payload = {
+      model: 'qwen3.6-plus',
+      messages: [{ role: 'user', content: 'What is 99 * 182? Please think step by step.' }],
+      stream: true
+    };
+
+    const req = new Request('http://localhost/v1/chat/completions', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(payload)
+    });
+
+    const res = await app.fetch(req);
+    assert.strictEqual(res.status, 200);
+    assert.strictEqual(res.headers.get('Content-Type'), 'text/event-stream');
+
+    const reader = res.body?.getReader();
+    assert.ok(reader, 'Response should have a readable body');
+
+    const decoder = new TextDecoder();
+    let hasReasoning = false;
+    let hasContent = false;
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      const chunk = decoder.decode(value);
+      const lines = chunk.split('\n');
+      
+      for (const line of lines) {
+        if (line.trim() === 'data: [DONE]') {
+          break;
+        }
+        if (line.startsWith('data: ')) {
+          try {
+            const dataStr = line.slice(6);
+            if (dataStr !== '[DONE]') {
+              const data = JSON.parse(dataStr);
+              
+              if (data.choices && data.choices[0] && data.choices[0].delta) {
+              const delta = data.choices[0].delta;
+              if (delta.content) {
+                hasContent = true;
+              }
+                if (delta.reasoning_content) {
+                  hasReasoning = true;
+                }
+              }
+            }
+          } catch (err) {
+            // Partial JSON ignored
+            // console.error("Parse error:", err);
+          }
+        }
+      }
+    }
+
+    assert.ok(hasReasoning, 'Should have received streamed chunks with reasoning_content (Thinking enabled)');
+    assert.ok(hasContent, 'Should have received streamed chunks with content');
+  } finally {
+    globalThis.fetch = originalFetch;
+    await closePlaywright();
+  }
+});
+
+test('Chat Completions returns explicit error for non-SSE upstream JSON errors', async () => {
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = async (input: any) => {
+    const url = typeof input === 'string' ? input : input.url;
+    if (url.includes('/api/v2/chat/completions')) {
+      return new Response(JSON.stringify({
+        success: false,
+        data: {
+          code: 'RateLimited',
+          details: "You've reached the upper limit for today's usage.",
+          num: 3
+        }
+      }), { status: 200, headers: { 'Content-Type': 'application/json' } });
+    }
+    return originalFetch(input);
+  };
+
+  await initPlaywright(false);
+
+  try {
+    const req = new Request('http://localhost/v1/chat/completions', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        model: 'qwen3.6-plus',
+        messages: [{ role: 'user', content: 'hello' }],
+        stream: false
+      })
+    });
+
+    const res = await app.fetch(req);
+    assert.strictEqual(res.status, 429);
+
+    const body = await res.json();
+    assert.match(body.error.message, /Qwen upstream error: RateLimited/);
+    assert.match(body.error.message, /upper limit/);
+  } finally {
+    globalThis.fetch = originalFetch;
+    await closePlaywright();
+  }
+});
+
+test('Chat Completions returns a JSON chat.completion object for non-streaming requests', async () => {
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = async (input: any) => {
+    const url = typeof input === 'string' ? input : input.url;
+    if (url.includes('/api/v2/chat/completions')) {
+      const stream = new ReadableStream({
+        start(c) {
+          c.enqueue(new TextEncoder().encode('data: {"choices": [{"delta": {"phase": "answer", "content": "Hello"}}]}\n\n'));
+          c.enqueue(new TextEncoder().encode('data: [DONE]\n\n'));
+          c.close();
+        }
+      });
+      return new Response(stream, { status: 200 });
+    }
+    return originalFetch(input);
+  };
+
+  await initPlaywright(false);
+
+  try {
+    const req = new Request('http://localhost/v1/chat/completions', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        model: 'qwen3.6-plus',
+        messages: [{ role: 'user', content: 'hello' }],
+        stream: false
+      })
+    });
+
+    const res = await app.fetch(req);
+    assert.strictEqual(res.status, 200);
+
+    const body = await res.json();
+    assert.strictEqual(body.object, 'chat.completion');
+    assert.strictEqual(body.choices[0].message.role, 'assistant');
+    assert.strictEqual(body.choices[0].message.content, 'Hello');
+  } finally {
+    globalThis.fetch = originalFetch;
+    await closePlaywright();
+  }
+});
+
+test('API Key protection', async () => {
+  const originalApiKey = process.env.API_KEY;
+  process.env.API_KEY = 'test-api-key';
+
+  try {
+    // 1. Test request without API Key
+    const req1 = new Request('http://localhost/v1/models');
+    const res1 = await app.fetch(req1);
+    assert.strictEqual(res1.status, 401, 'Should return 401 Unauthorized without API Key');
+
+    // 2. Test request with wrong API Key
+    const req2 = new Request('http://localhost/v1/models', {
+      headers: { 'Authorization': 'Bearer wrong-key' }
+    });
+    const res2 = await app.fetch(req2);
+    assert.strictEqual(res2.status, 401, 'Should return 401 Unauthorized with wrong API Key');
+
+    // 3. Test request with correct API Key
+    // Mock fetch for models list
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = async () => new Response(JSON.stringify({ data: [] }), { status: 200 });
+
+    try {
+      const req3 = new Request('http://localhost/v1/models', {
+        headers: { 'Authorization': 'Bearer test-api-key' }
+      });
+      const res3 = await app.fetch(req3);
+      assert.strictEqual(res3.status, 200, 'Should return 200 OK with correct API Key');
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  } finally {
+    process.env.API_KEY = originalApiKey;
+  }
+});
+
+test('Chat Completions endpoint - Non-streaming (stream: false)', async () => {
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = async (input: any) => {
+    const url = typeof input === 'string' ? input : input.url;
+    if (url.includes('/api/models')) {
+      return new Response(JSON.stringify({ data: [{ id: 'qwen3.6-plus', owned_by: 'qwen' }] }), { status: 200 });
+    }
+    if (url.includes('/api/v2/chat/completions')) {
+      const stream = new ReadableStream({
+        start(c) {
+          c.enqueue(new TextEncoder().encode('data: {"choices": [{"delta": {"phase": "thinking_summary", "extra": {"summary_thought": {"content": ["Thinking non-stream..."]}}}}]}\n\n'));
+          c.enqueue(new TextEncoder().encode('data: {"choices": [{"delta": {"phase": "answer", "content": "Hello non-stream"}}]}\n\n'));
+          c.enqueue(new TextEncoder().encode('data: [DONE]\n\n'));
+          c.close();
+        }
+      });
+      return new Response(stream, { status: 200 });
+    }
+    return originalFetch(input);
+  };
+
+  // Initialize playwright for this test
+  await initPlaywright(false);
+
+  try {
+    const payload = {
+      model: 'qwen3.6-plus',
+      messages: [{ role: 'user', content: 'Hello' }],
+      stream: false
+    };
+
+    const req = new Request('http://localhost/v1/chat/completions', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(payload)
+    });
+
+    const res = await app.fetch(req);
+    assert.strictEqual(res.status, 200);
+    assert.ok(res.headers.get('Content-Type')?.includes('application/json'));
+
+    const body = await res.json();
+    assert.strictEqual(body.object, 'chat.completion');
+    assert.strictEqual(body.model, 'qwen3.6-plus');
+    assert.ok(body.choices);
+    assert.strictEqual(body.choices.length, 1);
+    
+    const choice = body.choices[0];
+    assert.strictEqual(choice.message.role, 'assistant');
+    assert.strictEqual(choice.message.content, 'Hello non-stream');
+    assert.strictEqual(choice.message.reasoning_content, 'Thinking non-stream...');
+    assert.strictEqual(choice.finish_reason, 'stop');
+    
+    assert.ok(body.usage);
+    assert.ok(body.usage.prompt_tokens > 0);
+    assert.ok(body.usage.completion_tokens >= 0);
+  } finally {
+    globalThis.fetch = originalFetch;
+    await closePlaywright();
+  }
+});
+
+test('Models endpoint caching: subsequent requests return cached models without fetch', async () => {
+  const originalFetch = globalThis.fetch;
+  let fetchCount = 0;
+  globalThis.fetch = async (input: any) => {
+    const url = typeof input === 'string' ? input : input.url;
+    if (url.includes('/api/models')) {
+      fetchCount++;
+      return new Response(JSON.stringify({ data: [{ id: 'qwen3.6-plus-cached-test', owned_by: 'qwen' }] }), { status: 200 });
+    }
+    return originalFetch(input);
+  };
+
+  try {
+    const { cache } = await import('../cache/memory-cache.js');
+    await cache.flush();
+
+    // First request
+    const req1 = new Request('http://localhost/v1/models');
+    const res1 = await app.fetch(req1);
+    assert.strictEqual(res1.status, 200);
+    const body1 = await res1.json();
+    assert.ok(body1.data.some((m: any) => m.id === 'qwen3.6-plus-cached-test'));
+    assert.strictEqual(fetchCount, 1);
+
+    // Second request
+    const req2 = new Request('http://localhost/v1/models');
+    const res2 = await app.fetch(req2);
+    assert.strictEqual(res2.status, 200);
+    const body2 = await res2.json();
+    assert.ok(body2.data.some((m: any) => m.id === 'qwen3.6-plus-cached-test'));
+    assert.strictEqual(fetchCount, 1);
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});

package/src/tests/jsonFix.test.ts

@@ -0,0 +1,98 @@
+import { robustParseJSON } from '../utils/json.ts';
+
+const problematicString = '{"name": "suggest", "arguments": {"suggest": "Landing page para escritório de advocacia criada em src/pages/Index.tsx", "actions": [{"label": "Revisar alterações", "description": "Executar review local das mudanças não commitadas", "prompt": "/local-review-uncommitted"}]})';
+
+console.log('Testing problematic string...');
+try {
+    const result = robustParseJSON(problematicString);
+    console.log('Successfully parsed:', JSON.stringify(result, null, 2));
+    if (result.name === 'suggest' && result.arguments.actions.length === 1) {
+        console.log('✅ Problematic string test passed!');
+    } else {
+        console.error('❌ Result structure is incorrect');
+    }
+} catch (e) {
+    console.error('❌ Failed to parse problematic string:', e);
+}
+
+const missingBraces = '{"name": "test", "arguments": {"foo": "bar"';
+console.log('\nTesting missing braces...');
+try {
+    const result = robustParseJSON(missingBraces);
+    console.log('Successfully parsed:', JSON.stringify(result, null, 2));
+    if (result.arguments.foo === 'bar') {
+        console.log('✅ Missing braces test passed!');
+    } else {
+        console.error('❌ Result structure is incorrect');
+    }
+} catch (e) {
+    console.error('❌ Failed to parse missing braces:', e);
+}
+
+const controlChars = '{"name": "control", "msg": "line 1\\nline 2"}';
+console.log('\nTesting control characters in string...');
+try {
+    // Note: in a real string from the model, it would be a literal newline
+    const literalNewline = '{"name": "control", "msg": "line 1\\nline 2"}'.replace('\\n', '\n');
+    const result = robustParseJSON(literalNewline);
+    console.log('Successfully parsed:', JSON.stringify(result, null, 2));
+    if (result.msg.includes('line 1') && result.msg.includes('line 2')) {
+        console.log('✅ Control characters test passed!');
+    } else {
+        console.error('❌ Result content is incorrect');
+    }
+} catch (e) {
+    console.error('❌ Failed to parse control characters:', e);
+}
+
+const crazyCase = `{"name": "suggest", "arguments": {"suggest": "Landing page criada para escritório de advocacia com design corporativo", "actions": [{"label": "Revisar código local", "description": "Exec<tool_call>\n{"name": "bashutar revisão local das", "arguments": alterações {"command": não commitadas", "npm run lint "prompt", "description":": "/local-review "Run lint-uncommitted"}] to verify code quality})"}}`;
+console.log('\nTesting crazy nested hallucination case...');
+try {
+    const result = robustParseJSON(crazyCase);
+    console.log('Successfully parsed (at least some of it):', JSON.stringify(result, null, 2));
+    console.log('✅ Crazy case handled without crashing!');
+} catch (e: any) {
+    console.log('⚠️ Crazy case failed (too malformed), but error was:', e.message);
+}
+
+const invalidEscapes = '{"path": "C:\\\\Users\\\\name\\\\Documents"}';
+console.log('\nTesting invalid backslash escapes in string...');
+try {
+    const result = robustParseJSON(invalidEscapes);
+    console.log('Successfully parsed:', JSON.stringify(result, null, 2));
+    if (result.path === 'C:\\\\Users\\\\name\\\\Documents' || result.path === 'C:\\Users\\name\\Documents') {
+        console.log('✅ Invalid backslash escapes test passed!');
+    } else {
+        console.error('❌ Result path is incorrect:', result.path);
+    }
+} catch (e) {
+    console.error('❌ Failed to parse invalid backslash escapes:', e);
+}
+
+const doubleKey = '{"name": "name": "create_file", "arguments": {"path": "b.txt"}}';
+console.log('\nTesting double key hallucination...');
+try {
+    const result = robustParseJSON(doubleKey);
+    console.log('Successfully parsed:', JSON.stringify(result, null, 2));
+    if (result.name === 'create_file') {
+        console.log('✅ Double key test passed!');
+    } else {
+        console.error('❌ Result name is incorrect:', result.name);
+    }
+} catch (e) {
+    console.error('❌ Failed to parse double key:', e);
+}
+
+const unquotedArgs = '{"name":"Read",arguments:{"file_path":"test.ts","limit":100}}';
+console.log('\nTesting unquoted arguments key...');
+try {
+    const result = robustParseJSON(unquotedArgs);
+    console.log('Successfully parsed:', JSON.stringify(result, null, 2));
+    if (result.arguments && result.arguments.limit === 100) {
+        console.log('✅ Unquoted arguments test passed!');
+    } else {
+        console.error('❌ Result structure is incorrect');
+    }
+} catch (e) {
+    console.error('❌ Failed to parse unquoted arguments:', e);
+}