capybara-mcp-shared 0.1.0 → 0.1.2

package/dist/schemas/asset-tool-schema.js

@@ -14,367 +14,262 @@ export const assetTypeSchema = z.enum([
     "map_vfx",
     "music_bg",
 ]);
-const referenceIdSchema = z
-    .union([z.string(), z.array(z.string()).min(1)])
-    .describe("Dependency handle(s) pointing at completed asset(s) the pipeline must wait for. Use a single string for one dependency; use a string array when multiple assets must exist first.");
 const outputFramesSchema = z
-    .preprocess((value) => {
-    if (value == null)
-        return undefined;
-    if (typeof value === "number")
-        return String(value);
-    return value;
-}, z.enum(["8", "12", "16", "24"]).optional())
-    .transform((value) => value == null ? undefined : Number(value));
-export const mapConnectionDirectionSchema = z
-    .enum(["right", "left", "down"])
-    .describe("Direction FROM the reference map TO the new map. 'right' = new map is east of reference; 'left' = west; 'down' = south. Never 'up' — North is always the wall side.");
-export const mapConnectionSchema = z.object({
+    .preprocess((value) => value == null
+    ? undefined
+    : typeof value === "number"
+        ? String(value)
+        : value, z.enum(["8", "12", "16", "24"]).optional())
+    .transform((value) => value == null ? undefined : Number(value))
+    .describe("Target frame count for looping sheets. Use 8 frames for subtle idle sways, 12 frames for walks and standard tasks, and 16 frames for complex, multi-stage actions.");
+const mapConnectionSchema = z.object({
     referenceId: z
         .string()
-        .describe("Id of the base_map or extend_map this new room connects to."),
-    direction: mapConnectionDirectionSchema,
+        .describe("ID of the existing map this connection connects to."),
+    direction: z
+        .enum(["right", "left", "down"])
+        .describe("Direction of travel from the reference map to this new map. East/West/South edges are walkable. North (up) is reserved for structural walls."),
 });
 const mapOverlayStateSchema = z.object({
     label: z
         .string()
-        .describe("Short stable state id for this overlay, e.g. 'closed', 'open', 'looted'."),
+        .describe("Stable state ID for this overlay state (e.g., 'closed', 'open', 'looted', 'repaired')."),
     prompt: z
         .string()
-        .describe("Visual prompt for this specific overlay state on the anchored map structure."),
+        .describe("Visual-only prompt of the structure in this state. Exclude characters or floating UI labels."),
 });
-const baseAssetFields = {
+const coreFields = {
     id: z
         .string()
-        .describe("Unique asset id used as storage key and dependency handle. Ensure consistency across iterations so the coding agent can track references."),
-    prompt: z.string().describe("Primary visual or audio prompt for this asset."),
+        .describe("Unique asset ID used as the storage key and dependency handle."),
+    prompt: z
+        .string()
+        .describe("Primary visual or audio prompt. Exclude camera terms like 'top-down', '2.5D', or 'isometric' for world assets. Focus on layout, materials, and flat ambient lighting."),
     gamePlay: z
         .string()
         .min(1)
-        .describe("Required concise gameplay logic and wiring brief for the codeAgent. Include placement, interaction, runtime UI state, or playback timing as appropriate for this asset."),
+        .describe("Detailed wiring instructions for the coding agent. Describe spawn areas, collision behaviors, boundary limits, and interaction triggers."),
 };
-const characterBodyFormatSchema = z
-    .enum(["humanoid", "quadruped_animal"])
-    .describe("Body format for generation and walk animation. humanoid (default): upright biped with human-like proportions — humans, fantasy races, and anthropomorphic animals (fox shopkeeper, cat villager walking on two legs). quadruped_animal: natural four-legged anatomy — farm livestock, wild wolves, pets on all fours. Default to humanoid unless the game explicitly needs quadruped farm/wildlife; even animal-themed games usually use humanoid NPCs.");
-const legacyAssetSchema = z.object({
-    ...baseAssetFields,
-    type: assetTypeSchema.describe("Asset mode layer type."),
-    propsMultipleBreakdown: z
-        .string()
-        .optional()
-        .describe("ONLY FOR props_multiple: Optional secondary prompt mapping numbered bounding boxes to individual prop descriptions. This is NOT a substitute for the required prompt field."),
-    multipleHudsBreakdown: z
-        .string()
-        .optional()
-        .describe("ONLY FOR multiple_huds: Optional secondary prompt mapping numbered HUD widgets to individual descriptions, ids/names, and intended runtime behavior. This is NOT a substitute for the required prompt field."),
-    anchorDescription: z
-        .string()
-        .optional()
-        .describe("ONLY FOR props_map_overlay: Description of the exact existing map-baked structure/prop being overlaid, including its location on the map."),
-    overlayStateBreakdown: z
-        .array(mapOverlayStateSchema)
-        .min(1)
-        .optional()
-        .describe("ONLY FOR props_map_overlay: Required array of overlay states ({ label, prompt }[]). Each entry is one visual state on the same map anchor."),
-    defaultAnimation: z
+const assetArray = (schema, description) => z.array(schema).default([]).describe(description);
+const baseMapSchema = z.object({
+    ...coreFields,
+    id: coreFields.id.describe("Unique map ID starting with 'map_' (e.g., 'map_town_hall'). Depicts the unaltered, 'before' state of the environment."),
+    art_reference_url: z
         .string()
         .optional()
-        .describe("Built-in ENGINE idle preset name (e.g., 'Breathing Idle'). Set on base_character for player and simple-NPC tiers. Set on base_character_variant for job-NPC tiers (idle while holding the signature prop). Omit on job-NPC empty-handed parent base_characters and pure static references."),
-    characterBodyFormat: characterBodyFormatSchema.optional(),
-    referenceId: referenceIdSchema.optional(),
-    outputFrames: outputFramesSchema
-        .optional()
-        .describe("ONLY FOR character_animation: Spritesheet frame count for the Pixel Engine animator. REQUIRED on every character_animation."),
-    connections: z
-        .array(mapConnectionSchema)
-        .min(1)
-        .max(3)
-        .optional()
-        .describe("ONLY FOR extend_map: One entry per existing map this room connects to. Index 0 is the anchor used for outpainting. Additional entries declare other open transition sides."),
-});
-const baseMapSchema = z.object({
-    ...baseAssetFields,
-    id: baseAssetFields.id.describe("Unique id for a base map. Start with 'map_' followed by a descriptive name (e.g., 'map_wooden_desk_room')."),
-    prompt: baseAssetFields.prompt.describe("For base_map: Describe the environment theme, North boundary, 5-8 small/compact/modest major floor props, and 5-8 small/compact/modest decor floor props. Keep furniture rectilinear. Keep dynamic gameplay items, pickups, NPCs, changing clues, and stateful objects out of the prompt; put them in gamePlay and separate prop/character/overlay assets. Omit camera perspective keywords (like top-down or 2.5D) as the pipeline enforces them automatically."),
-    gamePlay: baseAssetFields.gamePlay.describe("For base_map: Tell the codeAgent the rough player spawn area and rough placement for any characters/NPCs/enemies, plus WHICH props/characters belong on WHICH obstacles; ensure furniture mentioned here is in the map prompt."),
+        .describe("Optional art style reference for this map: an http(s) image URL or a local file path. The tool fetches/reads it and sends base64 to the API."),
 });
 const extendMapSchema = z.object({
-    ...baseAssetFields,
-    id: baseAssetFields.id.describe("Unique id for an extended map. Start with 'map_extend_'."),
-    prompt: baseAssetFields.prompt.describe("For extend_map: Describe the new outpainted wing with 5-8 small/compact/modest floor props per map tile/wing, keeping every shared seam completely open with no props, furniture, blockers, or decor. MUST match the reference map's shell type (interior stays interior, exterior stays exterior), copy the reference floor material phrase verbatim, and match north-wall material for interiors. Keep dynamic gameplay items out of the prompt and put them in gamePlay/prop assets. New room purpose is fine; changing environment type (indoor↔outdoor, biome, or terrain) is invalid — use base_map instead."),
-    gamePlay: baseAssetFields.gamePlay.describe("For extend_map: State shell continuity with the reference map (e.g. 'same interior metallic lab wing'), transition direction, rough spawn/entry area, important placements, and gameplay interactions — not just 'seamless walk'."),
+    ...coreFields,
+    id: coreFields.id.describe("Unique ID starting with 'map_extend_' (e.g., 'map_extend_kitchen'). Represents an adjacent wing of the same biome and flooring material."),
     connections: z
         .array(mapConnectionSchema)
         .min(1)
         .max(3)
-        .describe("One entry per existing map this room connects to. Index 0 is the visual anchor: its map image and direction drive outpainting; the extension must continue that map's floor material at the shared edge. Additional entries declare other open transition sides for prompts, validation, and codeAgent wiring."),
+        .describe("At least one adjacent map boundary. Transition seams must be left completely open."),
 });
 const editMapSchema = z.object({
-    ...baseAssetFields,
-    id: baseAssetFields.id.describe("Unique id for a map edit. Start with 'map_edit_'."),
-    prompt: baseAssetFields.prompt.describe("For edit_map: Describe exactly one static floor-prop/obstacle/collider edit on an existing base_map or extend_map — adding, removing, or replacing one static floor prop per edit request. Be explicit about what to add and what to remove. Do NOT use this for dynamic gameplay items, ambient animations, or sprite-sheet VFX."),
-    gamePlay: baseAssetFields.gamePlay.describe("For edit_map: Explain what changes and why."),
-    referenceId: referenceIdSchema.describe("One id of a completed base_map or extend_map."),
+    ...coreFields,
+    id: coreFields.id.describe("Unique ID starting with 'map_edit_'. Use ONLY for static, post-build changes to map obstacles (e.g., removing a fallen tree blocking a path)."),
+    referenceId: z.string().describe("ID of the existing map being modified."),
 });
 const mapVfxSchema = z.object({
-    ...baseAssetFields,
-    id: baseAssetFields.id.describe("Unique id for map VFX. Start with 'map_vfx_'."),
-    prompt: baseAssetFields.prompt.describe("For map_vfx: Describe animated VFX on an existing base_map or extend_map — which elements should get sprite-sheet animation, motion/effect, and any VFX to remove or stop. Do NOT use this for adding/removing static obstacles."),
-    gamePlay: baseAssetFields.gamePlay.describe("For map_vfx: Explain what changes and why."),
-    referenceId: referenceIdSchema.describe("One id of a completed base_map or extend_map."),
+    ...coreFields,
+    id: coreFields.id.describe("Unique ID starting with 'map_vfx_'. Use for looping environmental animations (e.g., flickering fire, swaying lanterns, river ripples)."),
+    referenceId: z
+        .string()
+        .describe("ID of the existing map hosting this visual effect overlay."),
 });
 const baseCharacterSchema = z.object({
-    ...baseAssetFields,
-    id: baseAssetFields.id.describe("Unique id for a base character. Start with 'char_'."),
-    characterBodyFormat: characterBodyFormatSchema.default("humanoid"),
-    prompt: baseAssetFields.prompt.describe("For base_character: Describe clothing and physical traits. State body format explicitly (upright humanoid biped OR natural quadruped on four legs) — must match characterBodyFormat. Draw the character facing the camera, angled slightly toward screen-right (¾ turn); the engine mirrors this single sprite (flipX) for the opposite direction. Full body centered with generous empty padding on all sides on solid neon green (#00FF00). Art style is inferred globally. Omit camera-perspective keywords. Player and simple NPCs: empty-handed. Job NPCs: also empty-handed here — the prop-in-pose lives on the base_character_variant."),
-    gamePlay: baseAssetFields.gamePlay.describe("For base_character: Role, placement, player interaction, animation tier (player / simple NPC / job NPC parent base), and characterBodyFormat (humanoid vs quadruped_animal) when not obvious from the role."),
+    ...coreFields,
+    id: coreFields.id.describe("Unique ID starting with 'char_' (e.g., 'char_merchant'). Represents the empty-handed, baseline sprite facing forward and turned 3/4 right."),
+    characterBodyFormat: z
+        .enum(["humanoid", "quadruped_animal"])
+        .default("humanoid")
+        .describe("Body format. Use humanoid for player and bipedal NPCs. Use quadruped_animal for livestock or wildlife."),
     defaultAnimation: z
         .string()
         .optional()
-        .describe("Built-in ENGINE idle preset (e.g., 'Breathing Idle') for player and simple-NPC tiers only. Omit for job-NPC parent base_characters and pure static references."),
+        .describe("Engine idle preset name (e.g., 'Breathing Idle'). Omit on empty-handed parents of Job NPCs."),
 });
 const baseCharacterVariantSchema = z.object({
-    ...baseAssetFields,
-    id: baseAssetFields.id.describe("Unique id for a base character variant. Start with the base_character id, followed by the variant name."),
-    prompt: baseAssetFields.prompt.describe("For base_character_variant: Describe a static KEYFRAME pose — the job NPC's default visual with the signature prop already held/worn. Must match the FIRST frame of follow-up character_animation prompts. Same camera-facing, right-angled orientation as the parent base_character. Full body centered with generous empty padding on solid neon green (#00FF00). Props are blended via referenceId; do not invent new objects not in the references."),
-    gamePlay: baseAssetFields.gamePlay.describe("For base_character_variant: Default visual and idle anchor for a job NPC; set defaultAnimation here for looping idle while the signature prop is visible. Anchor for all movement/task character_animations on this character. State when idle vs walk vs task clips play."),
+    ...coreFields,
+    id: coreFields.id.describe("Unique ID starting with 'char_' (e.g., 'char_blacksmith_working'). Used for Job NPCs. Depicts the character holding their signature prop in their default pose."),
+    referenceId: z
+        .union([z.string(), z.array(z.string()).min(1)])
+        .describe("Parent character ID, or an array of the parent character ID and held tool prop ID."),
     defaultAnimation: z
         .string()
         .optional()
-        .describe("REQUIRED for job-NPC variants: built-in ENGINE idle preset (e.g., 'Breathing Idle'). Auto-generates a looping idle clip from this prop-holding variant sprite."),
-    referenceId: referenceIdSchema.describe("Parent base_character id, OR [base_character_id, prop_id] when blending a props_single or props_multiple asset into the pose. Job NPCs: one variant per character with the single signature prop — all task/walk clips reference this variant, not the empty-handed base_character."),
+        .describe("Engine idle preset name (e.g., 'Breathing Idle') to auto-generate a looping idle sheet while holding a prop."),
 });
 const characterAnimationSchema = z.object({
-    ...baseAssetFields,
-    id: baseAssetFields.id.describe("Unique id for a character animation. Start with the base_character id, followed by the animation name."),
-    prompt: baseAssetFields.prompt.describe("For character_animation: Write a temporally dense motion script for the image-to-video animator — NOT a short label. Animate ONLY the default right-angled camera-facing sprite; the engine mirrors it (flipX) for the opposite direction. Structure: starting pose (must match the reference sprite) → transitions using 'begins by…', 'then…', 'as they…' → loop or recovery back to start. Describe ONLY body motion; props/tools must already be visible on the referenceId sprite. Player/simple NPC walk clips reference base_character. Job NPC clips (idle-with-prop, walk-with-prop, task loop) reference base_character_variant — never the empty-handed base_character."),
-    gamePlay: baseAssetFields.gamePlay.describe("For character_animation: When this clip should play. Job NPCs: cap at 2-3 cohesive clips per character, all serving the same role/prop."),
-    referenceId: referenceIdSchema.describe("One id — base_character (player/simple NPC walk) OR base_character_variant (all job-NPC clips). Job NPC animations must reference the prop-in-pose variant, not the empty-handed base_character."),
-    outputFrames: outputFramesSchema.describe("Spritesheet frame count for the Pixel Engine animator. REQUIRED on every character_animation — pick by action complexity: 8 subtle idle sways, 12 standard walk/run/task loops, 16 elaborate, 24 rare long sequences."),
+    ...coreFields,
+    id: coreFields.id.describe("Unique ID starting with 'char_' (e.g., 'char_player_walk'). Represents a looping sprite sheet."),
+    referenceId: z
+        .union([z.string(), z.array(z.string()).min(1)])
+        .describe("ID of the base character this animation sheet is for."),
+    outputFrames: outputFramesSchema,
 });
 const propsSingleSchema = z.object({
-    ...baseAssetFields,
-    id: baseAssetFields.id.describe("Unique id for a single prop. Start with 'prop_'."),
-    prompt: baseAssetFields.prompt.describe("For props_single: Describe one isolated, small pick-up item as a purely physical shape. Keep surfaces clear of text or complex symbols so it remains legible as a tiny map icon."),
-    gamePlay: baseAssetFields.gamePlay.describe("For props_single: Pickup, placement, inventory, cursor use, or crafting role."),
-    referenceId: referenceIdSchema
-        .describe("Optional placement/style reference. Use a base_map or extend_map id for world props; use a hud_element id for UI-layer props. Omit to default to the batch map.")
-        .optional(),
+    ...coreFields,
+    id: coreFields.id.describe("Unique ID starting with 'prop_' (e.g., 'prop_iron_key'). A single portable item, pickup, or weapon. Describe as a physical shape without text."),
+    referenceId: z
+        .union([z.string(), z.array(z.string()).min(1)])
+        .describe("Map ID when world-anchored, or parent HUD ID when UI-anchored."),
+});
+const propsMultipleSchema = z.object({
+    ...coreFields,
+    id: coreFields.id.describe("Unique ID starting with 'prop_' (e.g., 'prop_farming_tools'). A sequential sheet of related items or lifecycle states (e.g., tilled soil stages)."),
+    referenceId: z
+        .union([z.string(), z.array(z.string()).min(1)])
+        .describe("Map ID when world-anchored, or parent HUD ID when UI-anchored."),
+    propsMultipleBreakdown: z
+        .string()
+        .min(1)
+        .describe("Description mapping each item index left-to-right on the sheet."),
 });
 const propsMapOverlaySchema = z.object({
-    id: baseAssetFields.id.describe("Unique id for a map-anchored overlay group. Start with 'prop_' followed by a descriptive name (e.g., 'prop_kitchen_cupboard_states')."),
+    id: coreFields.id.describe("Unique ID starting with 'prop_' (e.g., 'prop_dungeon_door'). A stateful texture overlay aligned with an existing map structure."),
     anchorDescription: z
         .string()
-        .describe("For props_map_overlay: Describe the exact existing map-baked structure/prop this overlay attaches to, including a stable location phrase from the map prompt/gameplay (e.g., 'north-wall kitchen cupboard', 'closed chest beside the bed', 'locked iron gate at the east path'). This is used to find the anchor and align every overlay state."),
-    gamePlay: baseAssetFields.gamePlay.describe("For props_map_overlay: When each state shows/hides, interaction trigger, and whether the base map raw state stays visible underneath. Do not rely on this to identify the anchor; put the target structure in anchorDescription. Persisted on the parent map JSON under mapOverlays."),
-    referenceId: referenceIdSchema.describe("Required: base_map or extend_map id — overlay states are written into that map's JSON file under mapOverlays."),
+        .describe("Exact description of the map-baked structure this overlay aligns with (e.g., 'iron cell gate on north wall')."),
+    gamePlay: coreFields.gamePlay,
+    referenceId: z
+        .string()
+        .describe("ID of the base or extend map hosting the anchor structure."),
     overlayStateBreakdown: z
         .array(mapOverlayStateSchema)
         .min(1)
-        .describe("Required visual states for this map anchor. One entry per composited state. Single-state overlays use a one-item array. Example: [{ label: 'closed', prompt: 'Kitchen cupboard with shut doors' }, { label: 'open', prompt: 'Same cupboard with doors open revealing shelves' }]."),
-});
-const propsMultipleSchema = z.object({
-    ...baseAssetFields,
-    id: baseAssetFields.id.describe("Unique id for a multi-prop sheet. Start with 'prop_'."),
-    prompt: baseAssetFields.prompt.describe("For props_multiple: Describe isolated, small pick-up items as purely physical shapes. This primary prompt is REQUIRED; use it for the overall composition, and use propsMultipleBreakdown only as extra numbered split guidance."),
-    gamePlay: baseAssetFields.gamePlay.describe("For props_multiple: Pickup, placement, inventory, cursor use, state progression, or crafting role."),
-    propsMultipleBreakdown: z
-        .string()
-        .optional()
-        .describe("Optional secondary prompt mapping numbered bounding boxes to individual prop descriptions (e.g., 'Prop 1: bare dark tilled soil; Prop 2: tiny green sprout'). This is NOT a substitute for the required prompt field."),
-    referenceId: referenceIdSchema
-        .describe("Optional placement/style reference. Use a base_map or extend_map id for world props; use a hud_element id for UI-layer props. Omit to default to the batch map.")
-        .optional(),
+        .describe("Visual state variants for the anchor. Exclude a top-level prompt field on this asset."),
 });
 const hudElementSchema = z.object({
-    ...baseAssetFields,
-    id: baseAssetFields.id.describe("Unique id for a HUD element. Start with 'hud_'."),
-    prompt: baseAssetFields.prompt.describe("For hud_element: Describe the full UI layout using the HUD art-vs-code strategy: generated art owns atmosphere and stable chrome; code owns state, data, accessibility, and interactivity. Immersive/gameplay-facing HUDs (title/start screens, result screens, health/resource frames, hotbars, inventory grids, dialogue, shop, inspect/case-file views, compact status widgets, stylized quest/ledger shells) should bake stable frames, slots, panel borders, short stable labels, neutral button chrome, and title/menu artwork into the image. Title menus (hud_title_menu / hud_start_screen): cinematic full-screen composition with baked game title and baked neutral menu button artwork for stable labels such as Start Game, Load Game, Continue, Settings, or Credits; arrange buttons with clear rectangular hit regions for transparent code overlays. Hybrid information screens need a generated thematic backplate/border/header but a plain high-contrast blank surface for runtime text. Clean system UI such as settings, keybindings, save/load lists, and credits should usually be code-rendered rather than custom HUD art. Use neutral/default chrome only; put runtime state in gamePlay. Floating UI panels need solid flat neon green chroma-key background (#00FF00); full-screen title menus should use high-fidelity cinematic backgrounds instead."),
-    gamePlay: baseAssetFields.gamePlay.describe("For hud_element: Explain UI wiring and runtime-only visual state that must NOT appear in the prompt: transparent hit regions, active tab highlights, hover/focus effects, disabled dimming/masks, dynamic text/numbers, slot contents, meter fill levels, scroll/list contents, and click behavior."),
+    ...coreFields,
+    id: coreFields.id.describe("Unique ID starting with 'hud_' (e.g., 'hud_start_screen'). Full-screen overlays, dialogue borders, menu boards, or shop panels."),
 });
 const multipleHudsSchema = z.object({
-    ...baseAssetFields,
-    id: baseAssetFields.id.describe("Unique id for a multi-HUD sheet. Start with 'hud_' followed by a group name, e.g. 'hud_common_widgets'."),
-    prompt: baseAssetFields.prompt.describe("For multiple_huds: Describe several small isolated HUD widgets generated together in one sheet for cost-effective cropping/codegen. Use for compact reusable UI chrome like dialogue panels, quest widgets, status widgets, tooltip frames, command bubbles, notification plaques, portrait frames, and small inventory subpanels. The sheet must have a solid neon green #00FF00 background, generous spacing between widgets, neutral/default chrome only, and blank high-contrast runtime text surfaces. Do NOT use for full-screen title menus, result screens, large shop screens, or highly complex unique layouts; use hud_element for those."),
-    gamePlay: baseAssetFields.gamePlay.describe("For multiple_huds: Explain the runtime role of each cropped widget, including dynamic text/data, transparent hit regions, hover/focus effects, open/close behavior, and where each small HUD should appear."),
+    ...coreFields,
+    id: coreFields.id.describe("Unique ID starting with 'hud_' (e.g., 'hud_small_panels'). A single green chroma-key sheet containing small reusable HUD widgets."),
     multipleHudsBreakdown: z
         .string()
-        .describe("Required secondary prompt mapping numbered cropped HUD widgets to individual descriptions, ids/names, and runtime behavior. Example: 'HUD 1: dialogue panel with portrait frame and blank text parchment; HUD 2: compact top-left quest tracker with two blank objective rows.'"),
+        .describe("Cropping coordinates and descriptions for each small widget on the sheet."),
 });
 const musicBgSchema = z.object({
-    ...baseAssetFields,
-    id: baseAssetFields.id.describe("Unique id for background music. Start with 'music_'."),
-    prompt: baseAssetFields.prompt.describe("For music_bg: Provide a cohesive, comma-separated list of tags. ALWAYS start with 'Instrumental' unless vocals are explicitly requested; include rhythmic glue, balanced instrument roles, exact game mood/setting, and end with utility tags like 'loopable, steady relaxed tempo'."),
-    gamePlay: baseAssetFields.gamePlay.describe("For music_bg: Explain when the track should play (e.g., 'Loops during daytime gameplay')."),
+    id: coreFields.id.describe("Unique ID starting with 'music_' (e.g., 'music_pastoral_theme'). Background tracks. Always start with the word 'Instrumental' and include rhythmic anchors. No SFX."),
+    prompt: coreFields.prompt,
+    gamePlay: z
+        .string()
+        .optional()
+        .describe("Optional in-game usage context for the track."),
 });
-const assetArray = (schema, description) => z.array(schema).default([]).describe(description);
-export const assetToolSchema = z
-    .object({
+const assetBatchFields = {
     artStyle: z
         .string()
-        .describe("Shared style direction applied across all visual assets. This should stay consistent across the entire game."),
-    isFirstBuild: z
-        .boolean()
-        .describe("Indicate if this is the first time running the assets tool and there has been no previous successful asset generation in this workspace (including after cloning another workspace). " +
-        "When true, default to one base_map and avoid extend_map, edit_map, or map_vfx unless the user explicitly asks for more."),
-    baseMaps: assetArray(baseMapSchema, "Base map assets to generate. CRITICAL: You must ensure absolute spatial consistency between the visual prompt and the gameplay field. If gameplay requires an NPC or player to stand 'behind' a counter, bar, table, or desk, the visual prompt must explicitly describe a walkable aisle/gap between that furniture and the North wall. Do not place furniture flush against walls if characters need to occupy the space behind them."),
-    extendMaps: assetArray(extendMapSchema, "Map extension assets to generate. Only when the new wing shares the reference map's shell and floor — BAD: interior lab extend_map to exterior dock; GOOD: interior lab extend_map to interior corridor with same floor phrase.  Must share the reference map's shell and floor material. Maintain the same spatial rules: ensure any counter or barrier where NPCs stand has a clear, described walkable aisle behind it, completely free of wall collisions."),
-    editMaps: assetArray(editMapSchema, "Surgical static map edit assets to generate."),
-    mapVfx: assetArray(mapVfxSchema, "Animated map VFX assets to generate."),
-    baseCharacters: assetArray(baseCharacterSchema, "Base character sprites. Set characterBodyFormat on every entry (default humanoid). Player/simple NPC: empty-handed with defaultAnimation. Job NPC: empty-handed parent base with NO defaultAnimation — pair with a base_character_variant for the visible prop-in-pose."),
-    baseCharacterVariants: assetArray(baseCharacterVariantSchema, "Job-NPC prop-in-pose keyframes. One variant per job NPC with the signature prop; set defaultAnimation for looping idle and use as anchor for movement/task character_animations. Do not create variants for player or simple NPCs."),
-    characterAnimations: assetArray(characterAnimationSchema, "Character animation spritesheets. Player/simple NPC: one walk loop on base_character (idle via base_character defaultAnimation). Job NPC: up to 2 movement/task clips on the variant (idle via variant defaultAnimation). Never exceed 3 generated clips per job NPC."),
-    propsSingles: assetArray(propsSingleSchema, "Single prop assets to generate."),
-    propsMultiples: assetArray(propsMultipleSchema, "Multiple-prop sheet assets to generate."),
-    propsMapOverlays: assetArray(propsMapOverlaySchema, "Map-anchored structural overlay props. Use when a state change must align with a specific map-baked structure (open cupboard, repaired building, opened chest). Returns image URL + box_2d per state. Not for portable pickups or generic zone tiles."),
-    hudElements: assetArray(hudElementSchema, "HUD/UI image assets to generate."),
-    multipleHuds: assetArray(multipleHudsSchema, "Multi-HUD sheets to generate. Each sheet is cropped into multiple small HUD widgets and each crop receives generated widget code."),
-    backgroundMusic: assetArray(musicBgSchema, "Background music assets to generate."),
-})
-    .describe("Expensive asset generation request. Before filling this schema, decide the complete asset batch needed for the user's requested outcome. Preserve the user's visual wording, style constraints, placement, and exclusions in the asset prompts/gamePlay; do not simplify them into a different asset idea. Bundle all related asset needs for the user's current turn into one call. Do not call assetsAgent again to verify, double-check, or add items that should have been included in the same batch unless the first call failed/incomplete, a required dependency blocks describing the second batch up front, or the user explicitly approves another separate batch.")
-    .refine((input) => input.baseMaps.length +
-    input.extendMaps.length +
-    input.editMaps.length +
-    input.mapVfx.length +
-    input.baseCharacters.length +
-    input.baseCharacterVariants.length +
-    input.characterAnimations.length +
-    input.propsSingles.length +
-    input.propsMultiples.length +
-    input.propsMapOverlays.length +
-    input.hudElements.length +
-    input.multipleHuds.length +
-    input.backgroundMusic.length >
-    0, "At least one asset array must contain an asset.");
-const withType = (assets, type) => (assets ?? []).map((asset) => ({ ...asset, type }));
-export const mapAssetToolInputToLegacy = (input) => ({
-    artStyle: input.artStyle,
-    isFirstBuild: input.isFirstBuild,
-    assets: [
-        ...withType(input.baseMaps, "base_map"),
-        ...withType(input.extendMaps, "extend_map"),
-        ...withType(input.editMaps, "edit_map"),
-        ...withType(input.mapVfx, "map_vfx"),
-        ...withType(input.hudElements, "hud_element"),
-        ...withType(input.multipleHuds, "multiple_huds"),
-        ...withType(input.baseCharacters, "base_character"),
-        ...withType(input.propsSingles, "props_single"),
-        ...withType(input.propsMultiples, "props_multiple"),
-        ...input.propsMapOverlays.map((asset) => ({
-            ...asset,
-            type: "props_map_overlay",
-            prompt: asset.overlayStateBreakdown
-                .map((state) => `${state.label}: ${state.prompt}`)
-                .join(" | "),
-        })),
-        ...withType(input.baseCharacterVariants, "base_character_variant"),
-        ...withType(input.characterAnimations, "character_animation"),
-        ...withType(input.backgroundMusic, "music_bg"),
-    ],
-});
-export const codingAgentTaskTypeSchema = z.enum([
-    "new_game",
-    "bug_fix",
-    "revisit_previous_bug_fix",
-    "feature_implementation",
-    "explore",
-    "general",
-]);
-const codingAgentTaskFieldDescription = "What the coding agent should do this turn. Scale the detail to 'type' — do NOT force a full game brief on every call. The coding agent automatically reads the asset manifest, so always omit file paths and pixel dimensions and focus on functional game logic and asset behavior. " +
-    "Preserve the user's actual wording and context. Include a short current-vs-desired framing when relevant: what the user says currently happens, what they want instead, when it should happen, what UI/game state it applies to, and any negations or 'not X, but Y' distinctions. Put implementation hints after that preserved context, not instead of it. " +
-    "This is an expensive coding tool: before setting task/type, decide the user's requested outcome, pick the workflow type, and draft one bundled task brief that covers all related code work. Default to one codeAgent call per user turn, bundle all related code changes into one task, and never call it again just to verify, double-check, or polish the same successful task. A second same-turn codeAgent call is only for a failed/incomplete prior call, a clear user-reported unresolved prior bug via revisit_previous_bug_fix, or genuinely independent work that cannot be safely bundled. " +
-    "For 'new_game': on the first build the server injects the approved plan automatically — pass a short placeholder (for example \"Use approved plan\"). " +
-    "For 'bug_fix': use when something is broken, incorrect, crashing, or not working as expected for the first fix attempt on that bug. Pass one or more related bug reports in a single task (e.g. 'Player falls through floor; inventory count is wrong'). Do not use 'explore' first as a preflight. " +
-    "For 'revisit_previous_bug_fix': use only after a prior successful codeAgent bug_fix when the user says the bug still isn't fixed and their updated description is clear enough to act on. Loads the last bug-fix session and retries without re-analyzing the compiled bundle. Pass the user's updated bug description in task. If the user's report is vague or may reflect misunderstood intent, ask a clarifying follow-up question in chat instead of calling this type. " +
-    "For 'feature_implementation': use when the user wants new behavior, mechanics, UI, asset wiring, SDK integrations, balance changes, or polish — not fixing broken existing behavior. Pass one or more related feature requests in a single task. Do not use 'explore' first as a preflight. " +
-    "If a single user turn mixes bug fixes and feature work, prefer one bundled codeAgent call using the dominant type when the items affect the same feature, subsystem, UI flow, or player-facing outcome. Split only for genuinely independent tasks that require different workflows and cannot be safely bundled. " +
-    "For 'explore': a plain read-only question about the codebase, asset manifest, wired gameplay, or game state (e.g., 'List all asset IDs and types in src/data' or 'Summarize the current map layout and wired mechanics'). Do not request any changes. Never use for broken behavior or implementation requests unless the user explicitly asks for read-only/no-change analysis. " +
-    "For 'general': fallback only when the task clearly needs code changes but does not fit new_game, bug_fix, revisit_previous_bug_fix, feature_implementation, or explore. Pass a concise task brief.";
-const codingAgentTypeFieldDescription = "Select the coding workflow. " +
-    "This is an expensive coding tool: before choosing the type, decide the bundled task brief and choose the one workflow that best fits the user's requested outcome. Do not use a second codeAgent call for verification after a successful complete result. " +
-    "'new_game': the first playable implementation after assets are generated on a brand-new game (no prior successful codeAgent run in this workspace); starts a fresh coding session. " +
-    "'bug_fix': first attempt to fix broken behavior after the first build. Builds and analyzes the compiled bundle for root cause, then implements a minimal fix. Use for errors, crashes, logic bugs, and initial 'not working' reports. A single call may include multiple related bug fixes in the task string. " +
-    "'revisit_previous_bug_fix': retry a bug fix after a prior successful bug_fix when the user says it still isn't fixed and you have a clear updated description. Resumes the last bug-fix Pi session without re-analyzing the compiled bundle. If the user's report is vague or you may have misunderstood the original bug, ask a clarifying follow-up in chat instead. " +
-    "'feature_implementation': add or change game behavior after the first build when nothing is fundamentally broken. Use for new mechanics, UI behavior, asset wiring, SDK integrations, balance changes, and polish. A single call may include multiple related feature requests in the task string. " +
-    "When one user turn contains both bug fixes and feature requests, prefer one bundled call with the dominant type when the items are related; split only for genuinely independent tasks that require different workflows. Do not use 'explore' first as a preflight for either workflow. " +
-    "'explore': read-only inspection of the codebase, asset manifest, wired gameplay, or game state with NO changes; pass a plain exploration question as the task. Never use for broken behavior, vague 'not working' reports, or implementation requests unless the user explicitly asks for read-only diagnosis. " +
-    "'general': last resort when code changes are needed but no other workflow applies. Runs the coding agent directly on the task without specialized pre-analysis.";
-export const parseCodingAgentTaskType = (type) => {
-    const parsed = codingAgentTaskTypeSchema.safeParse(type);
-    if (parsed.success) {
-        return { ok: true, value: parsed.data };
-    }
-    const allowed = codingAgentTaskTypeSchema.options
-        .map((option) => `"${option}"`)
-        .join(" | ");
-    return {
-        ok: false,
-        summary: `Invalid codeAgent type "${type}". Expected one of: ${allowed}.`,
-    };
+        .describe("Shared visual style constraints for all assets in this batch to maintain stylistic consistency."),
+    baseMaps: assetArray(baseMapSchema, "New base maps."),
+    extendMaps: assetArray(extendMapSchema, "Map extensions connected to existing maps."),
+    editMaps: assetArray(editMapSchema, "Static edits to an existing map."),
+    mapVfx: assetArray(mapVfxSchema, "Animated VFX on an existing map."),
+    baseCharacters: assetArray(baseCharacterSchema, "Character sprites."),
+    baseCharacterVariants: assetArray(baseCharacterVariantSchema, "Job-NPC prop-in-pose variants."),
+    characterAnimations: assetArray(characterAnimationSchema, "Character animation sheets."),
+    propsSingles: assetArray(propsSingleSchema, "Single pickup props."),
+    propsMultiples: assetArray(propsMultipleSchema, "Multi-prop sprite sheets."),
+    propsMapOverlays: assetArray(propsMapOverlaySchema, "Map-anchored overlay states (doors, chests, etc.)."),
+    hudElements: assetArray(hudElementSchema, "HUD/UI images."),
+    multipleHuds: assetArray(multipleHudsSchema, "Multi-widget HUD sheets."),
+    backgroundMusic: assetArray(musicBgSchema, "Background music tracks."),
 };
-/** DurableAgent tool boundary — accepts any string type; validate in execute. */
-export const codingAgentToolLooseSchema = z.object({
-    task: z.string().describe(codingAgentTaskFieldDescription),
-    type: z.string().describe(codingAgentTypeFieldDescription),
-});
-export const codingAgentToolSchema = z.object({
-    task: z.string().describe(codingAgentTaskFieldDescription),
-    type: codingAgentTaskTypeSchema.describe(codingAgentTypeFieldDescription),
-});
-export const newGameCodeAgentToolSchema = z.object({});
-export const exploreCodeAgentToolSchema = z.object({
-    query: z
-        .string()
-        .min(1)
-        .describe("One high-level natural-language, read-only codebase question for the coding agent to answer. Ask for current behavior, ownership, risks, and the safest implementation path. Do NOT include shell commands, grep terms, guessed file paths, or a file-by-file checklist unless those exact details came from prior tool output."),
-    isFollowup: z
-        .boolean()
-        .describe("Spell this field exactly as isFollowup. Use true only when continuing the most recent successful exploreCodeAgent session in this chat. Use false for a fresh, unrelated user goal. When true, the query should summarize the previous user question, the prior exploreCodeAgent query, the exploreCodeAgent output, and what needs clarification now."),
-});
-export const implementCodeAgentToolSchema = z.object({
-    task: z
-        .string()
-        .min(1)
-        .describe("One high-level natural-language implementation task for the coding agent. Write in first-person as a playtester reporting visible symptoms — do not guess file paths, subsystems, or technical root causes. NEVER embed or append raw file contents (assets.md, SCENES.md, package.json, scene files, or source code); Codex reads those autonomously. Do not write this as a chat transcript. For normal bugs/features, lead with the task and desired outcome, then include the user's symptom language as player report/context. For browser/runtime errors, keep the useful exception signature but drop hosted workspace URLs, repeated stack frames, minified line/column offsets, and bundled main.js/dist/main.js locations; do not infer feature/domain ownership from a property name alone. Ask the coding agent to ground the fix in actual code/assets and validate appropriately — do not invent root causes, subsystems, file names, inspected paths, or exact validation results. When isFollowup is true, summarize the prior same-tool chain in this task: what the user originally said, what you previously asked implementCodeAgent to do, what implementCodeAgent output, what changed or remained incomplete, and what the user is asking now. When attemptType is stuck_bug_loop, use isFollowup false and put the full stuck-bug context in this brief: original user report(s) verbatim, what you asked implementCodeAgent in each prior attempt, each prior implementCodeAgent output, previous changes it reported, latest user feedback verbatim, baseline commitId from the first checkpoint in that bug chain when available, and ask the coding agent to re-investigate from first principles, identify the real cause, and fix it. Do not split normal bug fixes or feature changes into locate/fix/verify task lists."),
-    isFollowup: z
-        .boolean()
-        .default(false)
-        .describe("Spell this field exactly as isFollowup. Use true only when continuing the most recent successful implementCodeAgent session in this chat. Use false for a fresh user goal, for an unrelated goal, or when the prior same-tool session was exploreCodeAgent rather than implementCodeAgent. For attemptType stuck_bug_loop, always use false — context goes in the task brief, not session history."),
-    attemptType: z
-        .enum(["normal", "stuck_bug_loop"])
-        .default("normal")
-        .describe("Use normal for fresh implementation and ordinary same-session follow-ups. Use stuck_bug_loop only when the user reports the same bug is still unresolved after one or more prior implementCodeAgent attempts; pair with isFollowup false and put original user report(s), what you asked implementCodeAgent in each prior attempt, each prior implementCodeAgent output, previous changes it reported, latest user feedback, and baseline commitId (if available) in the task brief. This starts a fresh coding-agent session with the full prior chain in the prompt."),
-});
-export const ASSET_TOOL_DESCRIPTION = "Generate layered game assets for a Stardew Valley–style 2.5D top-down (¾ bird's-eye) browser game. " +
-    "Preserve the user's visual wording, style constraints, placement, and exclusions in the asset brief; do not simplify them into a different asset idea. " +
-    "This is an expensive generation tool: before calling it, decide the complete asset batch needed for the user's requested outcome. Bundle all related asset needs into one call, and do not call it again to verify or add items that belonged in the same batch unless the first call failed/incomplete or the user explicitly approves another separate batch.";
-export const mcpGenerateAssetInputSchema = assetToolSchema.and(z.object({
+const mcpClientExtraFields = {
     output_dir: z
         .string()
         .optional()
-        .describe("Directory to write generated assets into. Defaults to the workspace root."),
+        .describe("Write directory. Defaults to workspace root."),
     workspace_root: z
         .string()
         .optional()
-        .describe("Root directory to read workspace context from (assets.md, src/data/*.json). Defaults to the current working directory."),
-    plan_used_to_build: z
-        .string()
-        .optional()
-        .describe("Optional plan text for first-time asset generation when assets.md is empty (replaces in-app plan chat lookup)."),
-    art_reference_url: z
-        .string()
-        .optional()
-        .describe("Optional art style reference image URL for base_map generation."),
-}));
-export const mcpGenerateAssetRequestSchema = mcpGenerateAssetInputSchema.and(z.object({
+        .describe("Root to read assets.md and src/data/*.json from."),
+};
+const mcpServerExtraFields = {
     workspace_files: z
         .record(z.string(), z.string())
         .optional()
-        .describe("Client-provided workspace files keyed by repo-relative path."),
-    session_id: z
+        .describe("Repo-relative path → file content."),
+    session_id: z.string().optional().describe("Stable generation session id."),
+    gameId: z
         .string()
         .optional()
-        .describe("Stable session id for this generation run (usually the job id)."),
-}));
+        .describe("Existing game id from index.html; set automatically by the client."),
+};
+const countAssets = (input) => (input.baseMaps?.length ?? 0) +
+    (input.extendMaps?.length ?? 0) +
+    (input.editMaps?.length ?? 0) +
+    (input.mapVfx?.length ?? 0) +
+    (input.baseCharacters?.length ?? 0) +
+    (input.baseCharacterVariants?.length ?? 0) +
+    (input.characterAnimations?.length ?? 0) +
+    (input.propsSingles?.length ?? 0) +
+    (input.propsMultiples?.length ?? 0) +
+    (input.propsMapOverlays?.length ?? 0) +
+    (input.hudElements?.length ?? 0) +
+    (input.multipleHuds?.length ?? 0) +
+    (input.backgroundMusic?.length ?? 0);
+/** MCP tool input — assets grouped by type. */
+export const assetToolSchema = z.object(assetBatchFields);
+const withType = (assets, type) => (assets ?? []).map((asset) => ({ ...asset, type }));
+/** Flatten grouped MCP input into the API payload agent-server expects. */
+export const flattenAssetToolInput = (input) => {
+    if (countAssets(input) === 0) {
+        throw new Error("At least one asset array must contain an asset.");
+    }
+    return {
+        artStyle: input.artStyle,
+        assets: [
+            ...withType(input.baseMaps, "base_map"),
+            ...withType(input.extendMaps, "extend_map"),
+            ...withType(input.editMaps, "edit_map"),
+            ...withType(input.mapVfx, "map_vfx"),
+            ...withType(input.baseCharacters, "base_character"),
+            ...withType(input.baseCharacterVariants, "base_character_variant"),
+            ...withType(input.characterAnimations, "character_animation"),
+            ...withType(input.propsSingles, "props_single"),
+            ...withType(input.propsMultiples, "props_multiple"),
+            ...withType(input.hudElements, "hud_element"),
+            ...withType(input.multipleHuds, "multiple_huds"),
+            ...withType(input.backgroundMusic, "music_bg"),
+            ...(input.propsMapOverlays ?? []).map((asset) => ({
+                ...asset,
+                type: "props_map_overlay",
+                prompt: asset.overlayStateBreakdown
+                    .map((state) => `${state.label}: ${state.prompt}`)
+                    .join(" | "),
+            })),
+        ],
+    };
+};
+/** Accept grouped MCP input or an already-flattened REST payload. */
+export const normalizeAssetToolInput = (input) => {
+    if (Array.isArray(input.assets)) {
+        const flat = input;
+        if (flat.assets.length === 0) {
+            throw new Error("At least one asset must be provided.");
+        }
+        return flat;
+    }
+    return flattenAssetToolInput(input);
+};
+export const ASSET_TOOL_DESCRIPTION = "Generate visual and audio game assets for a 2.5D top-down (3/4 oblique) browser game. " +
+    "Bundle all related assets (maps, characters, walk loops, HUD layout, and looping background music) " +
+    "for the current design phase into a single tool invocation to maintain stylistic consistency and establish proper dependency linking.";
+// Plain z.object — MCP SDK only advertises tool parameters for object schemas
+// (not z.and / z.refine), otherwise clients see { properties: {} }.
+export const mcpGenerateAssetInputSchema = z.object({
+    ...assetBatchFields,
+    ...mcpClientExtraFields,
+});
+export const mcpGenerateAssetRequestSchema = z.object({
+    ...assetBatchFields,
+    ...mcpClientExtraFields,
+    ...mcpServerExtraFields,
+});
 //# sourceMappingURL=asset-tool-schema.js.map