@strav/brain 0.4.31 → 1.0.0-alpha.11

package/src/providers/openai_provider.ts

@@ -1,569 +1,416 @@
-import { parseSSE } from '../utils/sse_parser.ts'
-import { retryableFetch, type RetryOptions } from '../utils/retry.ts'
-import { ExternalServiceError } from '@strav/kernel'
-import type {
-  AIProvider,
-  CompletionRequest,
-  CompletionResponse,
-  StreamChunk,
-  EmbeddingResponse,
-  ProviderConfig,
-  Message,
-  ToolCall,
-  TranscribeRequest,
-  TranscriptionResponse,
-  Usage,
-} from '../types.ts'
-
 /**
- * OpenAI Chat Completions API provider.
+ * `OpenAIProvider` — implementation of `Provider` backed by the
+ * official `openai` SDK (chat completions API).
+ *
+ * Maps framework shapes to OpenAI's wire format:
+ *
+ *   - `system` becomes the first message with `role: 'system'`.
+ *     (OpenAI doesn't have a separate system field on chat
+ *     completions; o1/o3 reasoning models accept `developer` as
+ *     a synonym but `system` still works.)
+ *
+ *   - `Message` with string content → `{role, content: string}`.
+ *     `Message` with `ContentBlock[]`: text blocks concatenate into
+ *     a single content string; `ToolUseBlock`s on assistant turns
+ *     translate to `tool_calls`; `ToolResultBlock`s in user turns
+ *     each become their own `{role: 'tool', tool_call_id, content}`
+ *     message (OpenAI requires this layout, not a single user turn
+ *     with mixed content like Anthropic's).
+ *
+ *   - `Tool[]` → `[{type: 'function', function: {name, description,
+ *     parameters: tool.inputSchema}}]`. OpenAI wraps every tool in
+ *     a `function` namespace where Anthropic uses flat tool
+ *     definitions.
+ *
+ *   - `MCPServer[]` → throws `BrainError`. OpenAI has no
+ *     server-side MCP support; the local MCP client slice
+ *     (`@strav/brain/mcp`) lands when this is needed.
+ *
+ *   - `cache: true` is a no-op. OpenAI auto-caches; there's no
+ *     per-block cache_control to set. The framework flag is
+ *     accepted (so config that targets both providers still
+ *     works) but doesn't emit anything to the wire.
  *
- * Also serves DeepSeek and any OpenAI-compatible API by setting `baseUrl`
- * in the provider config. Uses raw `fetch()`.
+ *   - `thinking: 'adaptive'` maps to `reasoning_effort: 'medium'`
+ *     on reasoning models (o1, o3, o5, etc.); `'disabled'` maps
+ *     to `reasoning_effort: 'minimal'`. Non-reasoning models
+ *     silently ignore the field.
+ *
+ *   - `effort` (when set) maps directly to `reasoning_effort`
+ *     when supported by the model.
+ *
+ *   - `countTokens` is NOT implemented — OpenAI has no dedicated
+ *     count endpoint. `BrainManager.countTokens` returns `null`
+ *     when the configured provider doesn't expose the method.
  */
-export class OpenAIProvider implements AIProvider {
-  readonly name: string
-  private apiKey: string
-  private baseUrl: string
-  private defaultModel: string
-  private defaultMaxTokens?: number
-  private retryOptions: RetryOptions
 
-  constructor(config: ProviderConfig, name?: string) {
-    this.name = name ?? 'openai'
-    this.apiKey = config.apiKey
-    this.baseUrl = (config.baseUrl ?? 'https://api.openai.com').replace(/\/$/, '')
-    this.defaultModel = config.model
-    this.defaultMaxTokens = config.maxTokens
-    this.retryOptions = {
-      maxRetries: config.maxRetries ?? 3,
-      baseDelay: config.retryBaseDelay ?? 1000,
-    }
-  }
-
-  /** Whether this provider supports OpenAI's native json_schema response format. */
-  private get supportsJsonSchema(): boolean {
-    return this.baseUrl === 'https://api.openai.com'
-  }
-
-  async complete(request: CompletionRequest): Promise<CompletionResponse> {
-    const body = this.buildRequestBody(request, false)
+import OpenAI from 'openai'
+import type { AgentResult } from '../agent_result.ts'
+import { BrainError } from '../brain_error.ts'
+import type { OpenAIProviderConfig } from '../brain_config.ts'
+import type { Provider, RunWithToolsOptions } from '../provider.ts'
+import type { Tool } from '../tool.ts'
+import { ToolExecutionError } from '../tool_execution_error.ts'
+import type {
+  ChatOptions,
+  ChatResult,
+  ChatUsage,
+  ContentBlock,
+  Message,
+  StreamEvent,
+  SystemPrompt,
+  TextBlock,
+  ToolResultBlock,
+  ToolUseBlock,
+} from '../types.ts'
 
-    const response = await retryableFetch(
-      'OpenAI',
-      `${this.baseUrl}/v1/chat/completions`,
-      { method: 'POST', headers: this.buildHeaders(), body: JSON.stringify(body) },
-      this.retryOptions
-    )
+const DEFAULT_OPENAI_MODEL = 'gpt-5'
 
-    const data: any = await response.json()
-    return this.parseResponse(data)
+export class OpenAIProvider implements Provider {
+  readonly name: string
+  private readonly client: OpenAI
+  private readonly defaultModel: string
+  private readonly defaultMaxTokens: number
+
+  constructor(
+    name: string,
+    config: OpenAIProviderConfig,
+    options: { client?: OpenAI } = {},
+  ) {
+    this.name = name
+    this.defaultModel = config.defaultModel ?? DEFAULT_OPENAI_MODEL
+    this.defaultMaxTokens = config.defaultMaxTokens ?? 4096
+    this.client =
+      options.client ??
+      new OpenAI({
+        apiKey: config.apiKey,
+        ...(config.baseUrl !== undefined ? { baseURL: config.baseUrl } : {}),
+        ...(config.organization !== undefined ? { organization: config.organization } : {}),
+      })
   }
 
-  async *stream(request: CompletionRequest): AsyncIterable<StreamChunk> {
-    const body = this.buildRequestBody(request, true)
-
-    const response = await retryableFetch(
-      'OpenAI',
-      `${this.baseUrl}/v1/chat/completions`,
-      { method: 'POST', headers: this.buildHeaders(), body: JSON.stringify(body) },
-      this.retryOptions
-    )
+  async chat(messages: readonly Message[], options: ChatOptions = {}): Promise<ChatResult> {
+    const params = this.buildParams(messages, options, [])
+    const response = await this.client.chat.completions.create(params)
+    return this.toChatResult(response)
+  }
 
-    if (!response.body) {
-      throw new ExternalServiceError('OpenAI', undefined, 'No stream body returned')
+  async *stream(
+    messages: readonly Message[],
+    options: ChatOptions = {},
+  ): AsyncIterable<StreamEvent> {
+    const params: OpenAI.Chat.ChatCompletionCreateParamsStreaming = {
+      ...this.buildParams(messages, options, []),
+      stream: true,
+      stream_options: { include_usage: true },
     }
-
-    // Track in-progress tool calls for tool_start vs tool_delta distinction
-    const seenTools = new Set<number>()
-
-    for await (const sse of parseSSE(response.body)) {
-      if (sse.data === '[DONE]') {
-        yield { type: 'done' }
-        break
+    const stream = await this.client.chat.completions.create(params)
+    let aggregatedUsage: OpenAI.CompletionUsage | undefined
+    let finishReason: string | null = null
+    for await (const chunk of stream) {
+      const delta = chunk.choices[0]?.delta?.content
+      if (typeof delta === 'string' && delta.length > 0) {
+        yield { type: 'text', delta }
       }
-
-      let parsed: any
-      try {
-        parsed = JSON.parse(sse.data)
-      } catch {
-        continue
+      if (chunk.choices[0]?.finish_reason) {
+        finishReason = chunk.choices[0].finish_reason
       }
+      if (chunk.usage) aggregatedUsage = chunk.usage
+    }
+    yield {
+      type: 'stop',
+      stopReason: finishReason,
+      usage: toUsage(aggregatedUsage),
+    }
+  }
 
-      const choice = parsed.choices?.[0]
-      if (!choice) continue
+  async runWithTools(
+    messages: readonly Message[],
+    tools: readonly Tool[],
+    options: RunWithToolsOptions = {},
+  ): Promise<AgentResult> {
+    if (options.mcpServers && options.mcpServers.length > 0) {
+      throw new BrainError(
+        'OpenAIProvider.runWithTools: MCP servers are not supported by the OpenAI provider in V1. Use the Anthropic provider for server-side MCP, or wait for the local MCP client slice.',
+        { context: { provider: this.name } },
+      )
+    }
+    const maxIterations = options.maxIterations ?? 10
+    const toolMap = new Map<string, Tool>(tools.map((t) => [t.name, t]))
+    const workingMessages: Message[] = [...messages]
+    const aggregated: ChatUsage = {
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheReadTokens: 0,
+      cacheCreationTokens: 0,
+    }
+    let iterations = 0
 
-      const delta = choice.delta
-      if (!delta) continue
+    while (true) {
+      const params = this.buildParams(workingMessages, options, tools)
+      const response = await this.client.chat.completions.create(params)
+      addUsage(aggregated, response.usage)
 
-      // Text content
-      if (delta.content) {
-        yield { type: 'text', text: delta.content }
+      const choice = response.choices[0]
+      if (!choice) {
+        throw new BrainError('OpenAIProvider: response had no choices.')
       }
-
-      // Tool calls
-      if (delta.tool_calls) {
-        for (const tc of delta.tool_calls) {
-          const index: number = tc.index ?? 0
-
-          if (!seenTools.has(index)) {
-            // First chunk for this tool — emit tool_start
-            seenTools.add(index)
-            yield {
-              type: 'tool_start',
-              toolCall: { id: tc.id, name: tc.function?.name },
-              toolIndex: index,
-            }
-          }
-
-          // Argument fragments
-          if (tc.function?.arguments) {
-            yield {
-              type: 'tool_delta',
-              text: tc.function.arguments,
-              toolIndex: index,
-            }
-          }
+      const assistantMessage = choice.message
+
+      // Append assistant turn to working messages so we send it back
+      // verbatim on the next round-trip.
+      workingMessages.push({
+        role: 'assistant',
+        content: fromOpenAIAssistantMessage(assistantMessage),
+      })
+
+      const toolCalls = assistantMessage.tool_calls ?? []
+      if (toolCalls.length === 0 || choice.finish_reason !== 'tool_calls') {
+        return {
+          text: assistantMessage.content ?? '',
+          messages: workingMessages,
+          iterations,
+          stopReason: choice.finish_reason ?? 'stop',
+          usage: aggregated,
         }
       }
 
-      // Finish reason
-      if (choice.finish_reason) {
-        if (choice.finish_reason === 'tool_calls') {
-          // Emit tool_end for all tracked tools
-          for (const idx of seenTools) {
-            yield { type: 'tool_end', toolIndex: idx }
-          }
+      const resultBlocks: ContentBlock[] = []
+      for (const call of toolCalls) {
+        if (call.type !== 'function') continue
+        const tool = toolMap.get(call.function.name)
+        if (!tool) {
+          throw new ToolExecutionError(
+            call.function.name,
+            call.id,
+            new Error(`Tool "${call.function.name}" is not registered.`),
+          )
         }
-
-        // Usage in final chunk (if stream_options.include_usage is set)
-        if (parsed.usage) {
-          yield {
-            type: 'usage',
-            usage: {
-              inputTokens: parsed.usage.prompt_tokens ?? 0,
-              outputTokens: parsed.usage.completion_tokens ?? 0,
-              totalTokens: parsed.usage.total_tokens ?? 0,
-            },
-          }
+        let parsedInput: unknown
+        try {
+          parsedInput = call.function.arguments ? JSON.parse(call.function.arguments) : {}
+        } catch (err) {
+          throw new ToolExecutionError(
+            call.function.name,
+            call.id,
+            new Error(`Failed to parse tool input JSON: ${(err as Error).message}`),
+          )
+        }
+        let output: unknown
+        try {
+          output = await tool.execute(parsedInput, {
+            callId: call.id,
+            context: options.context ?? {},
+          })
+        } catch (cause) {
+          throw new ToolExecutionError(call.function.name, call.id, cause)
+        }
+        const resultBlock: ToolResultBlock = {
+          type: 'tool_result',
+          toolUseId: call.id,
+          content: typeof output === 'string' ? output : JSON.stringify(output),
+        }
+        resultBlocks.push(resultBlock)
+      }
+      workingMessages.push({ role: 'user', content: resultBlocks })
+
+      iterations++
+      if (iterations >= maxIterations) {
+        return {
+          text: assistantMessage.content ?? '',
+          messages: workingMessages,
+          iterations,
+          stopReason: 'max_iterations',
+          usage: aggregated,
         }
       }
     }
   }
 
-  async embed(input: string | string[], model?: string): Promise<EmbeddingResponse> {
-    const body = {
-      input: Array.isArray(input) ? input : [input],
-      model: model ?? 'text-embedding-3-small',
-    }
-
-    const response = await retryableFetch(
-      'OpenAI',
-      `${this.baseUrl}/v1/embeddings`,
-      { method: 'POST', headers: this.buildHeaders(), body: JSON.stringify(body) },
-      this.retryOptions
-    )
-
-    const data: any = await response.json()
-
-    return {
-      embeddings: data.data.map((d: any) => d.embedding),
-      model: data.model,
-      usage: { totalTokens: data.usage?.total_tokens ?? 0 },
-    }
-  }
-
-  /**
-   * Speech-to-text via the OpenAI Whisper API (/v1/audio/transcriptions).
-   *
-   * Defaults to `whisper-1` — the long-standing, broadly supported model.
-   * Override with `gpt-4o-transcribe` or `gpt-4o-mini-transcribe` for the
-   * newer architecture (better noise/accent robustness, similar pricing).
-   *
-   * Requests `verbose_json` so we can surface `language` and `duration`
-   * on the normalized response without a second round-trip.
-   */
-  async transcribe(request: TranscribeRequest): Promise<TranscriptionResponse> {
-    const filename = request.filename ?? defaultFilename(request.contentType)
-    const contentType = request.contentType ?? 'application/octet-stream'
-    const blob =
-      request.audio instanceof Blob
-        ? request.audio
-        : new Blob([request.audio], { type: contentType })
-
-    const form = new FormData()
-    form.append('file', blob, filename)
-    form.append('model', request.model ?? 'whisper-1')
-    form.append('response_format', 'verbose_json')
-    if (request.language) form.append('language', request.language)
-    if (request.prompt) form.append('prompt', request.prompt)
-
-    const response = await retryableFetch(
-      'OpenAI',
-      `${this.baseUrl}/v1/audio/transcriptions`,
-      {
-        method: 'POST',
-        // Don't set Content-Type — the runtime sets it with the
-        // multipart boundary derived from the FormData body.
-        headers: { Authorization: `Bearer ${this.apiKey}` },
-        body: form,
-      },
-      this.retryOptions
-    )
-
-    const data: any = await response.json()
-    return {
-      text: String(data.text ?? ''),
-      language: typeof data.language === 'string' ? data.language : undefined,
-      duration: typeof data.duration === 'number' ? data.duration : undefined,
-      raw: data,
-    }
-  }
-
-  // ── Private helpers ──────────────────────────────────────────────────────
-
-  private isReasoningModel(model: string): boolean {
-    return /^(o[1-9]|gpt-5)/.test(model)
-  }
-
-  private usesMaxCompletionTokens(model: string): boolean {
-    return this.isReasoningModel(model) || /^gpt-4\.1|gpt-4o-mini-2024/.test(model)
-  }
-
-  private buildHeaders(): Record<string, string> {
-    return {
-      'content-type': 'application/json',
-      authorization: `Bearer ${this.apiKey}`,
-    }
-  }
-
-  private buildRequestBody(request: CompletionRequest, stream: boolean): Record<string, unknown> {
-    const body: Record<string, unknown> = {
-      model: request.model ?? this.defaultModel,
-      messages: this.mapMessages(request.messages, request.system),
+  // ─── Param translation ──────────────────────────────────────────────────
+
+  private buildParams(
+    messages: readonly Message[],
+    options: ChatOptions,
+    tools: readonly Tool[],
+  ): OpenAI.Chat.ChatCompletionCreateParamsNonStreaming {
+    const model = options.model ?? this.defaultModel
+    const params: OpenAI.Chat.ChatCompletionCreateParamsNonStreaming = {
+      model,
+      max_completion_tokens: options.maxTokens ?? this.defaultMaxTokens,
+      messages: this.toMessages(options.system, messages),
     }
 
-    if (stream) body.stream = true
-    if (request.maxTokens ?? this.defaultMaxTokens) {
-      const tokens = request.maxTokens ?? this.defaultMaxTokens
-      const model = (body.model as string) ?? ''
-
-      if (this.usesMaxCompletionTokens(model)) {
-        body.max_completion_tokens = tokens
-      } else {
-        body.max_tokens = tokens
-      }
-    }
-    if (request.temperature !== undefined && !this.isReasoningModel((body.model as string) ?? '')) {
-      body.temperature = request.temperature
-    }
-    if (request.stopSequences?.length) body.stop = request.stopSequences
-
-    // Tools
-    if (request.tools?.length) {
-      body.tools = request.tools.map(t => ({
+    if (tools.length > 0) {
+      params.tools = tools.map((t) => ({
         type: 'function',
         function: {
           name: t.name,
           description: t.description,
-          parameters: t.parameters,
+          parameters: t.inputSchema as Record<string, unknown>,
         },
       }))
     }
 
-    // Tool choice
-    if (request.toolChoice) {
-      if (typeof request.toolChoice === 'string') {
-        body.tool_choice = request.toolChoice
-      } else {
-        body.tool_choice = {
-          type: 'function',
-          function: { name: request.toolChoice.name },
-        }
-      }
+    // Reasoning controls — only emitted when explicitly set so
+    // non-reasoning models don't get rejected.
+    if (options.effort !== undefined) {
+      params.reasoning_effort = options.effort as OpenAI.ReasoningEffort
+    } else if (options.thinking === 'adaptive') {
+      params.reasoning_effort = 'medium' as OpenAI.ReasoningEffort
+    } else if (options.thinking === 'disabled') {
+      params.reasoning_effort = 'minimal' as OpenAI.ReasoningEffort
     }
 
-    // Structured output
-    if (request.schema) {
-      const useStrict = this.supportsJsonSchema && this.isStrictCompatible(request.schema)
+    // `cache` is a no-op on OpenAI — prompt caching is automatic.
+    // We accept the flag silently so apps that target both providers
+    // with the same options object don't have to special-case.
 
-      if (useStrict) {
-        body.response_format = {
-          type: 'json_schema',
-          json_schema: {
-            name: 'response',
-            schema: this.normalizeSchemaForOpenAI(request.schema),
-            strict: true,
-          },
-        }
-      } else {
-        // Fallback: json_object mode with schema injected into system prompt
-        body.response_format = { type: 'json_object' }
-        const schemaHint = `\n\nYou MUST respond with valid JSON matching this schema:\n${JSON.stringify(request.schema, null, 2)}`
-        const messages = body.messages as any[]
-        if (messages[0]?.role === 'system') {
-          messages[0].content += schemaHint
-        } else {
-          messages.unshift({ role: 'system', content: `Respond with valid JSON.${schemaHint}` })
-        }
-      }
-    }
-
-    return body
+    return params
   }
 
-  private mapMessages(messages: Message[], system?: string): any[] {
-    const result: any[] = []
-
-    // System prompt as first message
-    if (system) {
-      result.push({ role: 'system', content: system })
+  private toMessages(
+    system: SystemPrompt | undefined,
+    messages: readonly Message[],
+  ): OpenAI.Chat.ChatCompletionMessageParam[] {
+    const out: OpenAI.Chat.ChatCompletionMessageParam[] = []
+    const systemText = systemPromptText(system)
+    if (systemText.length > 0) {
+      out.push({ role: 'system', content: systemText })
     }
-
-    for (const msg of messages) {
-      if (msg.role === 'tool') {
-        result.push({
-          role: 'tool',
-          tool_call_id: msg.toolCallId,
-          content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),
-        })
-      } else if (msg.role === 'assistant') {
-        const mapped: any = {
-          role: 'assistant',
-          content: typeof msg.content === 'string' ? msg.content : null,
+    for (const message of messages) {
+      // User-role messages with tool results in their content fan
+      // out into one `tool`-role message per result — OpenAI's
+      // contract is "one tool_call_id per tool message," not a
+      // single user message carrying multiple results.
+      if (
+        message.role === 'user' &&
+        Array.isArray(message.content) &&
+        message.content.some((b) => b.type === 'tool_result')
+      ) {
+        const remainingText: string[] = []
+        for (const block of message.content) {
+          if (block.type === 'tool_result') {
+            out.push({
+              role: 'tool',
+              tool_call_id: block.toolUseId,
+              content: typeof block.content === 'string'
+                ? block.content
+                : block.content.map((t) => t.text).join(''),
+            })
+          } else if (block.type === 'text') {
+            remainingText.push(block.text)
+          }
         }
-
-        if (msg.toolCalls?.length) {
-          mapped.tool_calls = msg.toolCalls.map(tc => ({
-            id: tc.id,
-            type: 'function',
-            function: {
-              name: tc.name,
-              arguments: JSON.stringify(tc.arguments),
-            },
-          }))
+        if (remainingText.length > 0) {
+          out.push({ role: 'user', content: remainingText.join('') })
         }
-
-        result.push(mapped)
-      } else {
-        result.push({
-          role: 'user',
-          content: typeof msg.content === 'string' ? msg.content : msg.content,
-        })
+        continue
       }
+      out.push(toOpenAIMessage(message))
     }
-
-    return result
+    return out
   }
 
-  private parseResponse(data: any): CompletionResponse {
-    const choice = data.choices?.[0]
-    const message = choice?.message
-
-    const content: string = message?.content ?? ''
-    const toolCalls: ToolCall[] = []
-
-    if (message?.tool_calls) {
-      for (const tc of message.tool_calls) {
-        let args: Record<string, unknown> = {}
-        try {
-          args = JSON.parse(tc.function.arguments)
-        } catch {
-          // Invalid JSON from the model — pass as-is in a wrapper
-          args = { _raw: tc.function.arguments }
-        }
-
-        toolCalls.push({
-          id: tc.id,
-          name: tc.function.name,
-          arguments: args,
-        })
-      }
-    }
-
-    const usage: Usage = {
-      inputTokens: data.usage?.prompt_tokens ?? 0,
-      outputTokens: data.usage?.completion_tokens ?? 0,
-      totalTokens: data.usage?.total_tokens ?? 0,
-    }
-
-    let stopReason: CompletionResponse['stopReason'] = 'end'
-    switch (choice?.finish_reason) {
-      case 'tool_calls':
-        stopReason = 'tool_use'
-        break
-      case 'length':
-        stopReason = 'max_tokens'
-        break
-      case 'stop':
-        stopReason = 'end'
-        break
-    }
-
+  private toChatResult(
+    response: OpenAI.Chat.ChatCompletion,
+  ): ChatResult<OpenAI.Chat.ChatCompletion> {
+    const choice = response.choices[0]
     return {
-      id: data.id ?? '',
-      content,
-      toolCalls,
-      stopReason,
-      usage,
-      raw: data,
+      text: choice?.message?.content ?? '',
+      model: response.model,
+      stopReason: choice?.finish_reason ?? null,
+      usage: toUsage(response.usage),
+      raw: response,
     }
   }
+}
 
-  /**
-   * OpenAI's strict structured output requires:
-   * - All properties listed in `required`
-   * - Optional properties use nullable types instead
-   * - `additionalProperties: false` on every object
-   */
-  /**
-   * Check if a schema is compatible with OpenAI's strict structured output.
-   * Record types (object with additionalProperties != false) are not supported.
-   */
-  private isStrictCompatible(schema: Record<string, unknown>): boolean {
-    if (schema == null || typeof schema !== 'object') return true
-
-    // Record type: object with additionalProperties that isn't false
-    if (
-      schema.type === 'object' &&
-      schema.additionalProperties !== undefined &&
-      schema.additionalProperties !== false
-    ) {
-      return false
-    }
-
-    // Check nested properties
-    if (schema.properties) {
-      for (const prop of Object.values(schema.properties as Record<string, any>)) {
-        if (!this.isStrictCompatible(prop)) return false
-      }
-    }
-
-    // Check array items
-    if (schema.items && !this.isStrictCompatible(schema.items as Record<string, unknown>))
-      return false
+// ─── Shape converters ─────────────────────────────────────────────────────
 
-    // Check anyOf / oneOf
-    for (const key of ['anyOf', 'oneOf'] as const) {
-      if (Array.isArray(schema[key])) {
-        for (const s of schema[key] as any[]) {
-          if (!this.isStrictCompatible(s)) return false
-        }
-      }
-    }
+function systemPromptText(system: SystemPrompt | undefined): string {
+  if (system === undefined) return ''
+  if (typeof system === 'string') return system
+  if (Array.isArray(system)) return system.map((b) => b.text).join('\n')
+  return system.text
+}
 
-    return true
+function toOpenAIMessage(message: Message): OpenAI.Chat.ChatCompletionMessageParam {
+  if (typeof message.content === 'string') {
+    return { role: message.role, content: message.content } as OpenAI.Chat.ChatCompletionMessageParam
   }
 
-  /** Keywords OpenAI strict mode does NOT support. */
-  private static UNSUPPORTED_KEYWORDS = new Set([
-    'propertyNames',
-    'patternProperties',
-    'if',
-    'then',
-    'else',
-    'not',
-    'contains',
-    'minItems',
-    'maxItems',
-    'minProperties',
-    'maxProperties',
-    'minLength',
-    'maxLength',
-    'minimum',
-    'maximum',
-    'exclusiveMinimum',
-    'exclusiveMaximum',
-    'multipleOf',
-    'pattern',
-    'format',
-    'contentEncoding',
-    'contentMediaType',
-    'unevaluatedProperties',
-    '$schema',
-  ])
-
-  private normalizeSchemaForOpenAI(schema: Record<string, unknown>): Record<string, unknown> {
-    if (schema == null || typeof schema !== 'object') return schema
-
-    // Strip unsupported keywords
-    const result: Record<string, unknown> = {}
-    for (const [k, v] of Object.entries(schema)) {
-      if (!OpenAIProvider.UNSUPPORTED_KEYWORDS.has(k)) {
-        result[k] = v
-      }
-    }
-
-    // Handle object types with explicit properties
-    if (result.type === 'object' && result.properties) {
-      const props = result.properties as Record<string, any>
-      const currentRequired = new Set(
-        Array.isArray(result.required) ? (result.required as string[]) : []
-      )
-
-      const normalizedProps: Record<string, any> = {}
-
-      for (const [key, prop] of Object.entries(props)) {
-        let normalizedProp = this.normalizeSchemaForOpenAI(prop)
-
-        // If property is not required, make it nullable and add to required
-        if (!currentRequired.has(key)) {
-          normalizedProp = this.makeNullable(normalizedProp)
-        }
-
-        normalizedProps[key] = normalizedProp
-      }
-
-      result.properties = normalizedProps
-      result.required = Object.keys(normalizedProps)
-      result.additionalProperties = false
-    }
-
-    // Handle arrays
-    if (result.type === 'array' && result.items) {
-      result.items = this.normalizeSchemaForOpenAI(result.items as Record<string, unknown>)
-    }
-
-    // Handle anyOf / oneOf
-    for (const key of ['anyOf', 'oneOf'] as const) {
-      if (Array.isArray(result[key])) {
-        result[key] = (result[key] as any[]).map((s: any) => this.normalizeSchemaForOpenAI(s))
-      }
+  // Assistant turns may contain text + tool_use blocks; we need to
+  // split tool_use blocks into the `tool_calls` field and put the
+  // remaining text into `content`.
+  if (message.role === 'assistant') {
+    const text = message.content
+      .filter((b): b is TextBlock => b.type === 'text')
+      .map((b) => b.text)
+      .join('')
+    const toolUses = message.content.filter((b): b is ToolUseBlock => b.type === 'tool_use')
+    const param: OpenAI.Chat.ChatCompletionAssistantMessageParam = { role: 'assistant' }
+    if (text.length > 0) param.content = text
+    if (toolUses.length > 0) {
+      param.tool_calls = toolUses.map((b) => ({
+        id: b.id,
+        type: 'function',
+        function: {
+          name: b.name,
+          arguments: JSON.stringify(b.input ?? {}),
+        },
+      }))
     }
-
-    return result
+    return param
   }
 
-  private makeNullable(schema: Record<string, unknown>): Record<string, unknown> {
-    // Already nullable
-    if (Array.isArray(schema.type) && schema.type.includes('null')) return schema
+  // User-role multi-block content — flatten text. MCP blocks (which
+  // are read-only and Anthropic-specific) are silently dropped.
+  const text = message.content
+    .filter((b): b is TextBlock => b.type === 'text')
+    .map((b) => b.text)
+    .join('')
+  return { role: 'user', content: text }
+}
 
-    // Has anyOf — add null variant
-    if (Array.isArray(schema.anyOf)) {
-      const hasNull = schema.anyOf.some((s: any) => s.type === 'null')
-      if (!hasNull) {
-        return { ...schema, anyOf: [...schema.anyOf, { type: 'null' }] }
+function fromOpenAIAssistantMessage(
+  msg: OpenAI.Chat.ChatCompletionMessage,
+): string | ContentBlock[] {
+  const blocks: ContentBlock[] = []
+  if (msg.content) blocks.push({ type: 'text', text: msg.content })
+  if (msg.tool_calls) {
+    for (const call of msg.tool_calls) {
+      if (call.type !== 'function') continue
+      let parsedInput: unknown = {}
+      try {
+        parsedInput = call.function.arguments ? JSON.parse(call.function.arguments) : {}
+      } catch {
+        parsedInput = call.function.arguments ?? {}
       }
-      return schema
-    }
-
-    // Simple type — wrap in anyOf with null
-    if (schema.type) {
-      const { type, ...rest } = schema
-      return { anyOf: [{ type, ...rest }, { type: 'null' }] }
+      blocks.push({
+        type: 'tool_use',
+        id: call.id,
+        name: call.function.name,
+        input: parsedInput,
+      } satisfies ToolUseBlock)
     }
+  }
+  if (blocks.length === 1 && blocks[0]?.type === 'text') return blocks[0].text
+  return blocks
+}
 
-    return schema
+function toUsage(u: OpenAI.CompletionUsage | undefined): ChatUsage {
+  return {
+    inputTokens: u?.prompt_tokens ?? 0,
+    outputTokens: u?.completion_tokens ?? 0,
+    cacheReadTokens: u?.prompt_tokens_details?.cached_tokens ?? 0,
+    cacheCreationTokens: 0,
   }
 }
 
-/**
- * Choose a multipart filename for Whisper based on the content type.
- * Whisper sniffs the extension when no MIME is supplied; sending a name
- * that matches the actual format avoids "unsupported file" 400s.
- */
-function defaultFilename(contentType?: string): string {
-  if (!contentType) return 'audio.bin'
-  const ext = contentType.split('/')[1]?.split(';')[0]?.trim()
-  return ext ? `audio.${ext}` : 'audio.bin'
+function addUsage(acc: ChatUsage, u: OpenAI.CompletionUsage | undefined): void {
+  if (!u) return
+  acc.inputTokens += u.prompt_tokens
+  acc.outputTokens += u.completion_tokens
+  acc.cacheReadTokens += u.prompt_tokens_details?.cached_tokens ?? 0
 }