Skip to content

Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure

TypeScript
9.3 KB
Raw Blame
/**
 * OpenAI LLM provider with tool/function calling support.
 */
import OpenAI from 'openai'
import {
  CompletionResponse,
  ChatMessage as CoreChatMessage,
  FinishReason,
  ToolCompletionResponse,
  ToolDefinition,
} from '../core/types'
import { logger } from '../logger'
import { resolveOfficialVisualDeliveryLimits } from '../visualInput/deliveryLimits'
import { assertVisualRequestFits } from '../visualInput/requestPolicy'
import { classifyByHttpStatus, classifyUnknown } from './errorClassification'
import type { ImageTransportOperation } from './imageInput'
import type { LlmProvider } from './registryCore'
import type { ClassifiedError, SingleTurnProvider } from './types'

export class OpenAIProvider implements SingleTurnProvider {
  private client: OpenAI
  private defaultModel: string

  getVisualDeliveryLimits(operation: ImageTransportOperation) {
    return resolveOfficialVisualDeliveryLimits('openai', this.client.baseURL, operation)
  }

  constructor(apiKeyOrClient: string | OpenAI, defaultModel: string = 'gpt-5.4-mini') {
    if (typeof apiKeyOrClient === 'string') {
      this.client = new OpenAI({ apiKey: apiKeyOrClient })
    } else {
      this.client = apiKeyOrClient
    }
    this.defaultModel = defaultModel
    logger.info({ model: defaultModel }, 'OpenAI transport initialized')
  }

  /**
   * Get the provider type.
   */
  getProviderType(): LlmProvider {
    return 'openai'
  }

  /**
   * OpenAI's reasoning/latest model families reject the legacy `max_tokens`
   * request field and require `max_completion_tokens`. Keep the internal
   * provider contract stable (`max_tokens`) while translating only those
   * native models at the wire boundary. OpenAI-compatible providers override
   * this hook because their portability contract still uses `max_tokens`.
   */
  protected usesMaxCompletionTokens(): boolean {
    return /^(?:gpt-5(?:[.-]|$)|o[1-9](?:[.-]|$))/i.test(this.defaultModel)
  }

  /**
   * ZAI requires reasoning to remain on assistant tool-call messages across a
   * tool turn. Native OpenAI and Azure keep the standard message shape, so a
   * provider-specific field from prior ZAI history must not leak during failover.
   */
  protected supportsReasoningContent(): boolean {
    return false
  }

  private tokenLimitOptions(maxTokens: number | undefined): {
    max_tokens?: number
    max_completion_tokens?: number
  } {
    if (maxTokens === undefined) return {}
    return this.usesMaxCompletionTokens()
      ? { max_completion_tokens: maxTokens }
      : { max_tokens: maxTokens }
  }

  classifyError(err: unknown): ClassifiedError {
    return classifyByHttpStatus(err) ?? classifyUnknown(err)
  }

  // ─── Single-Turn Methods ──────────────────────────────────

  async completeSingleTurn(
    messages: CoreChatMessage[],
    options?: { max_tokens?: number; temperature?: number; signal?: AbortSignal }
  ): Promise<CompletionResponse> {
    assertVisualRequestFits(messages, messages, false, this.getVisualDeliveryLimits('complete'))
    const openaiMessages = messages.map(m => ({
      role: m.role as 'system' | 'user' | 'assistant',
      content: m.content,
    }))

    const response = await this.client.chat.completions.create(
      {
        model: this.defaultModel,
        messages: openaiMessages,
        ...this.tokenLimitOptions(options?.max_tokens),
        temperature: options?.temperature,
      },
      { signal: options?.signal }
    )

    const choice = response.choices[0]
    const usageReported =
      response.usage != null &&
      Number.isInteger(response.usage.prompt_tokens) &&
      response.usage.prompt_tokens >= 0 &&
      Number.isInteger(response.usage.completion_tokens) &&
      response.usage.completion_tokens >= 0
    return {
      content: choice.message.content ?? '',
      usage: {
        input_tokens: response.usage?.prompt_tokens ?? 0,
        output_tokens: response.usage?.completion_tokens ?? 0,
        total_tokens: response.usage?.total_tokens ?? 0,
      },
      usage_reported: usageReported,
      finish_reason: this.mapFinishReason(choice.finish_reason),
    }
  }

  async completeSingleTurnWithTools(
    messages: CoreChatMessage[],
    tools: ToolDefinition[],
    options?: {
      max_tokens?: number
      temperature?: number
      tool_choice?: string
      signal?: AbortSignal
      verifyImageInput?: boolean
    }
  ): Promise<ToolCompletionResponse> {
    const openaiMessages = this.convertToOpenAIMessages(messages)

    // OpenAI rejects tools: [] with 400 error — must be undefined when empty
    const openaiTools =
      tools.length > 0
        ? tools.map(t => ({
            type: 'function' as const,
            function: {
              name: t.name,
              description: t.description,
              parameters: t.parameters,
            },
          }))
        : undefined

    const request = {
      model: this.defaultModel,
      messages: openaiMessages,
      tools: openaiTools,
      tool_choice: openaiTools
        ? ((options?.tool_choice ?? 'auto') as OpenAI.ChatCompletionToolChoiceOption)
        : undefined,
      ...this.tokenLimitOptions(options?.max_tokens),
      temperature: options?.temperature,
    }
    assertVisualRequestFits(
      messages,
      request,
      options?.verifyImageInput === true,
      this.getVisualDeliveryLimits('completeWithTools')
    )
    const response = await this.client.chat.completions.create(request, { signal: options?.signal })

    const choice = response.choices[0]
    const message = choice.message

    const toolCalls =
      message.tool_calls?.map(tc => ({
        id: tc.id,
        name: tc.function.name,
        arguments: this.parseArguments(tc.function.arguments),
      })) ?? null
    const reasoningContent = (message as { reasoning_content?: unknown }).reasoning_content

    const usageReported =
      response.usage != null &&
      Number.isInteger(response.usage.prompt_tokens) &&
      response.usage.prompt_tokens >= 0 &&
      Number.isInteger(response.usage.completion_tokens) &&
      response.usage.completion_tokens >= 0
    return {
      content: message.content,
      tool_calls: toolCalls && toolCalls.length > 0 ? toolCalls : null,
      reasoning_content: typeof reasoningContent === 'string' ? reasoningContent : null,
      usage: {
        input_tokens: response.usage?.prompt_tokens ?? 0,
        output_tokens: response.usage?.completion_tokens ?? 0,
        total_tokens: response.usage?.total_tokens ?? 0,
      },
      usage_reported: usageReported,
      finish_reason: this.mapFinishReason(choice.finish_reason),
    }
  }

  private convertToOpenAIMessages(
    messages: CoreChatMessage[]
  ): OpenAI.ChatCompletionMessageParam[] {
    return messages.map(m => {
      if (m.role === 'tool') {
        // Tool messages must be text-only (OpenAI rejects images in tool role).
        // Images from tool results are sent in a subsequent user message.
        return {
          role: 'tool' as const,
          tool_call_id: m.tool_call_id!,
          content: m.content,
        }
      }
      if (m.role === 'user' && m.contentParts?.length) {
        // User messages with images (e.g., screenshots from desktop tools)
        const content = m.contentParts.map(part => {
          if (part.type === 'text') {
            return { type: 'text' as const, text: part.text }
          }
          return {
            type: 'image_url' as const,
            image_url: { url: `data:${part.mimeType};base64,${part.data}` },
          }
        })
        return { role: 'user' as const, content }
      }
      if (m.role === 'assistant') {
        if (m.tool_calls) {
          const assistantMessage = {
            role: 'assistant' as const,
            content: m.content || null,
            tool_calls: m.tool_calls.map(tc => ({
              id: tc.id,
              type: 'function' as const,
              function: {
                name: tc.name,
                arguments: JSON.stringify(tc.arguments),
              },
            })),
          } as Record<string, unknown>
          if (m.reasoning_content && this.supportsReasoningContent()) {
            assistantMessage.reasoning_content = m.reasoning_content
          }
          return assistantMessage as unknown as OpenAI.ChatCompletionAssistantMessageParam
        }
        return { role: 'assistant' as const, content: m.content }
      }
      if (m.role === 'user') {
        return { role: 'user' as const, content: m.content }
      }
      // Operator/soul instruction channel. This API is WRC-JWT gated; the
      // host must forward system text to the model. Do not fold user/tool
      // content into this branch — that union was js/system-prompt-injection.
      return { role: 'system' as const, content: m.content }
    })
  }

  private parseArguments(argsString: string): Record<string, unknown> {
    try {
      return JSON.parse(argsString)
    } catch {
      return { _raw: argsString }
    }
  }

  private mapFinishReason(reason: string | null | undefined): FinishReason {
    switch (reason) {
      case 'stop':
        return FinishReason.Stop
      case 'length':
        return FinishReason.Length
      case 'tool_calls':
        return FinishReason.ToolUse
      case 'content_filter':
        return FinishReason.ContentFilter
      default:
        return FinishReason.Unknown
    }
  }
}