Skip to content

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

TypeScript
6.6 KB
Raw Blame
import type { RuntimeTokenProvider } from '../runtime-token-provider/provider'
import { requireRuntimeToken } from '../runtime-token-provider/provider'
import {
  AUTH_RETRY_DELAY_MS,
  AUTH_RETRY_MAX_ATTEMPTS,
  sendWithAuthRetryOn401,
} from '../status-reporter/authRetry'
import { emitLog } from '../status-reporter/logger'
import type { AgentStepRequest, AgentStepResult } from './types'

const DEFAULT_MCP_HOST_STEP_TIMEOUT_SECONDS = 300
const MAX_MCP_HOST_STEP_TIMEOUT_SECONDS = 5400
const MCP_HOST_STEP_TIMEOUT_SECONDS_ENV = 'MCP_HOST_STEP_TIMEOUT_SECONDS'
const TIMEOUT_BUFFER_MS = 5000

function readPositiveIntegerEnv(name: string, defaultValue: number): number {
  const raw = process.env[name]
  if (raw === undefined || raw === '') return defaultValue
  if (!/^\d+$/.test(raw)) throw new Error(`${name} must be a positive integer`)
  const parsed = Number.parseInt(raw, 10)
  if (!Number.isSafeInteger(parsed) || parsed < 1) {
    throw new Error(`${name} must be a positive integer`)
  }
  if (parsed > MAX_MCP_HOST_STEP_TIMEOUT_SECONDS) {
    throw new Error(`${name} must be <= ${MAX_MCP_HOST_STEP_TIMEOUT_SECONDS}`)
  }
  return parsed
}

function resolveStepTimeoutSeconds(req: AgentStepRequest): number {
  if (req.timeoutSeconds !== undefined) {
    if (
      !Number.isSafeInteger(req.timeoutSeconds) ||
      req.timeoutSeconds < 1 ||
      req.timeoutSeconds > MAX_MCP_HOST_STEP_TIMEOUT_SECONDS
    ) {
      throw new Error(
        `step timeoutSeconds must be between 1 and ${MAX_MCP_HOST_STEP_TIMEOUT_SECONDS}`
      )
    }
    return req.timeoutSeconds
  }
  return readPositiveIntegerEnv(
    MCP_HOST_STEP_TIMEOUT_SECONDS_ENV,
    DEFAULT_MCP_HOST_STEP_TIMEOUT_SECONDS
  )
}

function failedResult(stepId: string, error: string): AgentStepResult {
  return { stepId, status: 'failed', durationMs: 0, error }
}

function parseSseResult(raw: string): { event: string; data: string } | null {
  let currentEvent = ''
  let lastResult: { event: string; data: string } | null = null

  for (const line of raw.split('\n')) {
    if (line.startsWith('event: ')) {
      currentEvent = line.slice(7).trim()
      continue
    }
    if (!line.startsWith('data: ')) continue
    const data = line.slice(6)
    if (currentEvent === 'result' || currentEvent === 'error') {
      lastResult = { event: currentEvent, data }
    }
    currentEvent = ''
  }

  return lastResult
}

function sleep(ms: number): Promise<void> {
  return new Promise(resolve => setTimeout(resolve, ms))
}

function timeoutError(): Error {
  return Object.assign(new Error('timeout'), { name: 'AbortError' })
}

function remainingDeadlineMs(deadlineMs: number): number {
  const remainingMs = deadlineMs - Date.now()
  if (remainingMs < 1) throw timeoutError()
  return remainingMs
}

interface TimedResponse {
  response: Response
  clearTimeout: () => void
}

export class McpHostClient {
  private readonly url: string
  private readonly tokenProvider: RuntimeTokenProvider

  constructor(url: string, tokenProvider: RuntimeTokenProvider) {
    this.url = url
    this.tokenProvider = tokenProvider
  }

  private async authHeader(): Promise<string> {
    const token = await requireRuntimeToken(
      this.tokenProvider,
      'getMcpHostToken',
      'MCP_HOST_TOKEN_FILE'
    )
    return `Bearer ${token}`
  }

  private async postExecute(req: AgentStepRequest, timeoutMs: number): Promise<TimedResponse> {
    const controller = new AbortController()
    const timer = setTimeout(() => controller.abort(), timeoutMs)
    try {
      const response = await fetch(`${this.url}/api/v1/workflow/execute`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          Authorization: await this.authHeader(),
        },
        body: JSON.stringify(req),
        signal: controller.signal,
      })
      return {
        response,
        clearTimeout: () => clearTimeout(timer),
      }
    } catch (error) {
      clearTimeout(timer)
      throw error
    }
  }

  private async postExecuteWithAuthRetry(
    req: AgentStepRequest,
    timeoutMs: number
  ): Promise<TimedResponse> {
    const deadlineMs = Date.now() + timeoutMs
    for (let attempt = 1; ; attempt++) {
      const timed = await this.postExecute(req, remainingDeadlineMs(deadlineMs))
      if (timed.response.status !== 401 || attempt >= AUTH_RETRY_MAX_ATTEMPTS) {
        return timed
      }
      timed.clearTimeout()
      emitLog('warn', 'mcp-host execute returned 401; retrying with refreshed runtime token', {
        attempt,
        maxAttempts: AUTH_RETRY_MAX_ATTEMPTS,
      })
      await sleep(Math.min(AUTH_RETRY_DELAY_MS, remainingDeadlineMs(deadlineMs)))
    }
  }

  async executeAgentStep(req: AgentStepRequest): Promise<AgentStepResult> {
    try {
      const timeoutMs = resolveStepTimeoutSeconds(req) * 1000 + TIMEOUT_BUFFER_MS
      const timed = await this.postExecuteWithAuthRetry(req, timeoutMs)

      try {
        const resp = timed.response
        if (!resp.ok) {
          const errorText = await resp.text().catch(() => 'unknown')
          return failedResult(req.stepId, `mcp-host returned ${resp.status}: ${errorText}`)
        }

        const contentType = resp.headers?.get?.('content-type') ?? ''
        if (contentType.includes('text/event-stream')) {
          const raw = await resp.text()
          const event = parseSseResult(raw)
          if (event?.event === 'result') {
            return JSON.parse(event.data) as AgentStepResult
          }
          if (event?.event === 'error') {
            const parsed = JSON.parse(event.data) as { message?: string; error?: string }
            return failedResult(
              req.stepId,
              parsed.message ?? parsed.error ?? 'mcp-host stream error'
            )
          }
          return failedResult(req.stepId, 'mcp-host stream ended without a result event')
        }

        return (await resp.json()) as AgentStepResult
      } finally {
        timed.clearTimeout()
      }
    } catch (err) {
      const e = err as Error
      const isTimeout = e.name === 'AbortError' || e.message?.includes('timeout')
      emitLog('error', `Agent step execution failed: ${e.message}`, { stepId: req.stepId })
      return failedResult(req.stepId, isTimeout ? 'timeout' : e.message)
    }
  }

  async healthCheck(): Promise<{ status: 'healthy' | 'unhealthy' }> {
    try {
      const resp = await sendWithAuthRetryOn401(
        async () =>
          fetch(`${this.url}/v1/runtime/health`, {
            headers: { Authorization: await this.authHeader() },
          }),
        'mcp-host runtime health',
        { maxAttempts: 2, retryDelayMs: 0 }
      )
      return { status: resp.ok ? 'healthy' : 'unhealthy' }
    } catch {
      return { status: 'unhealthy' }
    }
  }
}