summer-engine 3.5.2 → 3.7.0

package/dist/core/capabilities/sfx-choices.js

@@ -0,0 +1,253 @@
+import { z } from "zod";
+/**
+ * Sound-effect choices (summer_generate_sfx_choices + summer_get_choices).
+ *
+ * Sound-effect models differ a lot from one sound to the next, so the agent
+ * can make one sound with several models and let the person pick by ear:
+ * POST /api/mcp/generate/audio/choices makes the versions and a choice set,
+ * the person listens and approves one or more on the Studio page
+ * /studio/choices/<id>, and GET /api/mcp/choices/<id> reads the decision.
+ * The server queues the page for the person's open Studio tab itself
+ * (studioTab.queued); only when no tab took it does this open a browser.
+ * An approval makes that model the person's default for later
+ * summer_generate_audio sound_effects calls without a modelId.
+ *
+ * One implementation for both faces: the MCP tools (generate-tools.ts) and
+ * `summer tool generate-sfx-choices` / `get-choices` (tool-dispatch.ts) pass
+ * their own gateway request functions and share everything else here.
+ */
+export const SFX_MODEL_IDS = ["eleven_text_to_sound_v2", "sonilo-sfx-1.1", "stable-audio-3-sfx"];
+export const SFX_CHOICES_ENDPOINT = "/api/mcp/generate/audio/choices";
+export const CHOICES_ENDPOINT_PREFIX = "/api/mcp/choices/";
+/** Three models run in parallel on the server; the slowest decides. */
+export const SFX_CHOICES_TIMEOUT_MS = 240_000;
+export const MAX_CHOICES_WAIT_SECONDS = 50;
+export const sfxChoicesArgsSchema = z.object({
+    text: z
+        .string()
+        .min(1)
+        .max(1000)
+        .describe("The sound to make, written as a Foley description (what hits what, the attack and the tail, close-mic, dry)"),
+    durationSeconds: z
+        .number()
+        .positive()
+        .max(30)
+        .optional()
+        .describe("Exact length in seconds. One-shots 0.5-2; animation-synced sounds match the animation. stable-audio-3-sfx needs >= 1, sonilo-sfx-1.1 >= 0.5"),
+    loop: z
+        .boolean()
+        .optional()
+        .describe("Ask for a seamless loop (eleven_text_to_sound_v2 only; say 'seamless loop' in text too)"),
+    models: z
+        .array(z.enum(SFX_MODEL_IDS))
+        .min(2)
+        .max(4)
+        .optional()
+        .describe("2-4 model ids to compare. Default: eleven_text_to_sound_v2, sonilo-sfx-1.1, stable-audio-3-sfx"),
+    open: z
+        .boolean()
+        .default(true)
+        .describe("Show the choices page in the browser when no open Studio tab took it. false: no browser, only return the URL"),
+});
+export const getChoicesArgsSchema = z.object({
+    choiceSetId: z.string().min(1).max(200).describe("The choiceSetId from summer_generate_sfx_choices"),
+    waitSeconds: z
+        .number()
+        .int()
+        .min(0)
+        .max(MAX_CHOICES_WAIT_SECONDS)
+        .optional()
+        .describe("Wait up to this many seconds (max 50) for the person to decide before answering. 0 or omitted: answer now"),
+});
+// ---------------------------------------------------------------------------
+// Showing the page
+// ---------------------------------------------------------------------------
+function hostOf(url) {
+    try {
+        return new URL(url).hostname.toLowerCase();
+    }
+    catch {
+        return null;
+    }
+}
+function isSummerHost(host) {
+    return host === "summerengine.com" || (host?.endsWith(".summerengine.com") ?? false);
+}
+function isLoopback(host) {
+    return host === "localhost" || host === "127.0.0.1" || host === "[::1]" || host === "::1";
+}
+/** Same rule as summer_open: a browser only ever opens summerengine.com, its subdomains, or loopback. */
+export function canOpenReviewUrl(url) {
+    const host = hostOf(url);
+    return isSummerHost(host) || isLoopback(host);
+}
+/** False where a browser launch cannot reach the person: CI, or Linux with no display. */
+export function defaultCanOpenBrowser(env = process.env, platform = process.platform) {
+    if (env.CI)
+        return false;
+    if (platform === "linux" && !env.DISPLAY && !env.WAYLAND_DISPLAY)
+        return false;
+    return true;
+}
+/** The server's studioTab answer: queued for the person's open tab, or why not. Missing on older servers. */
+function studioTabAnswer(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    const record = value;
+    return {
+        queued: record.queued === true,
+        ...(typeof record.reason === "string" ? { reason: record.reason } : {}),
+    };
+}
+async function showChoicesPage(reviewUrl, studioTab, deps) {
+    const notQueued = studioTab ? (studioTab.reason ?? "not_queued") : undefined;
+    if (!canOpenReviewUrl(reviewUrl))
+        return { shown: "not_opened", studioTab: notQueued, browser: "not_a_summer_url" };
+    if (!deps.canOpenBrowser())
+        return { shown: "not_opened", studioTab: notQueued, browser: "no_browser_here" };
+    try {
+        await deps.openUrl(reviewUrl);
+        return { shown: "browser", studioTab: notQueued };
+    }
+    catch (error) {
+        return { shown: "not_opened", studioTab: notQueued, browser: error instanceof Error ? error.message : String(error) };
+    }
+}
+// ---------------------------------------------------------------------------
+// summer_generate_sfx_choices
+// ---------------------------------------------------------------------------
+export function sfxChoicesRequestBody(args) {
+    const body = { capability: "sound_effects", text: args.text };
+    if (args.durationSeconds !== undefined)
+        body.durationSeconds = args.durationSeconds;
+    if (args.loop !== undefined)
+        body.loop = args.loop;
+    if (args.models)
+        body.models = args.models;
+    return body;
+}
+function clipSummary(clip) {
+    return {
+        clipId: clip.clipId,
+        modelId: clip.modelId,
+        modelName: clip.modelName,
+        audioUrl: clip.audioUrl,
+        assetId: clip.assetId,
+        durationSeconds: clip.durationSeconds,
+    };
+}
+export async function generateSfxChoices(args, deps) {
+    const reply = await deps.post(SFX_CHOICES_ENDPOINT, sfxChoicesRequestBody(args), SFX_CHOICES_TIMEOUT_MS);
+    if (reply.error) {
+        return { ok: false, error: reply.error, ...(reply.data ? { details: reply.data } : {}) };
+    }
+    const data = reply.data ?? {};
+    const clips = Array.isArray(data.clips) ? data.clips : [];
+    const failed = Array.isArray(data.failed) ? data.failed : [];
+    const choiceSetId = typeof data.choiceSetId === "string" ? data.choiceSetId : null;
+    const reviewUrl = typeof data.reviewUrl === "string" ? data.reviewUrl : null;
+    const studioPath = typeof data.studioPath === "string" ? data.studioPath : undefined;
+    if (!choiceSetId || !reviewUrl || clips.length === 0) {
+        return {
+            ok: false,
+            error: clips.length === 0 ? "No model made a version of this sound." : "The server did not return a choice set.",
+            failed,
+            hint: "Read failed[] for each model's error. Fix the request (a longer durationSeconds, a plainer description) or call summer_generate_audio with one modelId.",
+        };
+    }
+    // The server queued the Studio-tab open already; that happens even with
+    // open:false, so report it rather than hide it.
+    const studioTab = studioTabAnswer(data.studioTab);
+    const shown = studioTab?.queued
+        ? { shown: "studio_tab" }
+        : args.open
+            ? await showChoicesPage(reviewUrl, studioTab, deps)
+            : { shown: "not_opened", browser: "open_false" };
+    const count = clips.length;
+    const where = shown.shown === "studio_tab"
+        ? "I opened them in your Summer Studio tab"
+        : shown.shown === "browser"
+            ? "I opened them in your browser"
+            : `Open ${reviewUrl} to hear them`;
+    const say = `I made ${count} versions of this sound with ${count} different models. ${where}. Listen, approve the ones you like (one or more), then tell me. The model you approve becomes your default for sound effects.`;
+    return {
+        ok: true,
+        choiceSetId,
+        prompt: typeof data.prompt === "string" ? data.prompt : args.text,
+        reviewUrl,
+        ...(studioPath ? { studioPath } : {}),
+        shown: shown.shown,
+        ...(shown.studioTab || shown.browser
+            ? { notShownBecause: { ...(shown.studioTab ? { studioTab: shown.studioTab } : {}), ...(shown.browser ? { browser: shown.browser } : {}) } }
+            : {}),
+        clips: clips.map(clipSummary),
+        failed,
+        say,
+        next: `Tell the person the "say" text (include reviewUrl when shown is "not_opened"). Do not pick for them. Then call summer_get_choices with choiceSetId "${choiceSetId}" and waitSeconds ${MAX_CHOICES_WAIT_SECONDS}; call it again while status is "pending".`,
+    };
+}
+// ---------------------------------------------------------------------------
+// summer_get_choices
+// ---------------------------------------------------------------------------
+function fileExtension(url) {
+    if (!url)
+        return "wav";
+    try {
+        const match = /\.(wav|mp3|ogg)$/i.exec(new URL(url).pathname);
+        return match ? match[1].toLowerCase() : "wav";
+    }
+    catch {
+        return "wav";
+    }
+}
+export function choicesEndpoint(choiceSetId) {
+    return `${CHOICES_ENDPOINT_PREFIX}${encodeURIComponent(choiceSetId)}`;
+}
+export function choicesTimeoutMs(waitSeconds) {
+    return ((waitSeconds ?? 0) + 20) * 1000;
+}
+export async function getChoices(args, deps) {
+    const params = new URLSearchParams();
+    if (args.waitSeconds)
+        params.set("waitSeconds", String(args.waitSeconds));
+    const reply = await deps.get(choicesEndpoint(args.choiceSetId), params, choicesTimeoutMs(args.waitSeconds));
+    if (reply.error) {
+        return { ok: false, error: reply.error, ...(reply.data ? { details: reply.data } : {}) };
+    }
+    const data = reply.data ?? {};
+    const clips = Array.isArray(data.clips) ? data.clips : [];
+    const status = data.status === "decided" ? "decided" : "pending";
+    const approved = clips
+        .filter((clip) => clip.approved === true)
+        .map((clip) => ({
+        ...clipSummary(clip),
+        ...(clip.note ? { note: clip.note } : {}),
+        fileExtension: fileExtension(clip.audioUrl),
+    }));
+    let next;
+    if (status === "pending") {
+        next = `The person has not decided yet. Call summer_get_choices again with waitSeconds ${MAX_CHOICES_WAIT_SECONDS}, or wait until they say they picked. Do not pick for them.`;
+    }
+    else if (approved.length === 0) {
+        next = "They approved none. Ask what to change (the description, the length, the models) and run summer_generate_sfx_choices again.";
+    }
+    else {
+        next =
+            "Import each approved clip into the project: summer_import_from_url({ url: audioUrl, path: \"res://audio/sfx/<name>.<fileExtension>\" }) " +
+                "or summer_import_asset_by_id({ assetId, path }). Read each clip's note. Then wire it (sound-effect skill, step Wire). " +
+                (typeof data.preferredModelId === "string"
+                    ? `Their default sound-effect model is now ${data.preferredModelId}: later summer_generate_audio sound_effects calls without modelId use it.`
+                    : "");
+    }
+    return {
+        ok: true,
+        choiceSetId: typeof data.choiceSetId === "string" ? data.choiceSetId : args.choiceSetId,
+        kind: data.kind,
+        prompt: data.prompt,
+        status,
+        preferredModelId: data.preferredModelId ?? null,
+        approved,
+        clips: clips.map((clip) => ({ ...clipSummary(clip), approved: clip.approved === true, ...(clip.note ? { note: clip.note } : {}) })),
+        next: next.trim(),
+    };
+}

package/dist/core/capabilities/tool-dispatch.js

@@ -30,6 +30,7 @@ import { lookupApiDocs } from "./api-docs.js";
 import { BOARD_ENDPOINT, boardArgsSchema, boardQuery } from "./board.js";
 import { IMAGE_GENERATION_TIMEOUT_MS, imageGenerationArgsSchema, saveGeneratedImage } from "./image-generation.js";
 import { buildMotionRequestBody, motionGenerationArgsSchema } from "./motion-generation.js";
+import { defaultCanOpenBrowser, generateSfxChoices, getChoices, getChoicesArgsSchema, sfxChoicesArgsSchema, } from "./sfx-choices.js";
 import { ImportHdriError, importHdriArgsSchema, importPolyHavenHdri } from "./hdri-import.js";
 import { FABRICATE_FALLBACK, buildFabricateMeshOp, fabricateArgsSchema } from "./fabricate-mesh.js";
 import { buildUiActionsOp, buildUiActivateOp, buildUiScreenshotOp, buildUiTreeOp, executeUiOp, uiActionsArgsSchema, uiActivateArgsSchema, uiScreenshotArgsSchema, uiScreenshotCaption, uiScreenshotImage, uiTreeArgsSchema, withUiFailureDetails, } from "./ui-control.js";
@@ -46,12 +47,11 @@ import { getAuthToken } from "../auth.js";
 import open from "open";
 import { openArgsSchema, runOpen } from "./navigation/open.js";
 import { shapeEngineLogResponse } from "../log-filters.js";
-import { listCreatorReleases, publishCreator, } from "./creator.js";
 import { exportGame } from "./export-game.js";
 import { exportTemplates } from "./export-templates.js";
 import { captureGameplay } from "./capture-gameplay.js";
 import { publishBuild } from "./publish-build.js";
-import { CONFIG_KEYS, getConfigValue, isConfigKey, readSummerConfig, resolveGatewayUrl, setConfigValue, unsetConfigValue, } from "../config.js";
+import { resolveGatewayUrl } from "../config.js";
 import { createDebugReportArtifact } from "./debug-report.js";
 import { buildGameTaskPlan, gameTaskPlanInputSchema } from "./game-task-plan.js";
 import { buildProjectContext, projectContextInputSchema, projectSettingValue, } from "./project-context.js";
@@ -393,6 +393,25 @@ function optStr(args, key) {
 }
 /** Validate CLI args against the SAME zod schema the MCP face uses, so the
  *  two surfaces reject the same inputs with a readable message. */
+/** The gateway helpers as the shared sfx-choices module expects them: a reply, never a throw. */
+async function gatewayReply(call) {
+    try {
+        return { data: await call(), status: 200 };
+    }
+    catch (error) {
+        if (!(error instanceof ToolDispatchError))
+            throw error;
+        return { error: error.message, status: 0 };
+    }
+}
+function sfxChoicesDeps() {
+    return {
+        post: (endpoint, body, timeoutMs) => gatewayReply(() => gatewayPost(endpoint, body, timeoutMs)),
+        get: (endpoint, params, timeoutMs) => gatewayReply(() => gatewayGet(endpoint, params, timeoutMs)),
+        openUrl: (url) => open(url),
+        canOpenBrowser: () => defaultCanOpenBrowser(),
+    };
+}
 function parseToolArgs(schema, args, tool) {
     const parsed = schema.safeParse(args);
     if (parsed.success)
@@ -653,56 +672,6 @@ export const TOOL_DISPATCH = [
         ...(typeof args.waitSeconds === "number" ? { waitSeconds: args.waitSeconds } : {}),
         face: "cli",
     })),
-    entry("summer_creator_publish", "Deprecated: publish a .pck to the legacy creator API; use publish-build", false, (args) => publishCreator({
-        project: optStr(args, "project"),
-        artifact: optStr(args, "artifact"),
-        version: optStr(args, "version"),
-        manifest: optStr(args, "manifest"),
-        projectId: optStr(args, "projectId"),
-        channel: optStr(args, "channel"),
-        notes: optStr(args, "notes"),
-        confirm: args.confirm === true,
-        face: "cli",
-    })),
-    entry("summer_creator_releases", "Deprecated: list releases on the legacy creator API; use summer_store_releases", false, (args) => listCreatorReleases({
-        projectId: optStr(args, "projectId"),
-        limit: typeof args.limit === "number" ? args.limit : 20,
-        cursor: optStr(args, "cursor"),
-        face: "cli",
-    })),
-    entry("summer_creator_config", "Read or update the shared non-secret Summer configuration", false, async (args) => {
-        const action = str(args, "action");
-        if (action === "list") {
-            const config = await readSummerConfig();
-            return {
-                ok: true,
-                values: Object.fromEntries(CONFIG_KEYS.map((name) => [name, getConfigValue(config, name) ?? null])),
-            };
-        }
-        const key = optStr(args, "key");
-        if (!key || !isConfigKey(key)) {
-            throw new ToolDispatchError(`A valid key is required. Use one of ${CONFIG_KEYS.join(", ")}.`);
-        }
-        if (action === "get") {
-            return { ok: true, key, value: getConfigValue(await readSummerConfig(), key) ?? null };
-        }
-        if (args.confirm !== true) {
-            throw new ToolDispatchError(`Changing ${key} requires confirmation. Retry with "confirm": true after the user approves the exact change.`);
-        }
-        if (action === "set") {
-            const value = optStr(args, "value");
-            if (value === undefined) {
-                throw new ToolDispatchError(`A value is required for ${key}.`);
-            }
-            const config = await setConfigValue(key, value);
-            return { ok: true, key, value: getConfigValue(config, key) };
-        }
-        if (action === "unset") {
-            const config = await unsetConfigValue(key);
-            return { ok: true, key, value: getConfigValue(config, key) ?? null };
-        }
-        throw new ToolDispatchError(`Unknown action "${action}". Use list, get, set, or unset.`);
-    }),
     // --- debug ---
     entry("summer_get_diagnostics", "Overview of editor console and runtime debugger errors/warnings", true, async (args, ctx) => requireEngineSuccess(await (await ctx.engine()).getDiagnostics())),
     entry("summer_get_console", "Read recent editor Output panel messages (deduplicated)", true, async (args, ctx) => {
@@ -917,12 +886,26 @@ export const TOOL_DISPATCH = [
         }
         if (typeof args.durationSeconds === "number")
             body.durationSeconds = args.durationSeconds;
+        if (typeof args.loop === "boolean")
+            body.loop = args.loop;
         if (Array.isArray(args.inputs))
             body.inputs = args.inputs;
         if (args.options)
             body.options = args.options;
         return gatewayPost("/api/mcp/generate/audio", body);
     }),
+    entry("summer_generate_sfx_choices", "Make one sound effect with several models and show them for the person to pick", false, async (args) => {
+        const result = await generateSfxChoices(parseToolArgs(sfxChoicesArgsSchema, args, "generate-sfx-choices"), sfxChoicesDeps());
+        if (result.ok !== true)
+            throw new ToolResultError(result, String(result.error));
+        return result;
+    }),
+    entry("summer_get_choices", "Read which sound-effect versions the person approved", false, async (args) => {
+        const result = await getChoices(parseToolArgs(getChoicesArgsSchema, args, "get-choices"), sfxChoicesDeps());
+        if (result.ok !== true)
+            throw new ToolResultError(result, String(result.error));
+        return result;
+    }),
     entry("summer_generate_3d", "Generate a 3D model (optional auto-rig + animations)", false, async (args) => {
         const options = {
             ...(args.options ?? {}),

package/dist/core/config.d.ts

@@ -3,13 +3,8 @@ export interface SummerConfig {
     gateway?: {
         url?: string;
     };
-    creator?: {
-        apiUrl?: string;
-        projectId?: string;
-        channel?: string;
-    };
 }
-export declare const CONFIG_KEYS: readonly ["gateway.url", "creator.apiUrl", "creator.projectId", "creator.channel"];
+export declare const CONFIG_KEYS: readonly ["gateway.url"];
 export type ConfigKey = (typeof CONFIG_KEYS)[number];
 export declare function readSummerConfig(): Promise<SummerConfig>;
 export declare function getConfigValue(config: SummerConfig, key: ConfigKey): string | undefined;
@@ -27,4 +22,3 @@ export declare function isConfigKey(value: string): value is ConfigKey;
  * Returns an origin-like base without a trailing slash.
  */
 export declare function resolveGatewayUrl(): Promise<string>;
-export declare function getCreatorApiUrl(): Promise<string>;

package/dist/core/config.js

@@ -1,13 +1,7 @@
 import { readStoreJson, writeStoreJson } from "./store.js";
 const CONFIG_FILE = "config.json";
 const DEFAULT_GATEWAY_URL = "https://www.summerengine.com";
-const DEFAULT_CREATOR_API_URL = "https://summercraft.ai";
-export const CONFIG_KEYS = [
-    "gateway.url",
-    "creator.apiUrl",
-    "creator.projectId",
-    "creator.channel",
-];
+export const CONFIG_KEYS = ["gateway.url"];
 function emptyConfig() {
     return { schemaVersion: 1 };
 }
@@ -39,90 +33,30 @@ function validateGatewayUrl(value) {
     }
     return parsed.toString().replace(/\/+$/, "");
 }
-function validateCreatorApiUrl(value) {
-    let parsed;
-    try {
-        parsed = new URL(value);
-    }
-    catch {
-        throw new Error('creator.apiUrl must be a complete URL. Recovery: use "summer config set creator.apiUrl https://summercraft.ai".');
-    }
-    const local = parsed.hostname === "localhost" ||
-        parsed.hostname === "127.0.0.1" ||
-        parsed.hostname === "[::1]";
-    if (parsed.protocol !== "https:" && !(local && parsed.protocol === "http:")) {
-        throw new Error("creator.apiUrl must use HTTPS (HTTP is allowed only for localhost). Recovery: set an HTTPS URL and retry.");
-    }
-    if (parsed.username ||
-        parsed.password ||
-        parsed.pathname !== "/" ||
-        parsed.search ||
-        parsed.hash) {
-        throw new Error("creator.apiUrl must be an origin without credentials, a path, query parameters, or fragments.");
-    }
-    return parsed.origin;
-}
 function validateValue(key, value) {
     const clean = value.trim();
     if (!clean) {
         throw new Error(`Cannot set ${key} to an empty value. Recovery: provide a value, or run "summer config unset ${key}".`);
     }
-    if (key === "gateway.url")
-        return validateGatewayUrl(clean);
-    if (key === "creator.apiUrl")
-        return validateCreatorApiUrl(clean);
-    if (key === "creator.channel" && !/^[a-z0-9][a-z0-9._-]{0,63}$/i.test(clean)) {
-        throw new Error("creator.channel may contain letters, numbers, dots, underscores, and hyphens. Recovery: choose a channel such as production or preview.");
-    }
-    if (key === "creator.projectId" && clean.length > 128) {
-        throw new Error("creator.projectId is too long. Recovery: copy the project ID from the Summer creator dashboard and retry.");
-    }
-    return clean;
+    return validateGatewayUrl(clean);
 }
 export function getConfigValue(config, key) {
-    if (key === "gateway.url")
-        return config.gateway?.url;
-    if (key === "creator.apiUrl")
-        return config.creator?.apiUrl;
-    if (key === "creator.projectId")
-        return config.creator?.projectId;
-    return config.creator?.channel;
+    return config.gateway?.url;
 }
 export async function setConfigValue(key, rawValue) {
     const config = await readSummerConfig();
     const value = validateValue(key, rawValue);
-    if (key === "gateway.url") {
-        config.gateway = { ...config.gateway, url: value };
-    }
-    else if (key === "creator.apiUrl") {
-        config.creator = { ...config.creator, apiUrl: value };
-    }
-    else if (key === "creator.projectId") {
-        config.creator = { ...config.creator, projectId: value };
-    }
-    else {
-        config.creator = { ...config.creator, channel: value };
-    }
+    config.gateway = { ...config.gateway, url: value };
     await writeStoreJson(CONFIG_FILE, config);
     return config;
 }
 export async function unsetConfigValue(key) {
     const config = await readSummerConfig();
-    if (key === "gateway.url" && config.gateway)
+    if (config.gateway)
         delete config.gateway.url;
-    if (key === "creator.apiUrl" && config.creator)
-        delete config.creator.apiUrl;
-    if (key === "creator.projectId" && config.creator) {
-        delete config.creator.projectId;
-    }
-    if (key === "creator.channel" && config.creator)
-        delete config.creator.channel;
     if (config.gateway && Object.keys(config.gateway).length === 0) {
         delete config.gateway;
     }
-    if (config.creator && Object.keys(config.creator).length === 0) {
-        delete config.creator;
-    }
     await writeStoreJson(CONFIG_FILE, config);
     return config;
 }
@@ -147,7 +81,3 @@ export async function resolveGatewayUrl() {
     const configured = config.gateway?.url?.trim();
     return configured ? validateGatewayUrl(configured) : DEFAULT_GATEWAY_URL;
 }
-export async function getCreatorApiUrl() {
-    const config = await readSummerConfig();
-    return config.creator?.apiUrl ?? DEFAULT_CREATOR_API_URL;
-}

package/dist/mcp/server.d.ts

@@ -11,7 +11,8 @@ export declare const getCachedBootDriftNotice: typeof getCachedNotice;
  * turn and would otherwise learn the hard way. Kept under 600 characters so
  * it costs a few hundred tokens once; the full operating guide stays in the
  * summer_agent_playbook prompt / summer_get_agent_playbook tool. The last
- * sentence names the publishing path and the owner-approval rule.
+ * sentence names the publishing path, the owner-approval rule and where
+ * review feedback is read.
  */
 export declare const SUMMER_MCP_INSTRUCTIONS: string;
 export declare function configureMcpEngineSelection(selection?: EngineSelection): void;

package/dist/mcp/server.js

@@ -40,14 +40,15 @@ export const getCachedBootDriftNotice = getCachedNotice;
  * turn and would otherwise learn the hard way. Kept under 600 characters so
  * it costs a few hundred tokens once; the full operating guide stays in the
  * summer_agent_playbook prompt / summer_get_agent_playbook tool. The last
- * sentence names the publishing path and the owner-approval rule.
+ * sentence names the publishing path, the owner-approval rule and where
+ * review feedback is read.
  */
-export const SUMMER_MCP_INSTRUCTIONS = "Summer Engine MCP. Call summer_get_project_context first: it binds the open project and returns mainScene, projectMemory and any capabilitySkewWarning. " +
+export const SUMMER_MCP_INSTRUCTIONS = "Summer Engine MCP. Call summer_get_project_context first: it binds the open project, returns mainScene, projectMemory, any capabilitySkewWarning. " +
     "Before building or fixing, summer_search_library then summer_read_library the hit. " +
-    "After a playthrough read summer_get_diagnostics, not summer_get_console alone. " +
-    "An all-black screenshot means the viewport had not redrawn: recapture. " +
+    "After play, read summer_get_diagnostics, not summer_get_console alone. " +
+    "An all-black screenshot means no redraw yet: recapture. " +
     "Report verified entries via summer_library_feedback. " +
-    "Publishing: summer_export_game, summer_publish_build, summer_store_*; an agent never publishes alone: summer_store_submit returns the owner's approval link.";
+    "Publishing: summer_export_game, summer_publish_build, summer_store_*; agents never publish alone: summer_store_submit returns the owner's approval link; summer_store_review, feedback to fix.";
 /**
  * Fire-and-forget probe of the npm registry on MCP boot. Caches the result for
  * the session. We never await this in startup so a slow / offline registry

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

@@ -1,27 +1,16 @@
 import { z } from "zod";
-import { CreatorOperationError, listCreatorReleases, publishCreator, } from "../../core/capabilities/creator.js";
 import { captureGameplay } from "../../core/capabilities/capture-gameplay.js";
 import { exportGame } from "../../core/capabilities/export-game.js";
 import { STORE_TARGETS } from "../../core/capabilities/export-presets.js";
 import { exportTemplates, TEMPLATE_PLATFORMS } from "../../core/capabilities/export-templates.js";
 import { publishBuild } from "../../core/capabilities/publish-build.js";
 import { BuildToolError } from "../../core/capabilities/summer-bundle.js";
-import { CONFIG_KEYS, getConfigValue, isConfigKey, readSummerConfig, setConfigValue, unsetConfigValue, } from "../../core/config.js";
 import { textJson } from "./text-json.js";
 async function creatorResult(operation) {
     try {
         return textJson(await operation());
     }
     catch (error) {
-        if (error instanceof CreatorOperationError) {
-            return textJson({
-                ok: false,
-                code: error.code,
-                operation: error.operation,
-                message: error.message,
-                recovery: error.recovery,
-            }, true);
-        }
         if (error instanceof BuildToolError) {
             return textJson({
                 ok: false,
@@ -116,64 +105,4 @@ export function registerCreatorTools(server) {
         confirm: z.boolean().default(false).describe("Set true only after the user approves the exact upload."),
         waitSeconds: z.number().int().min(0).max(1800).optional().describe("How long to wait for Summer to make the Build (default 600). On timeout, call again to keep waiting."),
     }, async (args) => creatorResult(() => publishBuild({ ...args, face: "mcp" })));
-    server.tool("summer_creator_publish", "Deprecated: use summer_export_game, then summer_publish_build, which upload the summer.games .zip to the game's store listing. This old path publishes a .pck to the legacy Summercraft creator API with a separate sc_ token and will be removed. First call with confirm=false and present the returned project, version, digest, size, artifact path, channel, and notes; set confirm only after the user approves that exact target. The server independently verifies token scope, ownership, bytes, and review state.", {
-        project: z.string().optional().describe("Project root. Defaults to the current working directory."),
-        artifact: z.string().describe("Exact path to the exported Summer .pck artifact."),
-        version: z.string().describe("Immutable release version."),
-        manifest: z.string().optional().describe("Optional path to a JSON release manifest."),
-        projectId: z.string().optional().describe("Creator project ID. Defaults to ~/.summer/config.json."),
-        channel: z.string().optional().describe("Release channel. Defaults to the configured channel or production."),
-        notes: z.string().optional().describe("Release notes shown during confirmation and recorded in the local audit."),
-        confirm: z.boolean().default(false).describe("Set true only after the user approves the exact release target."),
-    }, async (args) => creatorResult(() => publishCreator({
-        ...args,
-        face: "mcp",
-    })));
-    server.tool("summer_creator_releases", "Deprecated: lists releases on the legacy Summercraft creator API (separate sc_ token), not summer.games. For what players get on summer.games, and which upload can be released, use summer_store_releases.", {
-        projectId: z.string().optional().describe("Creator project ID. Defaults to ~/.summer/config.json."),
-        limit: z.number().int().min(1).max(100).default(20),
-        cursor: z.string().optional().describe("Opaque nextCursor from the previous page."),
-    }, async (args) => creatorResult(() => listCreatorReleases({
-        ...args,
-        face: "mcp",
-    })));
-    server.tool("summer_creator_config", "Read or update the shared non-secret ~/.summer configuration used by the CLI and this MCP. Mutations require confirm=true. Tokens are never returned or accepted by this tool.", {
-        action: z.enum(["list", "get", "set", "unset"]),
-        key: z.enum(CONFIG_KEYS).optional(),
-        value: z.string().optional(),
-        confirm: z.boolean().default(false),
-    }, async ({ action, key, value, confirm }) => creatorResult(async () => {
-        if (action === "list") {
-            const config = await readSummerConfig();
-            return {
-                ok: true,
-                values: Object.fromEntries(CONFIG_KEYS.map((name) => [
-                    name,
-                    getConfigValue(config, name) ?? null,
-                ])),
-            };
-        }
-        if (!key || !isConfigKey(key)) {
-            throw new Error(`A valid key is required. Recovery: use one of ${CONFIG_KEYS.join(", ")}.`);
-        }
-        if (action === "get") {
-            return {
-                ok: true,
-                key,
-                value: getConfigValue(await readSummerConfig(), key) ?? null,
-            };
-        }
-        if (!confirm) {
-            throw new Error(`Changing ${key} requires confirmation. Recovery: show the exact change to the user, then retry with confirm=true.`);
-        }
-        if (action === "set") {
-            if (value === undefined) {
-                throw new Error(`A value is required for ${key}. Recovery: provide value and retry with confirm=true.`);
-            }
-            const config = await setConfigValue(key, value);
-            return { ok: true, key, value: getConfigValue(config, key) };
-        }
-        const config = await unsetConfigValue(key);
-        return { ok: true, key, value: getConfigValue(config, key) ?? null };
-    }));
 }