@elevasis/core 0.1.0

package/src/execution/engine/llm/adapters/mock-adapter.ts

@@ -0,0 +1,116 @@
+/**
+ * Mock LLM Adapter
+ * Provides a simple mock implementation for testing purposes
+ */
+
+import type { LLMAdapter, LLMGenerateRequest, LLMGenerateResponse } from '../types'
+import type { AgentAction } from '../../agent/actions/types'
+
+/**
+ * Mock response for agent iteration scenarios
+ */
+export interface MockIterationResponse {
+  reasoning?: string
+  memoryOps?: { set?: Record<string, string>, delete?: string[] }
+  nextActions?: AgentAction[]
+}
+
+/**
+ * Configuration for MockAdapter
+ * Supports multi-iteration scenarios via response queue
+ */
+export interface MockAdapterConfig {
+  // Queue of responses for multi-iteration scenarios
+  responses?: MockIterationResponse[]
+
+  // Completion phase output
+  completionOutput?: unknown
+}
+
+/**
+ * Check if the model and provider combination is for Mock
+ *
+ * @param model - Model identifier (e.g., 'mock')
+ * @param provider - Provider name
+ * @returns True if this is a mock model configuration
+ */
+export function isMockModel(model: string, provider: string): boolean {
+  return model === 'mock' || provider === 'mock'
+}
+
+/**
+ * Mock adapter that returns appropriate responses based on request schema
+ * Used for testing and development without making real API calls
+ *
+ * Supports:
+ * - Response queue for multi-iteration testing
+ * - Call count tracking
+ * - Realistic token usage simulation
+ * - Backward compatible default behavior
+ */
+/**
+ * Minimal JSON Schema interface for checking schema structure
+ */
+interface JsonSchemaWithProperties {
+  properties?: Record<string, unknown>
+}
+
+export class MockAdapter implements LLMAdapter {
+  private responseQueue: MockIterationResponse[] = []
+  private callCount = 0
+
+  constructor(private config: MockAdapterConfig = {}) {
+    this.responseQueue = [...(config.responses || [])]
+  }
+
+  async generate<T = unknown>(request: LLMGenerateRequest): Promise<LLMGenerateResponse<T>> {
+    // Check if this is an agent iteration request (has reasoning + nextActions)
+    const schema = request.responseSchema as JsonSchemaWithProperties | undefined
+    const isAgentIteration = schema?.properties?.reasoning && schema?.properties?.nextActions
+
+    this.callCount++
+
+    if (isAgentIteration) {
+      // Use next response from queue, or default to immediate completion
+      const response = this.responseQueue.shift() || {
+        reasoning: 'Mock reasoning',
+        nextActions: [{ type: 'complete' }]
+      }
+
+      // Return agent iteration response
+      return {
+        output: {
+          reasoning: response.reasoning || 'Mock reasoning',
+          memoryOps: response.memoryOps || {},
+          nextActions: response.nextActions || [{ type: 'complete' }]
+        } as T,
+        usage: {
+          inputTokens: 100 * this.callCount,
+          outputTokens: 50 * this.callCount,
+          totalTokens: 150 * this.callCount
+        }
+      }
+    }
+
+    // Return generic completion response
+    return {
+      output: (this.config.completionOutput || {
+        response: 'Mock response',
+        processedAt: new Date().toISOString()
+      }) as T,
+      usage: {
+        inputTokens: 50,
+        outputTokens: 25,
+        totalTokens: 75
+      }
+    }
+  }
+
+  /**
+   * Get total number of generate() calls made
+   * Useful for verifying expected iteration counts in tests
+   */
+  getCallCount(): number {
+    return this.callCount
+  }
+}

package/src/execution/engine/llm/adapters/server/adapter-factory.ts

@@ -0,0 +1,130 @@
+/**
+ * LLM Adapter Factory
+ * Creates LLM adapter instances based on model configuration
+ */
+
+import type { LLMAdapter } from '../../types'
+import type { ModelConfig, OpenRouterOptions, GoogleOptions, AnthropicOptions } from '../../model-info'
+import { OpenAIAdapter, isOpenAIModel } from './openai'
+import { OpenRouterAdapter, isOpenRouterModel } from './openrouter'
+import { GoogleAdapter, isGoogleModel } from './google'
+import { AnthropicAdapter, isAnthropicModel } from './anthropic'
+import { MockAdapter, isMockModel } from '../mock-adapter'
+import { UniversalLLMAdapter } from '../universal-adapter'
+import type { AIUsageCollector } from '../../../../../operations/observability/ai-usage-collector'
+import type { AICallContext, BaseAICall } from '../../../../../operations/observability/types'
+
+/**
+ * Resolve API key at runtime
+ * Handles the case where env vars weren't loaded at module import time
+ * (e.g., in Docker when dotenv runs after module imports)
+ *
+ * @param configApiKey - API key from config (may be placeholder)
+ * @param provider - Provider name to determine which env var to check
+ * @returns Resolved API key
+ */
+function resolveApiKey(configApiKey: string, provider: string): string {
+  // If the config has a real API key (not a placeholder), use it
+  const isPlaceholder =
+    !configApiKey ||
+    configApiKey.startsWith('placeholder-') ||
+    configApiKey.includes('placeholder') ||
+    configApiKey.includes('test-api-key')
+  if (!isPlaceholder) {
+    return configApiKey
+  }
+
+  // Resolve from environment at runtime based on provider
+  const envVarMap: Record<string, string | undefined> = {
+    anthropic: process.env.ANTHROPIC_API_KEY,
+    openai: process.env.OPENAI_API_KEY,
+    openrouter: process.env.OPENROUTER_API_KEY,
+    google: process.env.GOOGLE_AI_STUDIO_KEY
+  }
+
+  const envKey = envVarMap[provider]
+  if (envKey) {
+    return envKey
+  }
+
+  // Fallback to config value (will fail at API call time with auth error)
+  return configApiKey
+}
+
+/**
+ * Create base adapter based on model configuration
+ * Routes to the appropriate provider-specific adapter
+ *
+ * @param config - Model configuration from resource definition
+ * @returns Base LLM adapter instance (without observability wrapper)
+ */
+function createBaseAdapter(config: ModelConfig): LLMAdapter {
+  const { model, provider, modelOptions } = config
+  const apiKey = resolveApiKey(config.apiKey, provider)
+
+  // OpenAI models
+  if (isOpenAIModel(model, provider)) {
+    return new OpenAIAdapter({
+      apiKey,
+      model,
+      modelOptions // Flat structure - no vendor namespace needed
+    })
+  }
+
+  // OpenRouter models (access to 400+ models via single API)
+  if (isOpenRouterModel(model)) {
+    return new OpenRouterAdapter({
+      apiKey,
+      model,
+      modelOptions: modelOptions as OpenRouterOptions
+    })
+  }
+
+  // Google models (direct SDK access via @google/genai)
+  if (isGoogleModel(model, provider)) {
+    return new GoogleAdapter({
+      apiKey,
+      model,
+      modelOptions: modelOptions as GoogleOptions
+    })
+  }
+
+  // Anthropic models (direct SDK access via @anthropic-ai/sdk)
+  if (isAnthropicModel(model, provider)) {
+    return new AnthropicAdapter({
+      apiKey,
+      model,
+      modelOptions: modelOptions as AnthropicOptions
+    })
+  }
+
+  // Mock provider (for testing)
+  if (isMockModel(model, provider)) {
+    return new MockAdapter()
+  }
+
+  throw new Error(`Unsupported model: ${model} with provider: ${provider}`)
+}
+
+/**
+ * Create LLM adapter based on model configuration
+ * Creates a stateless adapter instance for the execution
+ * Automatically wraps with UniversalLLMAdapter for reliability and observability
+ *
+ * @param config - Model configuration from resource definition (includes model identifier)
+ * @param aiUsageCollector - Optional collector for tracking AI usage
+ * @param callType - Optional call type discriminator for observability
+ * @param context - Optional typed context for observability
+ * @returns Stateless LLM adapter instance (wrapped with UniversalLLMAdapter)
+ */
+export function createLLMAdapter(
+  config: ModelConfig,
+  aiUsageCollector?: AIUsageCollector,
+  callType?: BaseAICall['callType'],
+  context?: AICallContext
+): LLMAdapter {
+  const baseAdapter = createBaseAdapter(config)
+
+  // Wrap with UniversalLLMAdapter for automatic retry, circuit breaker, and observability
+  return new UniversalLLMAdapter(baseAdapter, config.model, aiUsageCollector, callType, context)
+}

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

@@ -0,0 +1,137 @@
+/**
+ * Anthropic Adapter
+ * Stateless translation layer between Universal Protocol and Anthropic API
+ *
+ * Responsibilities:
+ * 1. Translate LLMGenerateRequest to Anthropic message format
+ * 2. Call Anthropic SDK with tool_use for structured output
+ * 3. Parse Anthropic response (extract from tool_use block)
+ * 4. Translate back to LLMGenerateResponse
+ */
+
+import type { LLMAdapter, LLMGenerateRequest, LLMGenerateResponse } from '../../types'
+import type { LLMModel, ModelSpecificOptions } from '../../model-info'
+import { bslogExternalServiceError, isSystemError } from '../../../../../platform/utils/server/betterstack-logger'
+import { composeSignal } from './compose-signal'
+import { DEFAULT_LLM_TIMEOUT } from '../../../../../platform/constants/timeouts'
+
+/**
+ * Anthropic adapter configuration
+ */
+export interface AnthropicAdapterConfig {
+  apiKey: string
+  model: LLMModel
+  modelOptions?: ModelSpecificOptions
+}
+
+/**
+ * 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)
+ *
+ * Key differences from other adapters:
+ * - System messages go in separate `system` field (not in messages array)
+ * - Structured output via tool_use (not native JSON mode)
+ * - Response content is array of blocks (not string)
+ * - max_tokens is required (not optional)
+ * - Total tokens must be calculated (not provided)
+ */
+export class AnthropicAdapter implements LLMAdapter {
+  private clientPromise: Promise<import('@anthropic-ai/sdk').default>
+  private model: LLMModel
+
+  constructor(config: AnthropicAdapterConfig) {
+    // Lazy load Anthropic SDK
+    this.clientPromise = import('@anthropic-ai/sdk').then(
+      ({ default: AnthropicClass }) => new AnthropicClass({ apiKey: config.apiKey })
+    )
+    this.model = config.model
+    // modelOptions reserved for future use (e.g., extended thinking)
+  }
+
+  /**
+   * Generate structured output from messages using Anthropic Claude
+   *
+   * @param request - Generic generation request
+   * @returns Structured output with usage metadata
+   */
+  async generate<T>(request: LLMGenerateRequest): Promise<LLMGenerateResponse<T>> {
+    const client = await this.clientPromise
+
+    try {
+      // Extract system messages (Anthropic uses separate system field)
+      const systemMessages = request.messages.filter((msg) => msg.role === 'system')
+      const nonSystemMessages = request.messages.filter((msg) => msg.role !== 'system')
+
+      // Build system content (combine multiple system messages)
+      const systemContent =
+        systemMessages.length > 0 ? systemMessages.map((msg) => msg.content).join('\n\n') : undefined
+
+      // Convert messages to Anthropic format
+      const anthropicMessages = nonSystemMessages.map((msg) => ({
+        role: msg.role as 'user' | 'assistant',
+        content: msg.content
+      }))
+
+      // Use tool_use for structured output (Anthropic's recommended approach)
+      // 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
+          system: systemContent,
+          messages: anthropicMessages,
+          tools: [
+            {
+              name: 'structured_output',
+              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) }
+      )
+      const response = await stream.finalMessage()
+
+      // Extract structured output from tool_use block
+      const toolUseBlock = response.content.find((block) => block.type === 'tool_use')
+      if (!toolUseBlock || toolUseBlock.type !== 'tool_use') {
+        throw new Error('Anthropic response missing tool_use block for structured output')
+      }
+      const output = toolUseBlock.input as T
+
+      // Calculate total tokens (Anthropic doesn't provide total_tokens)
+      const usage = {
+        inputTokens: response.usage.input_tokens,
+        outputTokens: response.usage.output_tokens,
+        totalTokens: response.usage.input_tokens + response.usage.output_tokens
+      }
+
+      return { output, usage }
+    } catch (error) {
+      // Add Better Stack logging for system errors (5xx only)
+      if (isSystemError(error)) {
+        bslogExternalServiceError('anthropic', 'messages.create', error as Error, {
+          model: this.model
+        })
+      }
+
+      throw error
+    }
+  }
+}

package/src/execution/engine/llm/adapters/server/compose-signal.ts

@@ -0,0 +1,18 @@
+/**
+ * Signal composition helper for LLM adapter timeouts
+ * Composes an execution-level abort signal with a per-call timeout
+ */
+
+/**
+ * Compose an abort signal from a per-call timeout and an optional execution-level signal.
+ * Returns a single signal that fires when either source aborts.
+ *
+ * @param timeoutMs - Per-call timeout in milliseconds
+ * @param executionSignal - Optional execution-level abort signal (from coordinator)
+ * @returns Composed AbortSignal via AbortSignal.any()
+ */
+export function composeSignal(timeoutMs: number, executionSignal?: AbortSignal): AbortSignal {
+  const signals: AbortSignal[] = [AbortSignal.timeout(timeoutMs)]
+  if (executionSignal) signals.push(executionSignal)
+  return AbortSignal.any(signals)
+}

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

@@ -0,0 +1,283 @@
+/**
+ * Google Gemini Adapter
+ * Stateless translation layer between universal protocol and Google GenAI SDK
+ *
+ * Responsibilities:
+ * 1. Translate LLMGenerateRequest to Google GenAI format
+ * 2. Transform JSON Schema to Gemini-compatible format (const -> enum, inline $ref)
+ * 3. Call Google GenAI SDK with structured output
+ * 4. Parse Google response
+ * 5. Translate back to LLMGenerateResponse
+ */
+
+import type { LLMAdapter, LLMGenerateRequest, LLMGenerateResponse } from '../../types'
+import type { LLMModel, GoogleModel, ModelSpecificOptions } from '../../model-info'
+import { LLMResponseParseError } from '../../errors'
+import { bslogExternalServiceError, isSystemError } from '../../../../../platform/utils/server/betterstack-logger'
+import { composeSignal } from './compose-signal'
+import { DEFAULT_LLM_TIMEOUT } from '../../../../../platform/constants/timeouts'
+
+// ============================================================================
+// Schema Transformation for Gemini Compatibility
+// ============================================================================
+
+/**
+ * Transform JSON Schema for Gemini API compatibility
+ *
+ * Gemini uses a subset of JSON Schema. This function handles:
+ * 1. const: "value" -> enum: ["value"] + type: "string" (const keyword not supported)
+ * 2. Inline $ref references from $defs (for schema reuse)
+ * 3. Remove $schema property (Gemini rejects it)
+ * 4. Add placeholder property to empty object types (Gemini requires non-empty properties)
+ * 5. Ensure objects with additionalProperties also have a properties field
+ *
+ * @param schema - JSON Schema object to transform
+ * @param definitions - Map of $defs for $ref resolution (built during traversal)
+ * @returns Gemini-compatible schema
+ */
+function transformSchemaForGemini(schema: unknown, definitions?: Record<string, unknown>): unknown {
+  // Base case: null, undefined, or primitive values pass through unchanged
+  if (!schema || typeof schema !== 'object') {
+    return schema
+  }
+
+  const obj = schema as Record<string, unknown>
+  const result: Record<string, unknown> = {}
+
+  // Extract $defs at the current level for reference resolution
+  // These definitions are accumulated as we traverse down
+  if (obj.$defs && typeof obj.$defs === 'object') {
+    definitions = { ...definitions, ...(obj.$defs as Record<string, unknown>) }
+  }
+
+  for (const [key, value] of Object.entries(obj)) {
+    // Skip $schema - Gemini doesn't accept JSON Schema meta-schema
+    if (key === '$schema') {
+      continue
+    }
+
+    // Skip $defs - definitions are inlined when $ref is encountered
+    if (key === '$defs') {
+      continue
+    }
+
+    // Handle $ref - inline the referenced definition
+    // Format: "#/$defs/DefinitionName"
+    if (key === '$ref' && typeof value === 'string') {
+      const refPath = value.replace('#/$defs/', '')
+      if (definitions?.[refPath]) {
+        // Return the inlined definition (transformed recursively)
+        return transformSchemaForGemini(definitions[refPath], definitions)
+      }
+      // Skip unresolvable refs - they would cause errors anyway
+      continue
+    }
+
+    // Transform const to enum - Gemini doesn't support JSON Schema const keyword
+    // const: "value" becomes type: "string", enum: ["value"]
+    // This handles z.literal() from Zod which generates const
+    // Note: Gemini requires type: "string" when enum is present
+    if (key === 'const') {
+      result.type = 'string'
+      result.enum = [value]
+      continue
+    }
+
+    // Recursively transform nested structures
+    if (Array.isArray(value)) {
+      // Transform each array element (e.g., anyOf, oneOf, allOf, items as tuple)
+      result[key] = value.map((item) => transformSchemaForGemini(item, definitions))
+    } else if (value && typeof value === 'object') {
+      // Transform nested objects (properties, items, additionalProperties, etc.)
+      result[key] = transformSchemaForGemini(value, definitions)
+    } else {
+      // Primitive values pass through unchanged
+      result[key] = value
+    }
+  }
+
+  // SAFEGUARD: Gemini requires objects to have non-empty properties
+  // This handles several cases:
+  // 1. Object with empty properties: { type: "object", properties: {} }
+  // 2. Object with additionalProperties but no properties: { type: "object", additionalProperties: true }
+  // 3. Object with no properties field at all: { type: "object" }
+  //
+  // Google's API strictly requires properties to be non-empty for OBJECT type,
+  // even when additionalProperties is present.
+  if (result.type === 'object') {
+    const props = result.properties as Record<string, unknown> | undefined
+
+    if (!props || Object.keys(props).length === 0) {
+      // Use a property name that:
+      // 1. Google accepts (no underscore prefix)
+      // 2. Is clearly a placeholder (won't conflict with real data)
+      // 3. Is optional so it won't pollute required outputs
+      result.properties = {
+        placeholderField: {
+          type: 'string',
+          description: 'System placeholder for empty object schema. Ignore this field.'
+        }
+      }
+    }
+  }
+
+  return result
+}
+
+/**
+ * Google adapter configuration
+ */
+export interface GoogleAdapterConfig {
+  apiKey: string
+  model: GoogleModel
+  modelOptions?: ModelSpecificOptions
+}
+
+/**
+ * Check if the model and provider combination is for Google
+ *
+ * @param model - Model identifier (e.g., 'gemini-3-flash-preview')
+ * @param provider - Provider name
+ * @returns True if this is a Google model configuration
+ */
+export function isGoogleModel(model: LLMModel, provider: string): model is GoogleModel {
+  return model.startsWith('gemini-') && provider === 'google'
+}
+
+/**
+ * Google Gemini Adapter - Implements universal protocol
+ * Uses structured output via JSON schema for guaranteed schema compliance
+ */
+export class GoogleAdapter implements LLMAdapter {
+  private clientPromise: Promise<import('@google/genai').GoogleGenAI>
+  private model: GoogleModel
+  private modelOptions?: ModelSpecificOptions
+
+  constructor(config: GoogleAdapterConfig) {
+    // Lazy load Google GenAI SDK
+    this.clientPromise = import('@google/genai').then(
+      ({ GoogleGenAI }) =>
+        new GoogleGenAI({
+          apiKey: config.apiKey
+        })
+    )
+    this.model = config.model
+    this.modelOptions = config.modelOptions
+  }
+
+  /**
+   * Generate structured output from messages using Google Gemini
+   *
+   * @param request - Generic generation request
+   * @returns Structured output with usage metadata
+   */
+  async generate<T>(request: LLMGenerateRequest): Promise<LLMGenerateResponse<T>> {
+    const ai = await this.clientPromise
+
+    try {
+      // Build config object for structured output
+      // Transform schema for Gemini compatibility (const -> enum, inline $ref)
+      const generateConfig: Record<string, unknown> = {
+        responseMimeType: 'application/json',
+        responseSchema: transformSchemaForGemini(request.responseSchema)
+      }
+
+      // Add thinking level if specified (Gemini 3 specific feature)
+      if (this.modelOptions && 'thinkingLevel' in this.modelOptions) {
+        generateConfig.thinkingConfig = {
+          thinkingLevel: this.modelOptions.thinkingLevel
+        }
+      }
+
+      // Add max tokens if specified
+      if (request.maxOutputTokens) {
+        generateConfig.maxOutputTokens = request.maxOutputTokens
+      }
+
+      // Convert messages to Gemini format
+      // Gemini uses 'model' role instead of 'assistant' for AI messages
+      // System messages need special handling - prepend to first user message or use systemInstruction
+      const systemMessages = request.messages.filter((msg) => msg.role === 'system')
+      const nonSystemMessages = request.messages.filter((msg) => msg.role !== 'system')
+
+      // Use systemInstruction for system messages if present
+      if (systemMessages.length > 0) {
+        generateConfig.systemInstruction = systemMessages.map((msg) => msg.content).join('\n\n')
+      }
+
+      // Convert remaining messages to Gemini content format
+      const contents = nonSystemMessages.map((msg) => ({
+        role: msg.role === 'assistant' ? 'model' : 'user',
+        parts: [{ text: msg.content }]
+      }))
+
+      const response = await ai.models.generateContent({
+        model: this.model,
+        contents,
+        config: { ...generateConfig, abortSignal: composeSignal(DEFAULT_LLM_TIMEOUT, request.signal) }
+      })
+
+      // Detect empty/blocked responses before parsing
+      // Gemini returns no text when: safety filters block output, prompt is blocked,
+      // model produces empty candidates, or finish reason is non-STOP
+      if (!response.text) {
+        const candidate = response.candidates?.[0]
+        const finishReason = candidate?.finishReason
+        const blockReason = response.promptFeedback?.blockReason
+
+        const reasons: string[] = []
+        if (blockReason) reasons.push(`prompt blocked: ${blockReason}`)
+        if (finishReason && finishReason !== 'STOP') reasons.push(`finish reason: ${finishReason}`)
+        if (!response.candidates?.length) reasons.push('no candidates returned')
+
+        const detail = reasons.length > 0 ? reasons.join(', ') : 'empty response.text with no diagnostic metadata'
+
+        throw new LLMResponseParseError(`Google Gemini returned no output (${detail})`, {
+          finishReason,
+          blockReason,
+          hasCandidates: (response.candidates?.length ?? 0) > 0
+        })
+      }
+
+      // Parse structured output from response with error wrapping for retry support
+      let output: unknown
+      try {
+        output = JSON.parse(response.text)
+      } catch (error) {
+        if (error instanceof SyntaxError) {
+          throw new LLMResponseParseError(`Failed to parse LLM response as JSON: ${error.message}`, {
+            rawContent: response.text.substring(0, 500),
+            parseError: error.message
+          })
+        }
+        throw error
+      }
+
+      // Extract usage metadata for observability tracking
+      const usage = response.usageMetadata
+        ? {
+            inputTokens: response.usageMetadata.promptTokenCount || 0,
+            outputTokens: response.usageMetadata.candidatesTokenCount || 0,
+            totalTokens: response.usageMetadata.totalTokenCount || 0
+          }
+        : undefined
+
+      // Return response with usage (wrapper will extract and strip it)
+      return {
+        output: output as T,
+        usage
+      }
+    } catch (error) {
+      // Add Better Stack logging for system errors (5xx only)
+      if (isSystemError(error)) {
+        bslogExternalServiceError('google-genai', 'models.generateContent', error as Error, {
+          model: this.model,
+          thinkingLevel:
+            this.modelOptions && 'thinkingLevel' in this.modelOptions ? this.modelOptions.thinkingLevel : undefined
+        })
+      }
+
+      throw error
+    }
+  }
+}