@robota-sdk/agent-command 3.0.0-beta.90 → 3.0.0-beta.93

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

@@ -11,7 +11,11 @@ import {
   buildProviderDuplicate,
   buildProviderProfileDelete,
 } from './provider-command-profile-lifecycle.js';
-import { buildProviderEdit, buildProviderSwitch } from './provider-command-profile-operations.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';
@@ -72,8 +76,15 @@ export async function executeProviderCommand(
     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 (!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);
   }
@@ -87,12 +98,19 @@ export async function executeProviderCommand(
     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}"?`));
+      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);
+    return buildProviderProfileDelete(
+      settings.providers,
+      settings.currentProvider,
+      profileArg,
+      options,
+    );
   }
   if (subcommand === 'add') {
     return buildProviderSetup(ui, profileArg, options, isSetupRequired);
@@ -100,7 +118,7 @@ export async function executeProviderCommand(
 
   return {
     message:
-      'Usage: provider [current|list|switch <profile>|edit <profile>|duplicate <profile>|delete <profile>|add <type>|test [profile]]',
+      'Usage: provider [current|list|switch <profile>|edit <profile>|reconnect <profile>|duplicate <profile>|delete <profile>|add <type>|test [profile]]',
     success: false,
   };
 }

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

@@ -15,6 +15,17 @@ function buildProviderSubcommands(): ICommand[] {
     { 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' },
   ];
 }
@@ -23,11 +34,13 @@ export function createProviderCommandEntry(): ICommand {
   return {
     name: 'provider',
     displayName: 'Provider Setup',
-    description: 'Manage provider profiles',
+    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] | test [profile]',
+    argumentHint:
+      'current | list | switch <profile> | add [type] | edit <profile> | reconnect <profile> | test [profile]',
     subcommands: buildProviderSubcommands(),
     example: '/provider switch production',
   };

package/src/provider/provider-command-profile-operations.ts

@@ -4,11 +4,15 @@ import {
   isApiKeyPlaintext,
   setCurrentProvider,
   upsertProviderProfile,
-  validateProviderProfile,
 } from '@robota-sdk/agent-framework';
 
 import { runProviderSetupAsk } from './provider-command-setup.js';
 import { createProviderSetupFlow } from './provider-setup-flow.js';
+import {
+  hasProviderConnectionMethods,
+  runProviderConnectionSetup,
+} from './provider-connection-setup.js';
+import { validateProviderConnection } from './provider-connection-validation.js';
 
 import type { IUserInteraction } from '@robota-sdk/agent-core';
 import type {
@@ -27,11 +31,11 @@ export function formatProviderChoiceLabel(
   return `${marker}${name}: ${profile.type ?? 'unknown'} ${profile.model ?? '(no model)'}`;
 }
 
-export function buildProviderSwitch(
+export async function buildProviderSwitch(
   providers: Record<string, IProviderProfileSettings> | undefined,
   profileName: string | undefined,
   options: IProviderCommandModuleOptions,
-): ICommandResult {
+): Promise<ICommandResult> {
   if (!profileName) {
     return { message: 'Usage: /provider switch <profile>', success: false };
   }
@@ -48,7 +52,8 @@ export function buildProviderSwitch(
       success: false,
     };
   }
-  if (options.settings.readMergedSettings().currentProvider === profileName) {
+  const initial = options.settings.readMergedSettings();
+  if (initial.currentProvider === profileName) {
     return { message: `Already using provider "${profileName}".`, success: true };
   }
   const profile = providers[profileName];
@@ -58,10 +63,7 @@ export function buildProviderSwitch(
   // previous behavior wrote `currentProvider` unconditionally and let a downstream hot-swap failure
   // (e.g. "Unknown provider: anthropic. Currently supported: ", an empty list) stand uncorrected.
   try {
-    validateProviderProfile(profileName, profile, {
-      providerDefinitions: options.providerDefinitions,
-      ...(options.env === undefined ? {} : { env: options.env }),
-    });
+    await validateProviderConnection(profileName, profile, options);
   } catch (error) {
     return {
       message: `Failed to switch to "${profileName}": ${error instanceof Error ? error.message : String(error)}`,
@@ -70,6 +72,15 @@ export function buildProviderSwitch(
   }
   const target = options.settings.readTargetSettings();
   const merged = options.settings.readMergedSettings();
+  if (
+    merged.currentProvider !== initial.currentProvider ||
+    JSON.stringify(merged.providers?.[profileName]) !== JSON.stringify(profile)
+  ) {
+    return {
+      success: false,
+      message: 'Provider settings changed while switching. Run /provider switch again.',
+    };
+  }
   const next =
     target.providers?.[profileName] !== undefined || merged.providers?.[profileName] !== undefined
       ? { ...target, currentProvider: profileName }
@@ -99,10 +110,14 @@ export async function buildProviderEdit(
   let flow;
   try {
     flow = createProviderSetupFlow(profile.type, options.providerDefinitions, {
+      includeEditOnlySteps: true,
       profileName,
       setCurrent: false,
       initialValues: getProviderProfileSetupValues(profile),
     });
+    if (hasProviderConnectionMethods(profile.type, options)) {
+      flow = { ...flow, steps: flow.steps.filter((step) => step.key !== 'apiKey') };
+    }
   } catch (error) {
     return { message: error instanceof Error ? error.message : String(error), success: false };
   }
@@ -114,6 +129,29 @@ export async function buildProviderEdit(
   );
 }
 
+/** Explicitly replace this profile's connection; ordinary editing preserves its credential. */
+export async function buildProviderReconnect(
+  ui: IUserInteraction,
+  profileName: string,
+  options: IProviderCommandModuleOptions,
+): Promise<ICommandResult> {
+  const profile = options.settings.readMergedSettings().providers?.[profileName];
+  if (!profile?.type)
+    return { success: false, message: `Provider profile "${profileName}" was not found.` };
+  if (!hasProviderConnectionMethods(profile.type, options)) {
+    return {
+      success: false,
+      message: `Use /provider edit ${profileName} to update this provider's credentials.`,
+    };
+  }
+  const flow = createProviderSetupFlow(profile.type, options.providerDefinitions, {
+    profileName,
+    setCurrent: false,
+    initialValues: { ...(profile.model === undefined ? {} : { model: profile.model }) },
+  });
+  return runProviderConnectionSetup(ui, flow, options, false, true);
+}
+
 function getProviderProfileSetupValues(profile: IProviderProfileSettings): {
   model?: string;
   apiKey?: string;
@@ -147,10 +185,21 @@ function completeProviderEdit(
     };
   }
   const target = options.settings.readTargetSettings();
-  const patch = buildProviderSetupPatch(input, {
-    providerDefinitions: options.providerDefinitions,
-    ...(options.env === undefined ? {} : { env: options.env }),
-  });
+  const patch = buildProviderSetupPatch(
+    {
+      ...input,
+      ...(input.apiKey === undefined && currentProfile.apiKeyRef !== undefined
+        ? { apiKeyRef: currentProfile.apiKeyRef }
+        : {}),
+      ...(input.apiKey === undefined && currentProfile.apiKey !== undefined
+        ? { apiKey: currentProfile.apiKey }
+        : {}),
+    },
+    {
+      providerDefinitions: options.providerDefinitions,
+      ...(options.env === undefined ? {} : { env: options.env }),
+    },
+  );
   const updatedProfile = patch.providers[profileName];
   if (!updatedProfile) {
     return { message: `Provider profile "${profileName}" was not updated.`, success: false };

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

@@ -7,9 +7,11 @@ import {
 } from './provider-command-profile-lifecycle.js';
 import {
   buildProviderEdit,
+  buildProviderReconnect,
   buildProviderSwitch,
   formatProviderChoiceLabel,
 } from './provider-command-profile-operations.js';
+import { hasProviderConnectionMethods } from './provider-connection-setup.js';
 
 import type { IUserInteraction } from '@robota-sdk/agent-core';
 import type {
@@ -23,6 +25,7 @@ const ACTION_EDIT = 'edit';
 const ACTION_TEST = 'test';
 const ACTION_DUPLICATE = 'duplicate';
 const ACTION_DELETE = 'delete';
+const ACTION_RECONNECT = 'reconnect';
 
 /**
  * Ask the user to pick a provider profile, then drive its action menu (CMD-004 inline ask). Replaces
@@ -68,6 +71,9 @@ async function askProviderProfileAction(
     selectAction('provider-profile-action', `Provider profile: ${profileName}`, [
       { value: ACTION_SWITCH, label: 'Switch' },
       { value: ACTION_EDIT, label: 'Edit' },
+      ...(hasProviderConnectionMethods(settings.providers[profileName]?.type ?? '', options)
+        ? [{ value: ACTION_RECONNECT, label: 'Reconnect' }]
+        : []),
       { value: ACTION_TEST, label: 'Test' },
       { value: ACTION_DUPLICATE, label: 'Duplicate' },
       { value: ACTION_DELETE, label: 'Delete' },
@@ -91,6 +97,8 @@ async function executeProviderProfileAction(
       return buildProviderSwitch(settings.providers, profileName, options);
     case ACTION_EDIT:
       return buildProviderEdit(ui, profileName, options);
+    case ACTION_RECONNECT:
+      return buildProviderReconnect(ui, profileName, options);
     case ACTION_TEST:
       return testProviderProfileCommand(
         settings.currentProvider,

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

@@ -1,21 +1,22 @@
-import { textAction } from '@robota-sdk/agent-core';
 import { buildProviderSetupPatch, mergeProviderPatch } from '@robota-sdk/agent-framework';
 
+import { createProviderSetupFlow } from './provider-setup-flow.js';
+import { runProviderSetupAsk } from './provider-setup-ask.js';
 import {
-  createProviderSetupFlow,
-  formatProviderSetupHelpLinks,
-  getProviderSetupStep,
-  submitProviderSetupValue,
-} from './provider-setup-flow.js';
+  hasProviderConnectionMethods,
+  runProviderConnectionSetup,
+} from './provider-connection-setup.js';
 
 import type { IProviderSetupFlowState } from './provider-setup-flow.js';
-import type { IActionRequest, IUserInteraction } from '@robota-sdk/agent-core';
+import type { IUserInteraction } from '@robota-sdk/agent-core';
 import type {
   IProviderCommandModuleOptions,
   IProviderSetupInput,
 } from '@robota-sdk/agent-framework';
 import type { ICommandResult } from '@robota-sdk/agent-interface-command';
 
+export { runProviderSetupAsk } from './provider-setup-ask.js';
+
 const PROVIDER_RESTART_ACTION = {
   type: 'session-restart',
   reason: 'other',
@@ -30,58 +31,6 @@ export function createSetupFlow(
   });
 }
 
-/** Build the per-step `IActionRequest` for the current setup step (CMD-004 inline ask). */
-function toProviderSetupStepRequest(
-  flow: IProviderSetupFlowState,
-  errorMessage?: string,
-): IActionRequest {
-  const step = getProviderSetupStep(flow);
-  const placeholder =
-    step.masked === true && step.defaultValue !== undefined ? '(unchanged)' : step.defaultValue;
-  const helpLinks = formatProviderSetupHelpLinks(flow.setupHelpLinks);
-  const description =
-    [errorMessage, helpLinks.length > 0 ? helpLinks : undefined]
-      .filter((part): part is string => part !== undefined && part.length > 0)
-      .join('\n') || undefined;
-  return textAction(`provider-setup-${step.key}`, step.title, {
-    description,
-    placeholder,
-    allowEmpty: step.defaultValue !== undefined,
-    masked: step.masked,
-  });
-}
-
-/**
- * Drive the setup-step engine through inline `ui.ask` calls (CMD-004), re-asking the same step when a
- * step fails validation (the error is surfaced in the request description). The `complete` sink differs
- * between the add and edit paths.
- */
-export async function runProviderSetupAsk(
-  ui: IUserInteraction,
-  flow: IProviderSetupFlowState,
-  complete: (input: IProviderSetupInput) => ICommandResult,
-  cancelMessage: string,
-): Promise<ICommandResult> {
-  let state = flow;
-  let errorMessage: string | undefined;
-  for (;;) {
-    const response = await ui.ask(toProviderSetupStepRequest(state, errorMessage));
-    if (response.type === 'cancelled') {
-      return { message: cancelMessage, success: true };
-    }
-    const result = submitProviderSetupValue(state, response.text ?? '');
-    if (result.status === 'error') {
-      errorMessage = result.message;
-      continue;
-    }
-    if (result.status === 'complete') {
-      return complete(result.input);
-    }
-    state = result.state;
-    errorMessage = undefined;
-  }
-}
-
 /** Run the `/provider add` setup wizard inline. */
 export function runProviderAddSetup(
   ui: IUserInteraction,
@@ -89,6 +38,9 @@ export function runProviderAddSetup(
   options: IProviderCommandModuleOptions,
   isSetupRequired: boolean,
 ): Promise<ICommandResult> {
+  if (hasProviderConnectionMethods(flow.type, options)) {
+    return runProviderConnectionSetup(ui, flow, options, isSetupRequired);
+  }
   return runProviderSetupAsk(
     ui,
     flow,

package/src/provider/provider-connection-setup.ts

@@ -0,0 +1,287 @@
+import {
+  ENV_REFERENCE_PREFIX,
+  findProviderDefinition,
+  isEnvReference,
+  selectAction,
+  textAction,
+} from '@robota-sdk/agent-core';
+import {
+  buildProviderSetupPatch,
+  formatOrgPolicyViolationMessage,
+  mergeProviderPatch,
+  suggestProviderProfileName,
+} from '@robota-sdk/agent-framework';
+
+import { runProviderSetupAsk } from './provider-setup-ask.js';
+
+import type { ICredentialKey, IUserInteraction } from '@robota-sdk/agent-core';
+import type {
+  IProviderCommandModuleOptions,
+  IProviderSetupInput,
+  TProviderConnectionStage,
+} from '@robota-sdk/agent-framework';
+import type { ICommandResult } from '@robota-sdk/agent-interface-command';
+import type { IProviderSetupFlowState } from './provider-setup-flow.js';
+
+let nextAttempt = 0;
+const STAGE_LABELS: Record<TProviderConnectionStage, string> = {
+  'awaiting-approval': 'Waiting for browser approval',
+  exchanging: 'Completing browser authentication',
+  validating: 'Checking the connection',
+  saving: 'Finishing connection setup',
+};
+
+export function hasProviderConnectionMethods(
+  type: string,
+  options: IProviderCommandModuleOptions,
+): boolean {
+  return (
+    (findProviderDefinition(options.providerDefinitions, type)?.connectionMethods?.length ?? 0) > 0
+  );
+}
+
+/** Both frontends acquire new keys through the host; settings retain references to stored keys. */
+export async function runProviderConnectionSetup(
+  ui: IUserInteraction,
+  flow: IProviderSetupFlowState,
+  options: IProviderCommandModuleOptions,
+  isSetupRequired: boolean,
+  replace = false,
+): Promise<ICommandResult> {
+  const definition = findProviderDefinition(options.providerDefinitions, flow.type);
+  const profile =
+    flow.profileName ??
+    suggestProviderProfileName(
+      { type: flow.type },
+      { existingProfileNames: flow.existingProfileNames },
+    );
+  const initial = options.settings.readMergedSettings();
+  const previous = initial.providers?.[profile];
+  const previousSnapshot = JSON.stringify(previous);
+  if (
+    options.orgPolicy?.allowedProviders &&
+    !options.orgPolicy.allowedProviders.includes(profile)
+  ) {
+    return {
+      success: false,
+      message: formatOrgPolicyViolationMessage(
+        `Provider profile "${profile}" is not allowed by your organization policy.`,
+        options.orgPolicy.adminContact,
+      ),
+    };
+  }
+  const methods = (definition?.connectionMethods ?? []).filter(
+    (method) => options.orgPolicy?.requireApiKeyFromEnv !== true || method === 'api-key',
+  );
+  let description = options.orgPolicy?.requireApiKeyFromEnv
+    ? formatOrgPolicyViolationMessage(
+        'Your organization requires an environment reference such as $ENV:OPENROUTER_API_KEY.',
+        options.orgPolicy.adminContact,
+      )
+    : undefined;
+  for (;;) {
+    const methodAnswer = await ui.ask(
+      selectAction(
+        'provider-connection-method',
+        `Connect with ${definition?.displayName ?? flow.type}`,
+        methods.map((method) => ({
+          value: method,
+          label: method === 'api-key' ? 'API key' : 'Browser',
+        })),
+        { description },
+      ),
+    );
+    if (methodAnswer.type !== 'answer') return cancelled();
+    const method = methodAnswer.values[0];
+    if ((method !== 'api-key' && method !== 'browser') || !methods.includes(method))
+      return cancelled();
+    let apiKey: string | undefined;
+    if (method === 'api-key') {
+      const keyAnswer = await ui.ask(
+        textAction('provider-connection-key', 'API key or $ENV:VARIABLE_NAME', {
+          masked: true,
+          allowEmpty: false,
+        }),
+      );
+      if (keyAnswer.type !== 'answer') return cancelled();
+      apiKey = keyAnswer.text?.trim();
+      if (!apiKey || (options.orgPolicy?.requireApiKeyFromEnv && !isEnvReference(apiKey))) {
+        description = options.orgPolicy?.requireApiKeyFromEnv
+          ? formatOrgPolicyViolationMessage(
+              'Enter an environment reference such as $ENV:OPENROUTER_API_KEY.',
+              options.orgPolicy.adminContact,
+            )
+          : 'An API key is required.';
+        continue;
+      }
+      if (isEnvReference(apiKey)) {
+        const variable = apiKey.slice(ENV_REFERENCE_PREFIX.length).trim();
+        if (!variable || !(options.env ?? process.env)[variable]?.trim()) {
+          description =
+            'The environment reference is unset or invalid. Set its variable, then choose API key to try again.';
+          continue;
+        }
+      }
+    }
+    const controller = new AbortController();
+    let progress: AbortController | undefined;
+    let sequence = 0;
+    const attempt = ++nextAttempt;
+    const stopProgress = (): void => {
+      progress?.abort();
+      progress = undefined;
+    };
+    const onProgress = (stage: TProviderConnectionStage): void => {
+      stopProgress();
+      const prompt = new AbortController();
+      progress = prompt;
+      void ui
+        .ask(
+          selectAction(
+            `provider-connection-progress-${attempt}-${++sequence}`,
+            STAGE_LABELS[stage],
+            [{ value: 'cancel', label: 'Cancel connection' }],
+            { description: 'Keep this session open. You can cancel and choose API key setup.' },
+          ),
+          { signal: prompt.signal },
+        )
+        .then((response) => {
+          if (response.type === 'answer' || !prompt.signal.aborted) controller.abort();
+        })
+        .catch(() => {
+          if (!prompt.signal.aborted) controller.abort();
+        });
+    };
+    let result: ICommandResult | undefined;
+    const persist = async (reference?: ICredentialKey, hostSignal?: AbortSignal): Promise<void> => {
+      stopProgress();
+      const signal = hostSignal ?? controller.signal;
+      let input: IProviderSetupInput | undefined;
+      const modelFlow = {
+        ...flow,
+        profileName: profile,
+        steps: flow.steps.filter((step) => step.key !== 'apiKey' && step.key !== 'baseURL'),
+      };
+      if (modelFlow.steps.length === 0) {
+        input = {
+          profile,
+          type: flow.type,
+          model: definition?.defaults?.model,
+          setCurrent: flow.setCurrent ?? true,
+        };
+      } else {
+        await runProviderSetupAsk(
+          ui,
+          modelFlow,
+          (completed) => {
+            input = completed;
+            return { success: true, message: '' };
+          },
+          'Provider connection cancelled.',
+          signal,
+        );
+      }
+      if (!input || signal.aborted || controller.signal.aborted) {
+        controller.abort();
+        throw new Error('Provider connection cancelled.');
+      }
+      const current = options.settings.readMergedSettings();
+      if (
+        JSON.stringify(current.providers?.[profile]) !== previousSnapshot ||
+        current.currentProvider !== initial.currentProvider
+      ) {
+        throw new Error('Provider connection changed while setup was pending.');
+      }
+      const credential =
+        reference === undefined
+          ? { apiKeyEnv: apiKey?.slice(ENV_REFERENCE_PREFIX.length).trim() }
+          : { apiKeyRef: reference };
+      const patch = buildProviderSetupPatch(
+        { ...input, ...credential },
+        {
+          providerDefinitions: options.providerDefinitions,
+          env: options.env,
+        },
+      );
+      if (replace && previous !== undefined) {
+        const retained = { ...previous };
+        delete retained.apiKey;
+        delete retained.apiKeyRef;
+        patch.providers[profile] = { ...retained, ...patch.providers[profile] };
+      }
+      options.settings.writeTargetSettings(
+        mergeProviderPatch(options.settings.readTargetSettings(), patch),
+      );
+      const active = initial.currentProvider === profile;
+      result = {
+        success: true,
+        message: `Provider ${profile} connected.`,
+        ...(replace
+          ? active
+            ? {
+                hostActions: [
+                  {
+                    type: 'session-restart',
+                    reason: 'other',
+                    message: 'Provider connection restart',
+                  } as const,
+                ],
+              }
+            : {}
+          : {
+              hostActions: isSetupRequired
+                ? [{ type: 'provider-hot-swap', profileName: profile } as const]
+                : [
+                    {
+                      type: 'session-restart',
+                      reason: 'other',
+                      message: 'Provider setup restart',
+                    } as const,
+                  ],
+            }),
+      };
+    };
+    try {
+      if (apiKey !== undefined && isEnvReference(apiKey)) {
+        await persist();
+      } else if (options.connectionHost === undefined) {
+        description =
+          'Host connection support is unavailable. Choose API key and use an environment reference.';
+        continue;
+      } else {
+        await options.connectionHost.connect(
+          {
+            type: flow.type,
+            profile,
+            method,
+            ...(apiKey === undefined ? {} : { apiKey }),
+            signal: controller.signal,
+            ...(method === 'browser' ? { onProgress } : {}),
+          },
+          persist,
+        );
+      }
+      if (result === undefined) throw new Error('The host did not save a connection.');
+      return result;
+    } catch {
+      const recovery =
+        method === 'browser' && flow.type === 'openrouter'
+          ? ' If OpenRouter issued a key during this attempt, it may remain in your account. Review OpenRouter Keys at https://openrouter.ai/keys.'
+          : '';
+      if (controller.signal.aborted) {
+        description = `Connection cancelled. Choose a connection method to try again.${recovery}`;
+        continue;
+      }
+      return {
+        success: false,
+        message: `Connection failed. Retry with ${replace ? `/provider reconnect ${profile}` : `/provider add ${flow.type}`} and choose ${flow.type === 'openrouter' ? 'an ordinary OpenRouter API key or Browser' : 'API key or Browser'}.${recovery}`,
+      };
+    } finally {
+      stopProgress();
+    }
+  }
+}
+
+function cancelled(): ICommandResult {
+  return { success: true, message: 'Provider connection cancelled.' };
+}