@elevasis/core 0.46.0 → 0.48.0

package/src/execution/engine/llm/__tests__/model-validation.test.ts

@@ -71,20 +71,47 @@ describe('validateModelConfig', () => {
       }).not.toThrow()
     })
 
-    it('passes for config without topP', () => {
-      expect(() => {
-        validateModelConfig({
-          model: 'gpt-5',
-          provider: 'openai',
+    it('passes for config without topP', () => {
+      expect(() => {
+        validateModelConfig({
+          model: 'gpt-5',
+          provider: 'openai',
           apiKey: 'test-key',
           temperature: 1,
           maxOutputTokens: 8000
-        })
-      }).not.toThrow()
-    })
-  })
+        })
+      }).not.toThrow()
+    })
+
+    it.each(['claude-opus-4-8', 'claude-sonnet-4-6', 'claude-haiku-4-5-20251001', 'claude-haiku-4-5'] as const)(
+      'passes for Anthropic %s',
+      (model) => {
+        expect(() => {
+          validateModelConfig({
+            model,
+            provider: 'anthropic',
+            apiKey: 'test-key',
+            maxOutputTokens: 4000
+          })
+        }).not.toThrow()
+      }
+    )
+
+    it('passes for Sonnet 4.6 with sampling parameters', () => {
+      expect(() => {
+        validateModelConfig({
+          model: 'claude-sonnet-4-6',
+          provider: 'anthropic',
+          apiKey: 'test-key',
+          temperature: 0.7,
+          topP: 0.9,
+          maxOutputTokens: 4000
+        })
+      }).not.toThrow()
+    })
+  })
 
-  describe('Invalid Temperature', () => {
+  describe('Invalid Temperature', () => {
     it('throws for gpt-5 with temperature=0.7', () => {
       expect(() => {
         validateModelConfig({
@@ -109,9 +136,9 @@ describe('validateModelConfig', () => {
       }).toThrow(ModelConfigError)
     })
 
-    it('provides correct error details for invalid temperature', () => {
-      try {
-        validateModelConfig({
+    it('provides correct error details for invalid temperature', () => {
+      try {
+        validateModelConfig({
           model: 'gpt-5',
           provider: 'openai',
           apiKey: 'test-key',
@@ -123,10 +150,48 @@ describe('validateModelConfig', () => {
         expect(error).toBeInstanceOf(ModelConfigError)
         const modelError = error as ModelConfigError
         expect(modelError.field).toBe('temperature')
-        expect(modelError.model).toBe('gpt-5')
-      }
-    })
-  })
+        expect(modelError.model).toBe('gpt-5')
+      }
+    })
+
+    it('throws for Opus 4.8 with non-default temperature', () => {
+      expect(() => {
+        validateModelConfig({
+          model: 'claude-opus-4-8',
+          provider: 'anthropic',
+          apiKey: 'test-key',
+          temperature: 0.7,
+          maxOutputTokens: 4000
+        })
+      }).toThrow(ModelConfigError)
+    })
+  })
+
+  describe('Invalid Anthropic Sampling Parameters', () => {
+    it('throws for Opus 4.8 with non-default topP', () => {
+      expect(() => {
+        validateModelConfig({
+          model: 'claude-opus-4-8',
+          provider: 'anthropic',
+          apiKey: 'test-key',
+          topP: 0.9,
+          maxOutputTokens: 4000
+        })
+      }).toThrow(ModelConfigError)
+    })
+
+    it('throws for Opus 4.8 with top_k', () => {
+      expect(() => {
+        validateModelConfig({
+          model: 'claude-opus-4-8',
+          provider: 'anthropic',
+          apiKey: 'test-key',
+          maxOutputTokens: 4000,
+          top_k: 40
+        } as unknown as Parameters<typeof validateModelConfig>[0])
+      }).toThrow(ModelConfigError)
+    })
+  })
 
   describe('Invalid maxOutputTokens', () => {
     it('throws for maxOutputTokens below minimum', () => {

package/src/execution/engine/llm/adapters/__tests__/anthropic-adapter.test.ts

@@ -81,17 +81,18 @@ describe('AnthropicAdapter', () => {
     }
   }
 
-  describe('isAnthropicModel', () => {
-    it('returns true for claude models with anthropic provider', () => {
-      expect(isAnthropicModel('claude-opus-4-5', 'anthropic')).toBe(true)
-      expect(isAnthropicModel('claude-sonnet-4-5', 'anthropic')).toBe(true)
-      expect(isAnthropicModel('claude-haiku-4-5', 'anthropic')).toBe(true)
-    })
-
-    it('returns false for claude models with other providers', () => {
-      expect(isAnthropicModel('claude-opus-4-5', 'openrouter')).toBe(false)
-      expect(isAnthropicModel('claude-sonnet-4-5', 'google')).toBe(false)
-    })
+  describe('isAnthropicModel', () => {
+    it('returns true for claude models with anthropic provider', () => {
+      expect(isAnthropicModel('claude-opus-4-8', 'anthropic')).toBe(true)
+      expect(isAnthropicModel('claude-sonnet-4-6', 'anthropic')).toBe(true)
+      expect(isAnthropicModel('claude-haiku-4-5-20251001', 'anthropic')).toBe(true)
+      expect(isAnthropicModel('claude-haiku-4-5', 'anthropic')).toBe(true)
+    })
+
+    it('returns false for claude models with other providers', () => {
+      expect(isAnthropicModel('claude-opus-4-8', 'openrouter')).toBe(false)
+      expect(isAnthropicModel('claude-sonnet-4-6', 'google')).toBe(false)
+    })
 
     it('returns false for non-claude models', () => {
       expect(isAnthropicModel('gpt-5', 'anthropic')).toBe(false)
@@ -101,10 +102,10 @@ describe('AnthropicAdapter', () => {
 
   describe('Basic Configuration', () => {
     it('creates adapter without model options', async () => {
-      const adapter = new AnthropicAdapter({
-        apiKey: 'test-key',
-        model: 'claude-sonnet-4-5'
-      })
+      const adapter = new AnthropicAdapter({
+        apiKey: 'test-key',
+        model: 'claude-sonnet-4-6'
+      })
 
       mockStreamResponse(mockAnthropicResponse)
 
@@ -114,11 +115,11 @@ describe('AnthropicAdapter', () => {
     })
 
     it('creates adapter with model options', async () => {
-      const adapter = new AnthropicAdapter({
-        apiKey: 'test-key',
-        model: 'claude-opus-4-5',
-        modelOptions: {}
-      })
+      const adapter = new AnthropicAdapter({
+        apiKey: 'test-key',
+        model: 'claude-opus-4-8',
+        modelOptions: {}
+      })
 
       mockStreamResponse(mockAnthropicResponse)
 
@@ -130,10 +131,10 @@ describe('AnthropicAdapter', () => {
 
   describe('Message Translation', () => {
     it('converts system messages to separate system field', async () => {
-      const adapter = new AnthropicAdapter({
-        apiKey: 'test-key',
-        model: 'claude-sonnet-4-5'
-      })
+      const adapter = new AnthropicAdapter({
+        apiKey: 'test-key',
+        model: 'claude-sonnet-4-6'
+      })
 
       mockStreamResponse(mockAnthropicResponse)
 
@@ -157,10 +158,10 @@ describe('AnthropicAdapter', () => {
     })
 
     it('combines multiple system messages', async () => {
-      const adapter = new AnthropicAdapter({
-        apiKey: 'test-key',
-        model: 'claude-sonnet-4-5'
-      })
+      const adapter = new AnthropicAdapter({
+        apiKey: 'test-key',
+        model: 'claude-sonnet-4-6'
+      })
 
       mockStreamResponse(mockAnthropicResponse)
 
@@ -179,10 +180,10 @@ describe('AnthropicAdapter', () => {
     })
 
     it('handles requests without system messages', async () => {
-      const adapter = new AnthropicAdapter({
-        apiKey: 'test-key',
-        model: 'claude-sonnet-4-5'
-      })
+      const adapter = new AnthropicAdapter({
+        apiKey: 'test-key',
+        model: 'claude-sonnet-4-6'
+      })
 
       mockStreamResponse(mockAnthropicResponse)
 
@@ -197,10 +198,10 @@ describe('AnthropicAdapter', () => {
     })
 
     it('preserves user and assistant roles', async () => {
-      const adapter = new AnthropicAdapter({
-        apiKey: 'test-key',
-        model: 'claude-sonnet-4-5'
-      })
+      const adapter = new AnthropicAdapter({
+        apiKey: 'test-key',
+        model: 'claude-sonnet-4-6'
+      })
 
       mockStreamResponse(mockAnthropicResponse)
 
@@ -223,10 +224,10 @@ describe('AnthropicAdapter', () => {
 
   describe('Tool-based Structured Output', () => {
     it('configures tool_use for structured output', async () => {
-      const adapter = new AnthropicAdapter({
-        apiKey: 'test-key',
-        model: 'claude-sonnet-4-5'
-      })
+      const adapter = new AnthropicAdapter({
+        apiKey: 'test-key',
+        model: 'claude-sonnet-4-6'
+      })
 
       mockStreamResponse(mockAnthropicResponse)
 
@@ -244,10 +245,10 @@ describe('AnthropicAdapter', () => {
     })
 
     it('extracts response from tool_use block', async () => {
-      const adapter = new AnthropicAdapter({
-        apiKey: 'test-key',
-        model: 'claude-sonnet-4-5'
-      })
+      const adapter = new AnthropicAdapter({
+        apiKey: 'test-key',
+        model: 'claude-sonnet-4-6'
+      })
 
       mockStreamResponse({
         content: [
@@ -278,10 +279,10 @@ describe('AnthropicAdapter', () => {
     })
 
     it('throws error when no tool_use block in response', async () => {
-      const adapter = new AnthropicAdapter({
-        apiKey: 'test-key',
-        model: 'claude-sonnet-4-5'
-      })
+      const adapter = new AnthropicAdapter({
+        apiKey: 'test-key',
+        model: 'claude-sonnet-4-6'
+      })
 
       mockStreamResponse({
         content: [{ type: 'text', text: 'Hello!' }],
@@ -296,10 +297,10 @@ describe('AnthropicAdapter', () => {
 
   describe('Usage Metadata', () => {
     it('calculates total tokens from input + output', async () => {
-      const adapter = new AnthropicAdapter({
-        apiKey: 'test-key',
-        model: 'claude-sonnet-4-5'
-      })
+      const adapter = new AnthropicAdapter({
+        apiKey: 'test-key',
+        model: 'claude-sonnet-4-6'
+      })
 
       mockStreamResponse({
         content: [mockAnthropicResponse.content[0]],
@@ -319,10 +320,10 @@ describe('AnthropicAdapter', () => {
     })
 
     it('extracts token usage correctly', async () => {
-      const adapter = new AnthropicAdapter({
-        apiKey: 'test-key',
-        model: 'claude-sonnet-4-5'
-      })
+      const adapter = new AnthropicAdapter({
+        apiKey: 'test-key',
+        model: 'claude-sonnet-4-6'
+      })
 
       mockStreamResponse(mockAnthropicResponse)
 
@@ -338,10 +339,10 @@ describe('AnthropicAdapter', () => {
 
   describe('MaxTokens Configuration', () => {
     it('passes maxOutputTokens to API', async () => {
-      const adapter = new AnthropicAdapter({
-        apiKey: 'test-key',
-        model: 'claude-sonnet-4-5'
-      })
+      const adapter = new AnthropicAdapter({
+        apiKey: 'test-key',
+        model: 'claude-sonnet-4-6'
+      })
 
       mockStreamResponse(mockAnthropicResponse)
 
@@ -355,10 +356,10 @@ describe('AnthropicAdapter', () => {
     })
 
     it('uses default 4000 when maxOutputTokens not specified', async () => {
-      const adapter = new AnthropicAdapter({
-        apiKey: 'test-key',
-        model: 'claude-sonnet-4-5'
-      })
+      const adapter = new AnthropicAdapter({
+        apiKey: 'test-key',
+        model: 'claude-sonnet-4-6'
+      })
 
       mockStreamResponse(mockAnthropicResponse)
 
@@ -373,12 +374,12 @@ describe('AnthropicAdapter', () => {
     })
   })
 
-  describe('Temperature and TopP', () => {
-    it('passes temperature to API', async () => {
-      const adapter = new AnthropicAdapter({
-        apiKey: 'test-key',
-        model: 'claude-sonnet-4-5'
-      })
+  describe('Temperature and TopP', () => {
+    it('passes temperature to API', async () => {
+      const adapter = new AnthropicAdapter({
+        apiKey: 'test-key',
+        model: 'claude-sonnet-4-6'
+      })
 
       mockStreamResponse(mockAnthropicResponse)
 
@@ -392,10 +393,10 @@ describe('AnthropicAdapter', () => {
     })
 
     it('passes topP to API', async () => {
-      const adapter = new AnthropicAdapter({
-        apiKey: 'test-key',
-        model: 'claude-sonnet-4-5'
-      })
+      const adapter = new AnthropicAdapter({
+        apiKey: 'test-key',
+        model: 'claude-sonnet-4-6'
+      })
 
       mockStreamResponse(mockAnthropicResponse)
 
@@ -404,17 +405,37 @@ describe('AnthropicAdapter', () => {
         topP: 0.9
       })
 
-      const callParams = mockMessagesStream.mock.calls[0][0]
-      expect(callParams.top_p).toBe(0.9)
-    })
-  })
+      const callParams = mockMessagesStream.mock.calls[0][0]
+      expect(callParams.top_p).toBe(0.9)
+    })
+
+    it('omits sampling parameters for Opus 4.8', async () => {
+      const adapter = new AnthropicAdapter({
+        apiKey: 'test-key',
+        model: 'claude-opus-4-8'
+      })
+
+      mockStreamResponse(mockAnthropicResponse)
+
+      await adapter.generate({
+        ...baseRequest,
+        temperature: 0.7,
+        topP: 0.9
+      })
+
+      const callParams = mockMessagesStream.mock.calls[0][0]
+      expect(callParams).not.toHaveProperty('temperature')
+      expect(callParams).not.toHaveProperty('top_p')
+      expect(callParams).not.toHaveProperty('top_k')
+    })
+  })
 
   describe('Error Handling', () => {
     it('propagates API errors', async () => {
-      const adapter = new AnthropicAdapter({
-        apiKey: 'test-key',
-        model: 'claude-sonnet-4-5'
-      })
+      const adapter = new AnthropicAdapter({
+        apiKey: 'test-key',
+        model: 'claude-sonnet-4-6'
+      })
 
       const apiError = new Error('API rate limit exceeded')
       mockStreamError(apiError)
@@ -425,10 +446,10 @@ describe('AnthropicAdapter', () => {
 
   describe('Multiple Calls', () => {
     it('reuses client across multiple generate calls', async () => {
-      const adapter = new AnthropicAdapter({
-        apiKey: 'test-key',
-        model: 'claude-opus-4-5'
-      })
+      const adapter = new AnthropicAdapter({
+        apiKey: 'test-key',
+        model: 'claude-sonnet-4-6'
+      })
 
       mockStreamResponsePersistent(mockAnthropicResponse)
 
@@ -443,7 +464,7 @@ describe('AnthropicAdapter', () => {
   })
 
   describe('Model Selection', () => {
-    it.each(['claude-opus-4-5', 'claude-sonnet-4-5', 'claude-haiku-4-5'] as const)(
+    it.each(['claude-opus-4-8', 'claude-sonnet-4-6', 'claude-haiku-4-5-20251001', 'claude-haiku-4-5'] as const)(
       'supports %s model',
       async (model) => {
         const adapter = new AnthropicAdapter({

package/src/execution/engine/llm/adapters/server/anthropic.ts

@@ -25,19 +25,34 @@ export interface AnthropicAdapterConfig {
 }
 
 /**
- * Check if the model and provider combination is for Anthropic
- *
- * @param model - Model identifier (e.g., 'claude-opus-4-5-20251101')
- * @param provider - Provider name
- * @returns True if this is an Anthropic model configuration
- */
-export function isAnthropicModel(model: LLMModel, provider: string): boolean {
-  return model.startsWith('claude-') && provider === 'anthropic'
-}
-
-/**
- * Anthropic Claude Adapter - Implements universal protocol
- * Uses tool_use for structured output (Anthropic's recommended approach)
+ * Check if the model and provider combination is for Anthropic
+ *
+ * @param model - Model identifier (e.g., 'claude-opus-4-8')
+ * @param provider - Provider name
+ * @returns True if this is an Anthropic model configuration
+ */
+export function isAnthropicModel(model: LLMModel, provider: string): boolean {
+  return model.startsWith('claude-') && provider === 'anthropic'
+}
+
+function shouldOmitSamplingParameters(model: LLMModel): boolean {
+  return model === 'claude-opus-4-8'
+}
+
+function getSamplingParameters(model: LLMModel, request: LLMGenerateRequest): { temperature?: number; top_p?: number } {
+  if (shouldOmitSamplingParameters(model)) {
+    return {}
+  }
+
+  return {
+    ...(request.temperature !== undefined ? { temperature: request.temperature } : {}),
+    ...(request.topP !== undefined ? { top_p: request.topP } : {})
+  }
+}
+
+/**
+ * Anthropic Claude Adapter - Implements universal protocol
+ * Uses tool_use for structured output (Anthropic's recommended approach)
  *
  * Key differences from other adapters:
  * - System messages go in separate `system` field (not in messages array)
@@ -87,10 +102,10 @@ export class AnthropicAdapter implements LLMAdapter {
       // This guarantees schema compliance without requiring JSON mode
       // Stream + finalMessage() to avoid SDK non-streaming timeout rejection
       // at high max_tokens values (SDK calculates estimated time > 10 min → error)
-      const stream = client.messages.stream(
-        {
-          model: this.model,
-          max_tokens: request.maxOutputTokens || 4000, // Required for Anthropic
+      const stream = client.messages.stream(
+        {
+          model: this.model,
+          max_tokens: request.maxOutputTokens || 4000, // Required for Anthropic
           system: systemContent,
           messages: anthropicMessages,
           tools: [
@@ -99,13 +114,12 @@ export class AnthropicAdapter implements LLMAdapter {
               description: 'Return structured output matching the required schema',
               input_schema: request.responseSchema as import('@anthropic-ai/sdk').Anthropic.Tool['input_schema']
             }
-          ],
-          tool_choice: { type: 'tool', name: 'structured_output' },
-          temperature: request.temperature,
-          top_p: request.topP
-        },
-        { signal: composeSignal(DEFAULT_LLM_TIMEOUT, request.signal) }
-      )
+          ],
+          tool_choice: { type: 'tool', name: 'structured_output' },
+          ...getSamplingParameters(this.model, request)
+        },
+        { signal: composeSignal(DEFAULT_LLM_TIMEOUT, request.signal) }
+      )
       const response = await stream.finalMessage()
 
       // Extract structured output from tool_use block