@robota-sdk/agent-command 3.0.0-beta.100

package/src/provider/__tests__/provider-setup-flow.test.ts

@@ -0,0 +1,244 @@
+import { describe, expect, it, vi } from 'vitest';
+import type { IProviderDefinition } from '@robota-sdk/agent-core';
+import {
+  createProviderSetupFlow,
+  formatProviderSetupHelpLinks,
+  formatProviderSetupPromptLabel,
+  formatProviderSetupSelectionPrompt,
+  getProviderSetupStep,
+  resolveProviderSetupSelection,
+  runProviderSetupPromptFlow,
+  submitProviderSetupValue,
+} from '../provider-setup-flow.js';
+
+const openaiDefaults = {
+  apiKey: '$ENV:OPENAI_API_KEY',
+};
+
+const providerDefinitions: readonly IProviderDefinition[] = [
+  {
+    type: 'openai',
+    displayName: 'OpenAI',
+    description: 'Use OpenAI Responses API',
+    defaults: openaiDefaults,
+    setupHelpLinks: [
+      {
+        kind: 'api-key',
+        label: 'OpenAI API keys',
+        url: 'https://platform.openai.com/api-keys',
+      },
+    ],
+    setupSteps: [
+      {
+        key: 'model',
+        title: 'OpenAI model',
+        required: true,
+      },
+      {
+        key: 'apiKey',
+        title: 'OpenAI API key',
+        defaultValue: openaiDefaults.apiKey,
+        masked: true,
+      },
+    ],
+    requiresApiKey: true,
+    createProvider: () => {
+      throw new Error('not used');
+    },
+  },
+  {
+    type: 'anthropic',
+    displayName: 'Anthropic',
+    description: 'Use Claude models through Anthropic',
+    defaults: { model: 'claude-sonnet-4-6' },
+    setupSteps: [
+      { key: 'apiKey', title: 'Anthropic API key', required: true, masked: true },
+      { key: 'model', title: 'Anthropic model', defaultValue: 'claude-sonnet-4-6' },
+    ],
+    requiresApiKey: true,
+    createProvider: () => {
+      throw new Error('not used');
+    },
+  },
+];
+
+describe('provider setup flow', () => {
+  it('carries provider-owned setup help links into generic prompt labels', () => {
+    const state = createProviderSetupFlow('openai', providerDefinitions);
+
+    expect(state.setupHelpLinks).toEqual(providerDefinitions[0]?.setupHelpLinks);
+    expect(formatProviderSetupHelpLinks(state.setupHelpLinks)).toBe(
+      '  Setup help: API key: OpenAI API keys - https://platform.openai.com/api-keys',
+    );
+    expect(formatProviderSetupPromptLabel(getProviderSetupStep(state), state.setupHelpLinks)).toBe(
+      [
+        '  Setup help: API key: OpenAI API keys - https://platform.openai.com/api-keys',
+        '  OpenAI model: ',
+      ].join('\n'),
+    );
+  });
+
+  it('formats provider selection prompts from injected provider definitions', () => {
+    expect(formatProviderSetupSelectionPrompt(providerDefinitions)).toBe(
+      [
+        '  Select provider:',
+        '    1. OpenAI (openai) — Use OpenAI Responses API',
+        '    2. Anthropic (anthropic) — Use Claude models through Anthropic',
+        '  Provider [1-2] (default: 1): ',
+      ].join('\n'),
+    );
+  });
+
+  it('resolves provider selection by index or type without provider-specific branches', () => {
+    expect(resolveProviderSetupSelection('2', providerDefinitions)).toBe('anthropic');
+    expect(resolveProviderSetupSelection('openai', providerDefinitions)).toBe('openai');
+    expect(resolveProviderSetupSelection('', providerDefinitions)).toBe('openai');
+    expect(() => resolveProviderSetupSelection('gemma', providerDefinitions)).toThrow(
+      'Unknown provider: gemma',
+    );
+  });
+
+  it('builds OpenAI setup input from model and default API key submissions', () => {
+    let state = createProviderSetupFlow('openai', providerDefinitions);
+    expect(state.setupHelpLinks).toEqual([
+      {
+        kind: 'api-key',
+        label: 'OpenAI API keys',
+        url: 'https://platform.openai.com/api-keys',
+      },
+    ]);
+    expect(getProviderSetupStep(state)).toMatchObject({
+      key: 'model',
+      required: true,
+    });
+
+    const emptyModelResult = submitProviderSetupValue(state, '');
+    expect(emptyModelResult.status).toBe('error');
+
+    const modelResult = submitProviderSetupValue(state, 'gpt-4o');
+    expect(modelResult.status).toBe('next');
+    if (modelResult.status !== 'next') throw new Error('expected next');
+    state = modelResult.state;
+
+    const apiKeyResult = submitProviderSetupValue(state, '');
+    expect(apiKeyResult).toEqual({
+      status: 'complete',
+      input: {
+        profile: 'openai',
+        type: 'openai',
+        model: 'gpt-4o',
+        apiKey: openaiDefaults.apiKey,
+        setCurrent: true,
+      },
+    });
+  });
+
+  it('keeps Anthropic API key validation outside the TUI component', () => {
+    const state = createProviderSetupFlow('anthropic', providerDefinitions);
+
+    expect(submitProviderSetupValue(state, '')).toEqual({
+      status: 'error',
+      state,
+      message: 'Required',
+    });
+  });
+
+  it('suggests unique profile names from type and disambiguates duplicates', () => {
+    let state = createProviderSetupFlow('anthropic', providerDefinitions, {
+      existingProfileNames: ['anthropic'],
+    });
+    const apiKeyResult = submitProviderSetupValue(state, 'sk-ant-test');
+    expect(apiKeyResult.status).toBe('next');
+    if (apiKeyResult.status !== 'next') throw new Error('expected next');
+    state = apiKeyResult.state;
+
+    const modelResult = submitProviderSetupValue(state, '');
+
+    expect(modelResult).toEqual({
+      status: 'complete',
+      input: {
+        profile: 'anthropic-2',
+        type: 'anthropic',
+        model: 'claude-sonnet-4-6',
+        apiKey: 'sk-ant-test',
+        setCurrent: true,
+      },
+    });
+  });
+
+  it('builds edit input for a fixed profile from current profile values', () => {
+    let state = createProviderSetupFlow('anthropic', providerDefinitions, {
+      profileName: 'work-claude',
+      setCurrent: false,
+      initialValues: {
+        apiKey: '$ENV:ANTHROPIC_API_KEY',
+        model: 'claude-sonnet-4-6',
+      },
+    });
+
+    expect(getProviderSetupStep(state)).toMatchObject({
+      key: 'apiKey',
+      defaultValue: '$ENV:ANTHROPIC_API_KEY',
+      required: false,
+    });
+
+    const apiKeyResult = submitProviderSetupValue(state, '');
+    expect(apiKeyResult.status).toBe('next');
+    if (apiKeyResult.status !== 'next') throw new Error('expected next');
+    state = apiKeyResult.state;
+
+    const modelResult = submitProviderSetupValue(state, 'claude-opus-4-5');
+
+    expect(modelResult).toEqual({
+      status: 'complete',
+      input: {
+        profile: 'work-claude',
+        type: 'anthropic',
+        model: 'claude-opus-4-5',
+        apiKey: '$ENV:ANTHROPIC_API_KEY',
+        setCurrent: false,
+      },
+    });
+  });
+
+  it('runs prompt input with masked API key steps', async () => {
+    const promptInput = vi.fn(async (label: string) => (label.includes('model') ? 'gpt-4o' : ''));
+
+    const input = await runProviderSetupPromptFlow('openai', promptInput, providerDefinitions);
+
+    expect(input.model).toBe('gpt-4o');
+    expect(input.profile).toBe('openai');
+    expect(input.apiKey).toBe(openaiDefaults.apiKey);
+    expect(promptInput).toHaveBeenNthCalledWith(
+      1,
+      formatProviderSetupPromptLabel(
+        {
+          key: 'model',
+          title: 'OpenAI model',
+          required: true,
+        },
+        providerDefinitions[0]?.setupHelpLinks,
+      ),
+      false,
+    );
+    expect(promptInput).toHaveBeenNthCalledWith(
+      2,
+      formatProviderSetupPromptLabel(
+        {
+          key: 'apiKey',
+          title: 'OpenAI API key',
+          defaultValue: openaiDefaults.apiKey,
+          masked: true,
+        },
+        providerDefinitions[0]?.setupHelpLinks,
+      ),
+      true,
+    );
+  });
+
+  it('formats provider setup help links for generic setup descriptions', () => {
+    expect(formatProviderSetupHelpLinks(providerDefinitions[0]?.setupHelpLinks)).toBe(
+      '  Setup help: API key: OpenAI API keys - https://platform.openai.com/api-keys',
+    );
+  });
+});

package/src/provider/__tests__/provider-startup-host-settings.test.ts

@@ -0,0 +1,16 @@
+import { expect, it } from 'vitest';
+
+import { ensureProviderConfig } from '../provider-startup.js';
+
+it('requires host settings access before provider startup', async () => {
+  await expect(
+    ensureProviderConfig(
+      process.cwd(),
+      {} as never,
+      async () => '',
+      { writeLine: () => undefined, writeError: () => undefined } as never,
+      [],
+      { formatError: () => 'Provider is not configured.' },
+    ),
+  ).rejects.toThrow('Provider startup requires host settings sources and stores.');
+});

package/src/provider/__tests__/scripted-interaction.ts

@@ -0,0 +1,40 @@
+import { createTestCommandHost } from '@robota-sdk/agent-framework/testing';
+
+import type { IActionRequest, IUserInteraction, TActionResponse } from '@robota-sdk/agent-core';
+
+/**
+ * Build a command host context whose `getUserInteraction().ask` replays a scripted sequence of
+ * responses (CMD-004 test double). Each `ask` records the request it received (so tests can assert on
+ * the rendered action shape) and returns the next scripted answer; once the script is exhausted it
+ * returns `{ type: 'cancelled' }`, mirroring a user dismissing the prompt.
+ */
+export function scriptedContext(
+  answers: readonly TActionResponse[],
+  /**
+   * #3282 §3: whether THIS session is running with no provider configured yet — `/provider add`
+   * reads it (never settings) to decide hot-swap vs. restart. Defaults to `false`, an ordinary
+   * session, matching every test written before setup mode existed.
+   */
+  isSetupRequired = false,
+): {
+  context: ReturnType<typeof createTestCommandHost>;
+  requests: IActionRequest[];
+} {
+  const requests: IActionRequest[] = [];
+  let index = 0;
+  const ui: IUserInteraction = {
+    ask: (request) => {
+      requests.push(request);
+      const answer = answers[index];
+      index += 1;
+      return Promise.resolve(answer ?? { type: 'cancelled' });
+    },
+  };
+  // ARCH-029: the double answers "no capability of that kind" for everything else, so this fixture
+  // states exactly the one capability it scripts. The double cast it replaced —
+  // `as Partial<…> as ICommandHostContext` — asserted conformance twice over one member.
+  const context = createTestCommandHost({
+    overrides: { getUserInteraction: () => ui, isSetupRequired: () => isSetupRequired },
+  });
+  return { context, requests };
+}

package/src/provider/index.ts

@@ -0,0 +1,32 @@
+export {
+  ProviderCommandSource,
+  createProviderCommandEntry,
+  createProviderCommandModule,
+} from './provider-command-module.js';
+export { executeProviderCommand } from './provider-command-execution.js';
+export {
+  createProviderSetupFlow,
+  formatProviderSetupChoiceLabel,
+  formatProviderSetupHelpLinks,
+  formatProviderSetupPromptLabel,
+  formatProviderSetupSelectionPrompt,
+  getProviderSetupStep,
+  resolveProviderSetupSelection,
+  runProviderSetupPromptFlow,
+  submitProviderSetupValue,
+  validateProviderSetupValue,
+} from './provider-setup-flow.js';
+export type {
+  IProviderSetupFlowOptions,
+  IProviderSetupFlowState,
+  IProviderSetupPromptStep,
+  TProviderSetupFlowSubmitResult,
+  TProviderSetupType,
+  TPromptInput,
+} from './provider-setup-flow.js';
+export type {
+  IProviderCommandModuleOptions,
+  IProviderCommandSettingsAdapter,
+} from '@robota-sdk/agent-framework';
+export { ensureProviderConfig, runProviderStartupSetup } from './provider-startup.js';
+export type { IProviderStartupContext, IEnsureProviderConfigOptions } from './provider-startup.js';

package/src/provider/provider-command-execution.ts

@@ -0,0 +1,235 @@
+import {
+  confirmAction,
+  findProviderDefinition,
+  formatSupportedProviderTypes,
+  isConfirmed,
+  selectAction,
+} from '@robota-sdk/agent-core';
+import { testProviderProfileCommand } from '@robota-sdk/agent-framework';
+
+import {
+  buildProviderDuplicate,
+  buildProviderProfileDelete,
+} from './provider-command-profile-lifecycle.js';
+import {
+  buildProviderEdit,
+  buildProviderReconnect,
+  buildProviderSwitch,
+} from './provider-command-profile-operations.js';
+import { askProviderProfileSelection } from './provider-command-profile.js';
+import { createSetupFlow, runProviderAddSetup } from './provider-command-setup.js';
+import { formatProviderSetupChoiceLabel } from './provider-setup-flow.js';
+
+import type { IUserInteraction } from '@robota-sdk/agent-core';
+import type {
+  ICommandHostSetupState,
+  ICommandHostUserInteraction,
+  IProviderCommandModuleOptions,
+  IProviderProfileSettings,
+} from '@robota-sdk/agent-framework';
+import type { ICommandResult } from '@robota-sdk/agent-interface-command';
+
+export async function executeProviderCommand(
+  context: ICommandHostUserInteraction & ICommandHostSetupState,
+  args: string,
+  options: IProviderCommandModuleOptions,
+): Promise<ICommandResult> {
+  const ui = context.getUserInteraction();
+  // #3282 §3: the session's own live state, never inferred from settings — an ordinary env-default
+  // session also has no persisted `currentProvider`, and is not in setup mode either.
+  const isSetupRequired = context.isSetupRequired?.() === true;
+  const settings = options.settings.readMergedSettings();
+  const trimmedArgs = args.trim();
+  if (trimmedArgs.length === 0) {
+    return buildProviderProfilePicker(ui, settings.currentProvider, settings.providers, options);
+  }
+  const argTokens = trimmedArgs.split(/\s+/);
+  const [subcommand = 'current', profileArg] = argTokens;
+
+  if (subcommand === 'list') {
+    return buildProviderProfilePicker(ui, settings.currentProvider, settings.providers, options);
+  }
+  if (subcommand === 'current' || subcommand === '') {
+    return {
+      message: formatCurrentProvider(settings.currentProvider, settings.providers),
+      success: true,
+    };
+  }
+  if (subcommand === 'switch') {
+    return buildProviderSwitch(settings.providers, profileArg, options);
+  }
+  if (subcommand === 'test') {
+    return testProviderProfileCommand(
+      settings.currentProvider,
+      settings.providers,
+      profileArg,
+      options,
+    );
+  }
+  // #3282 §4b: direct, non-interactive forms of what the profile-action menu otherwise reaches
+  // through two asks (`askProviderProfileSelection` then `askProviderProfileAction`) — for a caller
+  // (the Settings screen, or a typed command) that already names the profile and does not want the
+  // "which profile" ask repeated. `edit`/`duplicate` still ask their own follow-up questions (the
+  // new name, the changed fields) exactly as the menu's Edit/Duplicate do.
+  if (subcommand === 'edit') {
+    if (!ui) return { message: 'Provider edit requires an interactive session.', success: false };
+    if (!profileArg) return { message: 'Usage: provider edit <profile>', success: false };
+    return buildProviderEdit(ui, profileArg, options);
+  }
+  if (subcommand === 'reconnect') {
+    if (!ui)
+      return { message: 'Provider reconnect requires an interactive session.', success: false };
+    if (!profileArg) return { message: 'Usage: /provider reconnect <profile>', success: false };
+    return buildProviderReconnect(ui, profileArg, options);
+  }
+  if (subcommand === 'duplicate') {
+    if (!ui)
+      return { message: 'Provider duplicate requires an interactive session.', success: false };
+    if (!profileArg) return { message: 'Usage: provider duplicate <profile>', success: false };
+    return buildProviderDuplicate(ui, profileArg, options);
+  }
+  if (subcommand === 'delete') {
+    // #3282 §4b: `--confirmed` is set ONLY by the Settings screen's own write (`settings-reporter.ts`)
+    // — its "Delete…" button already confirmed through its own ConfirmDialog before sending this, and
+    // a modal write has nowhere to ask a follow-up question. A plainly-typed `delete <profile>` never
+    // carries it, so it confirms here first when a human can answer (matching `/clear`'s "confirm only
+    // when interactive; with no human the explicit form proceeds") — deleting a profile also deletes
+    // its stored key, unlike `switch`, which this direct-form family otherwise mirrors.
+    if (!profileArg) return { message: 'Usage: provider delete <profile>', success: false };
+    const preConfirmed = argTokens.includes('--confirmed');
+    if (!preConfirmed && ui) {
+      const response = await ui.ask(
+        confirmAction('provider-delete', `Delete profile "${profileArg}"?`),
+      );
+      if (!isConfirmed(response)) {
+        return { message: 'Provider delete cancelled.', success: true };
+      }
+    }
+    return buildProviderProfileDelete(
+      settings.providers,
+      settings.currentProvider,
+      profileArg,
+      options,
+    );
+  }
+  if (subcommand === 'add') {
+    return buildProviderSetup(ui, profileArg, options, isSetupRequired);
+  }
+
+  return {
+    message:
+      'Usage: provider [current|list|switch <profile>|edit <profile>|reconnect <profile>|duplicate <profile>|delete <profile>|add <type>|test [profile]]',
+    success: false,
+  };
+}
+
+/**
+ * List the provider profiles. With an interactive renderer attached, drive the inline profile picker
+ * (CMD-004); without one (headless/automation) or with no profiles, return the formatted list as text.
+ */
+function buildProviderProfilePicker(
+  ui: IUserInteraction | undefined,
+  currentProvider: string | undefined,
+  providers: Record<string, IProviderProfileSettings> | undefined,
+  options: IProviderCommandModuleOptions,
+): Promise<ICommandResult> | ICommandResult {
+  if (!ui || Object.keys(providers ?? {}).length === 0) {
+    return { message: formatProviderList(currentProvider, providers), success: true };
+  }
+  return askProviderProfileSelection(ui, currentProvider, providers, options);
+}
+
+function formatProviderList(
+  currentProvider: string | undefined,
+  providers: Record<string, IProviderProfileSettings> | undefined,
+): string {
+  const entries = Object.entries(providers ?? {});
+  if (entries.length === 0) {
+    return 'No provider profiles configured.';
+  }
+  return entries
+    .map(([name, profile]) => {
+      const marker = name === currentProvider ? '*' : '-';
+      return `${marker} ${name}: ${profile.type ?? 'unknown'} ${profile.model ?? '(no model)'}`;
+    })
+    .join('\n');
+}
+
+function formatCurrentProvider(
+  currentProvider: string | undefined,
+  providers: Record<string, IProviderProfileSettings> | undefined,
+): string {
+  if (!currentProvider) {
+    return 'No current provider configured.';
+  }
+  const profile = providers?.[currentProvider];
+  if (!profile) {
+    return `Current provider "${currentProvider}" was not found in providers.`;
+  }
+  return [
+    `Current provider: ${currentProvider}`,
+    `Type: ${profile.type ?? 'unknown'}`,
+    `Model: ${profile.model ?? '(no model)'}`,
+    ...(profile.baseURL ? [`Base URL: ${profile.baseURL}`] : []),
+  ].join('\n');
+}
+
+/**
+ * Configure a provider profile. With an explicit `type`, run the setup wizard directly; without one,
+ * ask the user to pick a provider type first (CMD-004). Without an interactive renderer, setup cannot
+ * proceed — return usage text instead of a silent guess.
+ */
+function buildProviderSetup(
+  ui: IUserInteraction | undefined,
+  type: string | undefined,
+  options: IProviderCommandModuleOptions,
+  isSetupRequired: boolean,
+): Promise<ICommandResult> | ICommandResult {
+  if (type === undefined || type.length === 0) {
+    if (!ui) {
+      return {
+        message: `Usage: provider add <type>. Supported: ${formatSupportedProviderTypes(options.providerDefinitions)}`,
+        success: false,
+      };
+    }
+    return askProviderSetupType(ui, options, isSetupRequired);
+  }
+  if (findProviderDefinition(options.providerDefinitions, type) === undefined) {
+    return {
+      message: `Usage: provider add <type>. Supported: ${formatSupportedProviderTypes(options.providerDefinitions)}`,
+      success: false,
+    };
+  }
+  if (!ui) {
+    return {
+      message: `Provider setup for "${type}" requires an interactive session.`,
+      success: false,
+    };
+  }
+  return runProviderAddSetup(ui, createSetupFlow(type, options), options, isSetupRequired);
+}
+
+async function askProviderSetupType(
+  ui: IUserInteraction,
+  options: IProviderCommandModuleOptions,
+  isSetupRequired: boolean,
+): Promise<ICommandResult> {
+  const typeOptions = options.providerDefinitions.map((definition) => ({
+    value: definition.type,
+    label: formatProviderSetupChoiceLabel(definition),
+  }));
+  const response = await ui.ask(
+    selectAction('provider-type', 'Select provider', typeOptions, { maxVisible: 6 }),
+  );
+  if (response.type !== 'answer' || response.values[0] === undefined) {
+    return { message: 'Provider setup cancelled.', success: true };
+  }
+  const type = response.values[0];
+  if (findProviderDefinition(options.providerDefinitions, type) === undefined) {
+    return {
+      message: `Usage: provider add <type>. Supported: ${formatSupportedProviderTypes(options.providerDefinitions)}`,
+      success: false,
+    };
+  }
+  return runProviderAddSetup(ui, createSetupFlow(type, options), options, isSetupRequired);
+}

package/src/provider/provider-command-module.ts

@@ -0,0 +1,82 @@
+import { executeProviderCommand } from './provider-command-execution.js';
+
+import type {
+  ICommandModule as TCommandModule,
+  IProviderCommandModuleOptions,
+  IProviderCommandSettingsAdapter,
+  ISystemCommand as TSystemCommand,
+} from '@robota-sdk/agent-framework';
+import type { ICommand, ICommandSource } from '@robota-sdk/agent-interface-command';
+export type { IProviderCommandModuleOptions, IProviderCommandSettingsAdapter };
+
+function buildProviderSubcommands(): ICommand[] {
+  return [
+    { name: 'current', description: 'Show current provider', source: 'provider' },
+    { name: 'list', description: 'List provider profiles', source: 'provider' },
+    { name: 'switch', description: 'Hot-swap to another provider profile', source: 'provider' },
+    { name: 'add', description: 'Configure a provider profile', source: 'provider' },
+    {
+      name: 'edit',
+      description: 'Edit a profile, including optional server credentials',
+      source: 'provider',
+    },
+    {
+      name: 'reconnect',
+      description: 'Replace a named service connection through browser approval or API key entry',
+      source: 'provider',
+      modelInvocable: false,
+    },
+    { name: 'test', description: 'Test provider profile', source: 'provider' },
+  ];
+}
+
+export function createProviderCommandEntry(): ICommand {
+  return {
+    name: 'provider',
+    displayName: 'Provider Setup',
+    description:
+      'Show, configure or switch provider profiles. Suggest /provider reconnect <profile> when a saved service connection needs new credentials, or /provider edit <profile> for its model or server settings; returns profile details or the result of the change.',
+    source: 'provider',
+    // User-only: provider profiles hold account credentials; a credential action.
+    modelInvocable: false,
+    argumentHint:
+      'current | list | switch <profile> | add [type] | edit <profile> | reconnect <profile> | test [profile]',
+    subcommands: buildProviderSubcommands(),
+    example: '/provider switch production',
+  };
+}
+
+export class ProviderCommandSource implements ICommandSource {
+  readonly name = 'provider';
+
+  getCommands(): ICommand[] {
+    return [createProviderCommandEntry()];
+  }
+}
+
+function createProviderSystemCommand(options: IProviderCommandModuleOptions): TSystemCommand {
+  const entry = createProviderCommandEntry();
+  return {
+    name: entry.name,
+    displayName: entry.displayName,
+    description: entry.description,
+    example: entry.example,
+    requiresPermission: false,
+    userInvocable: true,
+    modelInvocable: false,
+    argumentHint: entry.argumentHint,
+    subcommands: entry.subcommands,
+    lifecycle: 'inline',
+    execute: (context, args) => executeProviderCommand(context, args, options),
+  };
+}
+
+export function createProviderCommandModule(
+  options: IProviderCommandModuleOptions,
+): TCommandModule {
+  return {
+    name: 'agent-command-provider',
+    commandSources: [new ProviderCommandSource()],
+    systemCommands: [createProviderSystemCommand(options)],
+  };
+}