@decocms/bindings 1.4.8 → 1.4.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decocms/bindings",
-  "version": "1.4.8",
+  "version": "1.4.10",
   "type": "module",
   "scripts": {
     "check": "tsc --noEmit",
@@ -9,15 +9,9 @@
   "dependencies": {
     "@decocms/mcp-utils": "^1.0.5",
     "@modelcontextprotocol/sdk": "1.29.0",
-    "@tanstack/react-router": "1.169.2",
-    "react": "^19.2.6",
     "zod": "^4.0.0",
     "zod-from-json-schema": "^0.5.2"
   },
-  "devDependencies": {
-    "hono": "^4.7.10",
-    "kysely": "^0.28.12"
-  },
   "exports": {
     ".": "./src/index.ts",
     "./collections": "./src/well-known/collections.ts",
@@ -28,10 +22,7 @@
     "./mcp": "./src/well-known/mcp.ts",
     "./assistant": "./src/well-known/assistant.ts",
     "./prompt": "./src/well-known/prompt.ts",
-    "./plugins": "./src/core/plugins.ts",
-    "./plugin-router": "./src/core/plugin-router.tsx",
     "./ai-gateway": "./src/well-known/ai-gateway.ts",
-    "./server-plugin": "./src/core/server-plugin.ts",
     "./trigger": "./src/well-known/trigger.ts",
     "./brand": "./src/well-known/brand.ts"
   },

package/src/index.ts

@@ -17,16 +17,6 @@ export {
   type ConnectionForBinding,
 } from "./core/binder";
 
-// Re-export plugin context types (not the React provider - use @decocms/bindings/plugins for that)
-export {
-  type PluginContext,
-  type PluginContextPartial,
-  type PluginConnectionEntity,
-  type PluginOrgContext,
-  type PluginSession,
-  type TypedToolCaller,
-} from "./core/plugin-context";
-
 // Re-export registry binding types
 export {
   MCPRegistryServerSchema,
@@ -49,41 +39,6 @@ export {
   type EventSubscriberBindingClient,
 } from "./well-known/event-subscriber";
 
-// Re-export event bus binding types (for interacting with an event bus)
-export {
-  EventPublishInputSchema,
-  type EventPublishInput,
-  EventPublishOutputSchema,
-  type EventPublishOutput,
-  EventSubscribeInputSchema,
-  type EventSubscribeInput,
-  EventSubscribeOutputSchema,
-  type EventSubscribeOutput,
-  EventUnsubscribeInputSchema,
-  type EventUnsubscribeInput,
-  EventUnsubscribeOutputSchema,
-  type EventUnsubscribeOutput,
-  EventCancelInputSchema,
-  type EventCancelInput,
-  EventCancelOutputSchema,
-  type EventCancelOutput,
-  EventAckInputSchema,
-  type EventAckInput,
-  EventAckOutputSchema,
-  type EventAckOutput,
-  SubscriptionItemSchema,
-  type SubscriptionItem,
-  SubscriptionDetailSchema,
-  type SubscriptionDetail,
-  EventSyncSubscriptionsInputSchema,
-  type EventSyncSubscriptionsInput,
-  EventSyncSubscriptionsOutputSchema,
-  type EventSyncSubscriptionsOutput,
-  EVENT_BUS_BINDING,
-  EventBusBinding,
-  type EventBusBindingClient,
-} from "./well-known/event-bus";
-
 // Re-export trigger binding types (for connections that can emit triggers)
 export {
   TriggerParamSchema,

package/src/core/plugin-context-provider.tsx

@@ -1,27 +0,0 @@
-/**
- * Plugin Context Provider Types
- *
- * The runtime implementations (PluginContextProvider, usePluginContext)
- * have moved to @decocms/mesh-sdk/plugins. Only types remain here
- * for backwards compatibility.
- */
-
-import type { Binder } from "./binder";
-import type { PluginContext, PluginContextPartial } from "./plugin-context";
-import type { ReactNode } from "react";
-
-export interface PluginContextProviderProps<TBinding extends Binder> {
-  value: PluginContext<TBinding> | PluginContextPartial<TBinding>;
-  children: ReactNode;
-}
-
-/**
- * Options for usePluginContext hook.
- */
-export interface UsePluginContextOptions {
-  /**
-   * Set to true when calling from an empty state component.
-   * This returns nullable connection fields since no valid connection exists.
-   */
-  partial?: boolean;
-}

package/src/core/plugin-context.ts

@@ -1,183 +0,0 @@
-/**
- * Plugin Context Types
- *
- * Provides typed context for plugins to access their selected connection
- * and call tools with full type safety based on the plugin's binding.
- */
-
-import type { Binder, ToolBinder } from "./binder";
-import type { z } from "zod";
-
-/**
- * Connection entity shape provided by the layout.
- */
-export interface PluginConnectionEntity {
-  id: string;
-  title: string;
-  icon: string | null;
-  description: string | null;
-  app_name: string | null;
-  app_id: string | null;
-  tools: Array<{
-    name: string;
-    description?: string;
-    inputSchema?: Record<string, unknown>;
-    outputSchema?: Record<string, unknown>;
-  }> | null;
-  metadata: Record<string, unknown> | null;
-}
-
-/**
- * Organization context.
- */
-export interface PluginOrgContext {
-  id: string;
-  slug: string;
-  name: string;
-}
-
-/**
- * User session provided to plugins.
- */
-export interface PluginSession {
-  user: {
-    id: string;
-    name: string;
-    email: string;
-    image?: string | null;
-  };
-}
-
-/**
- * Helper type to extract tool by name from a binding.
- */
-type ExtractToolByName<TBinding extends Binder, TName extends string> = Extract<
-  TBinding[number],
-  { name: TName }
->;
-
-/**
- * Typed tool caller for a specific binding.
- * Provides type-safe tool calls based on the binding definition.
- *
- * @template TBinding - The binding type to derive tool types from
- */
-export type TypedToolCaller<TBinding extends Binder> = <
-  TName extends TBinding[number]["name"] & string,
->(
-  toolName: TName,
-  args: ExtractToolByName<TBinding, TName> extends ToolBinder<
-    TName,
-    infer TInput,
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    infer _TOutput
-  >
-    ? TInput extends z.ZodType
-      ? z.infer<TInput>
-      : TInput
-    : unknown,
-) => Promise<
-  ExtractToolByName<TBinding, TName> extends ToolBinder<
-    TName,
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    infer _TInput,
-    infer TOutput
-  >
-    ? TOutput extends z.ZodType
-      ? z.infer<TOutput>
-      : TOutput
-    : unknown
->;
-
-/**
- * Base plugin context with connection fields always available.
- * Used by plugin routes where layout guarantees a valid connection.
- *
- * @template TBinding - The binding type the plugin requires
- *
- * @example
- * ```tsx
- * // In plugin route component (connection guaranteed)
- * const { toolCaller, connection } = usePluginContext<typeof REGISTRY_APP_BINDING>();
- *
- * // toolCaller and connection are non-null
- * const result = await toolCaller("COLLECTION_REGISTRY_APP_LIST", { limit: 20 });
- * ```
- */
-export interface PluginContext<TBinding extends Binder = Binder> {
-  /**
-   * The selected connection ID.
-   * Always defined in routes (layout handles empty state separately).
-   */
-  connectionId: string;
-
-  /**
-   * The selected connection entity.
-   * Always defined in routes.
-   */
-  connection: PluginConnectionEntity;
-
-  /**
-   * Typed tool caller for the selected connection.
-   * Call MCP tools with full type safety based on the plugin's binding.
-   */
-  toolCaller: TypedToolCaller<TBinding>;
-
-  /**
-   * Organization context.
-   * Always available.
-   */
-  org: PluginOrgContext;
-
-  /**
-   * Current user session.
-   * Available when user is authenticated.
-   */
-  session: PluginSession | null;
-}
-
-/**
- * Partial plugin context with nullable connection fields.
- * Used by empty state components where no valid connection exists.
- *
- * @template TBinding - The binding type the plugin requires
- *
- * @example
- * ```tsx
- * // In empty state component (no connection)
- * const { session, org } = usePluginContext<typeof REGISTRY_APP_BINDING>({ partial: true });
- *
- * // connection, connectionId, toolCaller are null
- * ```
- */
-export interface PluginContextPartial<TBinding extends Binder = Binder> {
-  /**
-   * The selected connection ID.
-   * Null when no valid connection is available.
-   */
-  connectionId: string | null;
-
-  /**
-   * The selected connection entity.
-   * Null when no valid connection is available.
-   */
-  connection: PluginConnectionEntity | null;
-
-  /**
-   * Typed tool caller for the selected connection.
-   * Null when no valid connection is available.
-   */
-  toolCaller: TypedToolCaller<TBinding> | null;
-
-  /**
-   * Organization context.
-   * Always available.
-   */
-  org: PluginOrgContext;
-
-  /**
-   * Current user session.
-   * Available when user is authenticated.
-   */
-  session: PluginSession | null;
-}

package/src/core/plugin-router.tsx

@@ -1,236 +0,0 @@
-import type { ReactNode } from "react";
-import {
-  createRoute,
-  lazyRouteComponent,
-  Route,
-  useNavigate,
-  useParams,
-  useSearch,
-  useLocation,
-  Link as TanStackLink,
-  type AnyRoute,
-  type RouteIds,
-  type RouteById,
-  type LinkProps,
-  type NavigateOptions,
-} from "@tanstack/react-router";
-import type { PluginSetupContext } from "./plugins";
-
-/**
- * Prepends the plugin base path (/$org/projects/$virtualMcpId/$pluginId) to a route path.
- * Handles both absolute plugin paths (starting with /) and relative paths.
- */
-function prependBasePath(
-  to: string | undefined,
-  org: string,
-  virtualMcpId: string,
-  pluginId: string,
-): string {
-  if (!to) return `/${org}/projects/${virtualMcpId}/${pluginId}`;
-
-  // If path starts with /, it's relative to the plugin root
-  if (to.startsWith("/")) {
-    return `/${org}/projects/${virtualMcpId}/${pluginId}${to}`;
-  }
-
-  // Otherwise, it's already a full path or relative
-  return to;
-}
-
-/**
- * Creates a typed plugin router from a route factory function.
- *
- * Routes are registered directly under ctx.parentRoute (which already has
- * component: Outlet). Return an array of sibling routes for multiple pages.
- *
- * @example
- * ```tsx
- * export const storeRouter = createPluginRouter((ctx) => {
- *   const indexRoute = ctx.routing.createRoute({
- *     getParentRoute: () => ctx.parentRoute,
- *     path: "/",
- *     component: ctx.routing.lazyRouteComponent(() => import("./routes/page.tsx")),
- *   });
- *
- *   const detailRoute = ctx.routing.createRoute({
- *     getParentRoute: () => ctx.parentRoute,
- *     path: "/$appName",
- *     component: ctx.routing.lazyRouteComponent(() => import("./routes/detail.tsx")),
- *     validateSearch: z.object({ tab: z.string().optional() }),
- *   });
- *
- *   return [indexRoute, detailRoute];
- * });
- *
- * // In plugin setup - register each route
- * export const storePlugin: AnyPlugin = {
- *   id: "store",
- *   setup: (ctx) => {
- *     const routes = storeRouter.createRoutes(ctx);
- *     for (const route of routes) {
- *       ctx.registerRootPluginRoute(route);
- *     }
- *   },
- * };
- *
- * // In components
- * function DetailPage() {
- *   const { appName } = storeRouter.useParams({ from: "/$appName" });
- *   const { tab } = storeRouter.useSearch({ from: "/$appName" });
- *
- *   const navigate = storeRouter.useNavigate();
- *   navigate({ to: "/$appName", params: { appName: "other" } });
- * }
- * ```
- */
-export function createPluginRouter<TRoutes extends AnyRoute | AnyRoute[]>(
-  createRoutes: (ctx: PluginSetupContext) => TRoutes,
-) {
-  // Extract route type from array or single route
-  type TRoute = TRoutes extends (infer R)[] ? R : TRoutes;
-  type TRouteId = TRoute extends AnyRoute ? RouteIds<TRoute> : never;
-  type TRouteById<TId extends TRouteId> = TRoute extends AnyRoute
-    ? RouteById<TRoute, TId>
-    : never;
-
-  return {
-    /**
-     * Create the route tree. Call this in your plugin's setup().
-     */
-    createRoutes,
-
-    /**
-     * Get route params with TanStack's type inference.
-     */
-    useParams: <TFrom extends TRouteId>(_options: { from: TFrom }) => {
-      return useParams({
-        strict: false,
-      }) as TRouteById<TFrom>["types"]["allParams"];
-    },
-
-    /**
-     * Get search params with TanStack's type inference.
-     */
-    useSearch: <TFrom extends TRouteId>(_options: { from: TFrom }) => {
-      return useSearch({
-        strict: false,
-      }) as TRouteById<TFrom>["types"]["fullSearchSchema"];
-    },
-
-    /**
-     * Navigate within the plugin.
-     * Automatically prepends /$org/$pluginId to the path.
-     */
-    useNavigate: () => {
-      const navigate = useNavigate();
-      const { org, virtualMcpId, pluginId } = useParams({ strict: false }) as {
-        org: string;
-        virtualMcpId: string;
-        pluginId: string;
-      };
-
-      return <TTo extends TRouteId>(
-        options: Omit<NavigateOptions, "to" | "params"> & {
-          to: TTo;
-          params?: TRouteById<TTo>["types"]["allParams"];
-          search?: TRouteById<TTo>["types"]["fullSearchSchema"];
-        },
-      ) => {
-        const to = prependBasePath(options.to, org, virtualMcpId, pluginId);
-
-        return navigate({
-          ...options,
-          to,
-          params: {
-            org,
-            virtualMcpId,
-            pluginId,
-            ...(options.params as Record<string, string>),
-          },
-        } as NavigateOptions);
-      };
-    },
-
-    /**
-     * Get the current location.
-     */
-    useLocation: () => {
-      return useLocation();
-    },
-
-    /**
-     * Link component for plugin navigation.
-     * Automatically prepends /$org/$pluginId to the path.
-     */
-    Link: function PluginLink<TTo extends TRouteId>(
-      props: Omit<LinkProps, "to" | "params" | "search"> & {
-        to: TTo;
-        params?: TRouteById<TTo>["types"]["allParams"];
-        search?: TRouteById<TTo>["types"]["fullSearchSchema"];
-        className?: string;
-        children?: ReactNode;
-      },
-    ) {
-      const { org, virtualMcpId, pluginId } = useParams({ strict: false }) as {
-        org: string;
-        virtualMcpId: string;
-        pluginId: string;
-      };
-
-      const to = prependBasePath(
-        props.to as string,
-        org,
-        virtualMcpId,
-        pluginId,
-      );
-
-      return (
-        <TanStackLink
-          {...(props as LinkProps)}
-          to={to}
-          params={{
-            org,
-            virtualMcpId,
-            pluginId,
-            ...props.params,
-          }}
-        />
-      );
-    },
-
-    /**
-     * Type helpers
-     */
-    _types: {
-      routes: undefined as unknown as TRoutes,
-      routeIds: undefined as unknown as TRouteId,
-    },
-  };
-}
-
-/**
- * Type helper to extract route IDs from a plugin router
- */
-export type PluginRouteIds<
-  TRouter extends ReturnType<typeof createPluginRouter>,
-> = TRouter["_types"]["routeIds"];
-
-/**
- * Type helper to extract routes from a plugin router
- */
-export type PluginRoutes<
-  TRouter extends ReturnType<typeof createPluginRouter>,
-> = TRouter["_types"]["routes"];
-
-// Re-export TanStack utilities for plugins
-export {
-  createRoute,
-  lazyRouteComponent,
-  Route,
-  TanStackLink as Link,
-  useNavigate,
-  useParams,
-  useSearch,
-  useLocation,
-};
-export type { AnyRoute, RouteIds, RouteById };

package/src/core/plugins.ts

@@ -1,132 +0,0 @@
-import {
-  createRoute,
-  lazyRouteComponent,
-  type AnyRoute,
-} from "@tanstack/react-router";
-import { Binder } from "./binder";
-import type { ReactNode } from "react";
-import type { PluginConnectionEntity } from "./plugin-context";
-
-export interface ToolViewItem {
-  toolName: string;
-  label: string;
-  icon: ReactNode;
-}
-
-export interface RegisterRootSidebarItemParams {
-  icon: ReactNode;
-  label: string;
-}
-
-export interface RegisterSidebarGroupParams {
-  id: string;
-  label: string;
-  items: RegisterRootSidebarItemParams[];
-  defaultExpanded?: boolean;
-}
-
-export interface RegisterEmptyStateParams {
-  component: ReactNode;
-}
-
-export interface RegisterSettingsSidebarItemParams {
-  key: string;
-  icon: ReactNode;
-  label: string;
-  to: string;
-}
-
-export interface PluginSetupContext {
-  parentRoute: AnyRoute;
-  routing: {
-    createRoute: typeof createRoute;
-    lazyRouteComponent: typeof lazyRouteComponent;
-  };
-  registerRootSidebarItem: (params: RegisterRootSidebarItemParams) => void;
-  registerSidebarGroup: (params: RegisterSidebarGroupParams) => void;
-  registerSettingsSidebarItem: (
-    params: RegisterSettingsSidebarItemParams,
-  ) => void;
-  registerPluginRoutes: (route: AnyRoute[]) => void;
-}
-
-export type PluginSetup = (context: PluginSetupContext) => void;
-
-/**
- * Props passed to plugin's renderHeader function.
- */
-export interface PluginRenderHeaderProps {
-  connections: PluginConnectionEntity[];
-  selectedConnectionId: string;
-  onConnectionChange: (connectionId: string) => void;
-}
-
-/**
- * Client Plugin interface.
- *
- * Defines the contract for client-side plugins that extend the Mesh UI.
- * Client plugins are separate from server plugins to avoid bundling
- * server code into the client bundle.
- */
-export interface ClientPlugin<TBinding extends Binder = Binder> {
-  id: string;
-  /**
-   * Short description of the plugin shown in the settings UI.
-   */
-  description?: string;
-  /**
-   * Binding schema used to filter compatible connections.
-   * Omit for plugins that manage their own connection (e.g. self MCP).
-   * @deprecated Use bindingName for server-side filtering instead.
-   */
-  binding?: TBinding;
-  /**
-   * Server-side binding name to filter connections (e.g., "WORKFLOW", "LLM").
-   * Preferred over `binding` as it avoids loading all connections client-side.
-   */
-  bindingName?: string;
-  setup?: PluginSetup;
-  /**
-   * Optional custom layout component for this plugin.
-   * If not provided, a default layout with connection selector will be used.
-   * @deprecated Use renderHeader and renderEmptyState instead.
-   */
-  LayoutComponent?: React.ComponentType;
-  /**
-   * Render the header with connection selector.
-   * Receives the list of valid connections and current selection handlers.
-   */
-  renderHeader?: (props: PluginRenderHeaderProps) => ReactNode;
-  /**
-   * Render the empty state when no valid connections are available.
-   */
-  renderEmptyState?: () => ReactNode;
-}
-
-/**
- * @deprecated Use ClientPlugin instead
- */
-export interface Plugin<TBinding extends Binder>
-  extends ClientPlugin<TBinding> {
-  setup: PluginSetup; // Required for backwards compatibility
-}
-
-export type AnyClientPlugin = ClientPlugin<Binder>;
-export type AnyPlugin = Plugin<Binder>;
-
-// Re-export plugin router utilities
-export {
-  createPluginRouter,
-  type PluginRouteIds,
-  type PluginRoutes,
-  type AnyRoute,
-  type RouteIds,
-  type RouteById,
-} from "./plugin-router";
-
-// Note: PluginContextProvider and usePluginContext have been moved to @decocms/mesh-sdk/plugins.
-// Types are re-exported here for backwards compatibility.
-export type {
-  PluginContextProviderProps,
-  UsePluginContextOptions,
-} from "./plugin-context-provider";

package/src/core/server-plugin.ts

@@ -1,227 +0,0 @@
-/**
- * Server Plugin Interface
- *
- * Defines the contract for server-side plugins that can extend Mesh with:
- * - MCP tools
- * - API routes (authenticated and public)
- * - Database migrations
- * - Storage factories
- * - Event handlers (via the event bus)
- *
- * Server plugins are separate from client plugins to avoid bundling
- * server code into the client bundle.
- */
-
-import type { Hono } from "hono";
-import type { Kysely } from "kysely";
-
-/**
- * Subset of StudioContext exposed to server plugin tool handlers.
- *
- * Plugins receive the full StudioContext at runtime but should only depend on
- * these properties. This keeps the plugin contract stable and avoids coupling
- * plugins to Mesh internals (db, vault, tracer, etc.).
- */
-export interface ServerPluginToolContext {
-  organization: { id: string } | null;
-  access: { check: () => Promise<void> };
-  auth: {
-    user?: { id: string; email?: string; name?: string };
-  };
-  /** Kysely database instance for direct queries. */
-  db: Kysely<unknown>;
-  createMCPProxy: (connectionId: string) => Promise<{
-    callTool: (args: {
-      name: string;
-      arguments?: Record<string, unknown>;
-    }) => Promise<{
-      isError?: boolean;
-      content?: Array<{ type?: string; text?: string }>;
-      structuredContent?: unknown;
-    }>;
-    listTools: () => Promise<{
-      tools: Array<{
-        name: string;
-        title?: string;
-        description?: string;
-        inputSchema?: Record<string, unknown>;
-        outputSchema?: Record<string, unknown>;
-        annotations?: Record<string, unknown>;
-      }>;
-    }>;
-    close?: () => Promise<void>;
-  }>;
-}
-
-/**
- * Tool definition for server plugins.
- */
-export interface ServerPluginToolDefinition {
-  name: string;
-  description?: string;
-  inputSchema: unknown;
-  outputSchema?: unknown;
-  handler: (input: unknown, ctx: ServerPluginToolContext) => Promise<unknown>;
-}
-
-/**
- * Database migration definition for plugins.
- */
-export interface ServerPluginMigration {
-  /** Unique name for ordering (e.g., "001-initial-schema") */
-  name: string;
-  /** Apply the migration */
-  up: (db: Kysely<unknown>) => Promise<void>;
-  /** Revert the migration */
-  down: (db: Kysely<unknown>) => Promise<void>;
-}
-
-/**
- * Context provided to server plugins for route registration and storage creation.
- */
-export interface ServerPluginContext {
-  /** Database instance */
-  db: Kysely<unknown>;
-  /** Credential vault for encrypting sensitive data */
-  vault: {
-    encrypt: (value: string) => Promise<string>;
-    decrypt: (value: string) => Promise<string>;
-  };
-}
-
-/**
- * Event handler context provided to plugin event handlers.
- * Contains the organization ID and a publish function for emitting follow-up events.
- */
-export interface ServerPluginEventContext {
-  /** Organization ID the events belong to */
-  organizationId: string;
-  /** Connection ID of the SELF MCP for this organization */
-  connectionId: string;
-  /** Publish a follow-up event to the event bus */
-  publish: (
-    type: string,
-    subject: string,
-    data?: Record<string, unknown>,
-    options?: { deliverAt?: string },
-  ) => Promise<void>;
-  /** Create an MCP proxy client for calling tools on a connection */
-  createMCPProxy: (connectionId: string) => Promise<{
-    callTool: (
-      params: { name: string; arguments?: Record<string, unknown> },
-      resultSchema?: unknown,
-      options?: { timeout?: number },
-    ) => Promise<{
-      content?: unknown;
-      structuredContent?: unknown;
-      isError?: boolean;
-    }>;
-    close: () => Promise<void>;
-  }>;
-}
-
-/**
- * Startup context provided to plugin onStartup hooks.
- * Contains the database and a publish function for emitting recovery events.
- */
-export interface ServerPluginStartupContext {
-  /** Database instance */
-  db: Kysely<unknown>;
-  /** Publish an event to the event bus for a given organization */
-  publish: (
-    organizationId: string,
-    event: { type: string; subject: string; data?: Record<string, unknown> },
-  ) => Promise<void>;
-}
-
-/**
- * Event definition for a CloudEvent received by a plugin.
- */
-export interface ServerPluginEvent {
-  id: string;
-  type: string;
-  source: string;
-  subject?: string;
-  data?: unknown;
-  time?: string;
-}
-
-/**
- * Server Plugin interface.
- *
- * Plugins export this interface from their server entry point.
- * Tools are registered at startup but gated by org settings at runtime.
- */
-export interface ServerPlugin {
-  /** Unique plugin identifier (e.g., "user-sandbox") */
-  id: string;
-
-  /** Short description shown in settings UI */
-  description?: string;
-
-  /**
-   * MCP tools this plugin provides.
-   * Tools are wrapped with org-enabled gating at registration time.
-   */
-  tools?: ServerPluginToolDefinition[];
-
-  /**
-   * Authenticated API routes.
-   * Mounted at /api/plugins/:pluginId/*
-   * Requires Mesh authentication.
-   */
-  routes?: (app: Hono, ctx: ServerPluginContext) => void;
-
-  /**
-   * Public API routes (no authentication required).
-   * Mounted at the root level.
-   * Use for endpoints that external users access (e.g., connect flow).
-   */
-  publicRoutes?: (app: Hono, ctx: ServerPluginContext) => void;
-
-  /**
-   * Database migrations for this plugin.
-   * Run alongside core migrations in name order.
-   */
-  migrations?: ServerPluginMigration[];
-
-  /**
-   * Factory to create plugin-specific storage adapters.
-   * Called during context initialization.
-   */
-  createStorage?: (ctx: ServerPluginContext) => unknown;
-
-  /**
-   * Event handler for this plugin.
-   *
-   * When defined, the system will:
-   * 1. Auto-subscribe the SELF connection to the specified event types per-organization
-   * 2. Route matching events from the event bus to this handler
-   *
-   * Events are durable (persisted in the event bus) with at-least-once delivery.
-   * The handler receives batches of events and a context for publishing follow-up events.
-   */
-  onEvents?: {
-    /** Event type patterns this plugin handles (e.g., "workflow.execution.created") */
-    types: string[];
-    /** Handle a batch of events. Errors are logged but don't affect other plugins. */
-    handler: (
-      events: ServerPluginEvent[],
-      ctx: ServerPluginEventContext,
-    ) => Promise<void> | void;
-  };
-
-  /**
-   * Startup hook called once after the event bus is ready.
-   *
-   * Use this to recover from crashes (e.g., resume stuck workflow executions).
-   * Called after storage is initialized and the event bus worker has started.
-   * Errors are logged but don't prevent other plugins from starting.
-   */
-  onStartup?: (ctx: ServerPluginStartupContext) => Promise<void>;
-}
-
-/**
- * Type helper for any server plugin
- */
-export type AnyServerPlugin = ServerPlugin;

package/src/well-known/event-bus.ts

@@ -1,454 +0,0 @@
-/**
- * Event Bus Well-Known Binding
- *
- * Defines the interface for interacting with an event bus via MCP.
- * Any MCP that implements this binding can publish events and manage subscriptions.
- *
- * This binding includes:
- * - EVENT_PUBLISH: Publish an event to the bus
- * - EVENT_SUBSCRIBE: Subscribe to events of a specific type
- * - EVENT_UNSUBSCRIBE: Remove a subscription
- *
- * Events follow the CloudEvents v1.0 specification.
- * @see https://cloudevents.io/
- */
-
-import { z } from "zod";
-import { bindingClient, type ToolBinder } from "../core/binder";
-
-// ============================================================================
-// Publish Schemas
-// ============================================================================
-
-/**
- * EVENT_PUBLISH Input Schema
- *
- * Input for publishing an event.
- * Note: `source` is automatically set by the event bus from the caller's connection ID.
- */
-export const EventPublishInputSchema = z.object({
-  /** Event type (e.g., "order.created", "user.signup") */
-  type: z.string().min(1).max(255).describe("Event type identifier"),
-
-  /** Optional subject/resource identifier */
-  subject: z
-    .string()
-    .max(255)
-    .optional()
-    .describe("Subject/resource identifier (e.g., order ID)"),
-
-  /** Event payload (any JSON value) */
-  data: z.unknown().optional().describe("Event payload"),
-
-  /**
-   * Optional scheduled delivery time (ISO 8601 timestamp).
-   * If provided, the event will not be delivered until this time.
-   * If omitted, the event is delivered immediately.
-   * Cannot be used together with `cron`.
-   */
-  deliverAt: z
-    .string()
-    .datetime()
-    .optional()
-    .describe(
-      "Scheduled delivery time (ISO 8601). Omit for immediate delivery.",
-    ),
-
-  /**
-   * Optional cron expression for recurring events.
-   * If provided, the event will be delivered repeatedly according to the schedule.
-   * Uses standard cron syntax (5 or 6 fields).
-   * Cannot be used together with `deliverAt`.
-   *
-   * Examples:
-   * - "0 9 * * 1" - Every Monday at 9:00 AM
-   * - "0 0 1 * *" - First day of every month at midnight
-   * - "0/15 * * * *" - Every 15 minutes
-   */
-  cron: z
-    .string()
-    .max(100)
-    .optional()
-    .describe(
-      "Cron expression for recurring delivery. Use EVENT_CANCEL to stop.",
-    ),
-});
-
-export type EventPublishInput = z.infer<typeof EventPublishInputSchema>;
-
-/**
- * EVENT_PUBLISH Output Schema
- */
-export const EventPublishOutputSchema = z.object({
-  /** Created event ID */
-  id: z.string().describe("Unique event ID"),
-
-  /** Event type */
-  type: z.string().describe("Event type"),
-
-  /** Source connection ID */
-  source: z.string().describe("Source connection ID"),
-
-  /** Event timestamp (ISO 8601) */
-  time: z.string().describe("Event timestamp"),
-});
-
-export type EventPublishOutput = z.infer<typeof EventPublishOutputSchema>;
-
-// ============================================================================
-// Subscribe Schemas
-// ============================================================================
-
-/**
- * EVENT_SUBSCRIBE Input Schema
- *
- * Input for subscribing to events.
- * The subscriber connection ID is automatically set from the caller's token.
- */
-export const EventSubscribeInputSchema = z.object({
-  /** Event type pattern to match */
-  eventType: z.string().min(1).max(255).describe("Event type to subscribe to"),
-
-  /** Optional: Only receive events from this publisher connection */
-  publisher: z
-    .string()
-    .optional()
-    .describe("Filter events by publisher connection ID"),
-
-  /** Optional: JSONPath filter expression on event data */
-  filter: z
-    .string()
-    .max(1000)
-    .optional()
-    .describe("JSONPath filter expression on event data"),
-});
-
-export type EventSubscribeInput = z.infer<typeof EventSubscribeInputSchema>;
-
-/**
- * EVENT_SUBSCRIBE Output Schema
- */
-export const EventSubscribeOutputSchema = z.object({
-  /** Created subscription */
-  subscription: z.object({
-    /** Subscription ID */
-    id: z.string().describe("Subscription ID"),
-
-    /** Subscriber connection ID */
-    connectionId: z.string().describe("Subscriber connection ID"),
-
-    /** Event type pattern */
-    eventType: z.string().describe("Event type pattern"),
-
-    /** Publisher connection filter */
-    publisher: z.string().nullable().describe("Publisher connection filter"),
-
-    /** JSONPath filter */
-    filter: z.string().nullable().describe("JSONPath filter expression"),
-
-    /** Whether subscription is enabled */
-    enabled: z.boolean().describe("Whether subscription is enabled"),
-
-    /** Created timestamp */
-    createdAt: z.string().datetime().describe("Created timestamp (ISO 8601)"),
-
-    /** Updated timestamp */
-    updatedAt: z.string().datetime().describe("Updated timestamp (ISO 8601)"),
-  }),
-});
-
-export type EventSubscribeOutput = z.infer<typeof EventSubscribeOutputSchema>;
-
-// ============================================================================
-// Sync Subscriptions Schemas
-// ============================================================================
-
-/**
- * Subscription item schema for sync operations
- */
-export const SubscriptionItemSchema = z.object({
-  /** Event type pattern to match */
-  eventType: z.string().min(1).max(255).describe("Event type to subscribe to"),
-
-  /** Optional: Only receive events from this publisher connection */
-  publisher: z
-    .string()
-    .optional()
-    .describe("Filter events by publisher connection ID"),
-
-  /** Optional: JSONPath filter expression on event data */
-  filter: z
-    .string()
-    .max(1000)
-    .optional()
-    .describe("JSONPath filter expression on event data"),
-});
-
-export type SubscriptionItem = z.infer<typeof SubscriptionItemSchema>;
-
-/**
- * Subscription detail schema (returned in responses)
- */
-export const SubscriptionDetailSchema = z.object({
-  /** Subscription ID */
-  id: z.string().describe("Subscription ID"),
-
-  /** Subscriber connection ID */
-  connectionId: z.string().describe("Subscriber connection ID"),
-
-  /** Event type pattern */
-  eventType: z.string().describe("Event type pattern"),
-
-  /** Publisher connection filter */
-  publisher: z.string().nullable().describe("Publisher connection filter"),
-
-  /** JSONPath filter */
-  filter: z.string().nullable().describe("JSONPath filter expression"),
-
-  /** Whether subscription is enabled */
-  enabled: z.boolean().describe("Whether subscription is enabled"),
-
-  /** Created timestamp */
-  createdAt: z.string().datetime().describe("Created timestamp (ISO 8601)"),
-
-  /** Updated timestamp */
-  updatedAt: z.string().datetime().describe("Updated timestamp (ISO 8601)"),
-});
-
-export type SubscriptionDetail = z.infer<typeof SubscriptionDetailSchema>;
-
-/**
- * EVENT_SYNC_SUBSCRIPTIONS Input Schema
- *
- * Input for syncing subscriptions to a desired state.
- * The system will create new, delete removed, and update changed subscriptions.
- * Subscriptions are identified by (eventType, publisher) - only one subscription
- * per combination is allowed.
- */
-export const EventSyncSubscriptionsInputSchema = z.object({
-  /** Desired subscriptions - system will create/update/delete to match */
-  subscriptions: z
-    .array(SubscriptionItemSchema)
-    .describe(
-      "Desired subscriptions - system will create/update/delete to match",
-    ),
-});
-
-export type EventSyncSubscriptionsInput = z.infer<
-  typeof EventSyncSubscriptionsInputSchema
->;
-
-/**
- * EVENT_SYNC_SUBSCRIPTIONS Output Schema
- */
-export const EventSyncSubscriptionsOutputSchema = z.object({
-  /** Number of new subscriptions created */
-  created: z.number().int().min(0).describe("Number of subscriptions created"),
-
-  /** Number of subscriptions with filter updated */
-  updated: z
-    .number()
-    .int()
-    .min(0)
-    .describe("Number of subscriptions with filter updated"),
-
-  /** Number of old subscriptions removed */
-  deleted: z.number().int().min(0).describe("Number of subscriptions removed"),
-
-  /** Number of subscriptions unchanged */
-  unchanged: z
-    .number()
-    .int()
-    .min(0)
-    .describe("Number of subscriptions unchanged"),
-
-  /** Current subscriptions after sync */
-  subscriptions: z
-    .array(SubscriptionDetailSchema)
-    .describe("Current subscriptions after sync"),
-});
-
-export type EventSyncSubscriptionsOutput = z.infer<
-  typeof EventSyncSubscriptionsOutputSchema
->;
-
-// ============================================================================
-// Unsubscribe Schemas
-// ============================================================================
-
-/**
- * EVENT_UNSUBSCRIBE Input Schema
- */
-export const EventUnsubscribeInputSchema = z.object({
-  /** Subscription ID to remove */
-  subscriptionId: z.string().describe("Subscription ID to remove"),
-});
-
-export type EventUnsubscribeInput = z.infer<typeof EventUnsubscribeInputSchema>;
-
-/**
- * EVENT_UNSUBSCRIBE Output Schema
- */
-export const EventUnsubscribeOutputSchema = z.object({
-  /** Success status */
-  success: z.boolean().describe("Whether unsubscribe was successful"),
-
-  /** Subscription ID that was removed */
-  subscriptionId: z.string().describe("Subscription ID that was removed"),
-});
-
-export type EventUnsubscribeOutput = z.infer<
-  typeof EventUnsubscribeOutputSchema
->;
-
-// ============================================================================
-// Cancel Schemas (for stopping recurring events)
-// ============================================================================
-
-/**
- * EVENT_CANCEL Input Schema
- *
- * Input for cancelling a recurring event.
- * Only the publisher connection can cancel its own events.
- */
-export const EventCancelInputSchema = z.object({
-  /** Event ID to cancel */
-  eventId: z.string().describe("Event ID to cancel"),
-});
-
-export type EventCancelInput = z.infer<typeof EventCancelInputSchema>;
-
-/**
- * EVENT_CANCEL Output Schema
- */
-export const EventCancelOutputSchema = z.object({
-  /** Success status */
-  success: z.boolean().describe("Whether cancellation was successful"),
-
-  /** Event ID that was cancelled */
-  eventId: z.string().describe("Event ID that was cancelled"),
-});
-
-export type EventCancelOutput = z.infer<typeof EventCancelOutputSchema>;
-
-// ============================================================================
-// Ack Schemas (for acknowledging async event processing)
-// ============================================================================
-
-/**
- * EVENT_ACK Input Schema
- *
- * Input for acknowledging an event delivery.
- * Used when ON_EVENTS returns retryAfter - the subscriber must call EVENT_ACK
- * to confirm successful processing, otherwise the event will be re-delivered.
- *
- * The subscriber connection ID is determined from the caller's token.
- */
-export const EventAckInputSchema = z.object({
-  /** Event ID to acknowledge */
-  eventId: z.string().describe("Event ID to acknowledge"),
-});
-
-export type EventAckInput = z.infer<typeof EventAckInputSchema>;
-
-/**
- * EVENT_ACK Output Schema
- */
-export const EventAckOutputSchema = z.object({
-  /** Success status */
-  success: z.boolean().describe("Whether ACK was successful"),
-
-  /** Event ID that was acknowledged */
-  eventId: z.string().describe("Event ID that was acknowledged"),
-});
-
-export type EventAckOutput = z.infer<typeof EventAckOutputSchema>;
-
-// ============================================================================
-// Event Bus Binding
-// ============================================================================
-
-/**
- * Event Bus Binding
- *
- * Defines the interface for interacting with an event bus.
- * Implementations must provide PUBLISH, SUBSCRIBE, UNSUBSCRIBE, CANCEL, ACK, and SYNC_SUBSCRIPTIONS tools.
- *
- * Required tools:
- * - EVENT_PUBLISH: Publish an event (supports one-time, scheduled, and recurring via cron)
- * - EVENT_SUBSCRIBE: Subscribe to events
- * - EVENT_UNSUBSCRIBE: Remove a subscription
- * - EVENT_CANCEL: Cancel a recurring event (stops future deliveries)
- * - EVENT_ACK: Acknowledge event delivery (for async processing with retryAfter)
- * - EVENT_SYNC_SUBSCRIPTIONS: Sync subscriptions to desired state
- */
-export const EVENT_BUS_BINDING = [
-  {
-    name: "EVENT_PUBLISH" as const,
-    inputSchema: EventPublishInputSchema,
-    outputSchema: EventPublishOutputSchema,
-  },
-  {
-    name: "EVENT_SUBSCRIBE" as const,
-    inputSchema: EventSubscribeInputSchema,
-    outputSchema: EventSubscribeOutputSchema,
-  },
-  {
-    name: "EVENT_UNSUBSCRIBE" as const,
-    inputSchema: EventUnsubscribeInputSchema,
-    outputSchema: EventUnsubscribeOutputSchema,
-  },
-  {
-    name: "EVENT_CANCEL" as const,
-    inputSchema: EventCancelInputSchema,
-    outputSchema: EventCancelOutputSchema,
-  },
-  {
-    name: "EVENT_ACK" as const,
-    inputSchema: EventAckInputSchema,
-    outputSchema: EventAckOutputSchema,
-  },
-  {
-    name: "EVENT_SYNC_SUBSCRIPTIONS" as const,
-    inputSchema: EventSyncSubscriptionsInputSchema,
-    outputSchema: EventSyncSubscriptionsOutputSchema,
-  },
-] satisfies ToolBinder[];
-
-/**
- * Event Bus Binding Client
- *
- * Use this to create a client for interacting with an event bus.
- *
- * @example
- * ```typescript
- * import { EventBusBinding } from "@decocms/bindings/event-bus";
- *
- * // For a connection
- * const client = EventBusBinding.forConnection(connection);
- *
- * // Publish an event
- * const event = await client.EVENT_PUBLISH({
- *   type: "order.created",
- *   data: { orderId: "123" }
- * });
- *
- * // Subscribe to events
- * const sub = await client.EVENT_SUBSCRIBE({
- *   eventType: "order.created"
- * });
- *
- * // Unsubscribe
- * await client.EVENT_UNSUBSCRIBE({
- *   subscriptionId: sub.subscription.id
- * });
- * ```
- */
-export const EventBusBinding = bindingClient(EVENT_BUS_BINDING);
-
-/**
- * Type helper for the Event Bus binding client
- */
-export type EventBusBindingClient = ReturnType<
-  typeof EventBusBinding.forConnection
->;