@llm-dev-ops/agentics-cli 1.4.27 → 1.4.29

package/dist/bundled-agents/memory-graph-agents/src/execution/agent-adapter.ts

@@ -1,249 +0,0 @@
-/**
- * Agent Adapters
- *
- * Provides a uniform interface for invoking any agent in the memory-graph repo
- * and wrapping its result into an AgentSpan. The orchestrator uses these adapters
- * so it doesn't need to know the internal structure of each agent.
- *
- * TS agents are invoked directly via their executeAsUnit() export.
- * Rust agents are invoked via HTTP to their warp endpoints.
- */
-
-import type { AgentSpan, ArtifactReference, SpanError } from './types.js';
-import { buildArtifacts } from './artifact-builder.js';
-
-// ============================================================================
-// AGENT ADAPTER INTERFACE
-// ============================================================================
-
-/**
- * Result from an agent's execution, before wrapping into an AgentSpan.
- */
-export interface AgentExecutionResult {
-  success: boolean;
-  output?: unknown;
-  decisionEvent?: { execution_ref: string; [key: string]: unknown };
-  error?: { error_code: string; message: string; details?: Record<string, unknown> };
-}
-
-/**
- * Uniform adapter interface. Each adapter knows how to invoke a specific agent
- * and return a raw result. The factory wraps these into AgentSpan objects.
- */
-export interface AgentAdapter {
-  readonly agentId: string;
-  readonly agentVersion: string;
-  execute(input: unknown): Promise<AgentExecutionResult>;
-}
-
-// ============================================================================
-// SPAN BUILDER
-// ============================================================================
-
-/**
- * Wrap an agent adapter's execution into a full AgentSpan with artifacts.
- * This is the central function that ensures every agent call produces a span,
- * regardless of success or failure.
- */
-export async function executeAndBuildSpan(
-  adapter: AgentAdapter,
-  input: unknown,
-  executionId: string,
-  repoSpanId: string,
-): Promise<AgentSpan> {
-  const spanId = crypto.randomUUID();
-  const startedAt = new Date().toISOString();
-  const startTime = Date.now();
-
-  let result: AgentExecutionResult;
-  try {
-    result = await adapter.execute(input);
-  } catch (err) {
-    // Agent threw -- produce an error span. Spans must ALWAYS be emitted.
-    const endedAt = new Date().toISOString();
-    return {
-      span_id: spanId,
-      parent_span_id: repoSpanId,
-      span_type: 'agent',
-      agent_id: adapter.agentId,
-      agent_version: adapter.agentVersion,
-      status: 'error',
-      started_at: startedAt,
-      ended_at: endedAt,
-      duration_ms: Date.now() - startTime,
-      error: {
-        error_code: 'AGENT_EXCEPTION',
-        message: err instanceof Error ? err.message : String(err),
-      },
-      artifacts: [],
-    };
-  }
-
-  const endedAt = new Date().toISOString();
-  const durationMs = Date.now() - startTime;
-
-  if (result.success) {
-    const artifacts = await buildArtifacts(adapter.agentId, executionId, result.output);
-
-    return {
-      span_id: spanId,
-      parent_span_id: repoSpanId,
-      span_type: 'agent',
-      agent_id: adapter.agentId,
-      agent_version: adapter.agentVersion,
-      status: 'ok',
-      started_at: startedAt,
-      ended_at: endedAt,
-      duration_ms: durationMs,
-      artifacts,
-      decision_event_ref: result.decisionEvent?.execution_ref,
-    };
-  }
-
-  // Agent returned failure -- still emit the span with error details.
-  const errorInfo: SpanError = {
-    error_code: result.error?.error_code ?? 'UNKNOWN_ERROR',
-    message: result.error?.message ?? 'Agent returned failure without error details',
-    details: result.error?.details,
-  };
-
-  return {
-    span_id: spanId,
-    parent_span_id: repoSpanId,
-    span_type: 'agent',
-    agent_id: adapter.agentId,
-    agent_version: adapter.agentVersion,
-    status: 'error',
-    started_at: startedAt,
-    ended_at: endedAt,
-    duration_ms: durationMs,
-    error: errorInfo,
-    artifacts: [],
-  };
-}
-
-// ============================================================================
-// CONCRETE ADAPTERS: TypeScript Agents
-// ============================================================================
-
-/**
- * Base adapter for TypeScript agents that expose an executeAsUnit function.
- * The executeAsUnit functions are dynamically imported from each agent package.
- */
-class TypeScriptAgentAdapter implements AgentAdapter {
-  constructor(
-    readonly agentId: string,
-    readonly agentVersion: string,
-    private readonly executeFn: (input: unknown) => Promise<AgentExecutionResult>,
-  ) {}
-
-  async execute(input: unknown): Promise<AgentExecutionResult> {
-    return this.executeFn(input);
-  }
-}
-
-/**
- * Adapter for Rust agents accessible via HTTP endpoints.
- * Makes an HTTP POST to the agent's endpoint and converts the response.
- */
-class HttpAgentAdapter implements AgentAdapter {
-  constructor(
-    readonly agentId: string,
-    readonly agentVersion: string,
-    private readonly baseUrl: string,
-    private readonly endpoint: string,
-  ) {}
-
-  async execute(input: unknown): Promise<AgentExecutionResult> {
-    const url = `${this.baseUrl}${this.endpoint}`;
-
-    const response = await fetch(url, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ input }),
-    });
-
-    const body = await response.json() as Record<string, unknown>;
-
-    if (response.ok && body.data) {
-      return {
-        success: true,
-        output: body.data,
-        decisionEvent: body.execution_ref
-          ? { execution_ref: body.execution_ref as string }
-          : undefined,
-      };
-    }
-
-    return {
-      success: false,
-      error: {
-        error_code: (body.error_code as string) ?? 'HTTP_ERROR',
-        message: (body.message as string) ?? `HTTP ${response.status}`,
-      },
-    };
-  }
-}
-
-// ============================================================================
-// ADAPTER REGISTRY
-// ============================================================================
-
-/**
- * Registry mapping agent IDs to their adapter factory functions.
- * TS agent adapters take a direct execute function; HTTP adapters take a URL.
- */
-type AdapterFactory = (config?: AdapterConfig) => AgentAdapter;
-
-export interface AdapterConfig {
-  /** Base URL for HTTP-based agents (Rust agents) */
-  httpBaseUrl?: string;
-  /** Direct execute function for TS agents */
-  executeFn?: (input: unknown) => Promise<AgentExecutionResult>;
-}
-
-const defaultAdapterFactories: Record<string, AdapterFactory> = {
-  'conversation-memory-agent': (config) => {
-    if (config?.executeFn) {
-      return new TypeScriptAgentAdapter('conversation-memory-agent', '1.0.0', config.executeFn);
-    }
-    throw new Error('conversation-memory-agent requires executeFn in adapter config');
-  },
-  'long-term-pattern-agent': (config) => {
-    if (config?.executeFn) {
-      return new TypeScriptAgentAdapter('long-term-pattern-agent', '1.0.0', config.executeFn);
-    }
-    throw new Error('long-term-pattern-agent requires executeFn in adapter config');
-  },
-  'knowledge-graph-builder-agent': (config) => {
-    if (config?.executeFn) {
-      return new TypeScriptAgentAdapter('knowledge-graph-builder-agent', '1.0.0', config.executeFn);
-    }
-    throw new Error('knowledge-graph-builder-agent requires executeFn in adapter config');
-  },
-  'memory-retrieval-agent': (config) => {
-    if (config?.executeFn) {
-      return new TypeScriptAgentAdapter('memory-retrieval-agent', '1.0.0', config.executeFn);
-    }
-    throw new Error('memory-retrieval-agent requires executeFn in adapter config');
-  },
-  'decision-memory-agent': (config) => {
-    const baseUrl = config?.httpBaseUrl ?? process.env['DECISION_MEMORY_URL'] ?? 'http://localhost:8080';
-    return new HttpAgentAdapter('decision-memory-agent', '1.0.0', baseUrl, '/api/v1/capture');
-  },
-  'prompt-lineage-agent': (config) => {
-    const baseUrl = config?.httpBaseUrl ?? process.env['PROMPT_LINEAGE_URL'] ?? 'http://localhost:8081';
-    return new HttpAgentAdapter('prompt-lineage-agent', '1.0.0', baseUrl, '/api/v1/track');
-  },
-};
-
-/**
- * Create an agent adapter by ID with optional configuration overrides.
- */
-export function createAgentAdapter(agentId: string, config?: AdapterConfig): AgentAdapter {
-  const factory = defaultAdapterFactories[agentId];
-  if (!factory) {
-    throw new Error(`Unknown agent: ${agentId}. Known agents: ${Object.keys(defaultAdapterFactories).join(', ')}`);
-  }
-  return factory(config);
-}

package/dist/bundled-agents/memory-graph-agents/src/execution/artifact-builder.ts

@@ -1,237 +0,0 @@
-/**
- * Artifact Builder
- *
- * Extracts artifacts from agent outputs and creates stable ArtifactReference
- * objects with content-addressable hashes and URIs.
- *
- * Each agent type produces a known output shape. This module maps those outputs
- * to ArtifactReference instances attached to the agent-level span.
- */
-
-import type { ArtifactReference } from './types.js';
-import { REPO_NAME } from './types.js';
-
-/**
- * Compute SHA-256 hash of content for artifact verification.
- */
-async function sha256(content: string): Promise<string> {
-  const encoder = new TextEncoder();
-  const data = encoder.encode(content);
-  const hashBuffer = await crypto.subtle.digest('SHA-256', data);
-  const hashArray = Array.from(new Uint8Array(hashBuffer));
-  return hashArray.map((b) => b.toString(16).padStart(2, '0')).join('');
-}
-
-/**
- * Build a single artifact reference from a content payload.
- */
-async function buildArtifact(
-  agentId: string,
-  executionId: string,
-  artifactType: string,
-  index: number,
-  content: unknown,
-): Promise<ArtifactReference> {
-  const serialized = JSON.stringify(content);
-  const contentHash = await sha256(serialized);
-
-  return {
-    artifact_ref: `${REPO_NAME}/${agentId}/${executionId}/${artifactType}/${index}`,
-    artifact_type: artifactType,
-    content_hash: contentHash,
-    size_bytes: new TextEncoder().encode(serialized).byteLength,
-    content,
-  };
-}
-
-/**
- * Extract artifacts from a conversation-memory agent output.
- *
- * Output shape: { nodes_created: NodeReference[], edges_created: EdgeReference[], ... }
- */
-async function extractConversationMemoryArtifacts(
-  executionId: string,
-  output: Record<string, unknown>,
-): Promise<ArtifactReference[]> {
-  const artifacts: ArtifactReference[] = [];
-  const agentId = 'conversation-memory-agent';
-
-  if (output.nodes_created && Array.isArray(output.nodes_created) && output.nodes_created.length > 0) {
-    artifacts.push(await buildArtifact(agentId, executionId, 'nodes_created', 0, output.nodes_created));
-  }
-  if (output.edges_created && Array.isArray(output.edges_created) && output.edges_created.length > 0) {
-    artifacts.push(await buildArtifact(agentId, executionId, 'edges_created', 0, output.edges_created));
-  }
-
-  return artifacts;
-}
-
-/**
- * Extract artifacts from a long-term-pattern agent output.
- *
- * Output shape: { patterns: DetectedPattern[], statistics: AnalysisStatistics, ... }
- */
-async function extractLongTermPatternArtifacts(
-  executionId: string,
-  output: Record<string, unknown>,
-): Promise<ArtifactReference[]> {
-  const artifacts: ArtifactReference[] = [];
-  const agentId = 'long-term-pattern-agent';
-
-  if (output.patterns && Array.isArray(output.patterns) && output.patterns.length > 0) {
-    artifacts.push(await buildArtifact(agentId, executionId, 'detected_patterns', 0, output.patterns));
-  }
-  if (output.statistics) {
-    artifacts.push(await buildArtifact(agentId, executionId, 'analysis_statistics', 0, output.statistics));
-  }
-
-  return artifacts;
-}
-
-/**
- * Extract artifacts from a knowledge-graph-builder agent output.
- *
- * Output shape: { concepts: ExtractedConcept[], relationships: ExtractedRelationship[], patterns: DetectedPattern[], ... }
- */
-async function extractKnowledgeGraphBuilderArtifacts(
-  executionId: string,
-  output: Record<string, unknown>,
-): Promise<ArtifactReference[]> {
-  const artifacts: ArtifactReference[] = [];
-  const agentId = 'knowledge-graph-builder-agent';
-
-  if (output.concepts && Array.isArray(output.concepts) && output.concepts.length > 0) {
-    artifacts.push(await buildArtifact(agentId, executionId, 'extracted_concepts', 0, output.concepts));
-  }
-  if (output.relationships && Array.isArray(output.relationships) && output.relationships.length > 0) {
-    artifacts.push(await buildArtifact(agentId, executionId, 'extracted_relationships', 0, output.relationships));
-  }
-  if (output.patterns && Array.isArray(output.patterns) && output.patterns.length > 0) {
-    artifacts.push(await buildArtifact(agentId, executionId, 'detected_patterns', 0, output.patterns));
-  }
-
-  return artifacts;
-}
-
-/**
- * Extract artifacts from a memory-retrieval agent output.
- *
- * Output shape: { subgraph: RetrievedSubgraph, traversal_stats: TraversalStats, ... }
- */
-async function extractMemoryRetrievalArtifacts(
-  executionId: string,
-  output: Record<string, unknown>,
-): Promise<ArtifactReference[]> {
-  const artifacts: ArtifactReference[] = [];
-  const agentId = 'memory-retrieval-agent';
-
-  if (output.subgraph) {
-    artifacts.push(await buildArtifact(agentId, executionId, 'retrieved_subgraph', 0, output.subgraph));
-  }
-  if (output.traversal_stats) {
-    artifacts.push(await buildArtifact(agentId, executionId, 'retrieval_statistics', 0, output.traversal_stats));
-  }
-
-  return artifacts;
-}
-
-/**
- * Extract artifacts from a decision-memory agent output.
- *
- * Output shape: { nodes_created: GraphNodeCreated[], edges_created: GraphEdgeCreated[], ... }
- */
-async function extractDecisionMemoryArtifacts(
-  executionId: string,
-  output: Record<string, unknown>,
-): Promise<ArtifactReference[]> {
-  const artifacts: ArtifactReference[] = [];
-  const agentId = 'decision-memory-agent';
-
-  if (output.nodes_created && Array.isArray(output.nodes_created) && output.nodes_created.length > 0) {
-    artifacts.push(await buildArtifact(agentId, executionId, 'decision_nodes', 0, output.nodes_created));
-  }
-  if (output.edges_created && Array.isArray(output.edges_created) && output.edges_created.length > 0) {
-    artifacts.push(await buildArtifact(agentId, executionId, 'decision_edges', 0, output.edges_created));
-  }
-
-  return artifacts;
-}
-
-/**
- * Extract artifacts from a prompt-lineage agent output.
- */
-async function extractPromptLineageArtifacts(
-  executionId: string,
-  output: Record<string, unknown>,
-): Promise<ArtifactReference[]> {
-  const artifacts: ArtifactReference[] = [];
-  const agentId = 'prompt-lineage-agent';
-
-  if (output.nodes_created && Array.isArray(output.nodes_created) && output.nodes_created.length > 0) {
-    artifacts.push(await buildArtifact(agentId, executionId, 'lineage_nodes', 0, output.nodes_created));
-  }
-  if (output.edges_created && Array.isArray(output.edges_created) && output.edges_created.length > 0) {
-    artifacts.push(await buildArtifact(agentId, executionId, 'lineage_edges', 0, output.edges_created));
-  }
-
-  return artifacts;
-}
-
-/**
- * Build artifacts for an agent's output. Dispatches to the appropriate extractor
- * based on agent_id.
- */
-export async function buildArtifacts(
-  agentId: string,
-  executionId: string,
-  agentOutput: unknown,
-): Promise<ArtifactReference[]> {
-  if (!agentOutput || typeof agentOutput !== 'object') {
-    return [];
-  }
-
-  const output = agentOutput as Record<string, unknown>;
-
-  switch (agentId) {
-    case 'conversation-memory-agent':
-      return extractConversationMemoryArtifacts(executionId, output);
-    case 'long-term-pattern-agent':
-      return extractLongTermPatternArtifacts(executionId, output);
-    case 'knowledge-graph-builder-agent':
-      return extractKnowledgeGraphBuilderArtifacts(executionId, output);
-    case 'memory-retrieval-agent':
-      return extractMemoryRetrievalArtifacts(executionId, output);
-    case 'decision-memory-agent':
-      return extractDecisionMemoryArtifacts(executionId, output);
-    case 'prompt-lineage-agent':
-      return extractPromptLineageArtifacts(executionId, output);
-    default:
-      // Unknown agent -- attempt generic extraction of any array/object fields
-      return extractGenericArtifacts(agentId, executionId, output);
-  }
-}
-
-/**
- * Generic artifact extraction for unknown agent types. Creates one artifact
- * per top-level field that is a non-empty array or non-null object.
- */
-async function extractGenericArtifacts(
-  agentId: string,
-  executionId: string,
-  output: Record<string, unknown>,
-): Promise<ArtifactReference[]> {
-  const artifacts: ArtifactReference[] = [];
-  let index = 0;
-
-  for (const [key, value] of Object.entries(output)) {
-    if (value === null || value === undefined) continue;
-
-    if (Array.isArray(value) && value.length > 0) {
-      artifacts.push(await buildArtifact(agentId, executionId, key, index++, value));
-    } else if (typeof value === 'object' && !Array.isArray(value)) {
-      artifacts.push(await buildArtifact(agentId, executionId, key, index++, value));
-    }
-  }
-
-  return artifacts;
-}

package/dist/bundled-agents/memory-graph-agents/src/execution/executor.ts

@@ -1,217 +0,0 @@
-/**
- * Execution Unit Orchestrator
- *
- * The central enforcement point for the Foundational Execution Unit protocol.
- * This orchestrator:
- *
- * 1. Validates execution_id and parent_span_id (rejects if missing)
- * 2. Creates the repo-level span (type: "repo", repo_name: "memory-graph")
- * 3. Invokes each requested agent via its adapter
- * 4. Collects agent-level spans with attached artifacts
- * 5. Enforces: no success without agent spans (requirement 6)
- * 6. On failure: still returns all emitted spans (requirement 7)
- * 7. Returns a complete ExecutionResponse with the span tree
- */
-
-import type {
-  ExecutionRequest,
-  ExecutionResponse,
-  ExecutionErrorResponse,
-  AgentSpan,
-  RepoSpan,
-  ExecutionSummary,
-} from './types.js';
-import { ExecutionRequestSchema, REPO_NAME } from './types.js';
-import { executeAndBuildSpan, createAgentAdapter } from './agent-adapter.js';
-import type { AdapterConfig, AgentExecutionResult } from './agent-adapter.js';
-
-// ============================================================================
-// ORCHESTRATOR
-// ============================================================================
-
-/**
- * Configuration for the execution unit orchestrator.
- */
-export interface OrchestratorConfig {
-  /** Override adapter configs per agent_id */
-  adapterConfigs?: Record<string, AdapterConfig>;
-}
-
-/**
- * Result type: either a valid ExecutionResponse or an error before execution started.
- */
-export type OrchestratorResult =
-  | { ok: true; response: ExecutionResponse }
-  | { ok: false; error: ExecutionErrorResponse };
-
-/**
- * ExecutionUnitOrchestrator enforces all FEU invariants.
- *
- * Usage:
- * ```typescript
- * const orchestrator = new ExecutionUnitOrchestrator();
- * const result = await orchestrator.execute(request);
- * if (result.ok) {
- *   // result.response contains the full span tree
- * } else {
- *   // result.error describes why the request was rejected
- * }
- * ```
- */
-export class ExecutionUnitOrchestrator {
-  private readonly config: OrchestratorConfig;
-
-  constructor(config?: OrchestratorConfig) {
-    this.config = config ?? {};
-  }
-
-  /**
-   * Execute the FEU request. This is the main entry point.
-   *
-   * ENFORCEMENT:
-   * - Rejects if execution_id or parent_span_id is missing (requirement 2)
-   * - Creates repo-level span immediately (requirement 3)
-   * - Creates one agent span per agent (requirement 4)
-   * - Never returns success with zero agent spans (requirement 6)
-   * - Always returns spans even on failure (requirement 7)
-   * - Forbids returning success if any agent ran without a span (requirement 9)
-   */
-  async execute(request: unknown): Promise<OrchestratorResult> {
-    // ── Step 1: Validate request ──────────────────────────────────────
-    const parseResult = ExecutionRequestSchema.safeParse(request);
-
-    if (!parseResult.success) {
-      const missingFields = parseResult.error.issues.map((i) => i.path.join('.')).join(', ');
-      return {
-        ok: false,
-        error: {
-          error_code: 'VALIDATION_ERROR',
-          message: `Invalid execution request. Issues: ${missingFields}`,
-          details: { issues: parseResult.error.issues },
-        },
-      };
-    }
-
-    const validRequest: ExecutionRequest = parseResult.data;
-    const { execution_id, parent_span_id, agents, options } = validRequest;
-
-    // ── Step 2: Create repo-level span ────────────────────────────────
-    const repoSpanId = crypto.randomUUID();
-    const repoStartedAt = new Date().toISOString();
-    const repoStartTime = Date.now();
-    const agentSpans: AgentSpan[] = [];
-
-    // ── Step 3: Execute each agent ────────────────────────────────────
-    for (const agentReq of agents) {
-      let adapter;
-      try {
-        const adapterConfig = this.config.adapterConfigs?.[agentReq.agent_id];
-        adapter = createAgentAdapter(agentReq.agent_id, adapterConfig);
-      } catch (err) {
-        // Unknown agent -- emit an error span for it
-        agentSpans.push({
-          span_id: crypto.randomUUID(),
-          parent_span_id: repoSpanId,
-          span_type: 'agent',
-          agent_id: agentReq.agent_id,
-          agent_version: '0.0.0',
-          status: 'error',
-          started_at: new Date().toISOString(),
-          ended_at: new Date().toISOString(),
-          duration_ms: 0,
-          error: {
-            error_code: 'UNKNOWN_AGENT',
-            message: err instanceof Error ? err.message : String(err),
-          },
-          artifacts: [],
-        });
-
-        if (options?.fail_fast) break;
-        continue;
-      }
-
-      const agentSpan = await executeAndBuildSpan(
-        adapter,
-        agentReq.input,
-        execution_id,
-        repoSpanId,
-      );
-      agentSpans.push(agentSpan);
-
-      // Fail-fast: stop on first error if configured
-      if (options?.fail_fast && agentSpan.status === 'error') {
-        break;
-      }
-    }
-
-    // ── Step 4: Enforcement checks ────────────────────────────────────
-
-    // INVARIANT: If no agent spans were emitted, execution is INVALID.
-    // This should never happen since we always emit spans (even error ones),
-    // but we enforce it defensively.
-    if (agentSpans.length === 0) {
-      return {
-        ok: false,
-        error: {
-          execution_id,
-          error_code: 'INVARIANT_VIOLATION',
-          message: 'No agent-level spans were emitted. Execution is invalid.',
-        },
-      };
-    }
-
-    // ── Step 5: Assemble repo span ────────────────────────────────────
-    const repoEndedAt = new Date().toISOString();
-    const repoDurationMs = Date.now() - repoStartTime;
-
-    const allSucceeded = agentSpans.every((s) => s.status === 'ok');
-
-    const repoSpan: RepoSpan = {
-      span_id: repoSpanId,
-      parent_span_id,
-      execution_id,
-      span_type: 'repo',
-      repo_name: REPO_NAME,
-      status: allSucceeded ? 'ok' : 'error',
-      started_at: repoStartedAt,
-      ended_at: repoEndedAt,
-      duration_ms: repoDurationMs,
-      agent_spans: agentSpans,
-    };
-
-    // ── Step 6: Build summary ─────────────────────────────────────────
-    const succeeded = agentSpans.filter((s) => s.status === 'ok').length;
-    const failed = agentSpans.filter((s) => s.status !== 'ok').length;
-    const totalArtifacts = agentSpans.reduce((sum, s) => sum + s.artifacts.length, 0);
-
-    const summary: ExecutionSummary = {
-      total_agents: agentSpans.length,
-      succeeded,
-      failed,
-      total_artifacts: totalArtifacts,
-      total_duration_ms: repoDurationMs,
-    };
-
-    // ── Step 7: Return response ───────────────────────────────────────
-    return {
-      ok: true,
-      response: {
-        execution_id,
-        repo_span: repoSpan,
-        success: allSucceeded,
-        summary,
-      },
-    };
-  }
-}
-
-/**
- * Create and execute in one call (convenience function).
- */
-export async function executeUnit(
-  request: unknown,
-  config?: OrchestratorConfig,
-): Promise<OrchestratorResult> {
-  const orchestrator = new ExecutionUnitOrchestrator(config);
-  return orchestrator.execute(request);
-}