summer-engine 4.5.0 → 4.8.0

package/dist/mcp/ops-surface.d.ts

@@ -1,5 +1,6 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { type ToolAnnotations } from "@modelcontextprotocol/sdk/types.js";
+import { type Answer } from "../core/ops/contract.js";
 import { type FileSaver } from "../core/ops/save-files.js";
 import type { HostedLocalHook } from "./hosted-mount.js";
 /**
@@ -23,6 +24,13 @@ import type { HostedLocalHook } from "./hosted-mount.js";
  */
 export declare const SUMMER_SEARCH = "summer_search";
 export declare const SUMMER_CALL = "summer_call";
+/**
+ * The first-game look rule. It opens the engine instructions because clients
+ * keep only the start of long server instructions (Codex: the first 512
+ * characters), and a project's first frame decides whether the person keeps
+ * going. The same rule is in the AGENTS.md block (project-memory/agent-instructions.ts).
+ */
+export declare const FIRST_GAME_LOOK_RULE: string;
 export declare const OPS_MCP_INSTRUCTIONS: string;
 /** The assets profile's version: no engine tools, so it names none. */
 export declare const OPS_MCP_ASSETS_INSTRUCTIONS: string;
@@ -38,6 +46,8 @@ export interface OpsSurfaceOptions {
     legacy?: boolean;
     /** Saves generated files on this machine (`out`, localPath); shared with the mounted hosted tools. */
     files: FileSaver;
+    /** A Studio page op in the running app's own Studio tab (core/ops/studio-page.ts); null sends it to Summer's server. */
+    studio?: (op: string, input: Record<string, unknown>) => Promise<Answer | null>;
 }
 /** Its v4 description, within the 300-character summary rule; the full text stays on the 3.x surface. */
 export declare const ENGINE_REFERENCE_SUMMARY = "Look up an engine class offline before writing script code: inherits, properties, methods, signals and constants, or one member. Lists only members declared on that class (walk inherits). No engine needed. Next: summer_run_script.";

package/dist/mcp/ops-surface.js

@@ -29,7 +29,18 @@ import { FOOTER_SUFFIX } from "../core/library-read.js";
  */
 export const SUMMER_SEARCH = "summer_search";
 export const SUMMER_CALL = "summer_call";
-export const OPS_MCP_INSTRUCTIONS = "Summer Engine MCP, operation catalog. Call summer_get_project_context first when Summer Engine is open. " +
+/**
+ * The first-game look rule. It opens the engine instructions because clients
+ * keep only the start of long server instructions (Codex: the first 512
+ * characters), and a project's first frame decides whether the person keeps
+ * going. The same rule is in the AGENTS.md block (project-memory/agent-instructions.ts).
+ */
+export const FIRST_GAME_LOOK_RULE = "First game in a new project: make it look finished, even if they asked for a quick prototype, because the first frame decides if they keep going. " +
+    "Keep their features and raise the look: sky and sun with shadows, fog, a texture on every surface, real models for player, characters and props (starter project and summer_assets_search first, never capsules or boxes as final art), one palette, a styled UI font. " +
+    "Before you say it is ready, play it and check a screenshot of the running game.";
+export const OPS_MCP_INSTRUCTIONS = "Summer Engine MCP. " +
+    FIRST_GAME_LOOK_RULE +
+    " Write GDScript files directly; create scenes and import assets through Summer while the project is open. summer_get_project_context tells you which project you are connected to. " +
     "Listed tools are the common jobs; for anything else, summer_search describes the job in words and returns the operation and its exact input, then summer_call runs it. " +
     "More than 3 scene edits: one summer_run_script with scenePath. Each engine tool's full guide: summer_docs_read. Long work answers with a job: jobs.wait. " +
     "Going live: skill/release-checklist, then store.go_live with the person's yes; a game is live once Summer's automated checks pass, so never tell anyone to wait for a review. Prices and other live changes may answer needs_approval with a link: give it to the person. " +
@@ -409,6 +420,12 @@ export function applyOpsSurface(server, options) {
                 return toolResult(errorAnswer("not_in_profile", `${resolved} is not served by this profile.`, { next: { say: "Run the MCP with --profile engine." } }));
             return toolResult(await runLocal(resolved, call, extra, dryRun === true, args));
         }
+        // The running Summer app answers its own Studio tab's ops itself; else Summer's server does.
+        if (options.studio && dryRun !== true) {
+            const inApp = await options.studio(resolved, args);
+            if (inApp)
+                return toolResult(inApp);
+        }
         // `out` stays here: this package saves the files (core/ops/save-files.ts).
         const { input: sent, out } = options.files.take(resolved, args);
         let raw;

package/dist/mcp/server.js

@@ -24,6 +24,7 @@ import { registerAssetTools } from "./tools/asset-tools.js";
 import { registerGenerateTools } from "./tools/generate-tools.js";
 import { registerCreatorTools } from "./tools/creator-tools.js";
 import { registerFeedbackTools } from "./tools/feedback-tools.js";
+import { registerApiTools } from "./tools/api-tools.js";
 import { registerNavigationTools } from "./tools/navigation-tools.js";
 import { registerLibraryTools } from "./tools/library-tools.js";
 import { getCachedBootDriftNotice as getCachedNotice, setCachedBootDriftNotice, } from "./boot-notice.js";
@@ -31,6 +32,7 @@ import { appendMcpLogEvent } from "../core/mcp-log.js";
 import { defaultHostedMountDependencies, prepareHostedMount } from "./hosted-mount.js";
 import { applyOpsSurface, hostedFileTools, OPS_MCP_ASSETS_INSTRUCTIONS, OPS_MCP_INSTRUCTIONS, SUMMER_CALL, SUMMER_SEARCH } from "./ops-surface.js";
 import { FileSaver } from "../core/ops/save-files.js";
+import { runInAppStudio } from "../core/ops/studio-page.js";
 import { opForToolCall } from "../core/ops/contract.js";
 import { knownOp } from "../core/ops/catalog.js";
 import { v4HostedUrl } from "../core/ops/cloud.js";
@@ -38,7 +40,8 @@ import { serveProviderSafeToolSchemas } from "./provider-safe-schema.js";
 import { legacyHostedDescription, resolveLegacy, takeLegacyToolset } from "./legacy-toolset.js";
 import { refreshInstalledSkills, refreshNotice } from "../installer/skills-refresh.js";
 import { OUTPUT_CAPS, PROFILE_TOOL_LIMIT, PROFILES, TOOLSETS, annotationsFor, registryAuthorities, resolveToolSelection, selectionIncludes, withMaxCharactersArg, } from "./tool-surface.js";
-import { shapeToolResult, singleEditCounter } from "./tool-results.js";
+import { shapeToolResult, singleEditCounter, withSignInLink } from "./tool-results.js";
+import { SignInLinks } from "../core/sign-in-link.js";
 import { recordLocalToolCall, recordMcpSession, toolErrorCode } from "../core/telemetry.js";
 import { boundProject } from "../core/usage-fields.js";
 import { currentToolContext, registerMcpClientSource, runWithToolContext } from "../core/agent-host.js";
@@ -224,7 +227,7 @@ function rawShapeIndex(args) {
     }
     return -1;
 }
-function installToolCallWrapper(server, surfaceMeta) {
+function installToolCallWrapper(server, surfaceMeta, signInLinks = new SignInLinks()) {
     const target = server;
     const original = target.tool.bind(server);
     const singleEdits = singleEditCounter();
@@ -305,6 +308,11 @@ function installToolCallWrapper(server, surfaceMeta) {
             catch {
                 // Shaping must never break the tool call; the raw result goes out.
             }
+            if (isError && !nested) {
+                // A cloud tool that needs a sign-in answers with a link the agent can
+                // show; the sign-in it starts turns the tool on without a restart.
+                result = await withSignInLink(result, toolErrorCode(result, meta?.failureReason ?? meta?.errorClass), signInLinks);
+            }
             try {
                 recordMcpSession();
                 recordUsage(!isError, durationMs, isError ? toolErrorCode(result, meta?.failureReason ?? meta?.errorClass) : null);
@@ -418,6 +426,7 @@ export function createMcpServer(selection = FULL_SELECTION, options = {}) {
     registerGenerateTools(server);
     registerCreatorTools(server);
     registerFeedbackTools(server);
+    registerApiTools(server);
     registerScriptTools(server);
     registerPerceptionTools(server);
     registerSpatialTools(server);
@@ -451,8 +460,11 @@ export function createMcpServer(selection = FULL_SELECTION, options = {}) {
     }
     // Without engine tools nothing imports a file into a project, so files save into it by default.
     const files = new FileSaver({ saveByDefault: !engine });
-    if (surface === "v4")
-        applyOpsSurface(server, { engine, cloud: options.cloud ?? NO_CLOUD, legacy: options.legacy === true, files });
+    if (surface === "v4") {
+        // Studio page ops go to the running app's own Studio tab when it offers them (no engine launch).
+        const studio = (op, input) => runInAppStudio(op, input, () => getClient({ launch: false }));
+        applyOpsSurface(server, { engine, cloud: options.cloud ?? NO_CLOUD, legacy: options.legacy === true, files, studio });
+    }
     return { server, getRegisteredToolCount: () => getWrappedToolCount() - removed, files };
 }
 /** What the hosted tools a profile mounts are, for summer_store_tools. */

package/dist/mcp/tool-results.d.ts

@@ -1,3 +1,4 @@
+import { type SignInKind } from "../core/sign-in-link.js";
 type Content = {
     type?: string;
     text?: unknown;
@@ -23,4 +24,12 @@ export declare const SINGLE_EDIT_HINT_AT = 4;
  * then every 6th.
  */
 export declare function singleEditCounter(): (tool: string, isError: boolean) => string | null;
+/**
+ * A `not_signed_in` / `store_login_required` answer gets one more text block:
+ * the sign-in link for the person (core/sign-in-link.ts). Anything else, or
+ * no link, leaves the result as it is. Never throws.
+ */
+export declare function withSignInLink(result: unknown, code: string | null, links: {
+    link: (kind: SignInKind) => Promise<string | null>;
+}): Promise<unknown>;
 export {};

package/dist/mcp/tool-results.js

@@ -1,4 +1,5 @@
 import { BATCH_EDIT_TOOLS, SINGLE_EDIT_TOOLS } from "./tool-surface.js";
+import { signInKindForCode, signInLinkText } from "../core/sign-in-link.js";
 /** Pretty-printed JSON text as compact JSON; anything else unchanged. */
 export function compactJsonText(text) {
     const first = text[0];
@@ -79,3 +80,66 @@ export function singleEditCounter() {
         return `Tip: ${run} single scene edits in a row. More than 3 edits: write one summer_run_script instead (snapshot, script, diff, screenshot).`;
     };
 }
+/** The store sign-ins a v4 answer names in error.details.was (core/ops/cloud.ts hostedCallFailure). */
+const STORE_SIGN_IN_WAS = new Set(["store_login_required", "store_login_expired"]);
+/**
+ * A v4 cloud answer `not_signed_in` whose cause is the store sign-in (the
+ * hosted server's OAuth grant), not the Summer account: the Summer app, for
+ * one, is signed in to the account, so only the store approval link helps.
+ */
+function storeSignInAnswer(result) {
+    const first = result.content[0];
+    if (!first || first.type !== "text" || typeof first.text !== "string")
+        return false;
+    try {
+        const parsed = JSON.parse(first.text);
+        const error = parsed?.error;
+        return error?.code === "not_signed_in" && typeof error.details?.was === "string" && STORE_SIGN_IN_WAS.has(error.details.was);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * A `not_signed_in` / `store_login_required` answer gets one more text block:
+ * the sign-in link for the person (core/sign-in-link.ts). Anything else, or
+ * no link, leaves the result as it is. Never throws.
+ */
+export async function withSignInLink(result, code, links) {
+    if (!result || typeof result !== "object" || !Array.isArray(result.content))
+        return result;
+    const kind = storeSignInAnswer(result) ? "store" : signInKindForCode(code);
+    if (!kind)
+        return result;
+    try {
+        const url = await links.link(kind);
+        if (!url)
+            return result;
+        const original = result;
+        const text = signInLinkText(kind, url);
+        // A JSON answer gets the link inside it (signInUrl, and recovery says what
+        // to do), so a caller that parses it (the v4 operation layer runs 3.x
+        // tools and reads their JSON) keeps the code and passes the link on.
+        const first = original.content[0];
+        if (first && first.type === "text" && typeof first.text === "string") {
+            try {
+                const parsed = JSON.parse(first.text);
+                if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                    const answer = parsed;
+                    const nested = answer.error && typeof answer.error === "object" ? answer.error : null;
+                    const target = nested && typeof nested.code === "string" ? nested : answer;
+                    target.signInUrl = url;
+                    target.recovery = text;
+                    return { ...original, content: [{ ...first, text: JSON.stringify(answer) }, ...original.content.slice(1)] };
+                }
+            }
+            catch {
+                // plain text: the link goes in its own block below
+            }
+        }
+        return { ...original, content: [...original.content, { type: "text", text }] };
+    }
+    catch {
+        return result;
+    }
+}

package/dist/mcp/tool-surface.js

@@ -37,10 +37,14 @@ const LOCAL_TOOLSETS = {
         "summer_get_asset_download_url",
     ],
     ship: ["summer_export_game", "summer_export_templates", "summer_publish_build", "summer_go_live", "summer_store_set_details", "summer_capture_gameplay"],
-    ui: ["summer_ui_actions", "summer_ui_activate", "summer_ui_screenshot", "summer_ui_tree"],
+    // summer_view_set is in the catalog (engine.view_set, summer_call) for every profile.
+    ui: ["summer_ui_actions", "summer_ui_activate", "summer_ui_screenshot", "summer_ui_tree", "summer_view_set"],
     // Create and open a project on this computer with no shell (the full profile;
     // the engine profile's clients have a shell, `summer dev`, and a tool cap).
     projects: ["summer_projects_create_local", "summer_projects_open_local"],
+    // The Summer API (the assets and full profiles; the engine profile's clients
+    // have a shell, `summer login` and `summer api`, and a tool cap).
+    tools: ["summer_api_models", "summer_api_estimate", "summer_api_run", "summer_api_batch", "summer_api_job"],
 };
 const localToolset = new Map(Object.entries(LOCAL_TOOLSETS).flatMap(([set, names]) => names.map((name) => [name, set])));
 /** Hosted tool names by pattern, first match wins. Unknown names land in `other` (full only). */
@@ -185,6 +189,7 @@ const ADDITIVE_OR_TRANSIENT = new Set([
     "summer_open_scene",
     "summer_open_main_scene",
     "summer_select_node",
+    "summer_view_set",
     "summer_clear_console",
     "summer_play",
     "summer_stop",
@@ -208,6 +213,7 @@ const IDEMPOTENT_WRITES = new Set([
     "summer_open_scene",
     "summer_open_main_scene",
     "summer_select_node",
+    "summer_view_set",
     "summer_clear_console",
     "summer_stop",
     "summer_enable_plugin",

package/dist/mcp/tools/api-tools.d.ts

@@ -0,0 +1,50 @@
+/**
+ * summer_api_models, summer_api_estimate, summer_api_run, summer_api_batch,
+ * summer_api_job — the Summer API (core/summer-api.ts), the same calls as
+ * `summer api models|estimate|run|run --batch|jobs`. MCP adapter only: schemas and descriptions here.
+ * Runs and jobs use the Summer sign-in on this computer (summer login: Supabase OAuth, refreshed by itself).
+ */
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+export declare const apiModelsInputShape: {
+    model: z.ZodOptional<z.ZodString>;
+    capability: z.ZodOptional<z.ZodEnum<["image", "3d", "video", "voice", "dialogue", "sound", "music"]>>;
+};
+export declare const apiEstimateInputShape: {
+    model: z.ZodString;
+    input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+};
+export declare const apiRunInputShape: {
+    model: z.ZodString;
+    input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    quoteId: z.ZodOptional<z.ZodString>;
+    idempotencyKey: z.ZodOptional<z.ZodString>;
+    wait: z.ZodOptional<z.ZodBoolean>;
+    out: z.ZodOptional<z.ZodString>;
+};
+export declare const apiBatchInputShape: {
+    jobs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        model: z.ZodString;
+        input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        idempotencyKey: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        model: string;
+        input?: Record<string, unknown> | undefined;
+        idempotencyKey?: string | undefined;
+    }, {
+        model: string;
+        input?: Record<string, unknown> | undefined;
+        idempotencyKey?: string | undefined;
+    }>, "many">>;
+    batchId: z.ZodOptional<z.ZodString>;
+    idempotencyKey: z.ZodOptional<z.ZodString>;
+    wait: z.ZodOptional<z.ZodBoolean>;
+    out: z.ZodOptional<z.ZodString>;
+};
+export declare const apiJobInputShape: {
+    jobId: z.ZodString;
+    wait: z.ZodOptional<z.ZodBoolean>;
+    out: z.ZodOptional<z.ZodString>;
+    cancel: z.ZodOptional<z.ZodBoolean>;
+};
+export declare function registerApiTools(server: McpServer): void;

package/dist/mcp/tools/api-tools.js

@@ -0,0 +1,65 @@
+import { z } from "zod";
+import { batchToolResult, cancelJob, checkBatch, createBatch, estimateJob, getBatch, getJob, jobToolResult, listModels, runJob, summerApiToolAnswer, } from "../../core/summer-api.js";
+import { textJson } from "./text-json.js";
+const modelId = z.string().min(1).max(120).describe("A Summer API model id or alias from summer_api_models, e.g. 3d/default.");
+const modelInput = z.record(z.string(), z.unknown()).optional().describe("The model's input, matching its inputSchema from summer_api_models.");
+const out = z.string().min(1).optional().describe("A folder on this computer: save the finished job's files there (implies wait).");
+export const apiModelsInputShape = {
+    model: modelId.optional().describe("One model id or alias; without it, every model."),
+    capability: z.enum(["image", "3d", "video", "voice", "dialogue", "sound", "music"]).optional().describe("Only this kind."),
+};
+export const apiEstimateInputShape = { model: modelId, input: modelInput };
+export const apiRunInputShape = {
+    model: modelId,
+    input: modelInput,
+    quoteId: z.string().min(1).max(600).optional().describe("From summer_api_estimate: refuse to charge more than it quoted."),
+    idempotencyKey: z.string().min(1).max(200).optional().describe("Reuse to retry the same run without running it twice."),
+    wait: z.boolean().optional().describe("Follow the job until it finishes (up to about a minute in this call)."),
+    out,
+};
+export const apiBatchInputShape = {
+    jobs: z
+        .array(z.object({
+        model: modelId,
+        input: modelInput,
+        idempotencyKey: z.string().min(1).max(200).optional().describe("This job's own key; by default the batch key and the job's position."),
+    }))
+        .min(1)
+        .max(500)
+        .optional()
+        .describe("Up to 500 jobs, all or none. Leave out with batchId."),
+    batchId: z.string().min(1).max(200).optional().describe("Read a batch summer_api_batch answered, instead of starting one."),
+    idempotencyKey: z.string().min(1).max(200).optional().describe("Reuse to retry the same batch without queuing it twice."),
+    wait: z.boolean().optional().describe("Follow every job until it finishes (up to about a minute in this call)."),
+    out,
+};
+export const apiJobInputShape = {
+    jobId: z.string().min(1).max(200).describe("The job id summer_api_run answered."),
+    wait: z.boolean().optional().describe("Follow the job until it finishes (up to about a minute in this call)."),
+    out,
+    cancel: z.boolean().optional().describe("Ask to stop the job instead. Summer API jobs, queued or running, run to the end: the answer is unsupported."),
+};
+const answer = async (work) => {
+    const result = await summerApiToolAnswer(work);
+    return textJson(result, result.ok === false);
+};
+export function registerApiTools(server) {
+    server.tool("summer_api_models", "The Summer API's curated game-dev models: id, capability, input schema, output formats, typical time and price in USD. No sign-in needed. Next: summer_api_estimate for one exact request.", apiModelsInputShape, async (args) => answer(() => listModels(args)));
+    server.tool("summer_api_estimate", "The exact USD price of one Summer API job before it runs, what makes it up, and a quoteId that holds the price for 15 minutes. Charges nothing; no sign-in needed. Next: summer_api_run with the quoteId.", apiEstimateInputShape, async (args) => answer(() => estimateJob(args.model, args.input ?? {})));
+    server.tool("summer_api_run", "Run one Summer API job into the person's Summer assets with the Summer sign-in on this computer (the person runs summer login first). Spends their paid credits within this app's limit (Connected apps): say what you will make and estimate it first. Short jobs come back done; past the account's running slots a job answers queued at a held price and starts in order. wait follows it, out saves its files on this computer. no_credits (the paid balance) or over_limit (this app's limit): show the person the message and its link.", apiRunInputShape, async (args) => answer(async () => {
+        const follow = args.wait === true || typeof args.out === "string";
+        const job = await runJob(args.model, args.input ?? {}, {
+            ...(args.quoteId ? { quoteId: args.quoteId } : {}),
+            ...(args.idempotencyKey ? { idempotencyKey: args.idempotencyKey } : {}),
+            ...(follow ? { waitSeconds: 30 } : {}),
+        });
+        return jobToolResult(job, args);
+    }));
+    server.tool("summer_api_batch", "Run up to 500 Summer API jobs at once with the Summer sign-in on this computer, all or none: when the person's paid credits and this app's limit (Connected apps) cover every job, all are queued at their held prices and run in order; if not, nothing runs and the error (no_credits or over_limit) says how many fit and how much more is needed (show the person its link). Say what you will make and what it costs first. batchId reads a batch; wait follows it, out saves the finished files on this computer.", apiBatchInputShape, async (args) => answer(async () => {
+        if (args.batchId)
+            return batchToolResult(await getBatch(args.batchId), args);
+        const batch = await createBatch(checkBatch(args.jobs ?? []), args.idempotencyKey ? { idempotencyKey: args.idempotencyKey } : {});
+        return batchToolResult(batch, args);
+    }));
+    server.tool("summer_api_job", "Read a Summer API job: its state (queued, running, done, failed, ...), price and, when done, its assets and Summer file URLs. wait follows it, out saves its files on this computer.", apiJobInputShape, async (args) => answer(async () => (args.cancel ? { job: await cancelJob(args.jobId) } : jobToolResult(await getJob(args.jobId), args))));
+}

package/dist/mcp/tools/local-project-tools.d.ts

@@ -1,4 +1,18 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+/** The tool call's progress line (notifications/progress), when the client asked for progress. */
+export declare function progressReporter(extra: {
+    _meta?: {
+        progressToken?: string | number;
+    };
+    sendNotification?: (notification: {
+        method: "notifications/progress";
+        params: {
+            progressToken: string | number;
+            progress: number;
+            message?: string;
+        };
+    }) => Promise<void>;
+} | undefined): ((message: string) => void) | undefined;
 /**
  * projects.create_local and projects.open_local: what `summer dev` does, for
  * agents with no shell (core/capabilities/projects-local.ts).

package/dist/mcp/tools/local-project-tools.js

@@ -16,6 +16,17 @@ async function localProjectResult(operation) {
         throw error;
     }
 }
+/** The tool call's progress line (notifications/progress), when the client asked for progress. */
+export function progressReporter(extra) {
+    const token = extra?._meta?.progressToken;
+    const send = extra?.sendNotification;
+    if (token === undefined || !send)
+        return undefined;
+    let step = 0;
+    return (message) => {
+        void send({ method: "notifications/progress", params: { progressToken: token, progress: ++step, message } }).catch(() => undefined);
+    };
+}
 /**
  * projects.create_local and projects.open_local: what `summer dev` does, for
  * agents with no shell (core/capabilities/projects-local.ts).
@@ -26,8 +37,8 @@ export function registerLocalProjectTools(server) {
         name: z.string().max(80).optional().describe("The project's name and folder name. Default my-game (or the template's name)."),
         dir: z.string().max(1000).optional().describe("The project folder: a new or empty folder, not inside another project; ~ is home. Default <name> next to the session's project, in the session's folder, or in ~/Documents/Summer."),
     }, async (args) => localProjectResult(() => createLocalProject(args, currentMcpEngineSelection()?.cwd)));
-    server.tool("summer_projects_open_local", "Open a project on this computer in Summer Engine, in the background, and wait until it connects (an editor that has it open is used as it is); this session's engine tools then work on it. When Summer Engine is not installed it answers engine_not_running: ask the person, and only with their yes call again with install: true (about 660 MB, free). A first open can take a few minutes: the answer says to call again. It adds summer-preview to the session folder's .claude/launch.json (Claude Code Desktop's Browser pane), and preview.url is where the game shows. Next: summer_get_project_context.", {
+    server.tool("summer_projects_open_local", "Open a project on this computer in Summer Engine, in the background, and wait until it connects (an editor that has it open is used as it is; an editor with another project open switches to it in the same window); this session's engine tools then work on it. When Summer Engine is not installed it answers engine_not_running: ask the person, and only with their yes call again with install: true (about 660 MB, free). A first open can take a few minutes: the answer says to call again. It adds summer-preview to the session folder's .claude/launch.json (Claude Code Desktop's Browser pane), and preview.url is where the game shows. Next: summer_get_project_context.", {
         path: z.string().max(1000).optional().describe("The project folder (holds project.godot), e.g. projectPath from summer_projects_create_local. Default this session's project."),
         install: z.boolean().default(false).describe("Install Summer Engine first when it is missing. Set true only after the person said yes."),
-    }, async (args) => localProjectResult(() => openLocalProject(args, currentMcpEngineSelection(), { log: logEngineSelfStart }, (root, client) => bindMcpProject(root, client))));
+    }, async (args, extra) => localProjectResult(() => openLocalProject(args, currentMcpEngineSelection(), { log: logEngineSelfStart, progress: progressReporter(extra) }, (root, client) => bindMcpProject(root, client))));
 }

package/dist/mcp/tools/navigation-tools.js

@@ -18,6 +18,7 @@ params: slot values — gameId + section (builds, releases, store-page, analytic
 open: false resolves only and returns url (+ login_url when the page needs login) or op; nothing opens, no engine needed.
 
 Result: { ok, action: opened | printed | listed | ambiguous | unsupported | engine_not_running | engine_error | not_found | invalid_params | open_failed | blocked_origin, target (with availability for editor ids), url, login_url, logged_in, opened_url, op, engine, failure_reason, matches, hint }.
+- Studio pages (/studio...) open in the Summer app's own Studio tab when the running engine advertises the studio destination (op Navigate target studio; result hint says so); otherwise in the browser.
 - Web targets that require login open through /login?returnUrl=<path> when this machine holds no Summer login token (logged_in:false) — the destination loads after sign-in.
 - Editor targets need Summer Engine running with the project open; otherwise action engine_not_running with the op that would have been sent and a 'summer run' hint. Nothing was opened.
 - Editor destinations are forwarded to the engine's own navigation table (op Navigate; ids advertised in /api/health capabilities.navigation). On an engine that predates it, scene/node/script/file and the three docks still work through their original ops; anything else answers action unsupported with failure_reason engine_lacks_op and an update hint. Never claim those opened. Listing (no target) shows each editor id's availability from the connected engine.

package/dist/mcp/tools/scene-tools.js

@@ -1,3 +1,4 @@
+import { viewSetOp } from "../../core/capabilities/view-set.js";
 import { z } from "zod";
 import { withEngine, ToolInputError } from "./with-engine.js";
 import { executeSceneMutation } from "../../core/capabilities/engine-ops.js";
@@ -245,6 +246,12 @@ PERSISTENCE IS VERIFIED: the engine's ConnectSignal op connects without CONNECT_
             op.scenePath = scenePath;
         return client.executeOps([op]);
     }));
+    server.tool("summer_view_set", "Show the person what you are working on: the editor's view (home, chat, 3d, 2d, script, game, studio), its right rail (files, scene, inspector, output, none), what to focus (a res:// script or scene, or a node path) and the nodes to frame the camera on. Changes only what is on screen. The navigate-summer skill says which view fits which moment.", {
+        view: z.enum(["home", "chat", "3d", "2d", "script", "game", "studio"]).describe("The view to show"),
+        rail: z.enum(["files", "scene", "inspector", "output", "none"]).optional().describe("The right rail; none hides it"),
+        focus: z.string().optional().describe("A res:// script or scene, or a node path"),
+        frame: z.array(z.string()).optional().describe("Node paths to frame the camera on"),
+    }, async ({ view, rail, focus, frame }) => withEngine(async (client) => client.executeOps([viewSetOp({ view, rail, focus, frame })])));
     server.tool("summer_replace_node", `Replace a node with a different scene/model or node type, keeping its parent, sibling index, name, transform and property overrides, and the children the scene added under it. Use it to swap a kit piece for another (a wall host for a door host), a placeholder for a prefab, or a StaticBody3D for a RigidBody3D.
 
 Give exactly one of scene or type. The scenePath must be a .tscn.

package/dist/project-memory/agent-instructions.js

@@ -36,10 +36,18 @@ export function renderAgentsBlock(commands = projectCommands()) {
         "",
         "This is a game made with Summer Engine, the game engine built for AI. Game code is GDScript (`.gd`), scenes are `.tscn`, resources are `.tres`, and `project.godot` is the project file.",
         "",
+        "## First game: make it look finished",
+        "",
+        "People judge Summer by the first frame of their first game, so make it look finished even when they ask for a quick prototype. Keep the features they asked for and raise the look:",
+        "- sky and sun with shadows, tonemapping, a little fog;",
+        "- a texture on every surface, and real models for the player, characters and main props (the starter project and the Summer asset library first), never capsules or boxes as final art;",
+        "- one colour palette and a styled UI font.",
+        "Before you say it is ready, play it and look at a screenshot of the running game, not the editor: the editor shows a preview sky and sun that the game does not have.",
+        "",
         "## How to work on it",
         "",
-        "- Change scenes through Summer while Summer Engine has the project open. The editor rewrites `.tscn` files when it saves, so hand edits get lost.",
-        "- With Summer's MCP server, call the `summer_*` tools and start with `summer_get_project_context`. Without it, run the same operations as `summer` commands in the shell (the `summer-cli` skill). If `summer` is missing or older than 4.0, use `npx -y summer-engine@latest` in its place.",
+        "- Write GDScript (`.gd`) files directly. Create and change scenes and import assets through Summer while Summer Engine has the project open: it imports new files, and the editor rewrites `.tscn` files when it saves, so hand edits to an open scene get lost.",
+        "- With Summer's MCP server, use the `summer_*` tools; `summer_get_project_context` tells you which project you are connected to. Without it, run the same operations as `summer` commands in the shell (the `summer-cli` skill). If `summer` is missing or older than 4.0, use `npx -y summer-engine@latest` in its place.",
         "- Summer's skills teach each part of a game. `npx -y summer-engine@latest setup <agent> --yes` installs them for your agent (add `--cli` for no MCP server). Start with `using-summer`, and find the right one with `summer docs search --query \"<the task>\"`.",
         "- `.summer/` is the project's memory: `GameSoul.md` says what the game is, `memory/` holds the decisions to keep. Read them before you change the game's look, sound or story.",
         "- Check your own work: script errors, a screenshot, a play run. Ask the person to play only for feel and fun.",
@@ -50,7 +58,7 @@ export function renderAgentsBlock(commands = projectCommands()) {
         "",
         "## Publishing",
         "",
-        "The `publish-your-game` skill has the steps; `summer ops search \"publish my game\"` finds each operation. `summer store publish` sends the game to Summer's store review, and the game's owner approves it: give them the link it prints. Nothing goes live until they approve.",
+        "The `publish-your-game` skill has the steps; `summer ops search \"publish my game\"` finds each operation. Going live needs the game owner's yes. A game goes live as soon as Summer's automated checks pass; Summer's staff review it after it is live, so never tell anyone to wait for a review.",
         SUMMER_BLOCK_END,
     ].join("\n");
 }

package/gemini-extension.json

@@ -1,7 +1,7 @@
 {
   "_generated": "GENERATED from integrations/gemini — do not edit; npm run generate:registry",
   "name": "summer",
-  "version": "4.5.0",
+  "version": "4.8.0",
   "description": "The game engine built for AI. Any agent makes a multiplayer game and publishes it. The Summer Engine MCP server, context primer and game-dev skills.",
   "contextFileName": "GEMINI.md",
   "mcpServers": {
@@ -27,7 +27,6 @@
     "./library/skills/3d-lighting/",
     "./library/skills/adaptive-music/",
     "./library/skills/agent-playtesting/",
-    "./library/skills/ai-characters-in-games/",
     "./library/skills/ambient-bed/",
     "./library/skills/animated-loop/",
     "./library/skills/animation-tree/",
@@ -107,6 +106,7 @@
     "./library/skills/store-art/",
     "./library/skills/store-listing/",
     "./library/skills/summer-analytics/",
+    "./library/skills/summer-api/",
     "./library/skills/summer-apps/",
     "./library/skills/summer-apps-design/",
     "./library/skills/summer-assets/",
@@ -117,6 +117,7 @@
     "./library/skills/summer-matchmaking/",
     "./library/skills/summer-parties/",
     "./library/skills/summer-player-data/",
+    "./library/skills/summer-router/",
     "./library/skills/summer-store/",
     "./library/skills/summer-world-chat/",
     "./library/skills/summer-world-saves/",

package/library/references/mcp-tools-reference/mcp-tools-reference.md

@@ -19,7 +19,7 @@
 
 **Rule of thumb:** project reads/writes go through Summer; live hierarchy/inspector changes use scene tools; process-level work remains with the host.
 
-## Tool surface (125 tools)
+## Tool surface (131 tools)
 
 ### Local projects (2)
 
@@ -93,7 +93,7 @@ No shell needed (Claude Desktop, chat apps); the `summer dev` command does both
 |---|---|
 | `summer_fabricate_3d` | Run a Blender Python (bpy) script in the user's OWN installed Blender — headless, engine-supervised — then import the exported `.glb` into `res://` and optionally instantiate it with `target_size`. For modular kits with exact dimensions, VFX meshes (shatter, sweeps, LOD chains), and post-processing generated models (decimate/UV/bake); generic props go to the library and characters to generation. Requires Blender on the machine (never bundled); `blender_not_found` carries the fix. The `fabricating-assets` skill has the bpy rules that survive glTF export. |
 
-### Editor UI control (4)
+### Editor UI control (5)
 
 Preview: needs Summer Engine 0.5.66 or newer; older engines return `engine_lacks_op`. Scene work never goes through the editor UI (use the scene, scripting, and perception tools). UI ops are for editor-workflow steps a human does with the mouse — open Project Settings, switch the main screen, clear a blocking dialog, read a dock. Ladder: dedicated tool → named action → tree + activate → screenshot (pixels last, never for coordinates). Quit / project-reload / delete-without-confirm actions are denied by the engine. The `driving-the-editor-ui` skill carries the patterns.
 
@@ -103,6 +103,7 @@ Preview: needs Summer Engine 0.5.66 or newer; older engines return `engine_lacks
 | `summer_ui_tree` | Structured Control tree of the live editor UI (class, path, rect, text/tooltip, `checked`/`enabled`/`tabs`/`current_tab`/`value`) from `root:"main" \| "window" \| "dock:<title\|id>" \| "dialog:<title>" \| "path:<node path>"`; `root:"dialogs"` lists every visible dialog/popup with `blocking`, `blocking_dialog`, and its `buttons`. The token-cheap alternative to a screenshot; its paths are what `summer_ui_activate` takes. |
 | `summer_ui_activate` | Activate one control by tree path through its own input path — `press`, `toggle`, `focus`, `select_tab` (incl. `path:"main_screen" value:"3D"`), `set_text` (+`submit`), `set_value` — and `action:"dismiss_dialog"` (by `path` or `title`, `button` cancel/ok/text) to clear a blocking dialog. `state` / `visible_after` are read back after the action, never echoed. |
 | `summer_ui_screenshot` | PNG of the editor window or one dock/dialog/control (`root`, `max_size`) returned as an image — the pixels-last fallback for LOOKING at the editor UI. Not for scene verification (`summer_screenshot`) and never for picking click coordinates. Honest `no_renderer` under a headless editor. |
+| `summer_view_set` (`engine.view_set`) | Show the person what you work on: the frame's view (home, chat, 3D, 2D, script, game, Studio), the right rail, the focus and the nodes to frame. Use it when you start editing a scene or script, play the game, or finish on the best view of the result; not for reading a node (`summer_inspect_node`) or opening a web page (`studio.open`). Needs Summer Engine 4.6 or newer. |
 
 ### Perception (4)
 
@@ -291,6 +292,18 @@ These come from the hosted Summer server (the one ChatGPT and Claude connect to)
 | `summer_docs_search` | Search the library (skills, tools, templates, references, examples, collections) by describing the task in plain words; ranked ids with `matched_by` (lexical / semantic). The first move for any task; works without the engine. |
 | `summer_docs_read` | Load one entry by id: a skill's SKILL.md plus metadata, a tool's call recipe, a template's pin, a reference's body. A body ends with its relative links and the id that loads each; a linked file loads by `<entry id>/<link as written>` (e.g. `skill/spatial-placement/references/kit-placement-tools.md`). The last line is the `entry_id` footer to report through `docs.feedback`. |
 
+### Summer API (5)
+
+Signed in with `summer login` (one browser sign-in on this computer, renewed by itself; `summer token` prints a one-hour token for the person's own HTTP code). Each app spends the person's paid credits up to the limit they set in Connected apps. No rate limits on paid usage: jobs past the account's running slots (10 at once, up to 40 as it buys credits) answer `queued` and start in order. Money is the only refusal: `no_credits` (the paid balance) or `over_limit` (the app's own limit). The `summer-api` skill has the workflow.
+
+| Tool | Use |
+|---|---|
+| `summer_api_models` (`models.list`) | The Summer API's curated game-dev models: id, capability, input schema, output formats, typical time and USD price; `model` for one, `capability` to filter. No sign-in. Shell: `summer api models`. |
+| `summer_api_estimate` (`models.estimate`) | The exact USD price of one job, its breakdown and a `quoteId` that holds it 15 minutes. Charges nothing. Shell: `summer api estimate`. |
+| `summer_api_run` (`models.run`) | Run one job into the person's Summer assets with the Summer sign-in on this computer; spends paid credits within the app's limit. `wait` follows it, `out` saves its files, `quoteId` caps the charge. Shell: `summer api run --wait --download`. |
+| `summer_api_batch` (`POST /v1/batches`) | Run up to 500 jobs at once, all or none: queued at held prices when paid credits and the app's limit cover them all; otherwise nothing runs and the error says how many fit. `batchId` reads a batch; `wait` and `out` as for one job. Shell: `summer api run --batch jobs.jsonl --wait --download`. |
+| `summer_api_job` (`jobs.get`, `jobs.cancel`) | Read a job (state, price, assets and file URLs); `wait`, `out` or `cancel`. Shell: `summer api jobs`. |
+
 ### Library feedback (1)
 
 | Tool | Use |

package/library/references/mcp-tools-reference/resource.yaml

@@ -1,6 +1,6 @@
 id: reference/mcp-tools-reference
 kind: reference
-version: 1.4.2
+version: 1.4.3
 summary: Canonical reference for which Summer MCP tool to call — skills should reference tool names exactly as written here.
 use_when:
   - choosing between Summer MCP tools and host tools for an operation