@decocms/bindings 1.1.0 → 1.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decocms/bindings",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "type": "module",
   "scripts": {
     "check": "tsc --noEmit",
@@ -13,6 +13,10 @@
     "zod": "^4.0.0",
     "zod-from-json-schema": "^0.5.2"
   },
+  "devDependencies": {
+    "hono": "^4.7.10",
+    "kysely": "^0.27.5"
+  },
   "exports": {
     ".": "./src/index.ts",
     "./collections": "./src/well-known/collections.ts",
@@ -24,7 +28,8 @@
     "./prompt": "./src/well-known/prompt.ts",
     "./workflow": "./src/well-known/workflow.ts",
     "./plugins": "./src/core/plugins.ts",
-    "./plugin-router": "./src/core/plugin-router.tsx"
+    "./plugin-router": "./src/core/plugin-router.tsx",
+    "./server-plugin": "./src/core/server-plugin.ts"
   },
   "engines": {
     "node": ">=24.0.0"

package/src/core/client/proxy.ts

@@ -67,16 +67,8 @@ export function createMCPClientProxy<T extends Record<string, unknown>>(
       }
       async function callToolFn(
         args: Record<string, unknown>,
-        toolNameOrRequestInit?: string | symbol | RequestInit,
+        toolName = name,
       ) {
-        let toolName: string | symbol;
-        let requestInit: RequestInit | undefined;
-        if (typeof toolNameOrRequestInit === "object") {
-          toolName = name;
-          requestInit = toolNameOrRequestInit;
-        } else {
-          toolName ??= name;
-        }
         const debugId = options?.debugId?.();
         const extraHeaders = debugId
           ? { "x-trace-debug-id": debugId }
@@ -85,21 +77,13 @@ export function createMCPClientProxy<T extends Record<string, unknown>>(
         const { client, callStreamableTool } = await createClient(extraHeaders);
 
         if (options?.streamable?.[String(toolName)]) {
-          return callStreamableTool(
-            String(toolName),
-            args,
-            requestInit?.signal ?? undefined,
-          );
+          return callStreamableTool(String(toolName), args);
         }
 
-        const { structuredContent, isError, content } = await client.callTool(
-          {
-            name: String(toolName),
-            arguments: args as Record<string, unknown>,
-          },
-          undefined,
-          { signal: requestInit?.signal ?? undefined },
-        );
+        const { structuredContent, isError, content } = await client.callTool({
+          name: String(toolName),
+          arguments: args as Record<string, unknown>,
+        });
 
         if (isError) {
           const maybeErrorMessage = (content as { text: string }[])?.[0]?.text;

package/src/core/plugins.ts

@@ -43,14 +43,21 @@ export interface PluginRenderHeaderProps {
   onConnectionChange: (connectionId: string) => void;
 }
 
-export interface Plugin<TBinding extends Binder> {
+/**
+ * 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> {
   id: string;
   /**
    * Short description of the plugin shown in the settings UI.
    */
   description?: string;
   binding: TBinding;
-  setup: PluginSetup;
+  setup?: PluginSetup;
   /**
    * Optional custom layout component for this plugin.
    * If not provided, a default layout with connection selector will be used.
@@ -68,7 +75,16 @@ export interface Plugin<TBinding extends Binder> {
   renderEmptyState?: () => ReactNode;
 }
 
-export type AnyPlugin = Plugin<any>;
+/**
+ * @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 {

package/src/core/server-plugin.ts

@@ -0,0 +1,103 @@
+/**
+ * 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
+ *
+ * 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";
+
+/**
+ * Tool definition compatible with MCP tools.
+ * This is a simplified type - the actual implementation uses the full ToolDefinition from mesh.
+ */
+export interface ServerPluginToolDefinition {
+  name: string;
+  description?: string;
+  inputSchema: unknown;
+  outputSchema?: unknown;
+  handler: (input: unknown, ctx: unknown) => 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>;
+  };
+}
+
+/**
+ * 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;
+}
+
+/**
+ * Type helper for any server plugin
+ */
+export type AnyServerPlugin = ServerPlugin;

package/src/well-known/workflow.ts

@@ -205,7 +205,12 @@ export const WorkflowExecutionSchema = BaseCollectionEntitySchema.extend({
   completed_steps: z
     .object({
       success: z
-        .array(z.string())
+        .array(
+          z.object({
+            name: z.string(),
+            completed_at_epoch_ms: z.number(),
+          }),
+        )
         .describe("Names of the steps that were completed successfully"),
       error: z.array(z.string()).describe("Names of the steps that errored"),
     })