Sunpeak

What is Sunpeak about?

Sunpeak provides a full‑stack framework that lets developers create cross‑platform MCP Apps (ChatGPT Apps, Claude Connectors, etc.) and run end‑to‑end, visual, and live tests locally. It replicates host runtimes, supplies an inspector UI, and integrates with Vercel AI SDK to run model‑level evals across several LLMs.

How to use Sunpeak?

# Create a new MCP app project with HMR and an inspector
npx sunpeak new

# Initialize tests for an existing MCP server
npx sunpeak test init --server http://localhost:8000/mcp

# Run the full test suite (e2e, visual, live, evals)
npx sunpeak test

# Launch the inspector against any MCP server
npx sunpeak inspect --server http://localhost:8000/mcp

The CLI scaffolds project structure, discovers tools/resources automatically, and ties into Playwright fixtures for CI.

Key Features of Sunpeak

• App Framework: Convention‑over‑configuration project layout, multi‑platform React hooks, automatic discovery of tools, resources, and simulation fixtures.
• Testing Framework: E2E, visual regression, live browser tests, and multi‑model evals powered by Playwright and Vercel AI SDK. Supports deterministic simulation fixtures.
• Inspector: Local replica of ChatGPT and Claude runtimes; toggle hosts, themes, display modes, and device types; real‑time HMR.
• Model Eval Suite: Runs each test case N times against GPT‑4o, GPT‑4o‑mini, o4‑mini, Claude Sonnet, Gemini 2.0 Flash, reporting pass/fail counts.
• Cross‑Language Compatibility: Works with MCP servers written in TypeScript, Python, Go, Rust, etc.
• Developer Experience: No external accounts or API credits needed for CI; hot reload for rapid iteration.

Use Cases of Sunpeak

1. MCP App Development – Build a ChatGPT or Claude app once and deploy to multiple hosts without duplicate code.
2. Automated CI Testing – Run comprehensive tests across host themes, data fixtures, and LLM models without manual refreshing.
3. Model Compatibility Validation – Ensure tool schemas and App Context work on cheaper models before production.
4. Debugging & Inspection – Visually inspect any MCP server locally, switch contexts instantly, and debug tool handlers.

FAQ from Sunpeak

Q: Do I need a paid OpenAI or Anthropic account for CI testing? A: No. Sunpeak simulates host runtimes locally, so tests run without external API credits.

Q: Can I test apps written in languages other than TypeScript? A: Yes. The testing framework communicates with any MCP server via the protocol, regardless of implementation language.

Q: How are simulation fixtures created? A: Place JSON files under tests/simulations/. Sunpeak auto‑discovers them and uses them to mock tool input/output.

Q: What browsers are supported for live tests? A: Playwright handles Chromium, Firefox, and WebKit out of the box.

Q: Is the inspector compatible with future host platforms? A: Sunpeak’s architecture is host‑agnostic; new host adapters can be added while keeping the same inspector UI.

sunpeak

Server-agnostic MCP testing framework and full-stack MCP App framework.

MCP Apps are cross-platform, meaning sunpeak is a ChatGPT App framework, Claude Connector framework, and more.

Current releases use MCP Apps SDK 2.0 and the split MCP TypeScript client, server, core, and Node packages. Projects that read tool handler context directly should use extra.mcpReq for request data and extra.http?.authInfo for validated HTTP auth.

ChatGPT apps are now submitted and published as plugins. The app remains an MCP-backed app, so sunpeak's architecture and runtime do not change. The plugin is the package used for local installation, review, and public distribution.

npx sunpeak new

Demo (Hosted) ~ Demo (Video) ~ Discord ~ Documentation ~ GitHub

Why sunpeak

Building an MCP App today means testing in ChatGPT and Claude by hand. Every code change costs a 4-click refresh in each host, every teammate needs a $20/month account per host, and every test burns credits.

sunpeak replicates the ChatGPT and Claude runtimes locally so you can:

• Run e2e and visual tests in CI across every host, theme, and data combo, without accounts or API credits.
• Iterate with HMR in ChatGPT and automatic rebuilds in Claude, instead of manual refreshes.
• 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, 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.

The same foundation powers an app framework for multi-platform MCP Apps and a standalone inspector that works with any MCP server in any language.

sunpeak has three use cases

1. App Framework

Building an MCP App from scratch means wiring up an MCP server, handling protocol message routing, managing resource HTML bundles, and setting up a dev environment with hot reload. Each host has different capabilities and CSS variables, so you end up writing platform-specific code without a clear structure.

sunpeak gives you a convention-over-configuration framework with the inspector and testing built in.

npx sunpeak new

This creates a project, starts a dev server with HMR, and opens the inspector at localhost:3000:

sunpeak-app/
├── src/resources/review/review.tsx    # UI component (React)
├── src/tools/review-diff.ts           # Tool handler, schema, resource link
├── tests/simulations/review-diff.json # Mock data for the inspector
└── package.json

Tools, resources, and simulations are auto-discovered from the file system. Multi-platform React hooks (useToolData, useAppState, useTheme, useDisplayMode) let you write your app logic once and deploy it across ChatGPT, Claude, and future hosts.

App framework documentation →

---

2. Testing Framework

MCP Apps render inside host iframes with host-specific themes, display modes, and capabilities. Standard browser testing can't replicate this because the runtime environment only exists inside ChatGPT and Claude. Each app also has many dimensions of state: tool inputs, tool results, server tool responses, host context, and display configuration. Testing all combinations manually is slow and error-prone.

sunpeak replicates these host runtimes and provides simulation fixtures (JSON files that define reproducible tool states) so you can test every combination of host, theme, and data in CI without accounts or API credits.

npx sunpeak test init --server http://localhost:8000/mcp

This scaffolds E2E tests, visual regression, live tests, and multi-model evals. Then run them:

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, schemas, and model-visible App Context work reliably across smaller and cheaper models, not just the flagship ones.

import { test, expect } from 'sunpeak/test';

test('search tool returns results', async ({ mcp }) => {
  const result = await mcp.callTool('search', { query: 'headphones' });
  expect(result.isError).toBeFalsy();
});

test('album cards render', async ({ inspector }) => {
  const result = await inspector.renderTool('show-albums');
  await expect(result.app().locator('button:has-text("Summer Slice")')).toBeVisible();
});

Testing documentation →

---

3. Inspector

MCP servers are opaque. You can call tools and read the JSON responses, but you can't see how your app actually looks and behaves inside ChatGPT or Claude without deploying to each host, setting up a tunnel, paying for accounts, and manually refreshing through a multi-step cycle on every code change.

The sunpeak inspector replicates the ChatGPT and Claude app runtimes locally. Point it at any MCP server and see your tools and resources rendered the same way they appear in production hosts.

npx sunpeak inspect --server http://localhost:8000/mcp

Toggle between hosts, themes, display modes, and device types from the sidebar. Call real tool handlers or load simulation fixtures for deterministic mock data. Changes reflect instantly via HMR. Works with any MCP server in any language.

Inspector documentation →

Resources

• MCP Apps Documentation
• MCP Overview · Tools · Resources
• MCP Apps SDK
• ChatGPT Apps SDK Design Guidelines
• Build ChatGPT Plugins · Submit ChatGPT Plugins
• Troubleshooting