@palettelab/cli 0.3.54 → 0.3.56

package/README.md

@@ -396,6 +396,58 @@ The CLI validates manifest shape, SDK compatibility, frontend bundling, backend
 imports, backend route permission gates, declared permissions, migration safety,
 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.27+`:
+
+```ts
+import { notifications } from "@palettelab/sdk"
+// or: palette.notifications.push(...)
+
+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 the target app at the resolved route. Use the SDK
+helper rather than hand-building platform notification API calls.
+
+Python plugin backends can push too, via `ctx.notifications` in the CLI-bundled
+backend SDK:
+
+```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",
+    )
+```
+
+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. See
+`docs/python-backend-sdk.md` ("OS Notifications From Python") for details.
+
+During `pltt dev`, frontend pushes call the platform backend directly
+(`NEXT_PUBLIC_API_URL`, default `http://localhost:8000`) in the user's session,
+so they land in the real notification pool. Backend pushes run against the
+local simulator, which logs them as `[palette-notification] {...}` and returns
+a stub. Sandboxed iframe apps are not supported yet (no session cookie inside
+the iframe).
+
 ## Commands
 
 ### `pltt init <name>`

package/backend-sdk/palette_sdk/__init__.py

@@ -6,6 +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 NotificationRecipient, NotificationsClient
 from palette_sdk.platform_services import (
     LocalRedisService,
     LocalVectorService,
@@ -44,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
@@ -62,6 +64,8 @@ __all__ = [
     "AppServiceClient",
     "MissingAppServiceError",
     "OrganizationMembersClient",
+    "NotificationsClient",
+    "NotificationRecipient",
     "LocalRedisService",
     "LocalVectorService",
     "PlatformServiceUnavailable",
@@ -93,6 +97,11 @@ __all__ = [
     "BrokerCallError",
     "CrossAppGrantError",
     "MissingDependencyError",
+    "McpClient",
+    "mcp",
+    "mcp_prompt",
+    "mcp_resource",
+    "mcp_tool",
     "get_config",
     "require_config",
     "sign_webhook",
@@ -101,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

@@ -0,0 +1,106 @@
+"""Backend OS notification helpers for plugin Python code.
+
+Push a persistent notification into the OS notification center from a plugin
+backend — the Python counterpart of the frontend SDK's `notifications.push()`:
+
+    from palette_sdk import PluginContext, get_plugin_context
+
+    @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",
+        )
+
+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.
+
+    In production/hosted sandbox the platform injects the service into
+    `PluginContext`. In local unit tests, pass a fake service with the same
+    async `push` method.
+    """
+
+    def __init__(self, service: Any = None):
+        self._service = service
+
+    def _require_service(self) -> Any:
+        if self._service is None:
+            raise RuntimeError(
+                "Notification service is not available in this runtime. "
+                "Run inside Palette OS/hosted sandbox or inject a fake service in tests."
+            )
+        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,
+        *,
+        body: str | None = None,
+        route: str | None = None,
+        severity: str | None = None,
+        data: dict[str, Any] | None = None,
+        user_id: str | None = None,
+        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,
+            body=body,
+            route=route,
+            severity=severity,
+            data=data,
+            user_id=user_id,
+            to=self._recipient_payload(to),
+            target_app=target_app,
+        )

package/backend-sdk/palette_sdk/plugin_context.py

@@ -14,6 +14,7 @@ from palette_sdk.data_rooms import DataRoomsClient
 from palette_sdk.connections import PluginConnectionsClient
 from palette_sdk.apps import AppInteropClient
 from palette_sdk.members import OrganizationMembersClient
+from palette_sdk.notifications import NotificationsClient
 from palette_sdk.platform_services import UnavailablePlatformService
 from palette_sdk.events import EventPublisher
 
@@ -40,6 +41,7 @@ class PluginContext:
         permissions: List of permissions declared in the manifest
         storage: Storage service for file upload/download
         members: Organization member helpers for the current org
+        notifications: OS notification center push helpers
     """
     db: AsyncSession
     user_id: str
@@ -52,6 +54,7 @@ class PluginContext:
     connections: PluginConnectionsClient = field(default_factory=PluginConnectionsClient)
     apps: AppInteropClient = field(default_factory=AppInteropClient)
     members: OrganizationMembersClient = field(default_factory=OrganizationMembersClient)
+    notifications: NotificationsClient = field(default_factory=NotificationsClient)
     redis: Any = field(default_factory=lambda: UnavailablePlatformService("redis"))
     vector: Any = field(default_factory=lambda: UnavailablePlatformService("vector"))
     events: EventPublisher = field(default_factory=EventPublisher)
@@ -128,6 +131,7 @@ async def get_plugin_context(request: Request) -> PluginContext:
             getattr(state, "org_members", None),
             getattr(state, "plugin_permissions", []),
         ),
+        notifications=NotificationsClient(getattr(state, "notifications", None)),
         redis=getattr(state, "redis", None) or UnavailablePlatformService("redis"),
         vector=getattr(state, "vector", None) or UnavailablePlatformService("vector"),
         events=EventPublisher(getattr(state, "plugin_events", None)),

package/backend-sdk/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "palette-sdk"
-version = "0.1.8"
+version = "0.1.9"
 description = "Palette Platform SDK for building backend plugins"
 readme = "README.md"
 requires-python = ">=3.12"

package/docs/python-backend-sdk.md

@@ -114,6 +114,7 @@ Available context values:
 | `ctx.data_rooms` | Backend Data Room client |
 | `ctx.connections` | Palette-managed third-party connection client |
 | `ctx.members` | Current organisation member client |
+| `ctx.notifications` | Push OS notification-center notifications |
 | `ctx.apps` / `services(ctx)` | Governed app-to-app calls through declared `consumes` contracts |
 | `ctx.events` | Publish event topics declared in `provides.events` |
 | `ctx.redis` | Plugin/org-scoped Redis-style service when `platform_services` includes `redis` |
@@ -141,6 +142,7 @@ These are the public Python helpers exported by `palette_sdk`.
 | `KNOWN_PERMISSIONS`, `is_known_permission(...)` | Permission vocabulary checks for manifests/tools |
 | `DataRoomsClient`, `ctx.data_rooms` | Backend Data Room room/folder/file helpers |
 | `OrganizationMembersClient`, `ctx.members` | Current-organization member lookup, invite, and role helpers |
+| `NotificationsClient`, `ctx.notifications` | Push notifications into the OS notification center |
 | `PluginConnectionsClient`, `ConnectionStatus`, `MissingConnectionError`, `ctx.connections` | Third-party connection status and token helpers |
 | `AppInteropClient`, `AppServiceClient`, `MissingAppServiceError`, `ctx.apps` | Call required apps/services without direct database access |
 | `service(...)`, `services(ctx)`, `ServicesClient`, `BrokerCallError` | Provide and consume OS-broker service methods/events |
@@ -592,6 +594,56 @@ In local unit tests outside the Palette runtime, inject a fake Data Room service
 if you need to test routes that call `ctx.data_rooms`. In hosted sandbox and
 real OS runtime, the platform injects the real service.
 
+## 8a. OS Notifications From Python
+
+Backend code can push persistent notifications into the OS notification
+center (the bell) — the Python counterpart of the frontend SDK's
+`notifications.push()`:
+
+```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",
+        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 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. Use
+recipient helpers to target same-org members:
+
+```python
+await ctx.notifications.push(
+    "Approval needed",
+    body=f"{requester.name} requested a budget increase.",
+    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",
+)
+```
+
+During `pltt dev` notifications are not delivered to a real notification
+center — the simulator logs them as `[palette-notification] {...}` and returns
+a stub response, so your code paths still run.
+
 ## 9. Config And Secrets
 
 Use config for app install settings and secrets for sensitive values.

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/commands/publish.js

@@ -410,6 +410,7 @@ async function run(argv, { cwd }) {
   log(`[pltt]     ${backend.length} bytes`)
 
   const backendSha = sha256(backend)
+  const frontendSha = frontend ? sha256(frontend) : null
   const api = makeApi(env)
 
   log("[pltt]   requesting signed URLs")
@@ -419,6 +420,7 @@ async function run(argv, { cwd }) {
       plugin_id: manifest.id,
       version: manifest.version,
       bundle_sha256: backendSha,
+      ...(frontendSha ? { frontend_sha256: frontendSha } : {}),
       publish_type: publishType,
     },
   })

package/lib/dev-simulator.js

@@ -178,6 +178,7 @@ import pathlib
 import re
 import sys
 import uuid
+from datetime import datetime, timezone
 from types import SimpleNamespace
 
 from fastapi import FastAPI, HTTPException, Request, Response
@@ -228,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+)$")
 
@@ -301,6 +314,51 @@ class LocalEventPublisher:
     async def publish(self, topic: str, payload=None):
         print("[palette-event]", topic, json.dumps(payload or {}, sort_keys=True))
 
+class LocalNotificationsService:
+    """Local stand-in for the platform notification pool: logs and returns a stub."""
+
+    def __init__(self):
+        self._next_id = 1
+
+    def _resolve_action_route(self, route, plugin_id, target_app=None):
+        app_id = target_app or plugin_id
+        if not route:
+            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/{app_id}{suffix}" if app_id else suffix
+
+    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,
+            "type": "app",
+            "title": str(title),
+            "body": body,
+            "data_json": json.dumps(data) if data is not None else None,
+            "source_app_id": plugin_id or None,
+            "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))
+        return notification
+
+NOTIFICATIONS = LocalNotificationsService()
+
 spec = importlib.util.spec_from_file_location("palette_local_backend", ENTRY)
 module = importlib.util.module_from_spec(spec)
 assert spec and spec.loader
@@ -331,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 = {
@@ -341,6 +400,7 @@ class DevPluginContextMiddleware(BaseHTTPMiddleware):
         request.state.plugin_local_connections = DEV_CONNECTIONS
         request.state.plugin_apps = LocalAppInteropService()
         request.state.plugin_events = LocalEventPublisher()
+        request.state.notifications = NOTIFICATIONS
         request.state.storage = DEV_STORAGE
         if DEV_REDIS is not None:
             request.state.redis = DEV_REDIS
@@ -498,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()
@@ -560,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

@@ -32,6 +32,8 @@ const TOP_LEVEL_KEYS = new Set([
   "category",
   "tagline",
   "description",
+  "release_notes",
+  "changelog",
   "icon",
   "gradient",
   "sdk",
@@ -54,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)) {
@@ -505,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"]
@@ -526,6 +624,8 @@ function validateManifest(m) {
   requireString(m, "category", "manifest", errors)
   requireString(m, "tagline", "manifest", errors)
   requireString(m, "description", "manifest", errors)
+  requireString(m, "release_notes", "manifest", errors)
+  requireString(m, "changelog", "manifest", errors)
   requireString(m, "icon", "manifest", errors)
 
   if (m.gradient !== undefined) {
@@ -576,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.54",
+  "version": "0.3.56",
   "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.24",
+    "@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.24",
+    "@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.24", "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.24", "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.24",
+    "@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.24",
+    "@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.24",
+    "@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.24",
+    "@palettelab/sdk": "^0.1.27",
     "react": "^19.0.0"
   }
 }