agentic-orchestrator 0.1.6 → 0.1.8

package/apps/control-plane/src/mcp/tool-registry-loader.ts

@@ -4,7 +4,12 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { pathExists } from '../core/fs.js';
 import { MCP_PROTOCOL_PIN, REQUIRED_MCP_TRANSPORTS } from './protocol-contract.js';
-import type { LoadedToolRegistry, ProtocolContract, ToolCatalog, ToolCatalogEntry } from './runtime-types.js';
+import type {
+  LoadedToolRegistry,
+  ProtocolContract,
+  ToolCatalog,
+  ToolCatalogEntry,
+} from './runtime-types.js';
 
 const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
 
@@ -113,7 +118,7 @@ export class ToolRegistryLoader {
       catalog,
       protocol,
       toolsByName,
-      toolsByHandlerId
+      toolsByHandlerId,
     };
   }
 
@@ -167,5 +172,4 @@ export class ToolRegistryLoader {
 
     return parsed;
   }
-
 }

package/apps/control-plane/src/mcp/tool-runtime.ts

@@ -56,7 +56,8 @@ function emitToolLog(params: {
   latencyMs: number;
   response: ToolResponse;
 }): void {
-  const operationId = typeof params.args.operation_id === 'string' ? params.args.operation_id : null;
+  const operationId =
+    typeof params.args.operation_id === 'string' ? params.args.operation_id : null;
   const featureId = typeof params.args.feature_id === 'string' ? params.args.feature_id : null;
   const errorCode = isFailResponse(params.response) ? params.response.error.code : null;
   const payload = {
@@ -67,7 +68,7 @@ function emitToolLog(params: {
     actor_type: params.claims.actor_type,
     latency_ms: params.latencyMs,
     result: params.response.ok ? 'ok' : 'error',
-    error_code: errorCode
+    error_code: errorCode,
   };
 
   process.stderr.write(`${JSON.stringify(payload)}\n`);
@@ -103,7 +104,9 @@ export class ToolRuntime {
 
   async listTools(): Promise<ToolDescriptor[]> {
     const descriptors: ToolDescriptor[] = [];
-    const sorted = [...this.registry.toolsByName.values()].sort((a, b) => a.name.localeCompare(b.name));
+    const sorted = [...this.registry.toolsByName.values()].sort((a, b) =>
+      a.name.localeCompare(b.name),
+    );
 
     for (const tool of sorted) {
       descriptors.push({
@@ -112,14 +115,18 @@ export class ToolRuntime {
         input_schema: await this.loader.readSchemaByRef(tool.input_schema_ref),
         output_schema: await this.loader.readSchemaByRef(tool.output_schema_ref),
         mutating: tool.mutating,
-        requires_operation_id: tool.requires_operation_id
+        requires_operation_id: tool.requires_operation_id,
       });
     }
 
     return descriptors;
   }
 
-  async callTool(toolName: string, args: Record<string, unknown>, claims: VerifiedActorClaims): Promise<ToolResponse> {
+  async callTool(
+    toolName: string,
+    args: Record<string, unknown>,
+    claims: VerifiedActorClaims,
+  ): Promise<ToolResponse> {
     const started = Date.now();
     const safeArgs = { ...(args ?? {}) };
     const tool = this.lookupTool(toolName);
@@ -148,7 +155,11 @@ export class ToolRuntime {
     }
 
     const executionResponse = await this.executor.execute(tool, safeArgs, claims);
-    const outputValidationResult = await this.validateExecutionResponse(tool, toolName, executionResponse);
+    const outputValidationResult = await this.validateExecutionResponse(
+      tool,
+      toolName,
+      executionResponse,
+    );
     if (outputValidationResult) {
       return this.finalize(started, claims, toolName, safeArgs, outputValidationResult);
     }
@@ -159,7 +170,7 @@ export class ToolRuntime {
         idempotencyResolution.operationId,
         toolName,
         idempotencyResolution.requestHash,
-        executionResponse
+        executionResponse,
       );
     }
 
@@ -173,13 +184,13 @@ export class ToolRuntime {
   private unknownToolResponse(toolName: string): ToolResponse {
     return fail(ERROR_CODES.INVALID_ARGUMENT, `Unknown tool ${toolName}`, {
       retryable: false,
-      requires_human: true
+      requires_human: true,
     });
   }
 
   private authorizeFeatureScope(
     claims: VerifiedActorClaims,
-    args: Record<string, unknown>
+    args: Record<string, unknown>,
   ): ToolResponse | null {
     if (featureScopeAllows(claims, args)) {
       return null;
@@ -188,7 +199,7 @@ export class ToolRuntime {
       retryable: false,
       requires_human: true,
       feature_scope: claims.feature_scope,
-      feature_id: args.feature_id
+      feature_id: args.feature_id,
     });
   }
 
@@ -196,18 +207,22 @@ export class ToolRuntime {
     if (this.authorizer.isAuthorized(claims.actor_type, toolName)) {
       return null;
     }
-    return fail(ERROR_CODES.FORBIDDEN_TOOL_FOR_ROLE, `Tool ${toolName} is not allowed for role ${claims.actor_type}`, {
-      retryable: false,
-      requires_human: true,
-      actor_type: claims.actor_type,
-      tool_name: toolName
-    });
+    return fail(
+      ERROR_CODES.FORBIDDEN_TOOL_FOR_ROLE,
+      `Tool ${toolName} is not allowed for role ${claims.actor_type}`,
+      {
+        retryable: false,
+        requires_human: true,
+        actor_type: claims.actor_type,
+        tool_name: toolName,
+      },
+    );
   }
 
   private async validateInput(
     tool: ToolCatalogEntry,
     toolName: string,
-    args: Record<string, unknown>
+    args: Record<string, unknown>,
   ): Promise<ToolResponse | null> {
     const inputValidation = await this.validator.validateInput(tool, args);
     if (inputValidation.valid) {
@@ -217,14 +232,14 @@ export class ToolRuntime {
       retryable: false,
       requires_human: true,
       errors: inputValidation.errors,
-      tool_name: toolName
+      tool_name: toolName,
     });
   }
 
   private async validateExecutionResponse(
     tool: ToolCatalogEntry,
     toolName: string,
-    response: ToolResponse
+    response: ToolResponse,
   ): Promise<ToolResponse | null> {
     if (response.ok) {
       const outputValidation = await this.validator.validateOutput(tool, response.data);
@@ -235,7 +250,7 @@ export class ToolRuntime {
         retryable: false,
         requires_human: true,
         errors: outputValidation.errors,
-        tool_name: toolName
+        tool_name: toolName,
       });
     }
 
@@ -247,7 +262,7 @@ export class ToolRuntime {
       retryable: false,
       requires_human: true,
       errors: envelope.errors,
-      tool_name: toolName
+      tool_name: toolName,
     });
   }
 
@@ -256,14 +271,14 @@ export class ToolRuntime {
     claims: VerifiedActorClaims,
     toolName: string,
     args: Record<string, unknown>,
-    response: ToolResponse
+    response: ToolResponse,
   ): ToolResponse {
     emitToolLog({
       claims,
       toolName,
       args,
       latencyMs: Date.now() - started,
-      response
+      response,
     });
     return response;
   }
@@ -272,8 +287,12 @@ export class ToolRuntime {
     tool: ToolCatalogEntry,
     toolName: string,
     args: Record<string, unknown>,
-    claims: VerifiedActorClaims
-  ): Promise<{ operationId: string | null; requestHash: string | null; result: ToolResponse | null }> {
+    claims: VerifiedActorClaims,
+  ): Promise<{
+    operationId: string | null;
+    requestHash: string | null;
+    result: ToolResponse | null;
+  }> {
     if (!tool.mutating) {
       return { operationId: null, requestHash: null, result: null };
     }
@@ -283,22 +302,30 @@ export class ToolRuntime {
       return {
         operationId: null,
         requestHash: null,
-        result: fail(ERROR_CODES.OPERATION_ID_REQUIRED, 'operation_id is required for mutating tools', {
-          retryable: false,
-          requires_human: true,
-          tool_name: toolName
-        })
+        result: fail(
+          ERROR_CODES.OPERATION_ID_REQUIRED,
+          'operation_id is required for mutating tools',
+          {
+            retryable: false,
+            requires_human: true,
+            tool_name: toolName,
+          },
+        ),
       };
     }
     if (!operationId) {
       return {
         operationId: null,
         requestHash: null,
-        result: fail(ERROR_CODES.OPERATION_ID_REQUIRED, 'operation_id is required for mutating tools', {
-          retryable: false,
-          requires_human: true,
-          tool_name: toolName
-        })
+        result: fail(
+          ERROR_CODES.OPERATION_ID_REQUIRED,
+          'operation_id is required for mutating tools',
+          {
+            retryable: false,
+            requires_human: true,
+            tool_name: toolName,
+          },
+        ),
       };
     }
 
@@ -308,7 +335,7 @@ export class ToolRuntime {
       return {
         operationId,
         requestHash,
-        result: dedupe.response
+        result: dedupe.response,
       };
     }
 
@@ -322,15 +349,15 @@ export class ToolRuntime {
           operation_id: operationId,
           request_hash: requestHash,
           existing_hash: dedupe.existing_hash,
-          tool_name: toolName
-        })
+          tool_name: toolName,
+        }),
       };
     }
 
     return {
       operationId,
       requestHash,
-      result: null
+      result: null,
     };
   }
 }

package/apps/control-plane/src/mcp/tools-markdown-generator.ts

@@ -11,7 +11,12 @@ export class ToolsMarkdownGenerator {
 
   renderFromCatalog(catalog: ToolCatalog): string {
     const names = [...catalog.tools].map((tool) => tool.name).sort((a, b) => a.localeCompare(b));
-    const lines = ['# AOP MCP Tool Surface', '', 'Generated from `agentic/orchestrator/tools/catalog.json`.', ''];
+    const lines = [
+      '# AOP MCP Tool Surface',
+      '',
+      'Generated from `agentic/orchestrator/tools/catalog.json`.',
+      '',
+    ];
     for (const name of names) {
       lines.push(`- ${name}`);
     }

package/apps/control-plane/src/providers/providers.ts

@@ -31,6 +31,7 @@ interface ResolveSelectionInput {
 }
 
 type ResolveSelectionRuntimeConfig = NonNullable<ResolveSelectionInput['agentsConfig']>['runtime'];
+const ENV_VAR_NAME_PATTERN = /^[A-Z_][A-Z0-9_]*$/;
 
 function isPlainObject(value: unknown): value is Record<string, unknown> {
   return typeof value === 'object' && value !== null && !Array.isArray(value);
@@ -52,7 +53,7 @@ function parseAgentConfigJson(raw: string, source: 'cli' | 'env'): Record<string
       reason: 'Invalid agent config JSON',
       source,
       value: raw,
-      parse_error: error instanceof Error ? error.message : String(error)
+      parse_error: error instanceof Error ? error.message : String(error),
     });
   }
 
@@ -60,7 +61,7 @@ function parseAgentConfigJson(raw: string, source: 'cli' | 'env'): Record<string
     throw invalidAgentConfigError({
       reason: 'Agent config JSON must be an object',
       source,
-      value: raw
+      value: raw,
     });
   }
 
@@ -69,7 +70,7 @@ function parseAgentConfigJson(raw: string, source: 'cli' | 'env'): Record<string
 
 function resolveConfiguredAgentConfig(
   provider: string,
-  runtime: ResolveSelectionRuntimeConfig
+  runtime: ResolveSelectionRuntimeConfig,
 ): Record<string, unknown> | null {
   if (!runtime) {
     return null;
@@ -87,28 +88,80 @@ function resolveConfiguredAgentConfig(
   return null;
 }
 
+function readNonEmptyEnvValue(env: NodeJS.ProcessEnv, key: string | null): string | null {
+  if (!key) {
+    return null;
+  }
+  const value = env[key];
+  if (typeof value !== 'string') {
+    return null;
+  }
+  return value.trim().length > 0 ? value : null;
+}
+
+function resolveProviderCredentialReference(
+  cliProviderConfigEnv: string | undefined,
+  configProviderConfigEnv: string | undefined,
+  env: NodeJS.ProcessEnv,
+): { providerConfigEnv: string | null; providerConfigRef: string | null } {
+  const cliConfiguredName = cliProviderConfigEnv?.trim() || null;
+  const configConfiguredName = configProviderConfigEnv?.trim() || null;
+  const unresolvedConfiguredName = cliConfiguredName ?? configConfiguredName ?? null;
+
+  const cliValue = readNonEmptyEnvValue(env, cliConfiguredName);
+  if (cliValue) {
+    return { providerConfigEnv: cliConfiguredName, providerConfigRef: cliValue };
+  }
+
+  const configValue = readNonEmptyEnvValue(env, configConfiguredName);
+  if (configValue) {
+    return { providerConfigEnv: configConfiguredName, providerConfigRef: configValue };
+  }
+
+  const aopFallback = readNonEmptyEnvValue(env, 'AOP_PROVIDER_CONFIG_ENV');
+  if (aopFallback) {
+    if (ENV_VAR_NAME_PATTERN.test(aopFallback)) {
+      const indirectValue = readNonEmptyEnvValue(env, aopFallback);
+      if (indirectValue) {
+        return { providerConfigEnv: aopFallback, providerConfigRef: indirectValue };
+      }
+    }
+
+    return {
+      providerConfigEnv: 'AOP_PROVIDER_CONFIG_ENV',
+      providerConfigRef: aopFallback,
+    };
+  }
+
+  return {
+    providerConfigEnv: unresolvedConfiguredName,
+    providerConfigRef: null,
+  };
+}
+
 export const SUPPORTED_PROVIDERS: Set<string> = new Set(REGISTERED_PROVIDER_NAMES);
-export const AUTH_REQUIRED_PROVIDERS: Set<string> = new Set(['codex', 'claude', 'gemini']);
+export const LOCAL_CLI_PROVIDERS: Set<string> = new Set([
+  'codex',
+  'claude',
+  'kiro-cli',
+  'copilot',
+  'custom',
+]);
+export const CREDENTIAL_REQUIRED_PROVIDERS: Set<string> = new Set(['gemini']);
 export type ProviderSelectionResolver = (input: ResolveSelectionInput) => ProviderSelection;
 
 export const resolveProviderSelection: ProviderSelectionResolver = ({ cli, env, agentsConfig }) => {
   const provider =
-    cli.agent_provider ||
-    env.AOP_AGENT_PROVIDER ||
-    agentsConfig?.runtime?.default_provider ||
-    null;
+    cli.agent_provider || env.AOP_AGENT_PROVIDER || agentsConfig?.runtime?.default_provider || null;
 
   const model =
-    cli.agent_model ||
-    env.AOP_AGENT_MODEL ||
-    agentsConfig?.runtime?.default_model ||
-    null;
+    cli.agent_model || env.AOP_AGENT_MODEL || agentsConfig?.runtime?.default_model || null;
 
-  const providerConfigEnv =
-    cli.provider_config_env ||
-    env.AOP_PROVIDER_CONFIG_ENV ||
-    agentsConfig?.runtime?.provider_config_env ||
-    null;
+  const { providerConfigEnv, providerConfigRef } = resolveProviderCredentialReference(
+    cli.provider_config_env,
+    agentsConfig?.runtime?.provider_config_env,
+    env,
+  );
 
   if (!provider) {
     const error = new Error(ERROR_CODES.AGENT_PROVIDER_NOT_CONFIGURED) as AppError;
@@ -123,15 +176,12 @@ export const resolveProviderSelection: ProviderSelectionResolver = ({ cli, env,
     throw error;
   }
 
-  if (
-    AUTH_REQUIRED_PROVIDERS.has(provider) &&
-    (!providerConfigEnv || !env[providerConfigEnv])
-  ) {
+  if (CREDENTIAL_REQUIRED_PROVIDERS.has(provider) && !providerConfigRef) {
     const error = new Error(ERROR_CODES.PROVIDER_AUTH_MISSING) as AppError;
     error.code = ERROR_CODES.PROVIDER_AUTH_MISSING;
     error.details = {
       provider,
-      provider_config_env: providerConfigEnv
+      provider_config_env: providerConfigEnv,
     };
     throw error;
   }
@@ -149,8 +199,8 @@ export const resolveProviderSelection: ProviderSelectionResolver = ({ cli, env,
     provider,
     model: model ?? `${provider}-default`,
     provider_config_env: providerConfigEnv,
-    provider_config_ref: providerConfigEnv ? env[providerConfigEnv] ?? null : null,
-    agent_config: agentConfig
+    provider_config_ref: providerConfigRef,
+    agent_config: agentConfig,
   };
 };
 
@@ -163,7 +213,11 @@ export interface WorkerSession {
 
 export interface WorkerProvider {
   selection: ProviderSelection;
-  createSession(role: string, featureId: string, systemPrompt: string | null): Promise<WorkerSession>;
+  createSession(
+    role: string,
+    featureId: string,
+    systemPrompt: string | null,
+  ): Promise<WorkerSession>;
   reattachSession(sessionId: string): Promise<WorkerSession | null>;
   closeSession(sessionId: string): Promise<{ closed: true }>;
   runWorker(input: {
@@ -197,23 +251,31 @@ export interface ProviderCommandRunnerOptions {
 }
 
 export interface ProviderCommandRunner {
-  run(command: string, args: string[], options?: ProviderCommandRunnerOptions): Promise<ProviderCommandResult>;
+  run(
+    command: string,
+    args: string[],
+    options?: ProviderCommandRunnerOptions,
+  ): Promise<ProviderCommandResult>;
 }
 
 export class NodeProviderCommandRunner implements ProviderCommandRunner {
-  async run(command: string, args: string[], options: ProviderCommandRunnerOptions = {}): Promise<ProviderCommandResult> {
+  async run(
+    command: string,
+    args: string[],
+    options: ProviderCommandRunnerOptions = {},
+  ): Promise<ProviderCommandResult> {
     return await new Promise<ProviderCommandResult>((resolve) => {
       let child;
       try {
         child = spawn(command, args, {
           env: options.env,
-          stdio: options.interactive ? 'inherit' : ['pipe', 'pipe', 'pipe']
+          stdio: options.interactive ? 'inherit' : ['pipe', 'pipe', 'pipe'],
         });
       } catch {
         resolve({
           exitCode: 127,
           signal: null,
-          errorCode: 'ENOENT'
+          errorCode: 'ENOENT',
         });
         return;
       }
@@ -244,7 +306,7 @@ export class NodeProviderCommandRunner implements ProviderCommandRunner {
         resolve({
           exitCode: code ?? (spawnErrorCode === 'ENOENT' ? 127 : 1),
           signal,
-          errorCode: spawnErrorCode
+          errorCode: spawnErrorCode,
         });
       });
     });
@@ -276,7 +338,7 @@ function readStringArray(value: unknown): string[] | null {
 function resolveTemplateFromAgentConfig(
   agentConfig: Record<string, unknown> | null | undefined,
   kind: 'attach' | 'send',
-  fallback: ProviderCommandTemplate | undefined
+  fallback: ProviderCommandTemplate | undefined,
 ): ProviderCommandTemplate | undefined {
   const nested = agentConfig?.[kind];
   const nestedRecord = isPlainObject(nested) ? nested : null;
@@ -307,24 +369,34 @@ function resolveProviderCommands(selection: ProviderSelection): ProviderCliComma
   const defaults: Record<string, ProviderCliCommands> = {
     codex: {
       attach: { command: 'codex', args: ['chat', '--session', '{session_id}'] },
-      send: { command: 'codex', args: ['chat', '--session', '{session_id}', '--message', '{message}'] }
+      send: {
+        command: 'codex',
+        args: ['chat', '--session', '{session_id}', '--message', '{message}'],
+      },
     },
     claude: {
       attach: { command: 'claude-code', args: ['chat', '--session', '{session_id}'] },
-      send: { command: 'claude-code', args: ['chat', '--session', '{session_id}', '--message', '{message}'] }
-    }
+      send: {
+        command: 'claude-code',
+        args: ['chat', '--session', '{session_id}', '--message', '{message}'],
+      },
+    },
   };
 
   const defaultsForProvider = defaults[selection.provider] ?? {};
   return {
-    attach: resolveTemplateFromAgentConfig(selection.agent_config, 'attach', defaultsForProvider.attach),
-    send: resolveTemplateFromAgentConfig(selection.agent_config, 'send', defaultsForProvider.send)
+    attach: resolveTemplateFromAgentConfig(
+      selection.agent_config,
+      'attach',
+      defaultsForProvider.attach,
+    ),
+    send: resolveTemplateFromAgentConfig(selection.agent_config, 'send', defaultsForProvider.send),
   };
 }
 
 function applyCommandArgsTemplate(
   args: string[],
-  values: { sessionId: string; message?: string }
+  values: { sessionId: string; message?: string },
 ): string[] {
   return args.map((arg) => {
     if (arg === '{session_id}') {
@@ -341,7 +413,7 @@ function commandFailureError(
   provider: string,
   capability: 'attach' | 'send',
   details: Record<string, unknown>,
-  code: string
+  code: string,
 ): AppError {
   const error = new Error(`${provider} provider ${capability} failed`) as AppError;
   error.code = code;
@@ -374,17 +446,21 @@ export class NullWorkerProvider implements WorkerProvider {
       this.getSessionInfo = (sessionId: string) =>
         Promise.resolve({
           active: Boolean(sessionId) && sessionId !== 'unknown' && sessionId !== 'unassigned',
-          provider: this.selection.provider
+          provider: this.selection.provider,
         });
     }
   }
 
-  createSession(role: string, featureId: string, systemPrompt: string | null): Promise<WorkerSession> {
+  createSession(
+    role: string,
+    featureId: string,
+    systemPrompt: string | null,
+  ): Promise<WorkerSession> {
     return Promise.resolve({
       session_id: `${role}-${featureId}-${crypto.randomUUID()}`,
       role,
       feature_id: featureId,
-      system_prompt_loaded: Boolean(systemPrompt)
+      system_prompt_loaded: Boolean(systemPrompt),
     });
   }
   reattachSession(sessionId: string): Promise<WorkerSession | null> {
@@ -395,7 +471,7 @@ export class NullWorkerProvider implements WorkerProvider {
       session_id: sessionId,
       role: 'orchestrator',
       feature_id: 'global',
-      system_prompt_loaded: false
+      system_prompt_loaded: false,
     });
   }
   closeSession(_sessionId: string): Promise<{ closed: true }> {
@@ -405,7 +481,7 @@ export class NullWorkerProvider implements WorkerProvider {
   runWorker({
     role,
     feature_id,
-    context_bundle
+    context_bundle,
   }: {
     role: string;
     feature_id: string;
@@ -421,9 +497,7 @@ export class NullWorkerProvider implements WorkerProvider {
     if (role === 'planner') {
       const state = context_bundle?.state;
       const frontMatter =
-        state && typeof state === 'object'
-          ? (state as Record<string, unknown>).front_matter
-          : null;
+        state && typeof state === 'object' ? (state as Record<string, unknown>).front_matter : null;
       const status =
         frontMatter && typeof frontMatter === 'object'
           ? (frontMatter as Record<string, unknown>).status
@@ -432,32 +506,36 @@ export class NullWorkerProvider implements WorkerProvider {
         type: 'NOTE',
         content: `Planner session active for ${feature_id}.`,
         context_snapshot: {
-          status: typeof status === 'string' ? status : 'unknown'
-        }
+          status: typeof status === 'string' ? status : 'unknown',
+        },
       });
     }
 
     return Promise.resolve({
       type: 'NOTE',
-      content: `${role} session active for ${feature_id}.`
+      content: `${role} session active for ${feature_id}.`,
     });
   }
 
-  private async executeCommand(kind: 'attach' | 'send', sessionId: string, message?: string): Promise<void> {
+  private async executeCommand(
+    kind: 'attach' | 'send',
+    sessionId: string,
+    message?: string,
+  ): Promise<void> {
     const template = kind === 'attach' ? this.commands.attach : this.commands.send;
     if (!template) {
       throw commandFailureError(
         this.selection.provider,
         kind,
         { reason: `Provider ${this.selection.provider} does not support ${kind}` },
-        ERROR_CODES.UNSUPPORTED_AGENT_PROVIDER
+        ERROR_CODES.UNSUPPORTED_AGENT_PROVIDER,
       );
     }
 
     const args = applyCommandArgsTemplate(template.args, { sessionId, message });
     const result = await this.commandRunner.run(template.command, args, {
       interactive: kind === 'attach',
-      timeoutMs: kind === 'send' ? 15_000 : undefined
+      timeoutMs: kind === 'send' ? 15_000 : undefined,
     });
 
     if (result.exitCode === 0) {
@@ -469,10 +547,15 @@ export class NullWorkerProvider implements WorkerProvider {
       args,
       exit_code: result.exitCode,
       signal: result.signal,
-      error_code: result.errorCode
+      error_code: result.errorCode,
     };
     if (result.exitCode === 127 || result.errorCode === 'ENOENT') {
-      throw commandFailureError(this.selection.provider, kind, details, ERROR_CODES.UNSUPPORTED_AGENT_PROVIDER);
+      throw commandFailureError(
+        this.selection.provider,
+        kind,
+        details,
+        ERROR_CODES.UNSUPPORTED_AGENT_PROVIDER,
+      );
     }
     throw commandFailureError(this.selection.provider, kind, details, ERROR_CODES.INTERNAL_ERROR);
   }