gen-mcp-server 0.1.0__tar.gz

gen_mcp_server-0.1.0/.gitignore

@@ -0,0 +1,7 @@
+.venv/
+__pycache__/
+*.egg-info/
+dist/
+build/
+.pytest_cache/
+*.pyc

gen_mcp_server-0.1.0/PKG-INFO

@@ -0,0 +1,53 @@
+Metadata-Version: 2.4
+Name: gen-mcp-server
+Version: 0.1.0
+Summary: GEN MCP server — exposes the GEN platform (Auto Content Engine + agent chat) to MCP clients like Claude Code, Cursor, and VS Code.
+Project-URL: Homepage, https://api.gen.pro
+Project-URL: Repository, https://github.com/poweredbyGEN/gen-agentic
+Author: GEN
+License: MIT
+Keywords: ai,content,gen,gen-pro,mcp,video
+Requires-Python: >=3.10
+Requires-Dist: fastmcp>=2.0.0
+Requires-Dist: httpx>=0.27.0
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: respx>=0.21; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# gen-mcp-server
+
+MCP server for the **GEN** platform — exposes the GEN Auto Content Engine + agent
+chat to MCP clients (Claude Code, Cursor, VS Code).
+
+It mirrors what a user can do through the GEN front end: set up agents, build
+vidsheets, generate images (incl. Nano Banana Pro) and video, voice, render,
+schedule/publish, manage credits, and run daily tasks. The `gen_do` tool
+delegates natural-language goals to the GEN composer for multi-step outcomes.
+
+## Install
+
+```bash
+pip install gen-mcp-server      # or: uvx gen-mcp-server
+```
+
+## Configure (Claude Code)
+
+```bash
+claude mcp add gen --env GEN_API_KEY=your-pat -- gen-mcp-server
+```
+
+Get a Personal Access Token at https://gen.pro (log in → pick an agent → API page).
+
+## Environment
+
+- `GEN_API_KEY` (required) — your Personal Access Token
+- `GEN_API_BASE_URL` (default `https://api.gen.pro/v1`)
+- `GEN_AGENT_API_URL` (default `https://agent.gen.pro/v1`)
+- `GEN_AGENT_CORE_API_URL` (default `https://agent-core.gen.pro/v1`)
+
+## Errors & credits
+
+Backend errors are surfaced cleanly. If you run out of credits, tools return
+`insufficient_credits: true` with a message pointing to `gen_buy_credits`.

gen_mcp_server-0.1.0/README.md

@@ -0,0 +1,35 @@
+# gen-mcp-server
+
+MCP server for the **GEN** platform — exposes the GEN Auto Content Engine + agent
+chat to MCP clients (Claude Code, Cursor, VS Code).
+
+It mirrors what a user can do through the GEN front end: set up agents, build
+vidsheets, generate images (incl. Nano Banana Pro) and video, voice, render,
+schedule/publish, manage credits, and run daily tasks. The `gen_do` tool
+delegates natural-language goals to the GEN composer for multi-step outcomes.
+
+## Install
+
+```bash
+pip install gen-mcp-server      # or: uvx gen-mcp-server
+```
+
+## Configure (Claude Code)
+
+```bash
+claude mcp add gen --env GEN_API_KEY=your-pat -- gen-mcp-server
+```
+
+Get a Personal Access Token at https://gen.pro (log in → pick an agent → API page).
+
+## Environment
+
+- `GEN_API_KEY` (required) — your Personal Access Token
+- `GEN_API_BASE_URL` (default `https://api.gen.pro/v1`)
+- `GEN_AGENT_API_URL` (default `https://agent.gen.pro/v1`)
+- `GEN_AGENT_CORE_API_URL` (default `https://agent-core.gen.pro/v1`)
+
+## Errors & credits
+
+Backend errors are surfaced cleanly. If you run out of credits, tools return
+`insufficient_credits: true` with a message pointing to `gen_buy_credits`.

gen_mcp_server-0.1.0/pyproject.toml

@@ -0,0 +1,34 @@
+[project]
+name = "gen-mcp-server"
+version = "0.1.0"
+description = "GEN MCP server — exposes the GEN platform (Auto Content Engine + agent chat) to MCP clients like Claude Code, Cursor, and VS Code."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "GEN" }]
+keywords = ["mcp", "gen", "gen-pro", "ai", "video", "content"]
+dependencies = [
+    "fastmcp>=2.0.0",
+    "httpx>=0.27.0",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=8.0", "pytest-asyncio>=0.23", "respx>=0.21"]
+
+[project.scripts]
+gen-mcp-server = "gen_mcp_server.server:main"
+
+[project.urls]
+Homepage = "https://api.gen.pro"
+Repository = "https://github.com/poweredbyGEN/gen-agentic"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/gen_mcp_server"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]

gen_mcp_server-0.1.0/src/gen_mcp_server/__init__.py

@@ -0,0 +1,3 @@
+"""gen-mcp-server — MCP server for the GEN platform."""
+
+__version__ = "0.1.0"

gen_mcp_server-0.1.0/src/gen_mcp_server/clients/__init__.py

@@ -0,0 +1,4 @@
+from .client import CLIENT_TAG, agent, agent_core, api
+from .errors import GenApiError, normalize_error
+
+__all__ = ["CLIENT_TAG", "GenApiError", "agent", "agent_core", "api", "normalize_error"]

gen_mcp_server-0.1.0/src/gen_mcp_server/clients/client.py

@@ -0,0 +1,101 @@
+"""HTTP clients for the three GEN backends.
+
+The MCP talks to three base URLs (same split the front end uses):
+  * api.gen.pro        — Rails: content engine, generations, assets, billing
+  * agent.gen.pro      — gen-agentic: chat/run, ideas, recurring jobs, schedule
+  * agent-core.gen.pro — agent-core: brand/onboarding, watchlists
+
+Every outbound request carries:
+  * ``X-API-Key`` — the user's PAT (from GEN_API_KEY)
+  * ``X-Client``  — usage attribution so existing GEN dashboards can filter MCP
+                    traffic (no new analytics system needed)
+
+Failures are normalized via :func:`normalize_error` into ``GenApiError`` so the
+MCP surfaces backend errors (especially out-of-credits) exactly like the FE.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Any
+
+import httpx
+
+from .errors import GenApiError, normalize_error
+
+__version__ = "0.1.0"
+CLIENT_TAG = f"gen-mcp-server/{__version__}"
+
+API_BASE = os.environ.get("GEN_API_BASE_URL", "https://api.gen.pro/v1")
+AGENT_BASE = os.environ.get("GEN_AGENT_API_URL", "https://agent.gen.pro/v1")
+AGENT_CORE_BASE = os.environ.get("GEN_AGENT_CORE_API_URL", "https://agent-core.gen.pro/v1")
+
+
+def _api_key() -> str:
+    key = os.environ.get("GEN_API_KEY")
+    if not key:
+        raise GenApiError(
+            "GEN_API_KEY is not set. Create a Personal Access Token at "
+            "https://gen.pro (log in → pick an agent → API page) and set it as "
+            "the GEN_API_KEY environment variable.",
+            error_code="missing_api_key",
+        )
+    return key
+
+
+class GenClient:
+    """A thin async HTTP client for one GEN backend base URL."""
+
+    def __init__(self, base_url: str) -> None:
+        self.base_url = base_url
+
+    async def request(
+        self,
+        method: str,
+        path: str,
+        *,
+        params: dict[str, Any] | None = None,
+        json: Any | None = None,
+        data: Any | None = None,
+    ) -> Any:
+        headers = {
+            "X-API-Key": _api_key(),
+            "X-Client": CLIENT_TAG,
+            "Accept": "application/json",
+        }
+        url = f"{self.base_url}{path}"
+        try:
+            async with httpx.AsyncClient(timeout=120) as http:
+                resp = await http.request(
+                    method, url, params=params, json=json, data=data, headers=headers
+                )
+        except httpx.TimeoutException as exc:
+            raise GenApiError(
+                "The GEN service took too long to respond. Try again.",
+                error_code="timeout",
+            ) from exc
+        except httpx.HTTPError as exc:
+            raise GenApiError(
+                "Could not reach the GEN service.", error_code="network_error"
+            ) from exc
+
+        if resp.is_success:
+            if not resp.content:
+                return {"ok": True}
+            try:
+                return resp.json()
+            except ValueError:
+                return {"ok": True, "raw": resp.text}
+
+        # Failure → normalize to a user-facing error (handles out-of-credits).
+        try:
+            body: Any = resp.json()
+        except ValueError:
+            body = resp.text
+        raise normalize_error(resp.status_code, body)
+
+
+# Singletons for the three backends.
+api = GenClient(API_BASE)
+agent = GenClient(AGENT_BASE)
+agent_core = GenClient(AGENT_CORE_BASE)

gen_mcp_server-0.1.0/src/gen_mcp_server/clients/errors.py

@@ -0,0 +1,118 @@
+"""Error normalization for the GEN MCP server.
+
+The MCP must surface backend errors to the user EXACTLY like the GEN backend
+tells the front end. The backend returns a standard shape on failure:
+
+    {"error": "<human message>", "error_code": "<machine_code>"}
+
+This module turns any HTTP failure into a clean, user-facing ``GenApiError``
+with a friendly message. Out-of-credits is treated specially: it is the most
+common paid-operation failure and the user should be told plainly that they are
+out of credits (and how to buy more), never shown a raw 422/500.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+# Backend error_codes that mean "not enough credits to run this paid operation".
+INSUFFICIENT_CREDITS_CODES = {
+    "insufficient_credits_for_job",
+    "insufficient_credits",
+    "not_enough_credits",
+    "insufficient_generic_credits",
+}
+
+
+class GenApiError(Exception):
+    """A normalized, user-facing GEN API error.
+
+    Attributes
+    ----------
+    message: friendly message to show the user
+    error_code: the backend machine code (may be None for transport errors)
+    status: HTTP status code (may be None)
+    insufficient_credits: True when this is an out-of-credits failure
+    """
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        error_code: str | None = None,
+        status: int | None = None,
+        insufficient_credits: bool = False,
+    ) -> None:
+        super().__init__(message)
+        self.message = message
+        self.error_code = error_code
+        self.status = status
+        self.insufficient_credits = insufficient_credits
+
+    def to_user_text(self) -> str:
+        """Render the error the way it should appear to the user via MCP."""
+        if self.insufficient_credits:
+            return (
+                "⚠️ You're out of credits for this operation. "
+                "Top up with the `gen_buy_credits` tool (or upgrade your plan with "
+                "`gen_upgrade_workspace`), then try again."
+            )
+        code = f" [{self.error_code}]" if self.error_code else ""
+        return f"❌ {self.message}{code}"
+
+
+def normalize_error(status: int, body: Any) -> GenApiError:
+    """Map a failed HTTP response into a GenApiError.
+
+    ``body`` is whatever the response carried — ideally the standard
+    ``{"error", "error_code"}`` dict, but we defend against html/plain/empty.
+    """
+    error_code: str | None = None
+    message: str | None = None
+
+    if isinstance(body, dict):
+        error_code = body.get("error_code") or body.get("code")
+        # FastAPI validation errors come back as {"detail": [...]} — handle first.
+        detail = body.get("detail")
+        if isinstance(detail, list):
+            message = (
+                "; ".join(str(d.get("msg", d)) if isinstance(d, dict) else str(d) for d in detail)
+                or "Validation error"
+            )
+        else:
+            message = (
+                body.get("error")
+                or body.get("message")
+                or (detail if isinstance(detail, str) else None)
+            )
+    elif isinstance(body, str) and body.strip():
+        message = body.strip()[:500]
+
+    insufficient = bool(error_code and error_code in INSUFFICIENT_CREDITS_CODES)
+    # Some backends only flag credits via 402 Payment Required.
+    if status == 402:
+        insufficient = True
+
+    if message is None:
+        message = _default_message_for_status(status)
+
+    return GenApiError(
+        message,
+        error_code=error_code,
+        status=status,
+        insufficient_credits=insufficient,
+    )
+
+
+def _default_message_for_status(status: int) -> str:
+    return {
+        400: "The request was invalid.",
+        401: "Authentication failed — check your GEN_API_KEY.",
+        403: "You don't have permission to do that.",
+        404: "Not found.",
+        422: "The request could not be processed.",
+        429: "Rate limited — please slow down and retry.",
+        500: "The GEN service hit an internal error.",
+        502: "The GEN service is temporarily unavailable.",
+        503: "The GEN service is temporarily unavailable.",
+    }.get(status, f"Request failed (HTTP {status}).")

gen_mcp_server-0.1.0/src/gen_mcp_server/prompts/__init__.py

@@ -0,0 +1,142 @@
+"""MCP Prompts — the GEN home-screen Plays.
+
+These are the 9 published default Plays shown on the per-agent home screen
+(``src/gen/plays/registry.py::DEFAULT_PLAYS``). Exposing them as MCP prompts
+gives MCP clients the same vetted, high-value starting points users get in the
+product. Each prompt returns the Play's seed instruction; the assistant runs it
+(via gen_do delegation or the deterministic tools).
+
+This module currently mirrors the registry statically. The follow-on phase
+derives these from the live ``shortcut_registry`` so new/edited Plays appear as
+MCP prompts automatically (and only gate-passed Plays are surfaced).
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+# Mirror of the 9 published default Plays (registry.py DEFAULT_PLAYS),
+# grouped: make_content / spot_trends / know_audience.
+DEFAULT_PLAYS: list[dict[str, str]] = [
+    {
+        "name": "monitor_and_create_daily",
+        "group": "make_content",
+        "title": "Monitor a topic/account and create videos every day",
+        "prompt": (
+            "I want to automatically monitor a topic or account and have videos "
+            "created for me in my formats every day. Help me set this up: ask me "
+            "what to monitor, which video formats, and how often, explain what the "
+            "daily automation will do, and walk me through turning it into a "
+            "recurring Task. Use multi-step orchestration so it can monitor then "
+            "create then schedule in one run once it's set up. Before creating the "
+            "Task, summarize the exact details — what's monitored, formats, cadence, "
+            "delivery — and ask me to confirm; only create it after I confirm."
+        ),
+    },
+    {
+        "name": "watchlist_and_weekly_report",
+        "group": "spot_trends",
+        "title": "Create a watchlist and send me a weekly report",
+        "prompt": (
+            "I want a watchlist of the topics or accounts I care about and a weekly "
+            "report emailed to me. Help me set this up: ask me what to track, confirm "
+            "the watchlist contents and the weekly report details, and only create "
+            "the watchlist and the recurring weekly Task after I confirm."
+        ),
+    },
+    {
+        "name": "top_videos_in_my_niche",
+        "group": "spot_trends",
+        "title": "Top-performing videos in my niche, ranked by views last month",
+        "prompt": (
+            "Find the top-performing videos in my niche over the last month, ranked "
+            "by view count. Return the top ~20 with creator, views, hook, and format; "
+            "group them into the 3-4 themes that dominate; and tell me which theme I "
+            "should make a video about first. If you can only pull N, say so — no "
+            "silent caps."
+        ),
+    },
+    {
+        "name": "competitor_sentiment",
+        "group": "know_audience",
+        "title": "Positive and negative sentiment about my competitors",
+        "prompt": (
+            "Pull recent comments across my competitors and classify sentiment "
+            "positive / negative / neutral. Summarize what people praise vs criticize "
+            "for each, with representative quotes, and flag the biggest opening for "
+            "me. Disclose how many comments you analyzed."
+        ),
+    },
+    {
+        "name": "my_account_hooks_and_views",
+        "group": "make_content",
+        "title": "Analyze my account's top videos by hooks and views",
+        "prompt": (
+            "Look at my account's best-performing recent videos by views. Break down "
+            "the hooks and formats that overperform my own average, what they have in "
+            "common, and 3 concrete things to repeat. If I haven't connected an "
+            "account, ask for my handle first."
+        ),
+    },
+    {
+        "name": "five_content_ideas",
+        "group": "make_content",
+        "title": "Give me 5 content ideas for my niche",
+        "prompt": (
+            "Give me 5 content ideas for my niche tuned to what's working right now — "
+            "each with a hook, format, and why it'll land. If you don't know my niche "
+            "yet, ask me first, then generate."
+        ),
+    },
+    {
+        "name": "ideas_from_a_video",
+        "group": "make_content",
+        "title": "Content ideas based on a specific video",
+        "prompt": (
+            "I want content ideas based on a specific video. Ask me for the link, "
+            "analyze its hook, format, and structure, then give me 5 ideas that adapt "
+            "what works to my brand."
+        ),
+    },
+    {
+        "name": "topic_comment_sentiment",
+        "group": "know_audience",
+        "title": "Analyze positive and negative comments for a topic",
+        "prompt": (
+            "Analyze positive and negative comments for a topic. Ask me for the topic "
+            "if I haven't given one, then pull recent comments, classify sentiment, "
+            "cluster the themes, and surface the strongest content angle. Disclose the "
+            "sample size."
+        ),
+    },
+    {
+        "name": "video_templates",
+        "group": "make_content",
+        "title": "Show me templates for creating videos",
+        "prompt": (
+            "Show me video templates matched to the formats I make. List the available "
+            "templates with what each is good for, and offer to clone one into a new "
+            "vidsheet so I can go from idea to finished video fast."
+        ),
+    },
+]
+
+
+def register_all(mcp: Any) -> None:
+    def _make(play: dict[str, str]):
+        seed = play["prompt"]
+
+        def _prompt(agent_id: str) -> str:
+            return (
+                f"[GEN Play — {play['title']}] (agent {agent_id})\n\n{seed}\n\n"
+                "Use gen_do to run this end-to-end, or the deterministic gen_* tools "
+                "for exact steps. If a paid step reports insufficient_credits, tell me "
+                "I'm out of credits and offer gen_buy_credits."
+            )
+
+        _prompt.__name__ = play["name"]
+        _prompt.__doc__ = f"GEN Play ({play['group']}): {play['title']}"
+        return _prompt
+
+    for play in DEFAULT_PLAYS:
+        mcp.prompt()(_make(play))

gen_mcp_server-0.1.0/src/gen_mcp_server/resources/__init__.py

@@ -0,0 +1,5 @@
+from . import guidance
+
+
+def register_all(mcp) -> None:
+    guidance.register(mcp)

gen_mcp_server-0.1.0/src/gen_mcp_server/resources/guidance.py

@@ -0,0 +1,135 @@
+"""MCP Resources — the guidance layer (mental model + how-to-combine).
+
+These teach the assistant HOW GEN works and how to combine tools into outcomes
+(the knowledge a flat tool list lacks). The mental model spans the FULL breadth
+of GEN; recipes show how to combine capabilities; the credits/errors note covers
+failure handling. The daily guidance Task can regenerate richer versions later.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+MENTAL_MODEL = """\
+# GEN — the full mental model
+
+GEN is an end-to-end platform for autonomous social video. It turns a brand or
+idea into finished, on-brand short-form (and stitched long-form) video, and runs
+the whole loop — research → ideate → produce → publish → monitor — on autopilot.
+
+## The core objects
+- **Workspace / Organization** — billing container; holds agents and credits.
+- **Agent (an "AI human")** — a persistent identity: brand, persona, voice, look,
+  avatars, linked social accounts, monitored topics. Everything is scoped to an
+  agent_id.
+- **Vidsheet (Auto Content Engine)** — a spreadsheet-as-video-editor: rows are
+  scenes/variants, columns are ingredients, cells hold content, and layers stack
+  (video / image / audio / captions / text overlays) into a final render.
+- **Generation** — any AI job: text, image, video, speech, lipsync, captions.
+- **Content idea / Play / Task** — the planning + automation layer.
+
+## What GEN can do (breadth)
+
+**1. Research & trends**
+- Trending videos / hashtags / sounds by niche, region, timeframe.
+- Creator discovery; analyze a creator's or your own hooks & formats.
+- Cross-platform web research (Reddit, X, YouTube, TikTok, IG, HN, etc.).
+- Comment mining: audience sentiment on a topic or competitors.
+- Watchlists: saved topics/accounts monitored over time + weekly reports.
+
+**2. Ideation**
+- Data-driven content ideas tuned to what's working now in your niche.
+- Ideas adapted from a specific reference video (analyze → adapt to brand).
+- Refine ideas conversationally; set persistent creative preferences.
+
+**3. Production (the vidsheet engine)**
+- Clone a template (fastest path) or build a vidsheet from scratch.
+- Generate images — Gemini "Nano Banana" family incl. **nano-banana-pro**
+  (Gemini 3 Pro Image), 2K, aspect 1:1/9:16/16:9.
+- Generate video — Seedance (1.0/1.5/2.0), Veo, Kling, Sora, Pika; short clips
+  (Seedance 2.0 up to ~15s) with ratios incl. 21:9.
+- Voice — list/create/design/clone voices; text-to-speech.
+- Avatars & talking avatars — create, train custom avatars, talking-head video,
+  lipsync.
+- Captions, text overlays, music selection, B-roll import (any length, from a
+  URL), background removal, upscaling, image variants.
+- **Render** — composite all layers/rows into ONE deliverable. This is how you
+  assemble multi-scene and long-form video (combine many clips + B-roll → render).
+
+**4. Publishing & scheduling**
+- Publish or schedule posts to **tiktok / instagram / youtube / x**.
+- schedule_type: now | specific_time (calendar) | next slot. Full post calendar
+  CRUD (add / list / update / delete).
+- Connect social accounts via an OAuth URL the user opens (no credentials handled
+  by the MCP).
+
+**5. Automation (Tasks)**
+- Recurring jobs: run any prompt on a schedule (daily/weekly/monthly). A fired
+  Task runs the SAME composer as chat, so a daily Task can generate + render +
+  (with confirmation) auto-publish video. Pause/resume/run-now/delete.
+
+**6. Billing / self-service**
+- Read credit balance + usage history (analyze your spend).
+- Buy credits / upgrade workspace (confirm price with the user first — real money).
+
+## Two ways to drive GEN via this MCP
+- **Deterministic tools** (gen_create_row, gen_create_video, gen_render_video,
+  gen_schedule_post, ...) — for EXACT single actions you know you want.
+- **gen_do(goal)** — delegate a natural-language OUTCOME to the GEN composer,
+  which classifies intent and orchestrates multi-step (e.g. "make a 5-scene 16:9
+  video about X and schedule it for tomorrow 9am"). Use this for composed goals.
+
+## Knowing what's possible vs how to combine
+Most real outcomes are COMBINATIONS (research → idea → produce → publish → repeat
+daily). A single clip is short; long/multi-scene video comes from combining clips
++ B-roll then rendering. When in doubt, describe the OUTCOME to gen_do and let the
+composer sequence the steps.
+"""
+
+LONGFORM_RECIPE = """\
+# Recipe: build a long / multi-scene video
+
+A single generation is one short clip (~5-15s). To make a long or multi-scene
+video, COMBINE clips + imported B-roll, then render:
+
+1. gen_create_engine (or gen_clone_template) → a vidsheet.
+2. For each scene: gen_create_row, then gen_create_video (per-scene prompt).
+   For images use gen_create_image with version='nano-banana-pro' (Gemini 3 Pro).
+3. Import long B-roll with gen_import_asset_from_url (YouTube/TikTok/direct file —
+   no length limit) and place as layers.
+4. gen_render_video on the final_video cell → ONE combined video.
+
+Or just: gen_do("create a 5-scene 16:9 video about <topic>") and let the
+composer do all of the above.
+
+To do it every day: gen_create_recurring_job(prompt="create a video about ...",
+cadence="daily", auto_publish=true) — confirm the details first.
+"""
+
+CREDITS_NOTE = """\
+# Credits & errors
+
+Paid operations (generation, voice, research) cost credits. If a tool returns
+insufficient_credits=true, the user is OUT OF CREDITS — tell them plainly and
+offer gen_buy_credits (confirm the plan/price first) or gen_upgrade_workspace.
+Check gen_get_credit_balance before large jobs; estimate with gen_estimate_job;
+analyze spend with gen_get_credit_usage.
+
+All backend errors are surfaced as {ok:false, error, error_code} — present the
+message to the user; never swallow it. Purchases and publishing are real-world
+actions — confirm with the user before executing.
+"""
+
+
+def register(mcp: Any) -> None:
+    @mcp.resource("gen://mental-model")
+    def mental_model() -> str:
+        return MENTAL_MODEL
+
+    @mcp.resource("gen://recipes/long-form-video")
+    def longform() -> str:
+        return LONGFORM_RECIPE
+
+    @mcp.resource("gen://credits-and-errors")
+    def credits() -> str:
+        return CREDITS_NOTE

gen_mcp_server-0.1.0/src/gen_mcp_server/server.py

@@ -0,0 +1,27 @@
+"""GEN MCP server entry point (FastMCP).
+
+Exposes the GEN platform to MCP clients. Tools mirror what a user can do through
+the GEN front end; gen_do delegates natural-language goals to the GEN composer.
+Backend errors — especially out-of-credits — are surfaced to the user cleanly.
+"""
+
+from __future__ import annotations
+
+from fastmcp import FastMCP
+
+from . import prompts, resources, tools
+
+mcp = FastMCP("gen")
+
+tools.register_all(mcp)
+resources.register_all(mcp)
+prompts.register_all(mcp)
+
+
+def main() -> None:
+    """Run over stdio (the transport MCP clients use)."""
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()