@robota-sdk/agent-command 3.0.0-beta.85 → 3.0.0-beta.87

package/src/mcp-activation/__tests__/mcp-skill-command.test.ts

@@ -0,0 +1,141 @@
+import { expect, it, vi } from 'vitest';
+import { SystemCommandExecutor } from '@robota-sdk/agent-framework';
+import { createTestCommandHost } from '@robota-sdk/agent-framework/testing';
+import { executeMCPActivationCommand } from '../mcp-activation-command.js';
+import { createMCPActivationCommandModule } from '../mcp-activation-command-module.js';
+import type { TCommandInvocationSource } from '@robota-sdk/agent-interface-command';
+
+const preview = {
+  serverId: 'docs',
+  uri: 'skill://docs/demo/SKILL.md',
+  namespace: 'origin',
+  fingerprint: 'a'.repeat(64),
+  name: 'demo',
+  description: 'Use this workflow',
+  frontmatter: { name: 'demo', description: 'Use this workflow', 'allowed-tools': 'Write' },
+  content: '---\nname: demo\n---\nInstructions for review.',
+};
+function fixture(source: TCommandInvocationSource | undefined, locality?: 'local' | 'remote') {
+  const skills = {
+    list: vi.fn(async () => [{ ...preview, content: undefined }]),
+    inspect: vi.fn(async () => preview),
+    approve: vi.fn(async () => preview),
+    withdraw: vi.fn(),
+  };
+  const host = createTestCommandHost({
+    overrides: {
+      getCommandHostAdapters: () => ({
+        mcpActivation: {
+          list: () => [],
+          approve: vi.fn(),
+          reject: vi.fn(),
+          revoke: vi.fn(),
+          skills,
+        },
+      }),
+      getCommandInvocationSource: () => source ?? 'user',
+      getCommandSurfaceLocalityEvidence: () => locality,
+    },
+  });
+  const {
+    getCommandInvocationSource: _source,
+    getCommandSurfaceLocalityEvidence: _locality,
+    ...base
+  } = host;
+  return {
+    skills,
+    host: {
+      ...base,
+      ...(source === undefined ? {} : { getCommandInvocationSource: () => source }),
+      ...(locality === undefined ? {} : { getCommandSurfaceLocalityEvidence: () => locality }),
+    },
+  };
+}
+
+it('lists model-visible metadata without inspecting or approving instructions', async () => {
+  const f = fixture('model');
+  const result = await executeMCPActivationCommand(f.host, 'skill-list docs');
+  expect(result.success).toBe(true);
+  expect(result.message).toContain('Use this workflow');
+  expect(f.skills.list).toHaveBeenCalledWith('docs');
+  expect(f.skills.inspect).not.toHaveBeenCalled();
+  expect(f.skills.approve).not.toHaveBeenCalled();
+});
+
+it('shows exact content and supplies a content-bound approval command for the user', async () => {
+  const f = fixture('user');
+  const result = await executeMCPActivationCommand(
+    f.host,
+    'skill-inspect docs skill://docs/demo/SKILL.md',
+  );
+  expect(result.success).toBe(true);
+  expect(result.message).toContain(preview.content);
+  expect(result.message).toContain(
+    `/mcp skill-approve docs skill://docs/demo/SKILL.md ${preview.fingerprint}`,
+  );
+  expect(f.skills.approve).not.toHaveBeenCalled();
+});
+
+it.each(['model', 'remote', undefined] as const)(
+  'refuses consent actions from %s before dispatch',
+  async (source) => {
+    const f = fixture(source);
+    for (const verb of ['skill-inspect', 'skill-approve', 'skill-withdraw']) {
+      const result = await executeMCPActivationCommand(
+        f.host,
+        `${verb} docs skill://docs/demo/SKILL.md ${preview.fingerprint}`,
+      );
+      expect(result.success).toBe(false);
+      expect(result.message).toContain('local user');
+    }
+    expect(f.skills.inspect).not.toHaveBeenCalled();
+    expect(f.skills.approve).not.toHaveBeenCalled();
+    expect(f.skills.withdraw).not.toHaveBeenCalled();
+  },
+);
+
+it('allows a proven local app user and refuses another-device transport', async () => {
+  const f = fixture('remote', 'local');
+  expect(
+    (
+      await executeMCPActivationCommand(
+        f.host,
+        `skill-approve docs ${preview.uri} ${preview.fingerprint}`,
+      )
+    ).success,
+  ).toBe(true);
+  expect(f.skills.approve).toHaveBeenCalledWith('docs', preview.uri, preview.fingerprint, 'user');
+  const remote = fixture('remote', 'remote');
+  expect(
+    (
+      await executeMCPActivationCommand(
+        remote.host,
+        `skill-approve docs ${preview.uri} ${preview.fingerprint}`,
+      )
+    ).success,
+  ).toBe(false);
+  expect(remote.skills.approve).not.toHaveBeenCalled();
+});
+
+it('allows only metadata listing through the model command executor', async () => {
+  const [command] = createMCPActivationCommandModule().systemCommands ?? [];
+  const execute = vi.fn();
+  const executor = new SystemCommandExecutor([{ ...command!, execute }]);
+  for (const verb of ['skill-inspect', 'skill-approve', 'skill-withdraw'])
+    expect(
+      (await executor.executeModelInvocable('mcp', createTestCommandHost(), `${verb} docs`))
+        ?.success,
+    ).toBe(false);
+  expect(execute).not.toHaveBeenCalled();
+  await executor.executeModelInvocable('mcp', createTestCommandHost(), 'skill-list docs');
+  expect(execute).toHaveBeenCalledOnce();
+});
+
+it('accepts JSON argument arrays for opaque names and URIs without shell evaluation', async () => {
+  const f = fixture('user');
+  const args = ['docs with spaces', 'skill://host/demo/SKILL.md?label=a b'];
+  expect(
+    (await executeMCPActivationCommand(f.host, `skill-inspect ${JSON.stringify(args)}`)).success,
+  ).toBe(true);
+  expect(f.skills.inspect).toHaveBeenCalledWith(...args);
+});

package/src/mcp-activation/mcp-activation-command-module.ts

@@ -11,7 +11,8 @@ export function createMCPActivationCommandEntry(): ICommand {
       "Show each MCP server's trust approval and OAuth sign-in state, or change one server: " +
       'approve, reject or revoke its trust; sign in to it (login, which connects it in this ' +
       'session) or out of it (logout). Use when an MCP server is not approved, needs a sign-in, or ' +
-      'should stop being used. Returns the status list, or what the one action did.',
+      'should stop being used. List MCP Skills metadata, inspect exact instructions, approve their ' +
+      'content fingerprint or withdraw content consent separately from server trust. Returns the status list, verified preview, or what the action did.',
     // Model-invocable for `status` only: when an MCP server's tools are missing or failing, the
     // model can see why and name the command the user should run. Approving, rejecting and revoking
     // a server are trust decisions and signing in or out is a credential action, so those stay
@@ -21,7 +22,11 @@ export function createMCPActivationCommandEntry(): ICommand {
       'server or its tools are missing, a tool call reports that a server needs sign-in or approval, ' +
       'or the user asks about MCP servers. Returns one line per server: its name, activation state, ' +
       'sign-in state, and the command to suggest to the user when the server needs their approval, ' +
-      'sign-in or workspace trust. You cannot approve, sign in or sign out yourself.',
+      'sign-in or workspace trust. Use skill-list <server> to discover advertised skill names, URIs ' +
+      'and descriptions without loading instructions. Returns an invocation name for each supported ' +
+      'skill; use the session skill activation command with that exact name when its workflow fits ' +
+      'the task. If content consent is needed, ask the user to ' +
+      'run /mcp skill-inspect <server> <uri> and approve the reviewed fingerprint. You cannot approve, inspect instructions, sign in or sign out yourself.',
     argumentHint:
       '[status] | <approve|reject|revoke|logout> <server> | login <server> [--no-browser]',
     source: 'mcp-activation',
@@ -35,6 +40,26 @@ export function createMCPActivationCommandEntry(): ICommand {
         source: 'mcp-activation',
         modelInvocable: true,
       },
+      {
+        name: 'skill-list',
+        description:
+          'Discover MCP skill metadata and exact invocation names, or reasons they are unavailable, without activating instructions',
+        argumentHint: '<server>',
+        source: 'mcp-activation',
+        modelInvocable: true,
+      },
+      ...(['skill-inspect', 'skill-approve', 'skill-withdraw'] as const).map((verb) => ({
+        name: verb,
+        description:
+          verb === 'skill-inspect'
+            ? 'Review verified MCP skill instructions and frontmatter without activation'
+            : verb === 'skill-approve'
+              ? 'Grant consent for an exactly reviewed MCP skill content fingerprint'
+              : 'Withdraw MCP skill content consent',
+        argumentHint: verb === 'skill-approve' ? '<server> <uri> <fingerprint>' : '<server> <uri>',
+        source: 'mcp-activation',
+        modelInvocable: false,
+      })),
       {
         name: 'reload',
         description: 'Retry connecting every MCP server that is not currently connected',

package/src/mcp-activation/mcp-activation-command.ts

@@ -15,6 +15,7 @@ import type {
   ICommandMCPOAuthStatus,
   ICommandMCPSourceProblem,
 } from '@robota-sdk/agent-framework';
+import type { ICommandProductVocabulary } from '@robota-sdk/agent-framework';
 import type { ICommandResult } from '@robota-sdk/agent-interface-command';
 
 function adapter(context: ICommandHostAdapterAccess): ICommandMCPActivationAdapter | undefined {
@@ -66,9 +67,13 @@ function serverArgument(serverId: string): string {
 }
 
 /** How to sign in to one server: in this session, or from a terminal. */
-function signInHint(serverId: string): string {
+function signInHint(serverId: string, cliName?: string): string {
   const argument = serverArgument(serverId);
-  const how = `run /mcp login ${argument}, or robota mcp login ${argument} in a terminal`;
+  const terminal =
+    cliName === undefined
+      ? 'sign in from a terminal'
+      : `run ${cliName} mcp login ${argument} in a terminal`;
+  const how = `run /mcp login ${argument}, or ${terminal}`;
   return shellArgumentForDisplay(serverId) === undefined
     ? ` (${how}; its name cannot be shown safely here)`
     : ` (${how})`;
@@ -77,13 +82,14 @@ function signInHint(serverId: string): string {
 function formatSummary(
   summary: ICommandMCPActivationSummary,
   oauth: ICommandMCPOAuthStatus['state'] | undefined,
+  cliName?: string,
 ): string {
   const label = summary.displayName ? ` (${summary.displayName})` : '';
   // A fixed word per state: nothing token-derived ever reaches this line.
   const signIn =
     oauth === undefined
       ? ''
-      : ` — OAuth: ${OAUTH_STATE_LABEL[oauth]}${oauth === 'sign-in-required' || oauth === 'signed-out' ? signInHint(summary.serverId) : ''}`;
+      : ` — OAuth: ${OAUTH_STATE_LABEL[oauth]}${oauth === 'sign-in-required' || oauth === 'signed-out' ? signInHint(summary.serverId, cliName) : ''}`;
   return `  ${summary.serverId}${label} — ${summary.status} — ${summary.source} — ${summary.reason}${signIn}`;
 }
 
@@ -108,7 +114,10 @@ async function oauthStates(
   return new Map(states.map((status) => [status.serverId, status.state]));
 }
 
-async function listResult(mcp: ICommandMCPActivationAdapter | undefined): Promise<ICommandResult> {
+async function listResult(
+  mcp: ICommandMCPActivationAdapter | undefined,
+  cliName?: string,
+): Promise<ICommandResult> {
   if (!mcp) {
     return {
       message: 'MCP activation management is not available in this environment.',
@@ -139,7 +148,7 @@ async function listResult(mcp: ICommandMCPActivationAdapter | undefined): Promis
   return {
     message: [
       `MCP activation status:\n${entries
-        .map((entry) => formatSummary(entry, oauth.get(entry.serverId)))
+        .map((entry) => formatSummary(entry, oauth.get(entry.serverId), cliName))
         .join('\n')}`,
       ...sourceProblemLines,
     ].join('\n\n'),
@@ -171,7 +180,10 @@ async function listResult(mcp: ICommandMCPActivationAdapter | undefined): Promis
 export type TMCPActivationCommandContext = ICommandHostAdapterAccess &
   Pick<ICommandHostSessionAccess, 'getSession'> &
   ICommandHostUserInteraction &
-  Partial<Pick<ICommandHostWorkspace, 'getCommandInvocationSource'>>;
+  Partial<Pick<ICommandHostWorkspace, 'getCommandInvocationSource'>> & {
+    getCommandSurfaceLocalityEvidence?(): 'local' | 'remote' | undefined;
+    getCommandProductVocabulary?(): ICommandProductVocabulary | undefined;
+  };
 
 export async function executeMCPActivationCommand(
   context: TMCPActivationCommandContext,
@@ -179,15 +191,18 @@ export async function executeMCPActivationCommand(
 ): Promise<ICommandResult> {
   const trimmed = args.trim();
   const spaceAt = trimmed.indexOf(' ');
+  const cliName = context.getCommandProductVocabulary?.()?.cliName;
   const verb = (spaceAt === -1 ? trimmed : trimmed.slice(0, spaceAt)).toLowerCase();
   const serverId = spaceAt === -1 ? '' : trimmed.slice(spaceAt + 1).trim();
 
+  if (verb.startsWith('skill-')) return skillResult(context, verb, serverId);
+
   if (verb === '' || verb === 'status' || verb === 'list') {
     // The full view only for a caller known to be a person; an unknown caller gets the model's view.
     const source = context.getCommandInvocationSource?.();
     return source === 'user' || source === 'remote'
-      ? listResult(adapter(context))
-      : mcpModelStatusResult(adapter(context));
+      ? listResult(adapter(context), cliName)
+      : mcpModelStatusResult(adapter(context), cliName);
   }
   if (verb === 'login') return loginResult(context, serverId);
   if (verb === 'reload') return reloadResult(context);
@@ -253,6 +268,115 @@ export async function executeMCPActivationCommand(
   }
 }
 
+/** JSON arrays preserve opaque identities; ordinary whitespace-separated arguments remain convenient. */
+function skillArguments(args: string): string[] | undefined {
+  if (!args.startsWith('[')) return args.split(/\s+/).filter(Boolean);
+  try {
+    const parsed: unknown = JSON.parse(args);
+    return Array.isArray(parsed) && parsed.every((value) => typeof value === 'string')
+      ? parsed
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+async function skillResult(
+  context: TMCPActivationCommandContext,
+  verb: string,
+  rest: string,
+): Promise<ICommandResult> {
+  const source = context.getCommandInvocationSource?.();
+  const localUser =
+    source === 'user' ||
+    (source === 'remote' && context.getCommandSurfaceLocalityEvidence?.() === 'local');
+  if (verb !== 'skill-list' && !localUser)
+    return {
+      success: false,
+      message: 'Only a known local user can inspect, approve or withdraw MCP skill instructions.',
+    };
+  const words = skillArguments(rest);
+  const count = verb === 'skill-list' ? 1 : verb === 'skill-approve' ? 3 : 2;
+  if (
+    !['skill-list', 'skill-inspect', 'skill-approve', 'skill-withdraw'].includes(verb) ||
+    !words ||
+    words.length !== count ||
+    words.some((word) => word.length === 0)
+  )
+    return {
+      success: false,
+      message:
+        'Usage: /mcp skill-list <server> | skill-inspect <server> <uri> | skill-approve <server> <uri> <fingerprint> | skill-withdraw <server> <uri>. JSON string arrays also accept opaque arguments.',
+    };
+  const skills = adapter(context)?.skills;
+  if (!skills)
+    return { success: false, message: 'MCP Skills are not available in this environment.' };
+  const serverId = words[0]!;
+  const uri = words[1]!;
+  try {
+    if (verb === 'skill-list') {
+      const entries = await skills.list(serverId);
+      return {
+        success: true,
+        message:
+          entries.length === 0
+            ? 'No MCP skills are advertised.'
+            : entries
+                .map(
+                  (entry) =>
+                    `${entry.name} — ${entry.uri}\n${entry.description}` +
+                    (entry.invocationName ? `\nInvoke skill: ${entry.invocationName}` : '') +
+                    (entry.unavailableReason ? `\nUnavailable: ${entry.unavailableReason}` : ''),
+                )
+                .join('\n\n'),
+        data: {
+          skills: entries.map((entry) => ({
+            serverId: entry.serverId,
+            uri: entry.uri,
+            name: entry.name,
+            description: entry.description,
+            ...(entry.invocationName ? { invocationName: entry.invocationName } : {}),
+            ...(entry.unavailableReason ? { unavailableReason: entry.unavailableReason } : {}),
+          })),
+        },
+      };
+    }
+    if (verb === 'skill-withdraw') {
+      skills.withdraw(serverId, uri, 'user');
+      return { success: true, message: 'MCP skill content consent withdrawn.' };
+    }
+    const preview =
+      verb === 'skill-approve'
+        ? await skills.approve(serverId, uri, words[2]!, 'user')
+        : await skills.inspect(serverId, uri);
+    const args = [serverId, uri, preview.fingerprint];
+    const approveArgs = args.every((arg) => /^[\w:./%-]+$/.test(arg))
+      ? args.join(' ')
+      : JSON.stringify(args);
+    return {
+      success: true,
+      message:
+        verb === 'skill-approve'
+          ? 'MCP skill content consent saved; activation remains a separate action.'
+          : `${preview.content}\n\nFrontmatter: ${JSON.stringify(preview.frontmatter)}\n\nApprove exactly this content: /mcp skill-approve ${approveArgs}`,
+      data: {
+        serverId: preview.serverId,
+        uri: preview.uri,
+        namespace: preview.namespace,
+        fingerprint: preview.fingerprint,
+        frontmatter: preview.frontmatter,
+        ...(verb === 'skill-inspect' ? { content: preview.content } : {}),
+      },
+    };
+  } catch {
+    return {
+      success: false,
+      message:
+        'MCP skill request refused. Check /mcp status; run /mcp skill-inspect <server> <uri> before granting content consent.',
+    };
+  }
+}
+
 async function logoutResult(
   mcp: ICommandMCPActivationAdapter,
   serverId: string,
@@ -389,7 +513,7 @@ function redirectReader(
 }
 
 /** Why a sign-in did not complete, and what to run instead, by fixed words only. */
-function loginFailureText(result: ICommandMCPOAuthLoginResult): string {
+function loginFailureText(result: ICommandMCPOAuthLoginResult, cliName?: string): string {
   const { serverId, failure } = result;
   const argument = serverArgument(serverId);
   switch (failure) {
@@ -400,9 +524,12 @@ function loginFailureText(result: ICommandMCPOAuthLoginResult): string {
     case 'sign-in-in-progress':
       return `A sign-in to MCP server ${serverId} is already in progress.`;
     case 'prompt-unavailable':
+      if (cliName === undefined) {
+        return 'Signing in without a browser needs a redirect URL pasted in a terminal, but no product command name is available in this session.';
+      }
       return (
         'Signing in without a browser needs the redirect URL pasted here, and nothing here can ask ' +
-        `for it; run robota mcp login ${argument} --no-browser in a terminal.`
+        `for it; run ${cliName} mcp login ${argument} --no-browser in a terminal.`
       );
     case 'browser-failed':
       return (
@@ -412,7 +539,9 @@ function loginFailureText(result: ICommandMCPOAuthLoginResult): string {
     default: {
       const secret =
         failure === 'token-exchange-failed' && result.preRegisteredClient
-          ? ` If its pre-registered client needs a secret, run robota mcp login ${argument} --client-secret in a terminal.`
+          ? cliName === undefined
+            ? ' If its pre-registered client needs a secret, sign in from a terminal configured for this product.'
+            : ` If its pre-registered client needs a secret, run ${cliName} mcp login ${argument} --client-secret in a terminal.`
           : '';
       return `Sign-in to MCP server ${serverId} failed (${failure ?? 'unexpected-error'}); nothing was changed.${secret}`;
     }
@@ -443,6 +572,7 @@ async function loginResult(
   context: TMCPActivationCommandContext,
   rest: string,
 ): Promise<ICommandResult> {
+  const cliName = context.getCommandProductVocabulary?.()?.cliName;
   const words = rest.split(/\s+/).filter((word) => word !== '');
   const noBrowser = words.includes('--no-browser');
   const withSecret = words.includes('--client-secret');
@@ -456,8 +586,9 @@ async function loginResult(
     // A secret typed here would become part of the conversation; it is asked for only in a terminal.
     return {
       message:
-        'A client secret is never typed into a session. Run robota mcp login ' +
-        `${argument} --client-secret in a terminal.`,
+        cliName === undefined
+          ? 'A client secret is never typed into a session. Sign in from a terminal configured for this product.'
+          : `A client secret is never typed into a session. Run ${cliName} mcp login ${argument} --client-secret in a terminal.`,
       success: false,
     };
   }
@@ -470,7 +601,10 @@ async function loginResult(
   }
   if (mcp.oauthLogin === undefined) {
     return {
-      message: `Signing in is not available in this session; run robota mcp login ${argument} in a terminal.`,
+      message:
+        cliName === undefined
+          ? 'Signing in is not available in this session; sign in from a terminal configured for this product.'
+          : `Signing in is not available in this session; run ${cliName} mcp login ${argument} in a terminal.`,
       success: false,
     };
   }
@@ -503,7 +637,7 @@ async function loginResult(
   });
   if (result.failure !== undefined) {
     return {
-      message: loginFailureText(result),
+      message: loginFailureText(result, cliName),
       success: false,
       data: { serverId, failure: result.failure },
     };

package/src/mcp-activation/mcp-model-notice.ts

@@ -26,15 +26,20 @@ export function mcpUserActionCommand(
   serverId: string,
   action: TMCPUserAction,
   surface: TMCPUserActionSurface = 'session',
-): string {
+  cliName?: string,
+): string | undefined {
   const name = shellArgumentForDisplay(serverId) ?? '<server>';
   switch (action) {
     case 'approve':
       return `/mcp approve ${name}`;
     case 'sign-in':
-      return surface === 'terminal' ? `robota mcp login ${name}` : `/mcp login ${name}`;
+      return surface === 'terminal'
+        ? cliName === undefined
+          ? undefined
+          : `${cliName} mcp login ${name}`
+        : `/mcp login ${name}`;
     case 'trust-workspace':
-      return 'robota trust';
+      return cliName === undefined ? undefined : `${cliName} trust`;
   }
 }
 
@@ -56,13 +61,21 @@ export function mcpUserActionNotice(
   serverId: string,
   action: TMCPUserAction,
   surface: TMCPUserActionSurface = 'session',
+  cliName?: string,
 ): string {
   const inTerminal =
     action === 'trust-workspace' || (action === 'sign-in' && surface === 'terminal');
   const where = inTerminal ? ' in a terminal, then restart the session' : '';
+  const command = mcpUserActionCommand(serverId, action, surface, cliName);
+  const ask =
+    command === undefined
+      ? action === 'trust-workspace'
+        ? 'ask the user to trust this workspace in a terminal'
+        : 'ask the user to sign in from a terminal'
+      : `ask the user to run \`${command}\`${where}`;
   return (
     `${subject(serverId)} ${NEED[action]}, so its tools are unavailable. You cannot do this ` +
-    `yourself; ask the user to run \`${mcpUserActionCommand(serverId, action, surface)}\`${where}.`
+    `yourself; ${ask}.`
   );
 }
 
@@ -72,10 +85,11 @@ export function mcpUserActionNotice(
  */
 export function mcpUnavailableServersNotice(
   servers: ReadonlyMap<string, TMCPUserAction>,
+  cliName?: string,
 ): string | undefined {
   if (servers.size === 0) return undefined;
   const lines = [...servers].map(
-    ([serverId, action]) => `- ${mcpUserActionNotice(serverId, action)}`,
+    ([serverId, action]) => `- ${mcpUserActionNotice(serverId, action, 'session', cliName)}`,
   );
   return [
     'MCP servers that did not start this session. Mention this only when the user needs one of ' +

package/src/mcp-activation/mcp-model-status.ts

@@ -46,6 +46,7 @@ function toModelView(
   summary: ICommandMCPActivationSummary,
   oauth: TOAuthState | undefined,
   surface: TMCPUserActionSurface,
+  cliName?: string,
 ): IModelServerView {
   const name = shellArgumentForDisplay(summary.serverId);
   const action = userActionFor(summary.status, oauth);
@@ -55,7 +56,10 @@ function toModelView(
     ...(oauth === undefined ? {} : { oauth }),
     ...(action === undefined
       ? {}
-      : { suggestCommand: mcpUserActionCommand(summary.serverId, action, surface) }),
+      : (() => {
+          const suggestCommand = mcpUserActionCommand(summary.serverId, action, surface, cliName);
+          return suggestCommand === undefined ? {} : { suggestCommand };
+        })()),
   };
 }
 
@@ -69,6 +73,7 @@ function formatLine(view: IModelServerView): string {
 
 export async function mcpModelStatusResult(
   mcp: ICommandMCPActivationAdapter | undefined,
+  cliName?: string,
 ): Promise<ICommandResult> {
   if (!mcp) {
     return { message: 'MCP is not available in this environment.', success: true };
@@ -79,7 +84,7 @@ export async function mcpModelStatusResult(
   const servers = mcp
     .list()
     .map((summary) =>
-      toModelView(summary, oauthStates.get(summary.serverId), mcp.userActionSurface ?? 'session'),
+      toModelView(summary, oauthStates.get(summary.serverId), mcp.userActionSurface ?? 'session', cliName),
     );
   const unreadableSources = (mcp.sourceProblems?.() ?? []).length;
   const lines =