sunpeak 0.20.35 → 0.20.42

package/README.md

@@ -41,7 +41,9 @@ sunpeak replicates the ChatGPT and Claude runtimes locally so you can:
 - Pin tool states with simulation fixtures so UI regressions can't ship.
 - Automate the real-host loop with live tests: scripts that open your browser, prompt ChatGPT, and assert against the rendered app so you stop click-testing by hand.
 
-sunpeak also runs evals against your MCP server across multiple models (GPT-4o, GPT-4o-mini, o4-mini, Claude Sonnet, Gemini 2.0 Flash) via the Vercel AI SDK. Each case runs N times per model, so you can prove your tool descriptions and schemas hold up on cheaper models, not just the flagship ones.
+sunpeak also runs evals against your MCP server across multiple models (GPT-4o, GPT-4o-mini, o4-mini, Claude Sonnet, Gemini 2.0 Flash) via the Vercel AI SDK. Each case runs N times per model, so you can prove your tool descriptions, schemas, and model-visible App Context hold up on cheaper models, not just the flagship ones.
+
+Eval cases can seed App Context with `appContext`, which lets you test follow-up prompts such as "Book this one" against state the app has shared through `updateModelContext`.
 
 <div align="center">
   <a href="https://sunpeak.ai/docs/testing/evals">
@@ -99,7 +101,7 @@ npx sunpeak test
 
 Playwright fixtures handle inspector startup, MCP connection, iframe traversal, and host switching. Works with Python, Go, TypeScript, Rust, or any language.
 
-Evals add a second dimension: model compatibility. The eval framework connects to your MCP server via the MCP protocol, discovers its tools, and sends prompts to multiple models (GPT-4o, GPT-4o-mini, o4-mini, Claude Sonnet, Gemini 2.0 Flash) via the Vercel AI SDK. Each case runs N times per model and reports pass/fail counts, so you can measure whether your tool descriptions and schemas work reliably across smaller and cheaper models, not just the flagship ones.
+Evals add a second dimension: model compatibility. The eval framework connects to your MCP server via the MCP protocol, discovers its tools, and sends prompts to multiple models (GPT-4o, GPT-4o-mini, o4-mini, Claude Sonnet, Gemini 2.0 Flash) via the Vercel AI SDK. Each case runs N times per model and reports pass/fail counts, so you can measure whether your tool descriptions, schemas, and model-visible App Context work reliably across smaller and cheaper models, not just the flagship ones.
 
 ```ts
 import { test, expect } from 'sunpeak/test';

package/bin/commands/inspect.mjs

@@ -1349,19 +1349,57 @@ async function getApiKeyStatus(provider) {
   };
 }
 
-function toolResourceUri(tool) {
-  return tool?._meta?.ui?.resourceUri ?? tool?._meta?.['ui/resourceUri'];
-}
-
 function isToolVisibleToModel(tool) {
   const visibility = tool?._meta?.ui?.visibility ?? tool?._meta?.['ui/visibility'];
   if (visibility == null) return true;
   return Array.isArray(visibility) && visibility.includes('model');
 }
 
-function sanitizeAiSdkSchema(schema) {
-  const clean = { ...(schema || { type: 'object', properties: {} }) };
+function getModelCallableTools(tools) {
+  return tools.filter((tool) => isToolVisibleToModel(tool));
+}
+
+function toolRendersApp(tool) {
+  return !!(tool?._meta?.ui?.resourceUri ?? tool?._meta?.['ui/resourceUri']);
+}
+
+function sanitizeAiSdkSchemaNode(schema) {
+  if (Array.isArray(schema)) {
+    return schema.map((item) => sanitizeAiSdkSchemaNode(item));
+  }
+  if (!schema || typeof schema !== 'object') return schema;
+
+  const clean = { ...schema };
   delete clean.$schema;
+  if (
+    clean.properties &&
+    typeof clean.properties === 'object' &&
+    !Array.isArray(clean.properties)
+  ) {
+    clean.properties = Object.fromEntries(
+      Object.entries(clean.properties).map(([key, value]) => [
+        key,
+        sanitizeAiSdkSchemaNode(value),
+      ])
+    );
+  }
+  if (clean.items !== undefined) {
+    clean.items = sanitizeAiSdkSchemaNode(clean.items);
+  }
+  for (const key of ['anyOf', 'allOf', 'oneOf']) {
+    if (Array.isArray(clean[key])) {
+      clean[key] = clean[key].map((item) => sanitizeAiSdkSchemaNode(item));
+    }
+  }
+
+  const isObjectSchema = clean.type === 'object' || clean.properties != null;
+  if (isObjectSchema) {
+    if (!clean.type) clean.type = 'object';
+    if (!clean.properties) clean.properties = {};
+    clean.additionalProperties = false;
+    return clean;
+  }
+
   if (
     clean.additionalProperties != null &&
     typeof clean.additionalProperties === 'object' &&
@@ -1369,8 +1407,14 @@ function sanitizeAiSdkSchema(schema) {
   ) {
     delete clean.additionalProperties;
   }
+  return clean;
+}
+
+export function sanitizeAiSdkSchema(schema) {
+  const clean = sanitizeAiSdkSchemaNode(schema || { type: 'object', properties: {} });
   if (!clean.type) clean.type = 'object';
   if (!clean.properties) clean.properties = {};
+  clean.additionalProperties = false;
   return clean;
 }
 
@@ -1388,15 +1432,39 @@ function normalizeModelId(modelId) {
   return trimmed;
 }
 
+function normalizeModelProviderModelId(provider, modelId) {
+  const normalizedModelId = normalizeModelId(modelId);
+  if (
+    provider === 'anthropic' &&
+    /^claude-\d+(?:-\d+)+-(opus|sonnet|haiku)$/i.test(normalizedModelId)
+  ) {
+    throw new Error(
+      `Unsupported Anthropic model ID "${normalizedModelId}". Use an Anthropic API model ID such as "claude-sonnet-4-20250514".`
+    );
+  }
+  return normalizedModelId;
+}
+
+function normalizeModelConversationId(conversationId) {
+  if (typeof conversationId !== 'string') return undefined;
+  const trimmed = conversationId.trim();
+  if (!trimmed) return undefined;
+  if (trimmed.length > 200 || /[\u0000-\u001f\u007f]/.test(trimmed)) {
+    throw new Error('Invalid model conversation ID.');
+  }
+  return trimmed;
+}
+
 async function createModelInstance(provider, modelId, apiKey) {
   assertModelProvider(provider);
-  const normalizedModelId = normalizeModelId(modelId);
+  const normalizedModelId = normalizeModelProviderModelId(provider, modelId);
   if (provider === 'openai') {
     const { createOpenAI } = await import('@ai-sdk/openai');
     const openai = createOpenAI({ apiKey });
+    const settings = { structuredOutputs: false };
     return typeof openai.chat === 'function'
-      ? openai.chat(normalizedModelId)
-      : openai(normalizedModelId);
+      ? openai.chat(normalizedModelId, settings)
+      : openai(normalizedModelId, settings);
   }
   const { createAnthropic } = await import('@ai-sdk/anthropic');
   return createAnthropic({ apiKey })(normalizedModelId);
@@ -1410,6 +1478,24 @@ function formatJsonForModel(value) {
   return `${json.slice(0, MODEL_VISIBLE_JSON_LIMIT_BYTES)}...`;
 }
 
+function normalizeModelChatHost(host) {
+  if (host === 'chatgpt' || host === 'claude') return host;
+  return 'generic';
+}
+
+function isPlainObject(value) {
+  return (
+    value !== null &&
+    typeof value === 'object' &&
+    !Array.isArray(value) &&
+    Object.getPrototypeOf(value) === Object.prototype
+  );
+}
+
+function normalizeToolArguments(args) {
+  return isPlainObject(args) ? args : {};
+}
+
 function normalizeModelAppContext(appContext) {
   if (!appContext || typeof appContext !== 'object') return undefined;
   const normalized = {};
@@ -1428,65 +1514,168 @@ function formatSharedAppContextForModel(appContext) {
   return formatJsonForModel(normalized);
 }
 
-function formatModelVisibleToolResult(tool, result) {
+function normalizeModelChatMessages(messages) {
+  if (!Array.isArray(messages)) return [];
+  return messages
+    .filter((message) => message?.role === 'user' || message?.role === 'assistant')
+    .map((message) => ({
+      role: message.role,
+      content: String(message.content ?? '').slice(0, 20000).trim(),
+    }))
+    .filter((message) => message.content.length > 0);
+}
+
+function getToolErrorText(tool, result) {
+  const toolName = tool?.name || 'MCP tool';
+  const text = (result?.content || [])
+    .filter((part) => part && typeof part === 'object' && part.type === 'text')
+    .map((part) => String(part.text ?? ''))
+    .join('\n')
+    .trim();
+  if (text) return text;
+  if (result?.structuredContent !== undefined) {
+    return formatJsonForModel({ structuredContent: result.structuredContent });
+  }
+  return text || `${toolName} returned an error.`;
+}
+
+function formatModelVisibleToolError(tool, result, { host, arguments: args, toolCallId } = {}) {
+  const toolName = tool?.name || 'MCP tool';
+  const errorText = getToolErrorText(tool, result);
+  const id = typeof toolCallId === 'string' && toolCallId.trim() ? toolCallId : toolName;
+
+  switch (normalizeModelChatHost(host)) {
+    case 'chatgpt':
+      return {
+        type: 'mcp_call',
+        id,
+        name: toolName,
+        arguments: normalizeToolArguments(args),
+        error: errorText,
+        output: null,
+        status: 'failed',
+      };
+    case 'claude':
+      return {
+        type: 'mcp_tool_result',
+        tool_use_id: id,
+        is_error: true,
+        content: [{ type: 'text', text: errorText }],
+      };
+    default:
+      return {
+        isError: true,
+        content: [{ type: 'text', text: errorText }],
+      };
+  }
+}
+
+function formatModelVisibleToolResult(tool, result, options = {}) {
   const toolName = tool?.name || 'MCP tool';
   if (result?.isError) {
-    const text = (result.content || [])
-      .filter((part) => part.type === 'text')
-      .map((part) => part.text)
-      .join('\n')
-      .trim();
-    return text || `${toolName} returned an error.`;
+    if (options.host) return formatModelVisibleToolError(tool, result, options);
+    return getToolErrorText(tool, result);
   }
 
   const visibleResult = {};
-  if (Array.isArray(result?.content)) {
+  if (Array.isArray(result?.content) && result.content.length > 0) {
     visibleResult.content = result.content;
   }
-  if (result && 'structuredContent' in result) {
+  if (result?.structuredContent !== undefined) {
     visibleResult.structuredContent = result.structuredContent;
   }
-  if (result?.isError != null) {
-    visibleResult.isError = result.isError;
-  }
-
   return Object.keys(visibleResult).length > 0
     ? formatJsonForModel(visibleResult)
-    : `${toolName} completed. The MCP App is ready to render.`;
+    : toolRendersApp(tool)
+      ? `${toolName} completed. The MCP App is ready to render.`
+      : `${toolName} completed.`;
 }
 
-async function executeModelChatToolCall({ client, name, arguments: args }) {
-  const safeArgs = args && typeof args === 'object' ? args : {};
+function errorToMessage(error) {
+  if (error instanceof Error && error.message) return error.message;
+  return String(error || 'Unknown MCP tool error');
+}
+
+function createModelChatToolErrorResult(error) {
+  const message = errorToMessage(error);
   return {
-    arguments: safeArgs,
-    result: await client.callTool({ name, arguments: safeArgs }),
-    source: 'mcp',
+    content: [{ type: 'text', text: message }],
+    isError: true,
   };
 }
 
-async function runModelChat({ client, provider, modelId, messages, apiKey, appContext }) {
+async function executeModelChatToolCall({ client, name, arguments: args }) {
+  const safeArgs = normalizeToolArguments(args);
+  try {
+    return {
+      arguments: safeArgs,
+      result: await client.callTool({ name, arguments: safeArgs }),
+      source: 'mcp',
+    };
+  } catch (error) {
+    return {
+      arguments: safeArgs,
+      result: createModelChatToolErrorResult(error),
+      source: 'mcp',
+    };
+  }
+}
+
+function getModelChatHostInstructions(host) {
+  switch (normalizeModelChatHost(host)) {
+    case 'chatgpt':
+      return 'ChatGPT surfaces failed MCP calls as mcp_call items with an error field. When a tool result object has type "mcp_call", status "failed", or a non-empty error field, treat it as a failed MCP call, not a successful result.';
+    case 'claude':
+      return 'Claude surfaces failed MCP calls as mcp_tool_result blocks with is_error=true. When a tool result object has type "mcp_tool_result" and is_error is true, treat it as a failed MCP call, not a successful result.';
+    default:
+      return 'MCP tool failures are model-visible tool results. When a tool result has isError=true or describes a failed MCP call, treat it as a failed tool call, not a successful result.';
+  }
+}
+
+function getModelChatRetryInstructions() {
+  return 'After a failed MCP tool call, use the error text to decide the next step. Retry with corrected arguments for validation or business-logic errors. For transient service, timeout, or connectivity errors, you may retry once if the user request still needs the tool. Do not repeat the same failing tool call with the same arguments more than once.';
+}
+
+async function runModelChat({
+  client,
+  provider,
+  modelId,
+  messages,
+  apiKey,
+  appContext,
+  host,
+  conversationId,
+}) {
   assertModelProvider(provider);
+  const normalizedHost = normalizeModelChatHost(host);
   const { generateText, tool: aiTool, jsonSchema } = await import('ai');
   const model = await createModelInstance(provider, modelId, apiKey);
   const { tools: mcpTools } = await client.listTools();
   const capturedToolCalls = [];
   const tools = {};
 
-  for (const mcpTool of mcpTools.filter(
-    (tool) => !!toolResourceUri(tool) && isToolVisibleToModel(tool)
-  )) {
+  for (const mcpTool of getModelCallableTools(mcpTools)) {
     tools[mcpTool.name] = aiTool({
       description: mcpTool.description || mcpTool.title || '',
       inputSchema: jsonSchema(sanitizeAiSdkSchema(mcpTool.inputSchema)),
       parameters: jsonSchema(sanitizeAiSdkSchema(mcpTool.inputSchema)),
-      execute: async (args) => {
+      execute: async (args, options) => {
         const { arguments: safeArgs, result } = await executeModelChatToolCall({
           client,
           name: mcpTool.name,
           arguments: args,
         });
-        capturedToolCalls.push({ name: mcpTool.name, arguments: safeArgs, result });
-        return formatModelVisibleToolResult(mcpTool, result);
+        capturedToolCalls.push({
+          name: mcpTool.name,
+          arguments: safeArgs,
+          result,
+          isError: !!result?.isError,
+        });
+        return formatModelVisibleToolResult(mcpTool, result, {
+          host: normalizedHost,
+          arguments: safeArgs,
+          toolCallId: options?.toolCallId,
+        });
       },
     });
   }
@@ -1497,22 +1686,25 @@ async function runModelChat({ client, provider, modelId, messages, apiKey, appCo
     model,
     tools,
     system: [
-      'You are chatting inside the Sunpeak Inspector. When you call an MCP tool that renders an app, the host will render the app below your message. Do not repeat raw tool output, JSON, image URLs, markdown image lists, or full item inventories. Keep any narration brief and let the app carry the visual result.',
+      'You are chatting inside the sunpeak Inspector. When you call an MCP tool that renders an app, the host will render the app below your message. Do not repeat raw tool output, JSON, image URLs, markdown image lists, or full item inventories. Keep any narration brief and let the app carry the visual result.',
+      getModelChatHostInstructions(normalizedHost),
+      getModelChatRetryInstructions(),
       sharedAppContext
         ? `Shared MCP App context from the currently rendered app, available for this turn:\n${sharedAppContext}`
         : '',
     ]
       .filter(Boolean)
       .join('\n\n'),
-    messages: messages.map((message) => ({
-      role: message.role,
-      content: String(message.content ?? ''),
-    })),
-    maxSteps: 5,
+    messages: normalizeModelChatMessages(messages),
+    // AI SDK v4 can send an empty assistant text block to Anthropic when a
+    // tool-only response is followed by another model step. We only need the
+    // tool result for inspector rendering, so skip that follow-up call.
+    maxSteps: provider === 'anthropic' ? 1 : 5,
     maxRetries: 0,
   });
 
   return {
+    ...(conversationId ? { conversationId } : {}),
     text: result.text || '',
     toolCalls: capturedToolCalls,
     finishReason: result.finishReason,
@@ -2513,18 +2705,13 @@ function sunpeakInspectEndpointsPlugin(getClient, setClient, pluginOpts = {}) {
             res.end(JSON.stringify({ error: `No ${provider} API key saved.` }));
             return;
           }
-          const messages = Array.isArray(parsed.messages) ? parsed.messages : [];
-          const safeMessages = messages
-            .filter((message) => message?.role === 'user' || message?.role === 'assistant')
-            .map((message) => ({
-              role: message.role,
-              content: String(message.content ?? '').slice(0, 20000),
-            }));
+          const safeMessages = normalizeModelChatMessages(parsed.messages);
           if (safeMessages.length === 0) {
             res.writeHead(400, { 'Content-Type': 'application/json' });
             res.end(JSON.stringify({ error: 'Missing chat messages.' }));
             return;
           }
+          const conversationId = normalizeModelConversationId(parsed.conversationId);
 
           const result = await withModelChatClient((client) =>
             runModelChat({
@@ -2533,7 +2720,9 @@ function sunpeakInspectEndpointsPlugin(getClient, setClient, pluginOpts = {}) {
               modelId: parsed.modelId,
               messages: safeMessages,
               apiKey,
+              host: parsed.host,
               appContext: normalizeModelAppContext(parsed.appContext),
+              conversationId,
             })
           );
           res.writeHead(200, { 'Content-Type': 'application/json' });
@@ -2672,12 +2861,16 @@ export const _securityTestExports = {
   isLoopbackRemoteAddress,
   isPrivateNetworkAddress,
   isToolVisibleToModel,
+  getModelCallableTools,
+  toolRendersApp,
   executeModelChatToolCall,
   formatModelVisibleToolResult,
   formatSharedAppContextForModel,
   normalizeApiKey,
+  normalizeModelChatMessages,
   normalizeModelAppContext,
   normalizeModelId,
+  normalizeModelProviderModelId,
   quoteSecurityInteractiveArg,
   readRequestBody,
   resolveHttpRedirectsForMcp,

package/bin/commands/test-init.mjs

@@ -77,10 +77,7 @@ export async function testInit(args = [], deps = defaultDeps) {
 
   // Parse --server flag from CLI args
   const serverIdx = args.indexOf('--server');
-  const cliServer =
-    serverIdx !== -1 && args[serverIdx + 1]
-      ? args[serverIdx + 1]
-      : undefined;
+  const cliServer = serverIdx !== -1 && args[serverIdx + 1] ? args[serverIdx + 1] : undefined;
 
   const projectType = detectProjectType(d);
   const interactive = d.isTTY();
@@ -119,7 +116,10 @@ export async function testInit(args = [], deps = defaultDeps) {
           for (const prov of providers) {
             for (const model of prov.models) {
               config = config.replace(
-                new RegExp(`^(\\s*)// ('${model.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}',?.*)$`, 'm'),
+                new RegExp(
+                  `^(\\s*)// ('${model.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}',?.*)$`,
+                  'm'
+                ),
                 '$1$2'
               );
             }
@@ -139,12 +139,16 @@ export async function testInit(args = [], deps = defaultDeps) {
           });
           if (!d.isCancel(key) && key) {
             // Strip newlines so a pasted value can't inject extra .env entries.
-            const cleanKey = String(key).replace(/[\r\n]+/g, '').trim();
+            const cleanKey = String(key)
+              .replace(/[\r\n]+/g, '')
+              .trim();
             if (cleanKey) envLines.push(`${prov.envVar}=${cleanKey}`);
           }
         }
         if (envLines.length > 0 && evalDir) {
-          const relEnvPath = evalDir.startsWith(d.cwd()) ? evalDir.slice(d.cwd().length + 1) : evalDir;
+          const relEnvPath = evalDir.startsWith(d.cwd())
+            ? evalDir.slice(d.cwd().length + 1)
+            : evalDir;
           d.writeFileSync(join(evalDir, '.env'), envLines.join('\n') + '\n');
           d.log.info(`API keys saved to ${relEnvPath}/.env (gitignored)`);
         }
@@ -165,7 +169,9 @@ export async function testInit(args = [], deps = defaultDeps) {
           stdio: 'inherit',
         });
       } catch {
-        d.log.info(`Skill install skipped. Install later: ${dlx} skills add Sunpeak-AI/sunpeak@test-mcp-server`);
+        d.log.info(
+          `Skill install skipped. Install later: ${dlx} skills add Sunpeak-AI/sunpeak@test-mcp-server`
+        );
       }
     }
   }
@@ -303,9 +309,10 @@ function scaffoldEvals(evalsDir, { server, isSunpeak, d: deps } = {}) {
   d.mkdirSync(evalsDir, { recursive: true });
 
   // Generate server line for eval config
-  let serverLine = '  // server: \'http://localhost:8000/mcp\',';
+  let serverLine = "  // server: 'http://localhost:8000/mcp',";
   if (isSunpeak) {
-    serverLine = '  // Omit server for sunpeak projects (auto-detected).\n  // server: \'http://localhost:8000/mcp\',';
+    serverLine =
+      "  // Omit server for sunpeak projects (auto-detected).\n  // server: 'http://localhost:8000/mcp',";
   } else if (server?.type === 'url') {
     serverLine = `  server: ${JSON.stringify(server.value)},`;
   } else if (server?.type === 'command') {
@@ -315,27 +322,27 @@ function scaffoldEvals(evalsDir, { server, isSunpeak, d: deps } = {}) {
   // Build the eval config content
   const configLines = [
     "import { defineEvalConfig } from 'sunpeak/eval';",
-    "",
-    "// API keys are loaded automatically from .env in this directory (gitignored).",
-    "// See .env.example for the format.",
-    "",
-    "export default defineEvalConfig({",
-    "  // MCP server to test.",
+    '',
+    '// API keys are loaded automatically from .env in this directory (gitignored).',
+    '// See .env.example for the format.',
+    '',
+    'export default defineEvalConfig({',
+    '  // MCP server to test.',
     serverLine,
-    "",
-    "  models: [",
-    "    // Uncomment models and install their provider packages:",
+    '',
+    '  models: [',
+    '    // Uncomment models and install their provider packages:',
     ...generateModelLines(),
-    "  ],",
-    "",
-    "  defaults: {",
-    "    runs: 5,           // Number of times to run each case per model",
-    "    maxSteps: 1,       // Max tool call steps per run",
-    "    temperature: 0,    // 0 for most deterministic results",
-    "    timeout: 30_000,   // Timeout per run in ms",
-    "  },",
-    "});",
-    "",
+    '  ],',
+    '',
+    '  defaults: {',
+    '    runs: 5,           // Number of times to run each case per model',
+    '    maxSteps: 1,       // Max tool call steps per run',
+    '    temperature: 0,    // 0 for most deterministic results',
+    '    timeout: 30_000,   // Timeout per run in ms',
+    '  },',
+    '});',
+    '',
   ];
 
   d.writeFileSync(join(evalsDir, 'eval.config.ts'), configLines.join('\n'));
@@ -367,6 +374,8 @@ function scaffoldEvals(evalsDir, { server, isSunpeak, d: deps } = {}) {
  *
  * Each case sends a prompt to every configured model and checks
  * that the model calls the expected tool with the expected arguments.
+ * Add appContext to test follow-up prompts that depend on state shared
+ * by the rendered MCP App through updateModelContext or useAppState.
  * Cases run multiple times (configured via \`runs\` in eval.config.ts)
  * to measure reliability across non-deterministic LLM responses.
  */
@@ -377,6 +386,8 @@ export default defineEval({
     {
       name: 'example (replace me)',
       prompt: 'Show me a demo',
+      // Optional: seed model-visible App Context for follow-up prompts.
+      // appContext: { structuredContent: { selectedItem: { id: 'demo' } } },
       // expect which tool gets called and (optionally) its arguments:
       expect: {
         tool: 'your-tool-name',
@@ -437,13 +448,8 @@ function scaffoldVisualTest(filePath, d) {
 //   // await result.screenshot('tool-dark');
 // });
 
-// Full-page screenshot (captures the inspector chrome too):
-// test('full page renders correctly', async ({ inspector }) => {
-//   const result = await inspector.renderTool('your-tool', {}, { theme: 'light' });
-//   const app = result.app();
-//   await expect(app.getByText('Expected text')).toBeVisible();
-//   await result.screenshot('tool-page', { target: 'page', maxDiffPixelRatio: 0.02 });
-// });
+// renderTool() hides inspector sidebars by default, and screenshot() captures only
+// the MCP App iframe area, so inspector UI changes do not break your visual baselines.
 `
   );
   d.log.success(`Created ${filePath}`);
@@ -485,9 +491,10 @@ function scaffoldLiveTests(liveDir, { isSunpeak, server, d } = {}) {
     const parts = server.value.split(/\s+/);
     const cmd = parts[0];
     const args = parts.slice(1);
-    serverOption = args.length > 0
-      ? `\n  server: { command: ${JSON.stringify(cmd)}, args: [${args.map(a => JSON.stringify(a)).join(', ')}] },`
-      : `\n  server: { command: ${JSON.stringify(cmd)} },`;
+    serverOption =
+      args.length > 0
+        ? `\n  server: { command: ${JSON.stringify(cmd)}, args: [${args.map((a) => JSON.stringify(a)).join(', ')}] },`
+        : `\n  server: { command: ${JSON.stringify(cmd)} },`;
   }
 
   const configContent = `${liveConfigPreamble}
@@ -637,7 +644,9 @@ test('server exposes tools', async ({ mcp }) => {
 
   d.log.success('Created tests/sunpeak/ with all test types.');
   if (server.type === 'later') {
-    d.log.warn('Server not configured. Edit tests/sunpeak/playwright.config.ts before running tests.');
+    d.log.warn(
+      'Server not configured. Edit tests/sunpeak/playwright.config.ts before running tests.'
+    );
   }
 
   // Auto-install dependencies so users can run tests immediately
@@ -653,14 +662,22 @@ test('server exposes tools', async ({ mcp }) => {
   try {
     d.execSync(`${pm} exec playwright install chromium`, { cwd: testDir, stdio: 'inherit' });
   } catch {
-    d.log.warn(`Browser install failed. Run manually: cd tests/sunpeak && ${pm} exec playwright install chromium`);
+    d.log.warn(
+      `Browser install failed. Run manually: cd tests/sunpeak && ${pm} exec playwright install chromium`
+    );
   }
 
   d.log.step('Ready! Run tests with:');
   d.log.message('  npx sunpeak test              # E2E tests');
-  d.log.message('  npx sunpeak test --visual      # Visual regression (generates baselines on first run)');
-  d.log.message('  npx sunpeak test --live         # Live tests against real hosts (requires login)');
-  d.log.message('  npx sunpeak test --eval         # Multi-model evals (configure models in evals/eval.config.ts)');
+  d.log.message(
+    '  npx sunpeak test --visual      # Visual regression (generates baselines on first run)'
+  );
+  d.log.message(
+    '  npx sunpeak test --live         # Live tests against real hosts (requires login)'
+  );
+  d.log.message(
+    '  npx sunpeak test --eval         # Multi-model evals (configure models in evals/eval.config.ts)'
+  );
 }
 
 async function initJsProject(cliServer, d) {