@pedrofariasx/qwenproxy 1.1.0

package/src/tests/advanced.test.ts

@@ -0,0 +1,227 @@
+import test from 'node:test';
+import assert from 'node:assert';
+
+process.env.TEST_MOCK_PLAYWRIGHT = 'true';
+
+delete process.env.API_KEY;
+
+import { app } from '../api/server.js';
+
+function setupFetchMock(handler: (url: string, init?: RequestInit) => Response | Promise<Response>) {
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = async (input: RequestInfo | URL, init?: RequestInit) => {
+    const urlStr = typeof input === 'string' ? input : ('url' in input ? input.url : String(input));
+    if (urlStr.includes('chat.qwen.ai')) {
+      if (urlStr.includes('/api/models')) {
+         return new Response(JSON.stringify({ data: [{ id: 'qwen3.6-plus', owned_by: 'qwen' }] }), { status: 200 });
+      }
+      return handler(urlStr, init);
+    }
+    return originalFetch(input);
+  };
+  return () => { globalThis.fetch = originalFetch; };
+}
+
+test('multiturn-thinking-tools: maintains reasoning_content history', async () => {
+  let capturedBody = '';
+
+  const restore = setupFetchMock((url, init) => {
+    capturedBody = init?.body as string || '';
+    const stream = new ReadableStream({
+      start(c) {
+        c.enqueue(new TextEncoder().encode('data: [DONE]\n\n'));
+        c.close();
+      }
+    });
+    return new Response(stream, { status: 200 });
+  });
+
+  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' },
+          { role: 'assistant', content: 'doing something', reasoning_content: 'thinking about hello', tool_calls: [{ id: 'call_1', type: 'function', function: { name: 'test', arguments: '{}' } }] },
+          { role: 'tool', name: 'test', content: 'success' }
+        ]
+      })
+    });
+    
+    const res = await app.fetch(req);
+    assert.strictEqual(res.status, 200);
+
+    // The proxy transforms messages into a Qwen-compatible prompt.
+    // Verify the prompt (in the request body) contains context from all messages.
+    assert.ok(capturedBody.includes('hello') || capturedBody.includes('User: hello'), 'Must include user message');
+    assert.ok(capturedBody.includes('thinking about hello'), 'Must include reasoning content');
+    assert.ok(capturedBody.includes('tool_call') || capturedBody.includes('"name": "test"'), 'Must include tool call info');
+    assert.ok(capturedBody.includes('Tool Response (test): success') || capturedBody.includes('success'), 'Must include tool response');
+  } finally {
+    restore();
+  }
+});
+
+test('streaming-whitespace: preserves exact whitespace', async () => {
+  const restore = setupFetchMock((url) => {
+    const stream = new ReadableStream({
+      start(c) {
+        c.enqueue(new TextEncoder().encode('data: {"choices": [{"delta": {"content": "   ", "phase": "answer"}}]}\n\n'));
+        c.enqueue(new TextEncoder().encode('data: {"choices": [{"delta": {"content": "  hello  ", "phase": "answer"}}]}\n\n'));
+        c.enqueue(new TextEncoder().encode('data: {"choices": [{"delta": {"content": "\\n\\n  ", "phase": "answer"}}]}\n\n'));
+        c.enqueue(new TextEncoder().encode('data: [DONE]\n\n'));
+        c.close();
+      }
+    });
+    return new Response(stream, { status: 200 });
+  });
+
+  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: 'test'}], stream: true })
+    });
+    
+    const res = await app.fetch(req);
+    const reader = res.body?.getReader();
+    const decoder = new TextDecoder();
+    let full = '';
+    while (true) {
+      const { done, value } = await reader!.read();
+      if (done) break;
+      const chunk = decoder.decode(value);
+      for (const line of chunk.split('\n')) {
+        if (line.startsWith('data: ') && line !== 'data: [DONE]') {
+          try {
+            const data = JSON.parse(line.slice(6));
+            if (data.choices?.[0]?.delta?.content) {
+              full += data.choices[0].delta.content;
+            }
+          } catch(e) {}
+        }
+      }
+    }
+    
+    // We expect exactly: "     hello  \n\n  "
+    assert.strictEqual(full, "     hello  \n\n  ");
+  } finally {
+    restore();
+  }
+});
+
+test('caching-streaming and cache-control: returns prompt_tokens_details', async () => {
+  const restore = setupFetchMock((url) => {
+    const stream = new ReadableStream({
+      start(c) {
+        c.enqueue(new TextEncoder().encode('data: {"choices": [{"delta": {"content": "done", "phase": "answer"}}], "usage": {"output_tokens": 10}}\n\n'));
+        c.enqueue(new TextEncoder().encode('data: [DONE]\n\n'));
+        c.close();
+      }
+    });
+    return new Response(stream, { status: 200 });
+  });
+
+  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: 'test'}], stream: true })
+    });
+    
+    const res = await app.fetch(req);
+    const reader = res.body?.getReader();
+    const decoder = new TextDecoder();
+    let usageBlock = null;
+    while (true) {
+      const { done, value } = await reader!.read();
+      if (done) break;
+      const chunk = decoder.decode(value);
+      for (const line of chunk.split('\n')) {
+        if (line.startsWith('data: ') && line !== 'data: [DONE]') {
+          try {
+            const data = JSON.parse(line.slice(6));
+            if (data.usage) {
+              usageBlock = data.usage;
+            }
+          } catch(e) {}
+        }
+      }
+    }
+    
+    assert.ok(usageBlock);
+    assert.strictEqual(usageBlock.completion_tokens, 10);
+    assert.ok(usageBlock.prompt_tokens > 0);
+    assert.strictEqual(usageBlock.prompt_tokens_details.cached_tokens, 0); // Tests caching-streaming shape!
+  } finally {
+    restore();
+  }
+});
+
+test('session-parent-tracking: appends messages using response message_id as parent', async () => {
+  let capturedPayloads: any[] = [];
+
+  const restore = setupFetchMock((url, init) => {
+    const bodyObj = JSON.parse(init?.body as string || '{}');
+    capturedPayloads.push(bodyObj);
+    
+    // Simulate Qwen returning a response_id
+    const mockMessageId = capturedPayloads.length === 1 ? 'qwen-1001' : 'qwen-1002';
+    
+    const stream = new ReadableStream({
+      start(c) {
+        c.enqueue(new TextEncoder().encode(`data: {"response.created":{"response_id":"${mockMessageId}"}}\n\n`));
+        c.enqueue(new TextEncoder().encode('data: [DONE]\n\n'));
+        c.close();
+      }
+    });
+    return new Response(stream, { status: 200 });
+  });
+
+  try {
+    process.env.TEST_SESSION_ID = 'test-session-parent-tracking';
+    // Turn 1
+    const req1 = 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: 'Turn 1' }]
+      })
+    });
+    
+    const res1 = await app.fetch(req1);
+    assert.strictEqual(res1.status, 200);
+    // Consume the stream to ensure the message_id is processed
+    await res1.text();
+
+    // Turn 2
+    const req2 = 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: 'Turn 1' },
+          { role: 'assistant', content: 'Response 1' },
+          { role: 'user', content: 'Turn 2' }
+        ]
+      })
+    });
+    
+    const res2 = await app.fetch(req2);
+    assert.strictEqual(res2.status, 200);
+    await res2.text();
+
+    assert.strictEqual(capturedPayloads.length, 2);
+    // In Turn 1, parent_id should be null (mock-session is fresh)
+    assert.strictEqual(capturedPayloads[0].parent_id, null);
+    // In Turn 2, parent_id should be qwen-1001 (the ID returned in Turn 1)
+    assert.strictEqual(capturedPayloads[1].parent_id, 'qwen-1001', 'Turn 2 should use response_id from Turn 1 as parent');
+    assert.strictEqual(capturedPayloads[1].messages[0].content, 'User: Turn 1\n\nAssistant: Response 1\n\nUser: Turn 2\n\n', 'Should send the full OpenAI message history');
+  } finally {
+    restore();
+  }
+});

package/src/tests/agenticStress.test.ts

@@ -0,0 +1,360 @@
+import test from 'node:test';
+import assert from 'node:assert';
+import fs from 'node:fs';
+import path from 'node:path';
+import net from 'node:net';
+import { serve } from '@hono/node-server';
+import { app } from '../api/server.js';
+import { initPlaywright, closePlaywright } from '../services/playwright.ts';
+
+const SANDBOX_DIR = '/tmp/kilo/sandbox';
+
+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++;
+  }
+}
+
+// Clean and recreate physical sandbox directory
+if (fs.existsSync(SANDBOX_DIR)) {
+  fs.rmSync(SANDBOX_DIR, { recursive: true, force: true });
+}
+fs.mkdirSync(SANDBOX_DIR, { recursive: true });
+
+function normalizePath(p: string): string {
+  return p.replace(/\\/g, '/').toLowerCase();
+}
+
+// Local real file system tool handlers
+const localTools = {
+  list_files: () => {
+    const files = fs.readdirSync(SANDBOX_DIR);
+    return JSON.stringify(files);
+  },
+  create_file: (args: { path: string; content: string }) => {
+    const filePath = path.join(SANDBOX_DIR, args.path);
+    const basePath = normalizePath(SANDBOX_DIR) + '/';
+    if (!normalizePath(filePath).startsWith(basePath)) {
+      return JSON.stringify({ error: 'Access denied: Directory traversal detected' });
+    }
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, args.content, 'utf8');
+    return JSON.stringify({ status: 'success', path: args.path });
+  },
+  read_file: (args: { path: string }) => {
+    const filePath = path.join(SANDBOX_DIR, args.path);
+    const basePath = normalizePath(SANDBOX_DIR) + '/';
+    if (!normalizePath(filePath).startsWith(basePath)) {
+      return JSON.stringify({ error: 'Access denied: Directory traversal detected' });
+    }
+    if (!fs.existsSync(filePath)) {
+      return JSON.stringify({ error: `File ${args.path} not found` });
+    }
+    const content = fs.readFileSync(filePath, 'utf8');
+    return JSON.stringify({ content });
+  },
+  edit_file: (args: { path: string; oldText: string; newText: string }) => {
+    const filePath = path.join(SANDBOX_DIR, args.path);
+    const basePath = normalizePath(SANDBOX_DIR) + '/';
+    if (!normalizePath(filePath).startsWith(basePath)) {
+      return JSON.stringify({ error: 'Access denied: Directory traversal detected' });
+    }
+    if (!fs.existsSync(filePath)) {
+      return JSON.stringify({ error: `File ${args.path} not found` });
+    }
+    const content = fs.readFileSync(filePath, 'utf8');
+    if (!content.includes(args.oldText)) {
+      return JSON.stringify({ error: `Old text not found in ${args.path}` });
+    }
+    fs.writeFileSync(filePath, content.replace(args.oldText, args.newText), 'utf8');
+    return JSON.stringify({ status: 'success', path: args.path });
+  },
+  delete_file: (args: { path: string }) => {
+    const filePath = path.join(SANDBOX_DIR, args.path);
+    const basePath = normalizePath(SANDBOX_DIR) + '/';
+    if (!normalizePath(filePath).startsWith(basePath)) {
+      return JSON.stringify({ error: 'Access denied: Directory traversal detected' });
+    }
+    if (!fs.existsSync(filePath)) {
+      return JSON.stringify({ error: `File ${args.path} not found` });
+    }
+    fs.unlinkSync(filePath);
+    return JSON.stringify({ status: 'success', path: args.path });
+  }
+};
+
+// Declares standard tool definitions in OpenAI format
+const toolDefinitions = [
+  {
+    type: 'function',
+    function: {
+      name: 'list_files',
+      description: 'List all files in the sandbox',
+      parameters: { type: 'object', properties: {} }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'create_file',
+      description: 'Create a new file with content',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string' },
+          content: { type: 'string' }
+        },
+        required: ['path', 'content']
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'read_file',
+      description: 'Read the content of a file',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string' }
+        },
+        required: ['path']
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'edit_file',
+      description: 'Edit a file replacing oldText with newText',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string' },
+          oldText: { type: 'string' },
+          newText: { type: 'string' }
+        },
+        required: ['path', 'oldText', 'newText']
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'delete_file',
+      description: 'Delete a file',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string' }
+        },
+        required: ['path']
+      }
+    }
+  }
+];
+
+test('Agentic Stress Test: >30 messages multi-turn using the REAL live API', { skip: process.env.CI ? 'Requires real accounts - skipped in CI' : false }, async () => {
+  const DEFAULT_PORT = process.env.PORT ? parseInt(process.env.PORT) : 3000;
+  const port = await getFreePort(DEFAULT_PORT);
+  
+  const server = serve({
+    fetch: app.fetch,
+    port: port
+  });
+  console.log(`[RealTest] Local Hono server started on port ${port}`);
+
+  // Initialize Playwright with headless mode to fetch real active session headers
+  console.log('[RealTest] Initializing Playwright browser context...');
+  await initPlaywright(true);
+
+  // Dynamic conversation prompt sequence (explicitly instructing tool calls)
+  const conversationScenario = [
+    "Please call the 'list_files' tool to check if the sandbox is currently empty.",
+    "Great. Create a file named 'a.txt' with content 'Hello A' and a file named 'b.txt' with content 'Hello B' by calling the 'create_file' tool for both.",
+    "Please call the 'read_file' tool for 'b.txt' to verify its content.",
+    "Now, call the 'edit_file' tool to replace 'Hello A' with 'Hello Awesome World' in 'a.txt'.",
+    "Please call the 'read_file' tool for 'a.txt' to check if the change was applied successfully.",
+    "Great! Now call the 'list_files' tool to see both of them.",
+    "Excellent. Now delete both files by calling the 'delete_file' tool for both.",
+    "Please call the 'list_files' tool one last time to make sure they are gone.",
+    "Perfect! Thank you so much."
+  ];
+
+  const messages: any[] = [
+    { role: 'system', content: 'You are an agentic file helper. You have access to tools to manage files in a sandbox directory. You MUST call the requested tools in every response to perform the file operations. Do not guess or assume results without executing the tool first. Wrap your tool calls exactly in <tool_call>...</tool_call> tags.' }
+  ];
+
+  try {
+    for (const userPrompt of conversationScenario) {
+      console.log(`\n👤 [User]: ${userPrompt}`);
+      messages.push({ role: 'user', content: userPrompt });
+
+      let agentTurnDone = false;
+      let loopLimiter = 0;
+
+      while (!agentTurnDone) {
+        loopLimiter++;
+        assert.ok(loopLimiter <= 10, 'Agent got stuck in an infinite tool calling loop');
+
+        // Add a 2.5 second delay to let the Qwen backend settle and prevent "The chat is in progress!" errors
+        await new Promise(resolve => setTimeout(resolve, 2500));
+
+        console.log(`[RealTest] Sending request to proxy completions endpoint (messages: ${messages.length})...`);
+
+        // Send request to real proxy completions API
+        const response = await fetch(`http://localhost:${port}/v1/chat/completions`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            model: 'qwen3.6-plus',
+            messages: messages,
+            tools: toolDefinitions,
+            stream: true
+          })
+        });
+
+        assert.strictEqual(response.status, 200, `Expected 200, got ${response.status}`);
+
+        const reader = response.body?.getReader();
+        assert.ok(reader, 'Response should have stream body');
+
+        const decoder = new TextDecoder();
+        let content = '';
+        let reasoning = '';
+        let toolCalls: any[] = [];
+        let buffer = '';
+
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split('\n');
+          buffer = lines.pop() || '';
+
+          for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || !trimmed.startsWith('data: ')) continue;
+            const dataStr = trimmed.slice(6);
+            if (dataStr === '[DONE]') continue;
+
+            try {
+              const chunk = JSON.parse(dataStr);
+              if (chunk.choices && chunk.choices[0] && chunk.choices[0].delta) {
+                const delta = chunk.choices[0].delta;
+                if (delta.content) {
+                  content += delta.content;
+                }
+                if (delta.reasoning_content) {
+                  reasoning += delta.reasoning_content;
+                }
+                if (delta.tool_calls) {
+                  for (const tc of delta.tool_calls) {
+                    const idx = tc.index ?? 0;
+                    if (!toolCalls[idx]) {
+                      toolCalls[idx] = { id: tc.id, name: tc.function?.name || '', arguments: '' };
+                    }
+                    if (tc.function?.arguments) {
+                      toolCalls[idx].arguments += tc.function.arguments;
+                    }
+                  }
+                }
+              }
+            } catch (err) {
+              // ignore partial chunk parsing errors
+            }
+          }
+        }
+
+        // Output and construct assistant message
+        const assistantMessage: any = { role: 'assistant' };
+        if (content) assistantMessage.content = content;
+        if (reasoning) assistantMessage.reasoning_content = reasoning;
+
+        if (reasoning) {
+          console.log(`💭 [Thinking]: ${reasoning}`);
+        }
+
+        if (toolCalls.length > 0) {
+          assistantMessage.tool_calls = toolCalls.map(tc => ({
+            id: tc.id,
+            type: 'function',
+            function: {
+              name: tc.name,
+              arguments: tc.arguments
+            }
+          }));
+
+          messages.push(assistantMessage);
+
+          for (const tc of assistantMessage.tool_calls) {
+            const toolName = tc.function.name as keyof typeof localTools;
+            const toolArgs = JSON.parse(tc.function.arguments || '{}');
+            console.log(`🛠️ [Tool Call]: ${toolName} with args:`, toolArgs);
+
+            let result = '';
+            if (typeof localTools[toolName] === 'function') {
+              try {
+                result = localTools[toolName](toolArgs as any);
+              } catch (err: any) {
+                result = JSON.stringify({ error: `Tool execution failed: ${err.message}` });
+              }
+            } else {
+              result = JSON.stringify({
+                error: `Tool '${toolName}' is not available. Please use one of the available tools: list_files, create_file, read_file, edit_file, delete_file.`
+              });
+            }
+            console.log(`🟢 [Tool Result]: ${result}`);
+
+            messages.push({
+              role: 'tool',
+              tool_call_id: tc.id,
+              name: toolName,
+              content: result
+            });
+          }
+        } else {
+          console.log(`🤖 [Agent]: ${content}`);
+          messages.push(assistantMessage);
+          agentTurnDone = true;
+        }
+      }
+    }
+
+    console.log(`\n[RealTest] Integration Test complete! Total chat history size: ${messages.length} messages.`);
+    assert.ok(messages.length > 30, `Expected conversation history to contain >30 messages, got ${messages.length}`);
+
+    // Sandbox must be clean at the end
+    const remainingFiles = fs.readdirSync(SANDBOX_DIR);
+    assert.strictEqual(remainingFiles.length, 0, 'Sandbox directory must be empty at the end');
+
+  } finally {
+    // Teardown browser context and Hono server
+    await closePlaywright();
+    if (server) {
+      server.close();
+      console.log('[RealTest] Server stopped and Playwright closed.');
+    } else {
+      console.log('[RealTest] Playwright closed.');
+    }
+  }
+});

package/src/tests/concurrency.test.ts

@@ -0,0 +1,103 @@
+import test from 'node:test';
+import assert from 'node:assert';
+
+process.env.TEST_MOCK_PLAYWRIGHT = 'true';
+
+import { app } from '../api/server.js';
+import { initPlaywright, closePlaywright } from '../services/playwright.ts';
+
+test('Concurrent requests are serialized by mutex', 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', info: { created_at: Date.now(), meta: {} } }] 
+      }), { status: 200 });
+    }
+    if (url.includes('/api/v2/chat/completions')) {
+      return new Response(
+        'data: {"choices": [{"delta": {"phase": "answer", "content": "OK"}}]}\n\ndata: [DONE]\n\n',
+        { status: 200, headers: { 'Content-Type': 'text/event-stream' } }
+      );
+    }
+    return originalFetch(input);
+  };
+
+  await initPlaywright(false);
+
+  try {
+    const promises = Array.from({ length: 5 }, (_, i) =>
+      app.fetch(
+        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: `Request ${i}` }],
+            stream: false
+          })
+        })
+      )
+    );
+
+    const responses = await Promise.all(promises);
+    
+    // All requests should complete (serialized by mutex)
+    for (const res of responses) {
+      assert.ok(
+        res.status === 200 || res.status === 429 || res.status === 502,
+        `Unexpected status: ${res.status}`
+      );
+    }
+  } finally {
+    globalThis.fetch = originalFetch;
+    await closePlaywright();
+  }
+});
+
+test('No-thinking model variant is accepted', 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', info: { created_at: Date.now(), meta: { max_context_length: 1000000 } } }] 
+      }), { status: 200 });
+    }
+    if (url.includes('/api/v2/chat/completions')) {
+      return new Response(
+        'data: {"choices": [{"delta": {"phase": "answer", "content": "OK"}}]}\n\ndata: [DONE]\n\n',
+        { status: 200, headers: { 'Content-Type': 'text/event-stream' } }
+      );
+    }
+    return originalFetch(input);
+  };
+
+  await initPlaywright(false);
+
+  try {
+    // Test no-thinking model is accepted without error
+    const res = await app.fetch(
+      new Request('http://localhost/v1/chat/completions', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          model: 'qwen3.6-plus-no-thinking',
+          messages: [{ role: 'user', content: 'Test' }],
+          stream: false
+        })
+      })
+    );
+
+    assert.ok(
+      res.status === 200 || res.status === 429 || res.status === 502,
+      `No-thinking model should be accepted, got status: ${res.status}`
+    );
+  } finally {
+    globalThis.fetch = originalFetch;
+    await closePlaywright();
+  }
+});