Skip to content

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

TypeScript
2.7 KB
Raw Blame
import type { Tool } from '../interfaces'
import type { ToolOutput } from '../types'
import { WorkflowBrokerClient } from './workflowBrokerClient'
import {
  type EnvGetter,
  type WorkflowCallerContext,
  type WorkflowToolOptions,
  defaultEnv,
} from './workflowShared'
import {
  type WorkflowControlTokenProvider,
  createWorkflowControlTokenProvider,
} from './workflowTokenProvider'

export abstract class WorkflowTool implements Tool {
  protected readonly getEnv: EnvGetter
  protected readonly client: WorkflowBrokerClient
  protected readonly workflowControlTokenProvider: WorkflowControlTokenProvider
  protected readonly workflowCallerContext: WorkflowCallerContext | null

  constructor(options: WorkflowToolOptions = {}) {
    this.getEnv = options.getEnv ?? defaultEnv
    this.workflowCallerContext = options.workflowCallerContext ?? null
    this.workflowControlTokenProvider =
      options.workflowControlTokenProvider ?? createWorkflowControlTokenProvider(this.getEnv)
    this.client = new WorkflowBrokerClient(this.getEnv, this.workflowControlTokenProvider)
  }

  abstract name(): string
  abstract description(): string
  abstract parametersSchema(): Record<string, unknown>
  abstract run(params: Record<string, unknown>): Promise<unknown>

  protected metadataForResult(_data: unknown): Record<string, unknown> | undefined {
    return undefined
  }

  requiresSanitization(): boolean {
    return false
  }

  requiresApproval(): boolean {
    return false
  }

  traceDescriptor(params: Record<string, unknown>, output?: ToolOutput) {
    const metadata = output?.metadata
    const scope =
      metadata && typeof metadata.workflowArtifactScope === 'object'
        ? (metadata.workflowArtifactScope as Record<string, unknown>)
        : null
    const namespace =
      (typeof scope?.namespace === 'string' && scope.namespace.trim()) ||
      (typeof params.namespace === 'string' && params.namespace.trim()) ||
      ''
    const name =
      (typeof scope?.name === 'string' && scope.name.trim()) ||
      (typeof params.name === 'string' && params.name.trim()) ||
      ''
    return {
      kind: 'workflow' as const,
      sourceRef: namespace && name ? `${namespace}/${name}` : name || 'workflow-control',
    }
  }

  async execute(params: Record<string, unknown>): Promise<ToolOutput> {
    const start = Date.now()
    try {
      const data = await this.run(params)
      return {
        content: JSON.stringify(data, null, 2),
        duration_ms: Date.now() - start,
        is_error: false,
        metadata: this.metadataForResult(data),
      }
    } catch (err) {
      return {
        content: `Error: ${err instanceof Error ? err.message : String(err)}`,
        duration_ms: Date.now() - start,
        is_error: true,
      }
    }
  }
}