tests/claude-code.test.ts

@@ -0,0 +1,178 @@
+/**
+ * Tests for ClaudeCodeProvider
+ *
+ * The provider shells out to the local Claude Code CLI via
+ * @anthropic-ai/claude-agent-sdk. Tests cover the public surface and the
+ * provider-specific hooks; full integration is not exercised because it
+ * would spawn a real CLI process.
+ */
+
+import { describe, it, expect, beforeEach } from 'bun:test';
+import { ClaudeCodeProvider } from '../src/providers/claude-code.js';
+import { AIProviderError, AIErrorType } from '../src/types/index.js';
+
+describe('ClaudeCodeProvider', () => {
+  let provider: ClaudeCodeProvider;
+
+  beforeEach(() => {
+    provider = new ClaudeCodeProvider({ apiKey: 'test-key' });
+  });
+
+  describe('Constructor', () => {
+    it('should accept empty config (subscription mode)', () => {
+      const p = new ClaudeCodeProvider({});
+      expect(p).toBeInstanceOf(ClaudeCodeProvider);
+    });
+
+    it('should accept apiKey override', () => {
+      const p = new ClaudeCodeProvider({ apiKey: 'sk-...' });
+      expect(p).toBeInstanceOf(ClaudeCodeProvider);
+    });
+
+    it('should accept custom defaults', () => {
+      const p = new ClaudeCodeProvider({
+        defaultModel: 'opus',
+        maxTurns: 5,
+        allowedTools: ['Read', 'Bash'],
+        cwd: '/tmp/agent'
+      });
+      expect(p).toBeInstanceOf(ClaudeCodeProvider);
+    });
+
+    it('should reject non-string apiKey', () => {
+      expect(() => new ClaudeCodeProvider({ apiKey: 123 as any }))
+        .toThrow(AIProviderError);
+    });
+  });
+
+  describe('getInfo', () => {
+    it('should advertise subscriptionAuth capability', () => {
+      const info = provider.getInfo();
+
+      expect(info.name).toBe('Claude Code');
+      expect(info.supportsStreaming).toBe(true);
+      expect(info.capabilities).toMatchObject({
+        subscriptionAuth: true,
+        requiresLocalCli: true,
+        systemMessages: true
+      });
+      expect(info.models).toContain('sonnet');
+      expect(info.models).toContain('opus');
+    });
+  });
+
+  describe('Error mapping', () => {
+    const mapError = (err: any) => (provider as any).mapProviderError(err);
+
+    it('should detect missing CLI', () => {
+      const err = new Error('spawn claude ENOENT');
+
+      const mapped = mapError(err);
+
+      expect(mapped).toBeInstanceOf(AIProviderError);
+      expect(mapped.type).toBe(AIErrorType.INVALID_REQUEST);
+      expect(mapped.message).toContain('CLI');
+    });
+
+    it('should detect missing authentication', () => {
+      const err = new Error('not logged in');
+
+      const mapped = mapError(err);
+
+      expect(mapped).toBeInstanceOf(AIProviderError);
+      expect(mapped.type).toBe(AIErrorType.AUTHENTICATION);
+    });
+
+    it('should return null for unrelated errors', () => {
+      expect(mapError(new Error('something else'))).toBeNull();
+    });
+  });
+
+  describe('SDK assistant error mapping', () => {
+    const mapSdkError = (code: string) => (provider as any).errorForSdkAssistantError(code);
+
+    it('should map authentication_failed', () => {
+      const err = mapSdkError('authentication_failed');
+      expect(err.type).toBe(AIErrorType.AUTHENTICATION);
+    });
+
+    it('should map rate_limit', () => {
+      const err = mapSdkError('rate_limit');
+      expect(err.type).toBe(AIErrorType.RATE_LIMIT);
+    });
+
+    it('should map model_not_found', () => {
+      const err = mapSdkError('model_not_found');
+      expect(err.type).toBe(AIErrorType.MODEL_NOT_FOUND);
+    });
+
+    it('should map server_error to NETWORK', () => {
+      const err = mapSdkError('server_error');
+      expect(err.type).toBe(AIErrorType.NETWORK);
+    });
+
+    it('should fall back to UNKNOWN for unrecognized codes', () => {
+      const err = mapSdkError('weird_new_code');
+      expect(err.type).toBe(AIErrorType.UNKNOWN);
+    });
+  });
+
+  describe('Prompt building', () => {
+    const build = (messages: any[]) => (provider as any).buildPrompt(messages);
+
+    it('should pass single user turn through unchanged', () => {
+      const result = build([{ role: 'user', content: 'Hello' }]);
+
+      expect(result.prompt).toBe('Hello');
+      expect(result.systemPrompt).toBeUndefined();
+    });
+
+    it('should combine multiple system messages', () => {
+      const result = build([
+        { role: 'system', content: 'Be brief' },
+        { role: 'system', content: 'Use British spelling' },
+        { role: 'user', content: 'Hi' }
+      ]);
+
+      expect(result.systemPrompt).toBe('Be brief\n\nUse British spelling');
+      expect(result.prompt).toBe('Hi');
+    });
+
+    it('should flatten multi-turn conversation with role labels', () => {
+      const result = build([
+        { role: 'user', content: 'What is 2+2?' },
+        { role: 'assistant', content: '4' },
+        { role: 'user', content: 'Why?' }
+      ]);
+
+      expect(result.prompt).toContain('Human: What is 2+2?');
+      expect(result.prompt).toContain('Assistant: 4');
+      expect(result.prompt).toContain('Human: Why?');
+      expect(result.prompt.endsWith('Assistant:')).toBe(true);
+    });
+
+    it('should reject empty turn list', () => {
+      expect(() => build([{ role: 'system', content: 'only system' }]))
+        .toThrow(AIProviderError);
+    });
+  });
+
+  describe('Validation', () => {
+    it('should require initialization before complete()', async () => {
+      await expect(
+        provider.complete({ messages: [{ role: 'user', content: 'test' }] })
+      ).rejects.toThrow('Provider must be initialized before use');
+    });
+
+    it('should validate temperature range when initialized', async () => {
+      (provider as any).initialized = true;
+
+      await expect(
+        provider.complete({
+          messages: [{ role: 'user', content: 'test' }],
+          temperature: 1.5
+        })
+      ).rejects.toThrow(/temperature must be at most 1/);
+    });
+  });
+});

tests/claude.test.ts

@@ -51,7 +51,7 @@ describe('ClaudeProvider', () => {
           messages: [{ role: 'user', content: 'test' }],
           temperature: 1.5
         })
-      ).rejects.toThrow('Temperature must be a number between 0.0 and 1.0');
+      ).rejects.toThrow(/temperature must be at most 1/);
     });
 
     it('should validate message format', async () => {
@@ -78,19 +78,20 @@ describe('ClaudeProvider', () => {
     it('should handle authentication errors', () => {
       const error = new Error('Unauthorized');
       (error as any).status = 401;
-      
+
-      const providerError = (provider as any).handleAnthropicError(error);
+      const providerError = (provider as any).normalizeError(error);
-      
+
       expect(providerError).toBeInstanceOf(AIProviderError);
       expect(providerError.type).toBe(AIErrorType.AUTHENTICATION);
+      expect(providerError.statusCode).toBe(401);
     });
 
     it('should handle rate limit errors', () => {
       const error = new Error('Rate limited');
       (error as any).status = 429;
-      
+
-      const providerError = (provider as any).handleAnthropicError(error);
+      const providerError = (provider as any).normalizeError(error);
-      
+
       expect(providerError).toBeInstanceOf(AIProviderError);
       expect(providerError.type).toBe(AIErrorType.RATE_LIMIT);
     });
@@ -98,12 +99,22 @@ describe('ClaudeProvider', () => {
     it('should handle model not found errors', () => {
       const error = new Error('Model not found');
       (error as any).status = 404;
-      
+
-      const providerError = (provider as any).handleAnthropicError(error);
+      const providerError = (provider as any).normalizeError(error);
-      
+
       expect(providerError).toBeInstanceOf(AIProviderError);
       expect(providerError.type).toBe(AIErrorType.MODEL_NOT_FOUND);
     });
+
+    it('should route 400 with max_tokens to mapProviderError', () => {
+      const error = new Error('max_tokens too large');
+      (error as any).status = 400;
+
+      const providerError = (provider as any).normalizeError(error);
+
+      expect(providerError.type).toBe(AIErrorType.INVALID_REQUEST);
+      expect(providerError.message).toMatch(/Max tokens/);
+    });
   });
 
   describe('message conversion', () => {

tests/gemini.test.ts

@@ -11,7 +11,7 @@ describe('GeminiProvider', () => {
   beforeEach(() => {
     provider = new GeminiProvider({
       apiKey: 'test-api-key',
-      defaultModel: 'gemini-1.5-flash'
+      defaultModel: 'gemini-2.5-flash'
     });
   });
 
@@ -52,13 +52,13 @@ describe('GeminiProvider', () => {
   describe('getInfo', () => {
     it('should return provider information', () => {
       const info = provider.getInfo();
-      
+
       expect(info.name).toBe('Gemini');
-      expect(info.version).toBe('1.0.0');
+      expect(info.version).toBe('2.0.0');
       expect(info.supportsStreaming).toBe(true);
-      expect(info.models).toContain('gemini-1.5-flash');
+      expect(info.models).toContain('gemini-2.5-flash');
+      expect(info.models).toContain('gemini-2.5-pro');
       expect(info.models).toContain('gemini-1.5-pro');
-      expect(info.models).toContain('gemini-1.0-pro');
       expect(info.maxContextLength).toBe(1048576);
       expect(info.capabilities).toHaveProperty('vision', true);
       expect(info.capabilities).toHaveProperty('functionCalling', true);
@@ -79,7 +79,7 @@ describe('GeminiProvider', () => {
           messages: [{ role: 'user', content: 'test' }],
           temperature: 1.5
         })
-      ).rejects.toThrow('Temperature must be a number between 0.0 and 1.0');
+      ).rejects.toThrow(/temperature must be at most 1/);
     });
 
     it('should validate top_p range', async () => {
@@ -92,7 +92,7 @@ describe('GeminiProvider', () => {
           messages: [{ role: 'user', content: 'test' }],
           topP: 1.5
         })
-      ).rejects.toThrow('Top-p must be a number between 0.0 (exclusive) and 1.0 (inclusive)');
+      ).rejects.toThrow(/topP must be at most 1/);
     });
 
     it('should validate message format', async () => {
@@ -129,11 +129,13 @@ describe('GeminiProvider', () => {
   });
 
   describe('error handling', () => {
+    const mapError = (err: any) => (provider as any).normalizeError(err);
+
     it('should handle authentication errors', () => {
       const error = new Error('API key invalid');
-      
+
-      const providerError = (provider as any).handleGeminiError(error);
+      const providerError = mapError(error);
-      
+
       expect(providerError).toBeInstanceOf(AIProviderError);
       expect(providerError.type).toBe(AIErrorType.AUTHENTICATION);
       expect(providerError.message).toContain('Invalid Google API key');
@@ -141,9 +143,9 @@ describe('GeminiProvider', () => {
 
     it('should handle rate limit errors', () => {
       const error = new Error('quota exceeded');
-      
+
-      const providerError = (provider as any).handleGeminiError(error);
+      const providerError = mapError(error);
-      
+
       expect(providerError).toBeInstanceOf(AIProviderError);
       expect(providerError.type).toBe(AIErrorType.RATE_LIMIT);
       expect(providerError.message).toContain('API quota exceeded');
@@ -151,9 +153,9 @@ describe('GeminiProvider', () => {
 
     it('should handle model not found errors', () => {
       const error = new Error('model not found');
-      
+
-      const providerError = (provider as any).handleGeminiError(error);
+      const providerError = mapError(error);
-      
+
       expect(providerError).toBeInstanceOf(AIProviderError);
       expect(providerError.type).toBe(AIErrorType.MODEL_NOT_FOUND);
       expect(providerError.message).toContain('Model not found');
@@ -161,36 +163,36 @@ describe('GeminiProvider', () => {
 
     it('should handle invalid request errors', () => {
       const error = new Error('invalid length request parameters');
-      
+
-      const providerError = (provider as any).handleGeminiError(error);
+      const providerError = mapError(error);
-      
+
       expect(providerError).toBeInstanceOf(AIProviderError);
       expect(providerError.type).toBe(AIErrorType.INVALID_REQUEST);
     });
 
     it('should handle network errors', () => {
       const error = new Error('network connection failed');
-      
+
-      const providerError = (provider as any).handleGeminiError(error);
+      const providerError = mapError(error);
-      
+
       expect(providerError).toBeInstanceOf(AIProviderError);
       expect(providerError.type).toBe(AIErrorType.NETWORK);
     });
 
     it('should handle timeout errors', () => {
       const error = new Error('request timeout');
-      
+
-      const providerError = (provider as any).handleGeminiError(error);
+      const providerError = mapError(error);
-      
+
       expect(providerError).toBeInstanceOf(AIProviderError);
       expect(providerError.type).toBe(AIErrorType.TIMEOUT);
     });
 
     it('should handle unknown errors', () => {
       const error = new Error('Unknown error');
-      
+
-      const providerError = (provider as any).handleGeminiError(error);
+      const providerError = mapError(error);
-      
+
       expect(providerError).toBeInstanceOf(AIProviderError);
       expect(providerError.type).toBe(AIErrorType.UNKNOWN);
     });
@@ -266,7 +268,7 @@ describe('GeminiProvider', () => {
         stopSequences: ['STOP', 'END']
       };
 
-      const result = (provider as any).buildGenerationConfig(params);
+      const result = (provider as any).buildConfig(params);
 
       expect(result.temperature).toBe(0.8);
       expect(result.topP).toBe(0.9);
@@ -279,20 +281,29 @@ describe('GeminiProvider', () => {
         messages: [{ role: 'user' as const, content: 'test' }]
       };
 
-      const result = (provider as any).buildGenerationConfig(params);
+      const result = (provider as any).buildConfig(params);
 
       expect(result.temperature).toBe(0.7);
       expect(result.maxOutputTokens).toBe(1000);
     });
+
+    it('should attach systemInstruction when passed', () => {
+      const params = { messages: [{ role: 'user' as const, content: 'test' }] };
+
+      const result = (provider as any).buildConfig(params, 'be helpful');
+
+      expect(result.systemInstruction).toBe('be helpful');
+    });
   });
 
   describe('response formatting', () => {
+    // The @google/genai SDK exposes `text` as a getter on GenerateContentResponse,
+    // so the mock provides it directly rather than reconstructing the candidate->parts tree.
+
     it('should format completion response correctly', () => {
       const mockResponse = {
+        text: 'Hello there!',
         candidates: [{
-          content: {
-            parts: [{ text: 'Hello there!' }]
-          },
           finishReason: 'STOP',
           safetyRatings: [],
           citationMetadata: null
@@ -304,42 +315,19 @@ describe('GeminiProvider', () => {
         }
       };
 
-      const result = (provider as any).formatCompletionResponse(mockResponse, 'gemini-1.5-flash');
+      const result = (provider as any).formatCompletionResponse(mockResponse, 'gemini-2.5-flash');
 
       expect(result.content).toBe('Hello there!');
-      expect(result.model).toBe('gemini-1.5-flash');
+      expect(result.model).toBe('gemini-2.5-flash');
       expect(result.usage.promptTokens).toBe(10);
       expect(result.usage.completionTokens).toBe(20);
       expect(result.usage.totalTokens).toBe(30);
       expect(result.metadata.finishReason).toBe('STOP');
     });
 
-    it('should handle multiple text parts', () => {
-      const mockResponse = {
-        candidates: [{
-          content: {
-            parts: [
-              { text: 'Hello ' },
-              { text: 'there!' },
-              { functionCall: { name: 'test' } } // Non-text part should be filtered
-            ]
-          },
-          finishReason: 'STOP'
-        }],
-        usageMetadata: {
-          promptTokenCount: 5,
-          candidatesTokenCount: 10,
-          totalTokenCount: 15
-        }
-      };
-
-      const result = (provider as any).formatCompletionResponse(mockResponse, 'gemini-1.5-flash');
-
-      expect(result.content).toBe('Hello there!');
-    });
-
     it('should throw error for empty response', () => {
       const mockResponse = {
+        text: '',
         candidates: [],
         usageMetadata: {
           promptTokenCount: 5,
@@ -349,8 +337,8 @@ describe('GeminiProvider', () => {
       };
 
       expect(() => {
-        (provider as any).formatCompletionResponse(mockResponse, 'gemini-1.5-flash');
+        (provider as any).formatCompletionResponse(mockResponse, 'gemini-2.5-flash');
-      }).toThrow('No candidates found in Gemini response');
+      }).toThrow('No text content found in Gemini response');
     });
   });
 

tests/openai.test.ts

@@ -73,7 +73,7 @@ describe('OpenAIProvider', () => {
           messages: [{ role: 'user', content: 'test' }],
           temperature: 1.5
         })
-      ).rejects.toThrow('Temperature must be a number between 0.0 and 1.0');
+      ).rejects.toThrow(/temperature must be at most 1/);
     });
 
     it('should validate top_p range', async () => {
@@ -85,7 +85,7 @@ describe('OpenAIProvider', () => {
           messages: [{ role: 'user', content: 'test' }],
           topP: 1.5
         })
-      ).rejects.toThrow('Top-p must be a number between 0.0 (exclusive) and 1.0 (inclusive)');
+      ).rejects.toThrow(/topP must be at most 1/);
     });
 
     it('should validate message format', async () => {
@@ -120,23 +120,25 @@ describe('OpenAIProvider', () => {
   });
 
   describe('error handling', () => {
+    const mapError = (err: any) => (provider as any).normalizeError(err);
+
     it('should handle authentication errors', () => {
       const error = new Error('Unauthorized');
       (error as any).status = 401;
-      
+
-      const providerError = (provider as any).handleOpenAIError(error);
+      const providerError = mapError(error);
-      
+
       expect(providerError).toBeInstanceOf(AIProviderError);
       expect(providerError.type).toBe(AIErrorType.AUTHENTICATION);
-      expect(providerError.message).toContain('Authentication failed');
+      expect(providerError.message).toContain('OpenAI API key');
     });
 
     it('should handle rate limit errors', () => {
       const error = new Error('Rate limited');
       (error as any).status = 429;
-      
+
-      const providerError = (provider as any).handleOpenAIError(error);
+      const providerError = mapError(error);
-      
+
       expect(providerError).toBeInstanceOf(AIProviderError);
       expect(providerError.type).toBe(AIErrorType.RATE_LIMIT);
       expect(providerError.message).toContain('Too many requests');
@@ -145,9 +147,9 @@ describe('OpenAIProvider', () => {
     it('should handle model not found errors', () => {
       const error = new Error('Model not found');
       (error as any).status = 404;
-      
+
-      const providerError = (provider as any).handleOpenAIError(error);
+      const providerError = mapError(error);
-      
+
       expect(providerError).toBeInstanceOf(AIProviderError);
       expect(providerError.type).toBe(AIErrorType.MODEL_NOT_FOUND);
       expect(providerError.message).toContain('Model not found');
@@ -156,9 +158,9 @@ describe('OpenAIProvider', () => {
     it('should handle invalid request errors', () => {
       const error = new Error('Bad request');
       (error as any).status = 400;
-      
+
-      const providerError = (provider as any).handleOpenAIError(error);
+      const providerError = mapError(error);
-      
+
       expect(providerError).toBeInstanceOf(AIProviderError);
       expect(providerError.type).toBe(AIErrorType.INVALID_REQUEST);
     });
@@ -166,21 +168,31 @@ describe('OpenAIProvider', () => {
     it('should handle server errors', () => {
       const error = new Error('Internal server error');
       (error as any).status = 500;
-      
+
-      const providerError = (provider as any).handleOpenAIError(error);
+      const providerError = mapError(error);
-      
+
       expect(providerError).toBeInstanceOf(AIProviderError);
       expect(providerError.type).toBe(AIErrorType.NETWORK);
     });
 
     it('should handle unknown errors', () => {
       const error = new Error('Unknown error');
-      
+
-      const providerError = (provider as any).handleOpenAIError(error);
+      const providerError = mapError(error);
-      
+
       expect(providerError).toBeInstanceOf(AIProviderError);
       expect(providerError.type).toBe(AIErrorType.UNKNOWN);
     });
+
+    it('should route 429 with quota to quota-specific message', () => {
+      const error = new Error('quota exceeded');
+      (error as any).status = 429;
+
+      const providerError = mapError(error);
+
+      expect(providerError.type).toBe(AIErrorType.RATE_LIMIT);
+      expect(providerError.message).toContain('Usage quota exceeded');
+    });
   });
 
   describe('message conversion', () => {

tests/openwebui.test.ts

@@ -1,5 +1,11 @@
 /**
  * Tests for OpenWebUI provider implementation
+ *
+ * The R3 refactor split message conversion, response formatting, and the
+ * HTTP client into openwebui-strategies.ts and openwebui-http.ts. Tests for
+ * those helpers should live alongside those files. This file covers the
+ * provider's public surface and the error-mapping hooks it adds on top of
+ * BaseAIProvider.
  */
 
 import { describe, it, expect, beforeEach, jest } from 'bun:test';
@@ -14,7 +20,7 @@ describe('OpenWebUIProvider', () => {
     mockConfig = {
       apiKey: 'test-bearer-token',
       baseUrl: 'http://localhost:3000',
-      defaultModel: 'llama3.1'
+      defaultModel: 'llama3.1:latest'
     };
   });
 
@@ -26,31 +32,32 @@ describe('OpenWebUIProvider', () => {
     });
 
     it('should use default values when not specified', () => {
-      const minimalConfig: OpenWebUIConfig = { apiKey: 'test' };
+      provider = new OpenWebUIProvider({ apiKey: 'test' });
-      provider = new OpenWebUIProvider(minimalConfig);
       expect(provider).toBeInstanceOf(OpenWebUIProvider);
     });
 
-    it('should handle custom configuration', () => {
+    it('should accept Ollama proxy mode', () => {
-      const config: OpenWebUIConfig = {
+      provider = new OpenWebUIProvider({
         apiKey: 'test',
         baseUrl: 'http://localhost:8080',
         defaultModel: 'mistral:7b',
         useOllamaProxy: true
-      };
+      });
-      provider = new OpenWebUIProvider(config);
       expect(provider).toBeInstanceOf(OpenWebUIProvider);
     });
 
-    it('should handle trailing slash in baseUrl', () => {
+    it('should normalize trailing slash in baseUrl', () => {
-      const config: OpenWebUIConfig = {
+      provider = new OpenWebUIProvider({
         apiKey: 'test',
-        baseUrl: 'http://localhost:3000/',
+        baseUrl: 'http://localhost:3000/'
-        defaultModel: 'llama3.1'
+      });
-      };
-      provider = new OpenWebUIProvider(config);
       expect(provider).toBeInstanceOf(OpenWebUIProvider);
     });
+
+    it('should reject malformed baseUrl', () => {
+      expect(() => new OpenWebUIProvider({ apiKey: 'test', baseUrl: 'not a url' }))
+        .toThrow(AIProviderError);
+    });
   });
 
   describe('getInfo', () => {
@@ -60,9 +67,9 @@ describe('OpenWebUIProvider', () => {
 
     it('should return correct provider information', () => {
       const info = provider.getInfo();
-      
+
       expect(info.name).toBe('OpenWebUI');
-      expect(info.version).toBe('1.0.0');
+      expect(info.version).toBe('2.0.0');
       expect(info.supportsStreaming).toBe(true);
       expect(info.maxContextLength).toBe(32768);
       expect(Array.isArray(info.models)).toBe(true);
@@ -70,345 +77,120 @@ describe('OpenWebUIProvider', () => {
 
     it('should include expected models', () => {
       const info = provider.getInfo();
-      
+
       expect(info.models).toContain('llama3.1:latest');
       expect(info.models).toContain('mistral:latest');
       expect(info.models).toContain('codellama:latest');
       expect(info.models).toContain('gemma:latest');
     });
 
-    it('should have correct capabilities', () => {
+    it('should expose capabilities', () => {
       const info = provider.getInfo();
-      
+
-      expect(info.capabilities).toEqual({
+      expect(info.capabilities).toMatchObject({
         vision: false,
         functionCalling: false,
-        jsonMode: false,
         systemMessages: true,
-        reasoning: true,
+        localDeployment: true
-        codeGeneration: true,
-        localDeployment: true,
-        multiModel: true
       });
     });
   });
 
-  describe('Error Handling', () => {
+  describe('Error mapping', () => {
+    const mapError = (err: any) => (provider as any).normalizeError(err);
+
     beforeEach(() => {
       provider = new OpenWebUIProvider(mockConfig);
     });
 
-    it('should handle connection refused errors', () => {
+    it('should map ECONNREFUSED to NETWORK', () => {
-      const mockError = new Error('connect ECONNREFUSED') as any;
+      const error = new Error('connect ECONNREFUSED') as any;
-      mockError.code = 'ECONNREFUSED';
+
-      
+      const aiError = mapError(error);
-      const aiError = (provider as any).handleOpenWebUIError(mockError);
+
-      
       expect(aiError).toBeInstanceOf(AIProviderError);
       expect(aiError.type).toBe(AIErrorType.NETWORK);
-      expect(aiError.message).toContain('Network error connecting to OpenWebUI');
     });
 
-    it('should handle hostname resolution errors', () => {
+    it('should map ENOTFOUND to NETWORK', () => {
-      const mockError = new Error('getaddrinfo ENOTFOUND') as any;
+      const error = new Error('getaddrinfo ENOTFOUND') as any;
-      mockError.code = 'ENOTFOUND';
+
-      
+      const aiError = mapError(error);
-      const aiError = (provider as any).handleOpenWebUIError(mockError);
+
-      
+      expect(aiError.type).toBe(AIErrorType.NETWORK);
-      expect(aiError).toBeInstanceOf(AIProviderError);
-      expect(aiError.type).toBe(AIErrorType.UNKNOWN);
-      expect(aiError.message).toContain('OpenWebUI error');
     });
 
-    it('should handle 404 model not found errors', () => {
+    it('should map 404 with "model" in message to MODEL_NOT_FOUND', () => {
-      const mockError = new Error('model not available') as any;
+      const error = new Error('model not available') as any;
-      mockError.status = 404;
+      error.status = 404;
-      mockError.message = 'model not available';
+
-      
+      const aiError = mapError(error);
-      const aiError = (provider as any).handleOpenWebUIError(mockError);
+
-      
-      expect(aiError).toBeInstanceOf(AIProviderError);
       expect(aiError.type).toBe(AIErrorType.MODEL_NOT_FOUND);
+      expect(aiError.message).toContain('OpenWebUI');
     });
 
-    it('should handle 404 endpoint not found errors', () => {
+    it('should map 404 without "model" in message to MODEL_NOT_FOUND with endpoint message', () => {
-      const mockError = new Error('Not found') as any;
+      const error = new Error('Not found') as any;
-      mockError.status = 404;
+      error.status = 404;
-      mockError.message = 'endpoint not found';
+
-      
+      const aiError = mapError(error);
-      const aiError = (provider as any).handleOpenWebUIError(mockError);
+
-      
+      expect(aiError.type).toBe(AIErrorType.MODEL_NOT_FOUND);
-      expect(aiError).toBeInstanceOf(AIProviderError);
+      expect(aiError.message).toContain('endpoint');
-      expect(aiError.type).toBe(AIErrorType.INVALID_REQUEST);
-      expect(aiError.message).toContain('OpenWebUI endpoint not found');
     });
 
-    it('should handle timeout errors', () => {
+    it('should map timeout errors to TIMEOUT', () => {
-      const mockError = new Error('Request timeout') as any;
+      const error = new Error('Request timeout') as any;
-      mockError.code = 'ETIMEDOUT';
+
-      
+      const aiError = mapError(error);
-      const aiError = (provider as any).handleOpenWebUIError(mockError);
+
-      
-      expect(aiError).toBeInstanceOf(AIProviderError);
       expect(aiError.type).toBe(AIErrorType.TIMEOUT);
     });
 
-    it('should handle rate limit errors', () => {
+    it('should map 429 to RATE_LIMIT', () => {
-      const mockError = new Error('Rate limit exceeded') as any;
+      const error = new Error('Rate limit exceeded') as any;
-      mockError.status = 429;
+      error.status = 429;
-      
+
-      const aiError = (provider as any).handleOpenWebUIError(mockError);
+      const aiError = mapError(error);
-      
+
-      expect(aiError).toBeInstanceOf(AIProviderError);
       expect(aiError.type).toBe(AIErrorType.RATE_LIMIT);
     });
 
-    it('should handle server errors', () => {
+    it('should map 500 to NETWORK', () => {
-      const mockError = new Error('Internal server error') as any;
+      const error = new Error('Internal server error') as any;
-      mockError.status = 500;
+      error.status = 500;
-      
+
-      const aiError = (provider as any).handleOpenWebUIError(mockError);
+      const aiError = mapError(error);
-      
+
-      expect(aiError).toBeInstanceOf(AIProviderError);
       expect(aiError.type).toBe(AIErrorType.NETWORK);
     });
 
-    it('should handle authentication errors', () => {
+    it('should map 401 to AUTHENTICATION with OpenWebUI hint', () => {
-      const mockError = new Error('Unauthorized') as any;
+      const error = new Error('Unauthorized') as any;
-      mockError.status = 401;
+      error.status = 401;
-      
+
-      const aiError = (provider as any).handleOpenWebUIError(mockError);
+      const aiError = mapError(error);
-      
+
-      expect(aiError).toBeInstanceOf(AIProviderError);
       expect(aiError.type).toBe(AIErrorType.AUTHENTICATION);
-      expect(aiError.message).toContain('Authentication failed with OpenWebUI');
+      expect(aiError.message).toContain('OpenWebUI');
     });
 
-    it('should handle unknown errors', () => {
+    it('should map unrecognized errors to UNKNOWN', () => {
-      const mockError = new Error('Unknown error');
+      const error = new Error('Unknown error');
-      
+
-      const aiError = (provider as any).handleOpenWebUIError(mockError);
+      const aiError = mapError(error);
-      
+
-      expect(aiError).toBeInstanceOf(AIProviderError);
       expect(aiError.type).toBe(AIErrorType.UNKNOWN);
     });
   });
 
-  describe('Message Conversion', () => {
-    beforeEach(() => {
-      provider = new OpenWebUIProvider(mockConfig);
-    });
-
-    it('should convert messages correctly for chat API', () => {
-      const messages = [
-        { role: 'system' as const, content: 'You are helpful' },
-        { role: 'user' as const, content: 'Hello' },
-        { role: 'assistant' as const, content: 'Hi there!' }
-      ];
-
-      const converted = (provider as any).convertMessages(messages);
-      
-      expect(converted).toHaveLength(3);
-      expect(converted[0]).toEqual({ role: 'system', content: 'You are helpful' });
-      expect(converted[1]).toEqual({ role: 'user', content: 'Hello' });
-      expect(converted[2]).toEqual({ role: 'assistant', content: 'Hi there!' });
-    });
-
-    it('should convert messages to prompt for Ollama API', () => {
-      const messages = [
-        { role: 'system' as const, content: 'You are helpful' },
-        { role: 'user' as const, content: 'Hello' },
-        { role: 'assistant' as const, content: 'Hi there!' }
-      ];
-
-      const prompt = (provider as any).convertMessagesToPrompt(messages);
-      
-      expect(prompt).toBe('System: You are helpful\n\nHuman: Hello\n\nAssistant: Hi there!\n\nAssistant: ');
-    });
-  });
-
-  describe('Response Formatting', () => {
-    beforeEach(() => {
-      provider = new OpenWebUIProvider(mockConfig);
-    });
-
-    it('should format chat completion response correctly', () => {
-      const mockResponse = {
-        id: 'test-id',
-        object: 'chat.completion',
-        created: 1234567890,
-        model: 'llama3.1',
-        choices: [{
-          index: 0,
-          message: { role: 'assistant', content: 'Hello there!' },
-          finish_reason: 'stop'
-        }],
-        usage: {
-          prompt_tokens: 10,
-          completion_tokens: 5,
-          total_tokens: 15
-        }
-      };
-
-      const response = (provider as any).formatChatResponse(mockResponse);
-
-      expect(response.content).toBe('Hello there!');
-      expect(response.model).toBe('llama3.1');
-      expect(response.id).toBe('test-id');
-      expect(response.usage.promptTokens).toBe(10);
-      expect(response.usage.completionTokens).toBe(5);
-      expect(response.usage.totalTokens).toBe(15);
-      expect(response.metadata?.finishReason).toBe('stop');
-      expect(response.metadata?.created).toBe(1234567890);
-    });
-
-    it('should format Ollama response correctly', () => {
-      const mockResponse = {
-        model: 'llama3.1',
-        created_at: '2024-01-01T00:00:00Z',
-        response: 'Hello there!',
-        done: true,
-        prompt_eval_count: 10,
-        eval_count: 5,
-        total_duration: 1000000,
-        eval_duration: 500000
-      };
-
-      const response = (provider as any).formatOllamaResponse(mockResponse);
-
-      expect(response.content).toBe('Hello there!');
-      expect(response.model).toBe('llama3.1');
-      expect(response.usage.promptTokens).toBe(10);
-      expect(response.usage.completionTokens).toBe(5);
-      expect(response.usage.totalTokens).toBe(15);
-      expect(response.metadata?.created).toBe(1704067200000);
-      expect(response.metadata?.totalDuration).toBe(1000000);
-    });
-
-    it('should handle response without content', () => {
-      const mockResponse = {
-        id: 'test-id',
-        object: 'chat.completion',
-        created: 1234567890,
-        model: 'llama3.1',
-        choices: [{
-          index: 0,
-          message: { role: 'assistant' }, // Message without content
-          finish_reason: 'stop'
-        }],
-        usage: { prompt_tokens: 5, completion_tokens: 0, total_tokens: 5 }
-      };
-
-      expect(() => {
-        (provider as any).formatChatResponse(mockResponse);
-      }).toThrow(AIProviderError);
-    });
-
-    it('should handle missing usage information', () => {
-      const mockResponse = {
-        id: 'test-id',
-        object: 'chat.completion',
-        created: 1234567890,
-        model: 'llama3.1',
-        choices: [{
-          index: 0,
-          message: { role: 'assistant', content: 'Hello there!' },
-          finish_reason: 'stop'
-        }]
-        // No usage information
-      };
-
-      const response = (provider as any).formatChatResponse(mockResponse);
-
-      expect(response.content).toBe('Hello there!');
-      expect(response.usage.promptTokens).toBe(0);
-      expect(response.usage.completionTokens).toBe(0);
-      expect(response.usage.totalTokens).toBe(0);
-    });
-  });
-
-  describe('Configuration Options', () => {
-    it('should handle custom baseUrl', () => {
-      const config: OpenWebUIConfig = {
-        apiKey: 'test',
-        baseUrl: 'https://my-openwebui.com'
-      };
-      
-      provider = new OpenWebUIProvider(config);
-      expect(provider).toBeInstanceOf(OpenWebUIProvider);
-    });
-
-    it('should handle custom default model', () => {
-      const config: OpenWebUIConfig = {
-        apiKey: 'test',
-        defaultModel: 'mistral:7b'
-      };
-      
-      provider = new OpenWebUIProvider(config);
-      expect(provider).toBeInstanceOf(OpenWebUIProvider);
-    });
-
-    it('should handle Ollama proxy mode', () => {
-      const config: OpenWebUIConfig = {
-        apiKey: 'test',
-        useOllamaProxy: true
-      };
-      
-      provider = new OpenWebUIProvider(config);
-      expect(provider).toBeInstanceOf(OpenWebUIProvider);
-    });
-
-    it('should handle SSL verification settings', () => {
-      const config: OpenWebUIConfig = {
-        apiKey: 'test',
-        dangerouslyAllowInsecureConnections: false
-      };
-      
-      provider = new OpenWebUIProvider(config);
-      expect(provider).toBeInstanceOf(OpenWebUIProvider);
-    });
-  });
-
-  describe('Request Generation', () => {
-    beforeEach(() => {
-      provider = new OpenWebUIProvider(mockConfig);
-    });
-
-    it('should generate correct headers', () => {
-      const headers = (provider as any).makeRequest('http://test.com', 'GET');
-      // Note: This would need to be mocked in a real test environment
-      expect(typeof headers).toBe('object');
-    });
-  });
-
-  describe('API Mode Selection', () => {
-    it('should use chat API by default', () => {
-      const config: OpenWebUIConfig = {
-        apiKey: 'test',
-        useOllamaProxy: false
-      };
-      
-      provider = new OpenWebUIProvider(config);
-      expect(provider).toBeInstanceOf(OpenWebUIProvider);
-    });
-
-    it('should use Ollama proxy when configured', () => {
-      const config: OpenWebUIConfig = {
-        apiKey: 'test',
-        useOllamaProxy: true
-      };
-      
-      provider = new OpenWebUIProvider(config);
-      expect(provider).toBeInstanceOf(OpenWebUIProvider);
-    });
-  });
-
   describe('Validation', () => {
     beforeEach(() => {
       provider = new OpenWebUIProvider(mockConfig);
     });
 
-    it('should validate provider is initialized before use', async () => {
+    it('should require initialization before use', async () => {
       const params: CompletionParams = {
         messages: [{ role: 'user', content: 'Hello' }]
       };
@@ -417,31 +199,31 @@ describe('OpenWebUIProvider', () => {
     });
   });
 
-  describe('structured responses', () => {
+  describe('Structured responses', () => {
-    it('should handle structured responses correctly', async () => {
+    it('should parse JSON content into typed responses', async () => {
-      const provider = new OpenWebUIProvider({ apiKey: 'test-key' });
+      const p = new OpenWebUIProvider({ apiKey: 'test-key' });
       const mockResponse = {
         content: JSON.stringify({ name: 'John Doe', age: 30 }),
-        model: 'llama3.1',
+        model: 'llama3.1:latest',
         usage: { promptTokens: 10, completionTokens: 20, totalTokens: 30 },
         id: 'test-id'
       };
-      (provider as any).doComplete = jest.fn().mockResolvedValue(mockResponse);
+      (p as any).doComplete = jest.fn().mockResolvedValue(mockResponse);
-      (provider as any).initialized = true;
+      (p as any).initialized = true;
 
-      const responseType = createResponseType<{ name: string; age: number }>
+      const responseType = createResponseType<{ name: string; age: number }>(
-        (`{ name: string; age: number }`,
+        `{ name: string; age: number }`,
         'A user profile'
       );
 
-      const response = await provider.complete<{ name: string; age: number }>({ 
+      const response = await p.complete<{ name: string; age: number }>({
         messages: [{ role: 'user', content: 'test' }],
         responseType
       });
 
       expect(response.content).toEqual({ name: 'John Doe', age: 30 });
       expect(response.rawContent).toBe(JSON.stringify({ name: 'John Doe', age: 30 }));
-      expect((provider as any).doComplete).toHaveBeenCalled();
+      expect((p as any).doComplete).toHaveBeenCalled();
     });
   });
-});
+});