@palettelab/cli 0.3.55 → 0.3.57

package/README.md

@@ -398,8 +398,39 @@ package dependency policy, and backend package size.
 
 ## OS Notifications
 
-Apps can push persistent notifications into the Palette OS notification center
-(the bell) with `@palettelab/sdk@0.1.25+`:
+Backend apps created or served by the CLI should use the Python helper from the
+CLI-bundled backend SDK. This is the helper to use for cross-user flows such as
+leave approvals, review requests, task assignment, and same-organisation
+recipient targeting:
+
+```python
+from palette_sdk import PluginContext, get_plugin_context, require_permission
+
+@router.post("/exports", dependencies=[require_permission("resources:write")])
+async def start_export(ctx: PluginContext = Depends(get_plugin_context)):
+    ...
+    await ctx.notifications.push(
+        "Approval needed",
+        body="A leave request needs approval.",
+        to=ctx.notifications.user(approver_user_id),
+        target_app="hierarchy-app",
+        route=f"/approvals/{request_id}",
+        severity="warning",            # "info" | "success" | "warning" | "error"
+        data={"request_id": request_id},
+    )
+```
+
+By default the backend helper notifies the user making the current request;
+pass `to=ctx.notifications.user(...)`, `.email(...)`, `.member(...)`,
+`.role(...)`, `.team(...)`, or `.mentions_from(...)` to notify other same-org
+members. `target_app` controls the app icon badge and default click target.
+`route` is optional and should only be set when the target app has a matching
+deep-link page. See `docs/python-backend-sdk.md` ("OS Notifications From
+Python") for details.
+
+Frontend apps can also push notifications for the current signed-in user with
+`@palettelab/sdk@0.1.27+`. This TypeScript helper is frontend-only and is not
+the Python backend helper:
 
 ```ts
 import { notifications } from "@palettelab/sdk"
@@ -409,35 +440,13 @@ await notifications.push({
   title: "Export complete",
   body: "Your report is ready to download.",
   severity: "success",          // "info" | "success" | "warning" | "error"
+  targetApp: "reports-app",     // app icon that owns the unread badge
   route: "/exports/123",        // opened inside your app on click
 })
 ```
 
-The notification shows as a live toast plus a notification-center entry;
-clicking it opens/focuses your app window at the resolved route. The stable
-contract is `POST /api/v1/notifications/` on the platform API (delivery streams
-over `GET /api/v1/notifications/stream`, SSE).
-
-Python plugin backends can push too, via `ctx.notifications` (palette-sdk
-`0.1.9+`):
-
-```python
-from palette_sdk import PluginContext, get_plugin_context, require_permission
-
-@router.post("/exports", dependencies=[require_permission("resources:write")])
-async def start_export(ctx: PluginContext = Depends(get_plugin_context)):
-    ...
-    await ctx.notifications.push(
-        "Export complete",
-        body="Your report is ready to download.",
-        severity="success",
-        route="/exports/123",
-    )
-```
-
-By default the backend helper notifies the user making the current request;
-pass `user_id` to notify another member of the same organisation. See
-`docs/python-backend-sdk.md` ("OS Notifications From Python") for details.
+Both helpers create a live toast plus a notification-center entry. Use these
+helpers rather than hand-building platform notification API calls.
 
 During `pltt dev`, frontend pushes call the platform backend directly
 (`NEXT_PUBLIC_API_URL`, default `http://localhost:8000`) in the user's session,

package/backend-sdk/palette_sdk/__init__.py

@@ -6,7 +6,7 @@ from palette_sdk.data_rooms import DataRoomsClient
 from palette_sdk.connections import ConnectionStatus, MissingConnectionError, PluginConnectionsClient
 from palette_sdk.apps import AppInteropClient, AppServiceClient, MissingAppServiceError
 from palette_sdk.members import OrganizationMembersClient
-from palette_sdk.notifications import NotificationsClient
+from palette_sdk.notifications import NotificationRecipient, NotificationsClient
 from palette_sdk.platform_services import (
     LocalRedisService,
     LocalVectorService,
@@ -45,6 +45,7 @@ from palette_sdk.services import (
     service,
     services,
 )
+from palette_sdk.mcp import McpClient, mcp, mcp_prompt, mcp_resource, mcp_tool
 from palette_sdk.config import get_config, require_config
 from palette_sdk.webhooks import sign_webhook, verify_webhook_signature
 from palette_sdk.testing import route_permission_issues
@@ -64,6 +65,7 @@ __all__ = [
     "MissingAppServiceError",
     "OrganizationMembersClient",
     "NotificationsClient",
+    "NotificationRecipient",
     "LocalRedisService",
     "LocalVectorService",
     "PlatformServiceUnavailable",
@@ -95,6 +97,11 @@ __all__ = [
     "BrokerCallError",
     "CrossAppGrantError",
     "MissingDependencyError",
+    "McpClient",
+    "mcp",
+    "mcp_prompt",
+    "mcp_resource",
+    "mcp_tool",
     "get_config",
     "require_config",
     "sign_webhook",
@@ -103,4 +110,4 @@ __all__ = [
     "LocalStorageService",
 ]
 
-__version__ = "0.1.8"
+__version__ = "0.1.9"

package/backend-sdk/palette_sdk/manifest.py

@@ -185,6 +185,60 @@ class PlatformServiceSpec(BaseModel):
     billing: Literal["org_wallet", "plugin_owner", "platform"] | None = None
 
 
+class McpToolSpec(BaseModel):
+    """An MCP tool this app provides. Compiled into a broker service method
+    (namespace = provides.namespace) and mirrored into the org MCP catalog."""
+
+    name: str
+    label: str | None = None
+    description: str = ""
+    input_schema: dict[str, Any] | str | None = None
+    output_schema: dict[str, Any] | str | None = None
+    annotations: dict[str, Any] | None = None  # readOnlyHint / destructiveHint ...
+    scope: str | None = None
+    expose_external: bool = False
+
+
+class McpResourceSpec(BaseModel):
+    name: str
+    uri_template: str | None = None
+    description: str = ""
+    mime_type: str | None = None
+    expose_external: bool = False
+
+
+class McpPromptSpec(BaseModel):
+    name: str
+    description: str = ""
+    arguments: list[dict[str, Any]] = Field(default_factory=list)
+    expose_external: bool = False
+
+
+class McpServerDependencySpec(BaseModel):
+    """An external MCP connector (by org-configured slug) this app uses."""
+
+    slug: str
+    optional: bool = False
+    reason: str = ""
+
+
+class McpProvidesSpec(BaseModel):
+    tools: list[McpToolSpec] = Field(default_factory=list)
+    resources: list[McpResourceSpec] = Field(default_factory=list)
+    prompts: list[McpPromptSpec] = Field(default_factory=list)
+
+
+class McpConsumesSpec(BaseModel):
+    servers: list[str | McpServerDependencySpec] = Field(default_factory=list)
+    tools: list[str] = Field(default_factory=list)  # "mcp.{slug}/v1#{tool}" targets
+
+
+class McpSpec(BaseModel):
+    provides: McpProvidesSpec | None = None
+    consumes: McpConsumesSpec | None = None
+    exposes_to_external_clients: bool = False
+
+
 class PluginManifest(BaseModel):
     """Validated plugin manifest from palette-plugin.json."""
 
@@ -214,6 +268,7 @@ class PluginManifest(BaseModel):
     provides: ProvidesSpec | None = None
     requires: RequiresSpec | None = None
     consumes: ConsumesSpec | None = None
+    mcp: McpSpec | None = None
     platform_services: list[Literal["llm", "redis", "storage", "vector"]] | dict[str, PlatformServiceSpec] = Field(default_factory=list)
     rating: float = 0.0
     reviews: int = 0

package/backend-sdk/palette_sdk/mcp.py

@@ -0,0 +1,175 @@
+"""MCP helpers — provide tools to the OS, consume connector/app tools.
+
+Provider example::
+
+    from palette_sdk import mcp_tool, PluginContext
+
+    @mcp_tool("invoice.summarize", description="Summarize an invoice")
+    async def summarize(ctx: PluginContext, payload: dict) -> dict:
+        return {"summary": ...}
+
+An app's MCP tool *is* a broker service method under the app's namespace —
+`@mcp_tool` registers through the same pending-handler list as `@service`, so
+dispatch, cross-app grants, schema validation, and audit are identical.
+Declare the tool in the manifest `mcp.provides.tools` block so it is indexed
+and (optionally) exposed to external MCP clients.
+
+Consumer example::
+
+    from palette_sdk import mcp
+
+    result = await mcp(ctx).call_tool("mcp.notion/v1#search_pages", {"query": "Q3"})
+    pages = await mcp(ctx).proxy("mcp.notion/v1").search_pages({"query": "Q3"})
+
+Targets use the OS qualified-name grammar: `mcp.{connector_slug}/v1#{tool}`
+for org-configured external servers, `{app_namespace}/v1#{tool}` for tools
+provided by other installed apps. Both must be declared in the manifest
+(`mcp.consumes.tools` or `consumes.services`).
+"""
+
+from __future__ import annotations
+
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass, field
+from typing import Any
+
+from palette_sdk.services import ServiceDecl, ServicesClient, _pending as _pending_services
+
+ToolHandler = Callable[[Any, dict[str, Any]], Awaitable[Any]]
+
+
+@dataclass(frozen=True)
+class McpResourceDecl:
+    name: str
+    handler: ToolHandler
+    uri_template: str | None = None
+    description: str | None = None
+    mime_type: str | None = None
+
+
+@dataclass(frozen=True)
+class McpPromptDecl:
+    name: str
+    handler: ToolHandler
+    description: str | None = None
+    arguments: list[dict[str, Any]] = field(default_factory=list)
+
+
+_pending_resources: list[McpResourceDecl] = []
+_pending_prompts: list[McpPromptDecl] = []
+
+
+def mcp_tool(
+    name: str,
+    *,
+    description: str | None = None,
+    label: str | None = None,
+    input_schema: dict | None = None,
+    output_schema: dict | None = None,
+    scope: str | None = None,
+) -> Callable[[ToolHandler], ToolHandler]:
+    """Mark an async function as an MCP tool this app provides.
+
+    Registered as a broker service method (namespace/version come from the
+    manifest at load time, like `@service`).
+    """
+
+    def decorator(fn: ToolHandler) -> ToolHandler:
+        _pending_services.append(
+            ServiceDecl(
+                name=name,
+                handler=fn,
+                scope=scope,
+                label=label,
+                description=description,
+                input_schema=input_schema,
+                output_schema=output_schema,
+            )
+        )
+        return fn
+
+    return decorator
+
+
+def mcp_resource(
+    name: str,
+    *,
+    uri_template: str | None = None,
+    description: str | None = None,
+    mime_type: str | None = None,
+) -> Callable[[ToolHandler], ToolHandler]:
+    """Mark an async function as an MCP resource provider (read-only)."""
+
+    def decorator(fn: ToolHandler) -> ToolHandler:
+        _pending_resources.append(
+            McpResourceDecl(
+                name=name,
+                handler=fn,
+                uri_template=uri_template,
+                description=description,
+                mime_type=mime_type,
+            )
+        )
+        return fn
+
+    return decorator
+
+
+def mcp_prompt(
+    name: str,
+    *,
+    description: str | None = None,
+    arguments: list[dict[str, Any]] | None = None,
+) -> Callable[[ToolHandler], ToolHandler]:
+    """Mark an async function as an MCP prompt provider."""
+
+    def decorator(fn: ToolHandler) -> ToolHandler:
+        _pending_prompts.append(
+            McpPromptDecl(
+                name=name,
+                handler=fn,
+                description=description,
+                arguments=list(arguments or []),
+            )
+        )
+        return fn
+
+    return decorator
+
+
+def drain_pending_mcp_resources() -> list[McpResourceDecl]:
+    """Platform-only."""
+    out = list(_pending_resources)
+    _pending_resources.clear()
+    return out
+
+
+def drain_pending_mcp_prompts() -> list[McpPromptDecl]:
+    """Platform-only."""
+    out = list(_pending_prompts)
+    _pending_prompts.clear()
+    return out
+
+
+# ----- Consumer accessor -----------------------------------------------------
+
+
+class McpClient:
+    """Returned by `mcp(ctx)`. Tool calls route through the OS broker, which
+    delegates `mcp.*` namespaces to the platform's MCP dispatch (connector
+    resolution, grants, schema validation, audit)."""
+
+    def __init__(self, services_client: ServicesClient):
+        self._services = services_client
+
+    async def call_tool(self, target: str, arguments: dict[str, Any] | None = None) -> Any:
+        return await self._services.call(target, arguments or {})
+
+    def proxy(self, namespace_version: str):
+        return self._services.proxy(namespace_version)
+
+
+def mcp(ctx: Any) -> McpClient:
+    """Create an MCP client bound to a request context."""
+    adapter = getattr(ctx, "apps", None)
+    return McpClient(ServicesClient(adapter))

package/backend-sdk/palette_sdk/notifications.py

@@ -9,24 +9,34 @@ backend — the Python counterpart of the frontend SDK's `notifications.push()`:
     async def start_export(ctx: PluginContext = Depends(get_plugin_context)):
         ...
         await ctx.notifications.push(
-            "Export complete",
-            body="Your report is ready to download.",
-            severity="success",
-            route="/exports/123",
+            "Approval needed",
+            body="A leave request needs approval.",
+            to=ctx.notifications.user(approver_user_id),
+            target_app="hierarchy-app",
         )
 
-`route` resolves relative to the calling app (`/apps/{plugin_id}/exports/123`);
-pass an absolute `/apps/...` route to target another app's window. By default
-the notification goes to the user making the current request; pass `user_id`
-to notify a different member of the same organisation (the platform rejects
-targets outside the caller's org).
+By default the notification goes to the user making the current request. Use
+`to=ctx.notifications.user(...)`, `.email(...)`, `.member(...)`, `.role(...)`,
+`.team(...)`, or `.mentions_from(...)` for explicit recipients. `target_app`
+controls which app icon gets the unread badge and which app opens by default.
+`route` is optional and only needed for a deep link inside that target app.
 """
 
 from __future__ import annotations
 
+from dataclasses import dataclass
 from typing import Any
 
 
+@dataclass(frozen=True)
+class NotificationRecipient:
+    kind: str
+    value: Any
+
+    def to_payload(self) -> dict[str, Any]:
+        return {"kind": self.kind, "value": self.value}
+
+
 class NotificationsClient:
     """Thin wrapper around the platform-injected notification service.
 
@@ -46,6 +56,31 @@ class NotificationsClient:
             )
         return self._service
 
+    def user(self, user_id: str) -> NotificationRecipient:
+        return NotificationRecipient("user", str(user_id))
+
+    def email(self, email: str) -> NotificationRecipient:
+        return NotificationRecipient("email", email)
+
+    def member(self, handle_or_email: str) -> NotificationRecipient:
+        return NotificationRecipient("member", handle_or_email)
+
+    def role(self, role: str) -> NotificationRecipient:
+        return NotificationRecipient("role", role)
+
+    def team(self, team: str | int) -> NotificationRecipient:
+        return NotificationRecipient("team", team)
+
+    def mentions_from(self, message: str) -> NotificationRecipient:
+        return NotificationRecipient("mentions", message)
+
+    def _recipient_payload(self, to: Any) -> Any:
+        if isinstance(to, NotificationRecipient):
+            return to.to_payload()
+        if isinstance(to, (list, tuple, set)):
+            return [self._recipient_payload(item) for item in to]
+        return to
+
     async def push(
         self,
         title: str,
@@ -55,7 +90,9 @@ class NotificationsClient:
         severity: str | None = None,
         data: dict[str, Any] | None = None,
         user_id: str | None = None,
-    ) -> dict[str, Any]:
+        to: Any = None,
+        target_app: str | None = None,
+    ) -> dict[str, Any] | list[dict[str, Any]]:
         """Push a notification; returns the serialized notification dict."""
         return await self._require_service().push(
             title=title,
@@ -64,4 +101,6 @@ class NotificationsClient:
             severity=severity,
             data=data,
             user_id=user_id,
+            to=self._recipient_payload(to),
+            target_app=target_app,
         )

package/docs/python-backend-sdk.md

@@ -607,30 +607,36 @@ from palette_sdk import PluginContext, get_plugin_context, require_permission
 async def start_export(ctx: PluginContext = Depends(get_plugin_context)):
     ...
     await ctx.notifications.push(
-        "Export complete",
-        body="Your report is ready to download.",
-        severity="success",            # "info" | "success" | "warning" | "error"
-        route="/exports/123",          # opened inside your app on click
-        data={"export_id": 123},       # arbitrary payload stored with it
+        "Approval needed",
+        body="A leave request needs approval.",
+        to=ctx.notifications.user(approver_user_id),
+        target_app="hierarchy-app",
+        severity="warning",            # "info" | "success" | "warning" | "error"
+        data={"request_id": request_id},
     )
 ```
 
 The notification shows as a live toast plus a notification-center entry and
-opens/focuses your app window at the resolved route when clicked. `route`
-resolves relative to your app (`/apps/{plugin_id}/exports/123`); pass an
-absolute `/apps/...` route to target another app's window. Omit `route` to
-open your app's main window.
+opens/focuses the target app when clicked. `target_app` controls the app icon
+badge and default click target. `route` is optional; pass it only for a
+deep-link inside the target app.
 
-By default the notification targets the user making the current request. Pass
-`user_id` to notify a different member of the same organisation (useful for
-approval flows); targets outside the caller's organisation are rejected:
+By default the notification targets the user making the current request. Use
+recipient helpers to target same-org members:
 
 ```python
 await ctx.notifications.push(
     "Approval needed",
     body=f"{requester.name} requested a budget increase.",
-    route="/approvals",
-    user_id=str(approver_id),
+    to=ctx.notifications.email("approver@example.com"),
+    target_app="approvals-app",
+)
+
+await ctx.notifications.push(
+    "Team update",
+    body="Finance review is ready.",
+    to=ctx.notifications.team("finance"),
+    target_app="finance-app",
 )
 ```
 

package/lib/bundler.js

@@ -596,6 +596,8 @@ async function bundleBackend(pluginDir, options = {}) {
 
     const backendDir = path.join(pluginDir, "backend")
     if (fs.existsSync(backendDir)) copy(backendDir, path.join(stage, "backend"))
+    const schemasDir = path.join(pluginDir, "schemas")
+    if (fs.existsSync(schemasDir)) copy(schemasDir, path.join(stage, "schemas"))
     for (const metadataFile of ["package.json", "pyproject.toml", "palette-plugin.json"]) {
       if (metadataFile === "palette-plugin.json" && options.manifest) continue
       const src = path.join(pluginDir, metadataFile)

package/lib/dev-simulator.js

@@ -229,6 +229,18 @@ if _service_enabled("storage"):
         organization_name="Palette Dev",
     )
 
+DEV_ORGANIZATION = {
+    "id": 1,
+    "name": "Palette Dev",
+    "slug": "palette-dev",
+    "description": "Local development organisation",
+    "company_type": "IT & Engineering",
+    "logo_url": None,
+    "theme_id": "mac",
+    "created_at": "2026-01-01T00:00:00+00:00",
+    "updated_at": "2026-01-01T00:00:00+00:00",
+}
+
 LOCAL_UPLOADS = {}
 CONTENT_RANGE_RE = re.compile(r"^bytes (?P<start>\\d+)-(?P<end>\\d+)/(?P<total>\\d+)$")
 
@@ -308,22 +320,24 @@ class LocalNotificationsService:
     def __init__(self):
         self._next_id = 1
 
-    def _resolve_action_route(self, route, plugin_id):
+    def _resolve_action_route(self, route, plugin_id, target_app=None):
+        app_id = target_app or plugin_id
         if not route:
-            return f"/apps/{plugin_id}" if plugin_id else None
+            return f"/apps/{app_id}" if app_id else None
         if "://" in route:
             raise ValueError("route must be an internal route starting with '/'")
         if route.startswith("/apps/"):
             return route
         suffix = route if route.startswith("/") else "/" + route
-        return f"/apps/{plugin_id}{suffix}" if plugin_id else suffix
+        return f"/apps/{app_id}{suffix}" if app_id else suffix
 
-    async def push(self, *, title, body=None, route=None, severity=None, data=None, user_id=None):
+    async def push(self, *, title, body=None, route=None, severity=None, data=None, user_id=None, to=None, target_app=None, target_app_id=None):
         if not title or not str(title).strip():
             raise ValueError("notification title is required")
         if severity is not None and severity not in ("info", "success", "warning", "error"):
             raise ValueError("severity must be one of: info, success, warning, error")
         plugin_id = MANIFEST.get("id", "")
+        badge_app = target_app_id or target_app
         notification = {
             "id": self._next_id,
             "organization_id": 1,
@@ -332,10 +346,12 @@ class LocalNotificationsService:
             "body": body,
             "data_json": json.dumps(data) if data is not None else None,
             "source_app_id": plugin_id or None,
-            "action_route": self._resolve_action_route(route, plugin_id),
+            "target_app_id": badge_app or plugin_id or None,
+            "action_route": self._resolve_action_route(route, plugin_id, badge_app),
             "severity": severity,
             "is_read": False,
             "created_at": datetime.now(timezone.utc).isoformat(),
+            "local_recipient": to or ({"kind": "user", "value": str(user_id)} if user_id is not None else {"kind": "current_user", "value": "local"}),
         }
         self._next_id += 1
         print("[palette-notification]", json.dumps(notification, sort_keys=True))
@@ -373,6 +389,7 @@ class DevPluginContextMiddleware(BaseHTTPMiddleware):
             organization_id=1,
         )
         request.state.org_role = "owner"
+        request.state.organization_info = DEV_ORGANIZATION
         request.state.plugin_id = MANIFEST.get("id", "")
         request.state.plugin_permissions = MANIFEST.get("permissions", [])
         request.state.plugin_config = {
@@ -541,9 +558,26 @@ function connectionListResponse() {
   })
 }
 
+const devOrganization = {
+  id: 1,
+  name: "Palette Dev",
+  slug: "palette-dev",
+  description: "Local development organisation",
+  company_type: "IT & Engineering",
+  logo_url: null,
+  created_at: "2026-01-01T00:00:00+00:00",
+  updated_at: "2026-01-01T00:00:00+00:00",
+}
+
 async function apiFetch(path, init) {
   const target = String(path || "")
   const method = String(init?.method || "GET").toUpperCase()
+  if (target === "/api/v1/org" && method === "GET") {
+    return new Response(JSON.stringify(devOrganization), {
+      status: 200,
+      headers: { "Content-Type": "application/json" },
+    })
+  }
   const connectionPrefix = "/api/v1/app-installs/" + encodeURIComponent(${JSON.stringify(manifest.id)}) + "/connections"
   if (target === connectionPrefix && method === "GET") {
     return connectionListResponse()
@@ -603,7 +637,7 @@ const basePlatform = {
   organizationId: 1,
   pluginId: ${JSON.stringify(manifest.id)},
   orgRole: "owner",
-  orgs: [{ id: 1, name: "Local Dev Org", slug: "local-dev", theme_id: "default", logo_url: null }],
+  orgs: [{ id: 1, name: "Palette Dev", slug: "palette-dev", theme_id: "default", logo_url: null }],
   agents: [],
   permissions: ${JSON.stringify(manifest.permissions || [])},
   apiFetch,

package/lib/manifest.js

@@ -56,8 +56,13 @@ const TOP_LEVEL_KEYS = new Set([
   "provides",
   "requires",
   "consumes",
+  "mcp",
 ])
 
+const MCP_NAME_RE = /^[a-zA-Z0-9][a-zA-Z0-9_.-]{0,127}$/
+const MCP_CONNECTOR_SLUG_RE = /^[a-z0-9][a-z0-9_-]{0,78}$/
+const MCP_TOOL_TARGET_RE = /^mcp\.[a-z0-9][a-z0-9_-]*\/[A-Za-z0-9_.-]+#[A-Za-z0-9_.-]+$/
+
 function loadManifest(cwd) {
   const manifestPath = path.join(cwd, MANIFEST_FILE)
   if (!fs.existsSync(manifestPath)) {
@@ -507,6 +512,97 @@ function validateConsumes(value, errors) {
   }
 }
 
+function validateMcp(value, errors) {
+  if (value === undefined) return
+  if (!isObject(value)) {
+    errors.push("mcp must be an object")
+    return
+  }
+  unknownKeys(value, new Set(["provides", "consumes", "exposes_to_external_clients"]), "mcp", errors)
+  requireBoolean(value, "exposes_to_external_clients", "mcp", errors)
+
+  if (value.provides !== undefined) {
+    if (!isObject(value.provides)) {
+      errors.push("mcp.provides must be an object")
+    } else {
+      unknownKeys(value.provides, new Set(["tools", "resources", "prompts"]), "mcp.provides", errors)
+      const allowedByBucket = {
+        tools: new Set(["name", "label", "description", "input_schema", "output_schema", "annotations", "scope", "expose_external"]),
+        resources: new Set(["name", "uri_template", "description", "mime_type", "expose_external"]),
+        prompts: new Set(["name", "description", "arguments", "expose_external"]),
+      }
+      for (const bucket of ["tools", "resources", "prompts"]) {
+        const entries = value.provides[bucket]
+        if (entries === undefined) continue
+        if (!Array.isArray(entries)) {
+          errors.push(`mcp.provides.${bucket} must be an array`)
+          continue
+        }
+        const seen = new Set()
+        entries.forEach((entry, i) => {
+          const label = `mcp.provides.${bucket}[${i}]`
+          if (!isObject(entry)) {
+            errors.push(`${label} must be an object`)
+            return
+          }
+          unknownKeys(entry, allowedByBucket[bucket], label, errors)
+          if (typeof entry.name !== "string" || !MCP_NAME_RE.test(entry.name)) {
+            errors.push(`${label}.name must be a valid MCP name`)
+            return
+          }
+          if (seen.has(entry.name)) errors.push(`duplicate mcp.provides.${bucket} name: ${entry.name}`)
+          seen.add(entry.name)
+          requireBoolean(entry, "expose_external", label, errors)
+          requireString(entry, "description", label, errors)
+        })
+      }
+    }
+  }
+
+  if (value.consumes !== undefined) {
+    if (!isObject(value.consumes)) {
+      errors.push("mcp.consumes must be an object")
+    } else {
+      unknownKeys(value.consumes, new Set(["servers", "tools"]), "mcp.consumes", errors)
+      if (value.consumes.servers !== undefined) {
+        if (!Array.isArray(value.consumes.servers)) {
+          errors.push("mcp.consumes.servers must be an array")
+        } else {
+          value.consumes.servers.forEach((entry, i) => {
+            const label = `mcp.consumes.servers[${i}]`
+            let slug
+            if (typeof entry === "string") {
+              slug = entry
+            } else if (isObject(entry)) {
+              unknownKeys(entry, new Set(["slug", "optional", "reason"]), label, errors)
+              slug = entry.slug
+              requireBoolean(entry, "optional", label, errors)
+              requireString(entry, "reason", label, errors)
+            } else {
+              errors.push(`${label} must be a slug string or object`)
+              return
+            }
+            if (typeof slug !== "string" || !MCP_CONNECTOR_SLUG_RE.test(slug)) {
+              errors.push(`${label}.slug must be a lowercase connector slug`)
+            }
+          })
+        }
+      }
+      if (value.consumes.tools !== undefined) {
+        if (!Array.isArray(value.consumes.tools)) {
+          errors.push("mcp.consumes.tools must be an array")
+        } else {
+          value.consumes.tools.forEach((entry, i) => {
+            if (typeof entry !== "string" || !MCP_TOOL_TARGET_RE.test(entry)) {
+              errors.push(`mcp.consumes.tools[${i}] must look like mcp.{slug}/v1#tool`)
+            }
+          })
+        }
+      }
+    }
+  }
+}
+
 function validateManifest(m) {
   const errors = []
   if (!isObject(m)) return ["manifest must be an object"]
@@ -580,6 +676,7 @@ function validateManifest(m) {
   validateProvides(m.provides, errors)
   validateRequires(m.requires, errors)
   validateConsumes(m.consumes, errors)
+  validateMcp(m.mcp, errors)
 
   if (m.sdk) {
     if (!isObject(m.sdk)) errors.push("sdk must be an object")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@palettelab/cli",
-  "version": "0.3.55",
+  "version": "0.3.57",
   "description": "Developer CLI for building Palette platform plugins — no platform source access required.",
   "bin": {
     "pltt": "bin/pltt.js"

package/template-fallback/package.json

@@ -4,7 +4,7 @@
   "private": true,
   "description": "A Palette platform plugin",
   "dependencies": {
-    "@palettelab/sdk": "^0.1.24"
+    "@palettelab/sdk": "^0.1.27"
   },
   "devDependencies": {
     "typescript": "^5.0.0",

package/template-fallback/templates/consumer-app/package.json

@@ -2,7 +2,7 @@
   "private": true,
   "type": "module",
   "dependencies": {
-    "@palettelab/sdk": "^0.1.25",
+    "@palettelab/sdk": "^0.1.27",
     "react": "^19.0.0",
     "react-dom": "^19.0.0"
   }

package/template-fallback/templates/dashboard/package.json

@@ -3,7 +3,7 @@
   "version": "1.0.0",
   "private": true,
   "dependencies": {
-    "@palettelab/sdk": "^0.1.25",
+    "@palettelab/sdk": "^0.1.27",
     "react": "^19.0.0"
   }
 }

package/template-fallback/templates/database/package.json

@@ -2,5 +2,5 @@
   "name": "my-db-plugin",
   "version": "1.0.0",
   "private": true,
-  "dependencies": { "@palettelab/sdk": "^0.1.25", "react": "^19.0.0" }
+  "dependencies": { "@palettelab/sdk": "^0.1.27", "react": "^19.0.0" }
 }

package/template-fallback/templates/external-service/package.json

@@ -2,5 +2,5 @@
   "name": "my-external-svc",
   "version": "1.0.0",
   "private": true,
-  "dependencies": { "@palettelab/sdk": "^0.1.25", "react": "^19.0.0" }
+  "dependencies": { "@palettelab/sdk": "^0.1.27", "react": "^19.0.0" }
 }

package/template-fallback/templates/frontend-only/package.json

@@ -3,7 +3,7 @@
   "version": "1.0.0",
   "private": true,
   "dependencies": {
-    "@palettelab/sdk": "^0.1.25",
+    "@palettelab/sdk": "^0.1.27",
     "react": "^19.0.0"
   }
 }

package/template-fallback/templates/next/package.json

@@ -3,7 +3,7 @@
   "version": "1.0.0",
   "private": true,
   "dependencies": {
-    "@palettelab/sdk": "^0.1.25",
+    "@palettelab/sdk": "^0.1.27",
     "react": "^19.0.0"
   },
   "devDependencies": {

package/template-fallback/templates/palette-app/package.json

@@ -3,7 +3,7 @@
   "version": "1.0.0",
   "private": true,
   "dependencies": {
-    "@palettelab/sdk": "^0.1.25",
+    "@palettelab/sdk": "^0.1.27",
     "react": "^19.0.0"
   },
   "devDependencies": {

package/template-fallback/templates/provider-app/package.json

@@ -2,7 +2,7 @@
   "private": true,
   "type": "module",
   "dependencies": {
-    "@palettelab/sdk": "^0.1.25",
+    "@palettelab/sdk": "^0.1.27",
     "react": "^19.0.0"
   }
 }