> ## Documentation Index
> Fetch the complete documentation index at: https://docs.summerengine.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Make Summer Games store art with your AI agent

> Your AI agent checks My assets, makes missing store art with the Summer MCP, crops it to each Summer Games slot, uploads it and puts it in the slot.

Your agent can fill every art slot on your store page. It uses your own art first and makes new art only for the slots that are empty.

The version of Summer made for Claude's connector directory cannot generate art. There, your agent uses your own art and My assets. The full server, `https://mcp.summerengine.com/mcp`, does everything on this page.

![Four steps: generate a picture with assets.generate\_image, crop it to the slot's shape around the focal point, upload it with assets.upload\_begin and assets.upload\_complete, and put it in the slot with store.set\_art.](https://mintcdn.com/summer-18f03259/EWsbF88vzOpECJxg/images/guide-art/publishing/crop-light.svg?fit=max\&auto=format\&n=EWsbF88vzOpECJxg\&q=85\&s=cc9a318e0ce29810e7aebbbfbebec83b)

## The order

**1. Read what is missing**

`summer_store_get_listing` lists every slot and what is in it. Add `previews: true` to see the current art.

**2. Check My assets**

`summer_assets_search` with `scope: "mine"` finds art you already have: key art, your hero, logos, screenshots. `summer_assets_get` shows one.

**3. Read the plan**

If your game has a plan, `plans.get` and `plans.directions` (its saved directions) hold its look, characters and world. New art should match them.

**4. Make what is missing**

`summer_assets_generate_image` makes the picture, then `summer_jobs_wait` waits for it. The new picture is saved in My assets.

**5. Crop it to the slot**

The agent crops the picture to the slot's exact shape and size itself, keeping the subject at the focal point.

**6. Upload the crop**

`assets.upload_begin`, then `assets.upload_complete`. The crop becomes one of your assets.

**7. Put it in the slot**

`store.set_art` with the slot id, the asset id and the focal point. It checks the shape before it uploads.

## Make one picture per shape

Ask the generator for the slot's own shape. Do not make one landscape picture and stretch it into every slot.

| Slot | Ask for | Prompt must say |
| - | - | - |
| `desktop.keyArt`, `mobile.keyArt` | 16:9, at least 1920×1080 | No text, no logo. Subject near the middle. |
| `mobile.tallCover` | 9:16, at least 1080×1920 | No text. Subject in the middle 4:5. Calm, dark bottom third. |
| `desktop.capsuleTall` | 3:4, at least 1200×1600 | Logo allowed, inside the middle 80%. |
| `desktop.capsuleWide` | 460:215, at least 920×430 | Logo allowed. |
| `desktop.icon`, `mobile.icon` | 1:1, 1024×1024 | No words. One clear silhouette on a plain background. |

### Reach the store sizes

Key art needs at least 1920×1080 and the tall cover at least 1080×1920. Many models return 1024×1024 by default, which is too small.

* Ask for the slot's shape and size: pass `aspectRatio` (`"16:9"`, `"9:16"`, `"1:1"`) to `summer_assets_generate_image`, with `width` and `height` set to the slot's minimum (for example `1920` and `1080`). Leave `model` out: Summer then picks a model that reaches that size.
* Check what came back: the result gives the real width and height. If the size is below the slot's minimum, do not stretch it.
* Or generate a large square and crop it. A 2048×2048 picture (for example from `seedream-5-pro`) crops to 2048×1152 for key art and 1152×2048 for the tall cover, both above the minimum.

**Screenshots are never generated.** They are real gameplay:

* `summer_capture_gameplay` runs your game in an offscreen engine window, with no editor open, and saves real frames at the size you ask, for example 1920×1080.
* With the editor open, `summer_screenshot` with `target: "game"` captures the running game.
* Or ask the owner to capture them.

Screenshots show the game as players see it. Its own HUD and interface are fine. Do not add captions, logos or overlays.

## Crop it yourself

Generators return their own sizes. Your agent crops each picture to the slot itself:

1. Compute the slot's shape. For example, from a 2048×1152 picture to a 9:16 tall cover: height 1152, width 1152 × 9 ÷ 16 = 648.
2. Center the crop on the subject, then move it so it stays inside the picture.
3. If the crop is below the slot's minimum (1080×1920 for the tall cover), generate a larger picture instead of stretching it.
4. Save it as PNG, JPEG or WebP.

```python title="crop_to_slot.py (Pillow)" theme={null}
from PIL import Image

def crop_to_slot(path, out, ratio_w, ratio_h, min_w, min_h, focus_x=0.5, focus_y=0.5):
    img = Image.open(path).convert("RGB")
    w, h = img.size
    target = ratio_w / ratio_h
    if w / h > target:            # too wide: cut the sides
        cw, ch = round(h * target), h
    else:                         # too tall: cut top and bottom
        cw, ch = w, round(w / target)
    left = min(max(round(focus_x * w - cw / 2), 0), w - cw)
    top = min(max(round(focus_y * h - ch / 2), 0), h - ch)
    if cw < min_w or ch < min_h:      # never stretch: make a larger picture
        raise ValueError(f"crop {cw}x{ch} is below the slot minimum {min_w}x{min_h}")
    img = img.crop((left, top, left + cw, top + ch))
    img.save(out, quality=92)

crop_to_slot("square-2048.png", "tall-cover.jpg", 9, 16, 1080, 1920, focus_x=0.45)
```

Each slot's shape must match within 2%.

## Upload the crop

`assets.upload_begin` takes no inputs. It returns a signed upload: an `uploadUrl`, the `fields` to send, and a ready `curl` example. Send the file with every field:

```bash theme={null}
curl -sS "<uploadUrl>" -F api_key=… -F timestamp=… -F signature=… \
  -F public_id=… -F folder=… -F allowed_formats=… -F overwrite=false \
  -F file=@./tall-cover.jpg
```

Then pass four values from Cloudinary's answer to `assets.upload_complete`. Its `uploadSignature` is the `signature` in that answer, not the one you sent in `fields`:

```json theme={null}
{
  "op": "assets.upload_complete",
  "input": {
    "publicId": "<public_id>",
    "version": 1760040000,
    "uploadSignature": "<signature>",
    "format": "jpg",
    "title": "Tall cover"
  }
}
```

It returns the `assetId`. Uploads are free, at most 32 MB per picture. A picture that is already at a public `https` address can skip this: pass it as a `url` source.

## Put it in the slot

Run `store.set_art` with `summer_call`:

```json title="One picture, with a focal point" theme={null}
{
  "op": "store.set_art",
  "input": {
    "gameId": "<gameId>",
    "slot": "mobile.tallCover",
    "sources": [{ "assetId": "<assetId>" }],
    "focalPoint": { "x": 0.45, "y": 0.4 }
  }
}
```

```json title="Add screenshots" theme={null}
{
  "op": "store.set_art",
  "input": {
    "gameId": "<gameId>",
    "slot": "desktop.screenshots",
    "sources": [{ "assetId": "<shot1>" }, { "assetId": "<shot2>" }],
    "mode": "append"
  }
}
```

* `focalPoint` is from 0 to 1, from the left and from the top. Key art, capsules and the tall cover only.
* `mode`: `replace` (default) or `append`. Screenshots take a list of up to 8; other slots take one picture.
* An empty `sources` list clears the slot.

## Ask your agent

**Make my missing store art.** Your agent makes, crops and uploads art for every empty slot.

Make the missing store art for my game on Summer Games. Use the Summer Engine
MCP and the `store-art` skill, and follow
[https://docs.summerengine.com/publishing/generate-store-art.md](https://docs.summerengine.com/publishing/generate-store-art.md).

* Read my store page and list the empty slots. Look in My assets first.
* For each slot still empty, read my plan's saved direction and make one
  picture in the slot's own shape with summer\_assets\_generate\_image, at least
  the slot's minimum size. No text, and no other game's characters.
* Crop it yourself to the slot's exact size around the subject, upload it
  with assets.upload\_begin and assets.upload\_complete, and put it in the
  slot with store.set\_art and a focal point.
* Show me each picture before it goes in. Never generate screenshots:
  capture real gameplay with summer\_capture\_gameplay.

## Rules

* Make art from **your** game: your hero, your world, your look. Never another game's characters. Never fake gameplay.
* Check My assets before you make anything. Making art uses your Summer credits: your agent spends within your credits and auto top-up limit.
* No text, logo or caption in key art, the tall cover or icons. Screenshots may show the game's own HUD, never added captions, logos or overlays.
* Stay inside the 20-picture budget across both stores.

Sizes and reasons for every slot: [Store art](https://docs.summerengine.com/publishing/store-art.md).

***

Does this not help you? [Reach out on Discord!](https://discord.gg/summerengine)


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.