@decocms/runtime 1.0.3 → 1.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decocms/runtime",
-  "version": "1.0.3",
+  "version": "1.1.1",
   "type": "module",
   "scripts": {
     "check": "tsc --noEmit",
@@ -8,13 +8,12 @@
   },
   "dependencies": {
     "@cloudflare/workers-types": "^4.20250617.0",
-    "@decocms/bindings": "1.0.3",
+    "@decocms/bindings": "1.0.7",
     "@modelcontextprotocol/sdk": "1.25.1",
-    "@ai-sdk/provider": "^2.0.0",
+    "@ai-sdk/provider": "^3.0.0",
     "hono": "^4.10.7",
     "jose": "^6.0.11",
-    "zod": "^3.25.76",
-    "zod-to-json-schema": "3.25.0"
+    "zod": "^4.0.0"
   },
   "exports": {
     ".": "./src/index.ts",
@@ -35,4 +34,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}

package/src/bindings/binder.ts

@@ -1,5 +1,6 @@
 /* oxlint-disable no-explicit-any */
 import { z } from "zod";
+import type { ZodType, ZodTypeAny } from "zod";
 import type { MCPConnection } from "../connection.ts";
 import {
   createMCPFetchStub,
@@ -17,8 +18,8 @@ export interface ToolLike<
 > {
   name: TName;
   description: string;
-  inputSchema: z.ZodType<TInput>;
-  outputSchema?: z.ZodType<TReturn>;
+  inputSchema: ZodType<TInput>;
+  outputSchema?: ZodType<TReturn>;
   handler: (props: TInput) => Promise<TReturn> | TReturn;
 }
 
@@ -36,7 +37,7 @@ export type BinderImplementation<
           TDefinition[K]["name"],
           z.infer<TDefinition[K]["inputSchema"]>,
           TDefinition[K] extends { outputSchema: infer Schema }
-            ? Schema extends z.ZodType
+            ? Schema extends ZodTypeAny
               ? z.infer<Schema>
               : never
             : never
@@ -51,7 +52,7 @@ export type BinderImplementation<
             TDefinition[K]["name"],
             z.infer<TDefinition[K]["inputSchema"]>,
             TDefinition[K] extends { outputSchema: infer Schema }
-              ? Schema extends z.ZodType
+              ? Schema extends ZodTypeAny
                 ? z.infer<Schema>
                 : never
               : never

package/src/bindings.ts

@@ -1,4 +1,4 @@
-import { CollectionBinding } from "packages/bindings/src/well-known/collections.ts";
+import type { CollectionBinding } from "@decocms/bindings/collections";
 import type { MCPConnection } from "./connection.ts";
 import type { RequestContext } from "./index.ts";
 import { type MCPClientFetchStub, MCPClient, type ToolBinder } from "./mcp.ts";
@@ -38,7 +38,7 @@ export const BindingOf = <
   name: TName,
 ) => {
   return z.object({
-    __type: z.literal<TName>(name).default(name),
+    __type: z.literal(name as string).default(name as string),
     value: z.string(),
   });
 };

package/src/events.ts

@@ -3,9 +3,20 @@ import type {
   EventResult,
   OnEventsOutput,
 } from "@decocms/bindings";
-import z from "zod";
+import { z } from "zod";
 import { isBinding } from "./bindings.ts";
 
+// ============================================================================
+// Constants
+// ============================================================================
+
+/**
+ * SELF is a well-known property key for event handlers that represents
+ * the current connection. When used, subscriptions are created with the
+ * current connection's ID as the publisher.
+ */
+export const SELF = "SELF" as const;
+
 // ============================================================================
 // Types
 // ============================================================================
@@ -34,12 +45,27 @@ export type BatchHandlerFn<TEnv> = (
 ) => OnEventsOutput | Promise<OnEventsOutput>;
 
 /**
- * Batch handler with explicit event types for subscription
+ * Batch handler with explicit event types for subscription.
+ *
+ * When used as a global handler, events must be prefixed with binding name:
+ * - "SELF::order.created" - subscribe to order.created from current connection
+ * - "DATABASE::record.updated" - subscribe to record.updated from DATABASE binding
+ *
+ * @example
+ * ```ts
+ * {
+ *   handler: async ({ events }, env) => ({ success: true }),
+ *   events: ["SELF::order.created", "DATABASE::record.updated"]
+ * }
+ * ```
  */
 export interface BatchHandler<TEnv> {
   /** Handler function */
   handler: BatchHandlerFn<TEnv>;
-  /** Event types to subscribe to */
+  /**
+   * Event types to subscribe to.
+   * Format: "BINDING::EVENT_TYPE" (e.g., "SELF::order.created")
+   */
   events: string[];
 }
 
@@ -56,24 +82,19 @@ export interface BatchHandler<TEnv> {
  * { handler: fn, events: ["order.created", "order.updated"] }
  * ```
  */
-export type BindingHandlers<TEnv, Binding = unknown> =
+export type BindingHandlers<TEnv> =
   | BatchHandler<TEnv>
-  | (Record<string, PerEventHandler<TEnv>> & CronHandlers<Binding, TEnv>);
+  | Record<string, PerEventHandler<TEnv>>;
 
-export type CronHandlers<Binding, Env = unknown> = Binding extends {
-  __type: "@deco/event-bus";
-  value: string;
-}
-  ? {
-      [key in `cron/${string}`]: (env: Env) => Promise<void>;
-    }
-  : {};
 /**
- * EventHandlers type supports three granularity levels:
+ * EventHandlers type supports four handler formats:
  *
- * @example Global handler with explicit events
+ * @example Global handler with prefixed events (BINDING::EVENT_TYPE)
  * ```ts
- * { handler: (ctx, env) => result, events: ["order.created"] }
+ * {
+ *   handler: (ctx, env) => result,
+ *   events: ["SELF::order.created", "DATABASE::record.updated"]
+ * }
  * ```
  *
  * @example Per-binding batch handler
@@ -85,22 +106,31 @@ export type CronHandlers<Binding, Env = unknown> = Binding extends {
  * ```ts
  * { DATABASE: { "order.created": (ctx, env) => result } }
  * ```
+ *
+ * @example SELF handlers for self-subscription (events from current connection)
+ * ```ts
+ * { SELF: { "order.created": (ctx, env) => result } }
+ * ```
  */
 export type EventHandlers<
   Env = unknown,
   TSchema extends z.ZodTypeAny = never,
 > = [TSchema] extends [never]
-  ? Record<string, never>
+  ? // When no schema, only SELF is available
+    BatchHandler<Env> | { SELF?: BindingHandlers<Env> }
   :
       | BatchHandler<Env> // Global handler with events
-      | {
+      | ({
           [K in keyof z.infer<TSchema> as z.infer<TSchema>[K] extends {
             __type: string;
             value: string;
           }
             ? K
-            : never]?: BindingHandlers<Env, z.infer<TSchema>[K]>;
-        };
+            : never]?: BindingHandlers<Env>;
+        } & {
+          /** SELF: Subscribe to events from the current connection */
+          SELF?: BindingHandlers<Env>;
+        });
 
 /**
  * Extract only the keys from T where the value is a Binding shape.
@@ -150,6 +180,49 @@ const isBatchHandler = <TEnv>(
 // Helper Functions
 // ============================================================================
 
+/**
+ * Event subscription separator - used in global handlers to specify binding
+ * Format: BINDING::EVENT_TYPE (e.g., "SELF::order.created", "DATABASE::record.updated")
+ */
+const EVENT_SEPARATOR = "::" as const;
+
+/**
+ * Parse a prefixed event type into binding and event type
+ * @param prefixedEvent - Event in format "BINDING::EVENT_TYPE"
+ * @returns Tuple of [binding, eventType] or null if not prefixed
+ */
+const parseEventPrefix = (
+  prefixedEvent: string,
+): [binding: string, eventType: string] | null => {
+  const separatorIndex = prefixedEvent.indexOf(EVENT_SEPARATOR);
+  if (separatorIndex === -1) {
+    return null;
+  }
+  const binding = prefixedEvent.substring(0, separatorIndex);
+  const eventType = prefixedEvent.substring(
+    separatorIndex + EVENT_SEPARATOR.length,
+  );
+  return [binding, eventType];
+};
+
+/**
+ * Parse a cron event type into name and expression
+ * Format: cron/NAME/EXPRESSION (e.g., "cron/daily-cleanup/0 9 * * 1")
+ * @param eventType - Event type that may be a cron event
+ * @returns Tuple of [name, cronExpression] or null if not a cron event
+ */
+const parseCronEvent = (
+  eventType: string,
+): [name: string, cron: string] | null => {
+  if (!eventType.startsWith("cron/")) return null;
+  const parts = eventType.substring(5); // Remove "cron/"
+  const slashIndex = parts.indexOf("/");
+  if (slashIndex === -1) return null;
+  const name = parts.substring(0, slashIndex);
+  const cron = parts.substring(slashIndex + 1);
+  return [name, cron];
+};
+
 /**
  * Get binding keys from event handlers object
  */
@@ -184,40 +257,84 @@ const getEventTypesForBinding = <TEnv, TSchema extends z.ZodTypeAny>(
   return Object.keys(bindingHandler);
 };
 
+/**
+ * Resolve a binding name to its publisher (connection ID)
+ * Handles SELF specially by using the current connectionId
+ */
+const resolvePublisher = (
+  binding: string,
+  state: Record<string, unknown>,
+  connectionId?: string,
+): string | null => {
+  if (binding === SELF) {
+    if (!connectionId) {
+      console.warn("[Event] SELF binding used but no connectionId available");
+      return null;
+    }
+    return connectionId;
+  }
+
+  const bindingValue = state[binding];
+  if (!isBinding(bindingValue)) {
+    console.warn(`[Event] Binding "${binding}" not found in state`);
+    return null;
+  }
+  return bindingValue.value;
+};
+
 /**
  * Get subscriptions from event handlers and state
  * Returns flat array of { eventType, publisher } for EVENT_SYNC_SUBSCRIPTIONS
+ *
+ * For global handlers, events must be prefixed with binding name:
+ * - "SELF::order.created" - subscribe to order.created from current connection
+ * - "DATABASE::record.updated" - subscribe to record.updated from DATABASE binding
+ *
+ * @param handlers - Event handlers configuration
+ * @param state - Resolved bindings state (can be unknown when only SELF is used)
+ * @param connectionId - Current connection ID (used for SELF subscriptions)
  */
 const eventsSubscriptions = <TEnv, TSchema extends z.ZodTypeAny = never>(
   handlers: EventHandlers<TEnv, TSchema>,
-  state: z.infer<TSchema>,
+  state: z.infer<TSchema> | Record<string, unknown>,
+  connectionId?: string,
 ): EventSubscription[] => {
+  const stateRecord = state as Record<string, unknown>;
+
   if (isGlobalHandler<TEnv>(handlers)) {
-    // Global handler - subscribe to all bindings with the explicit events
+    // Global handler - events must be prefixed with BINDING::EVENT_TYPE
     const subscriptions: EventSubscription[] = [];
-    for (const [, value] of Object.entries(state)) {
-      if (isBinding(value)) {
-        for (const eventType of handlers.events) {
-          subscriptions.push({
-            eventType,
-            publisher: value.value,
-          });
-        }
+    for (const prefixedEvent of handlers.events) {
+      const parsed = parseEventPrefix(prefixedEvent);
+      if (!parsed) {
+        console.warn(
+          `[Event] Global handler event "${prefixedEvent}" must be prefixed with BINDING:: (e.g., "SELF::${prefixedEvent}" or "DATABASE::${prefixedEvent}")`,
+        );
+        continue;
       }
+
+      const [binding, eventType] = parsed;
+      const publisher = resolvePublisher(binding, stateRecord, connectionId);
+      if (!publisher) continue;
+
+      subscriptions.push({
+        eventType,
+        publisher,
+      });
     }
     return subscriptions;
   }
 
   const subscriptions: EventSubscription[] = [];
   for (const binding of getBindingKeys(handlers)) {
-    const bindingValue = state[binding as keyof typeof state];
-    if (!isBinding(bindingValue)) continue;
+    const publisher = resolvePublisher(binding, stateRecord, connectionId);
+    if (!publisher) continue;
 
     const eventTypes = getEventTypesForBinding(handlers, binding);
     for (const eventType of eventTypes) {
       subscriptions.push({
         eventType,
-        publisher: bindingValue.value,
+        publisher,
       });
     }
   }
@@ -310,21 +427,55 @@ const mergeResults = (results: OnEventsOutput[]): OnEventsOutput => {
 /**
  * Execute event handlers and return merged result
  *
- * Supports three handler formats:
- * 1. Global: `(context, env) => result` - handles all events
- * 2. Per-binding: `{ BINDING: (context, env) => result }` - handles all events from binding
- * 3. Per-event: `{ BINDING: { "event.type": (context, env) => result } }` - handles specific events
+ * Supports four handler formats:
+ * 1. Global: `{ handler: fn, events: ["SELF::order.created", "DB::record.updated"] }` - prefixed events
+ * 2. Per-binding batch: `{ BINDING: { handler: fn, events: [...] } }` - handles all events from binding
+ * 3. Per-event: `{ BINDING: { "event.type": handler } }` - handles specific events
+ * 4. SELF: `{ SELF: { "event.type": handler } }` - handles events from current connection
+ *
+ * @param handlers - Event handlers configuration
+ * @param events - CloudEvents to process
+ * @param env - Environment
+ * @param state - Resolved bindings state (can be unknown when only SELF is used)
+ * @param connectionId - Current connection ID (used for SELF handlers)
  */
 const executeEventHandlers = async <TEnv, TSchema extends z.ZodTypeAny>(
   handlers: EventHandlers<TEnv, TSchema>,
   events: CloudEvent[],
-  env: z.infer<TSchema>,
-  state: z.infer<TSchema>,
+  env: TEnv,
+  state: z.infer<TSchema> | Record<string, unknown>,
+  connectionId?: string,
 ): Promise<OnEventsOutput> => {
-  // Case 1: Global handler
+  const stateRecord = state as Record<string, unknown>;
+
+  // Case 1: Global handler with prefixed events
   if (isGlobalHandler<TEnv>(handlers)) {
+    // Build a set of valid (publisher, eventType) pairs from prefixed events
+    const validSubscriptions = new Set<string>();
+    for (const prefixedEvent of handlers.events) {
+      const parsed = parseEventPrefix(prefixedEvent);
+      if (!parsed) continue;
+
+      const [binding, eventType] = parsed;
+      const publisher = resolvePublisher(binding, stateRecord, connectionId);
+      if (!publisher) continue;
+
+      // Create a key for quick lookup: "publisher:eventType"
+      validSubscriptions.add(`${publisher}:${eventType}`);
+    }
+
+    // Filter events to only those that match our subscriptions
+    const matchingEvents = events.filter((event) => {
+      const key = `${event.source}:${event.type}`;
+      return validSubscriptions.has(key);
+    });
+
+    if (matchingEvents.length === 0) {
+      return { success: true };
+    }
+
     try {
-      return await handlers.handler({ events }, env);
+      return await handlers.handler({ events: matchingEvents }, env);
     } catch (error) {
       return {
         success: false,
@@ -336,9 +487,9 @@ const executeEventHandlers = async <TEnv, TSchema extends z.ZodTypeAny>(
   // Build a map from connectionId -> binding key
   const connectionToBinding = new Map<string, string>();
   for (const binding of getBindingKeys(handlers)) {
-    const bindingValue = state[binding as keyof typeof state];
-    if (isBinding(bindingValue)) {
-      connectionToBinding.set(bindingValue.value, binding);
+    const publisher = resolvePublisher(binding, stateRecord, connectionId);
+    if (publisher) {
+      connectionToBinding.set(publisher, binding);
     }
   }
 
@@ -383,7 +534,7 @@ const executeEventHandlers = async <TEnv, TSchema extends z.ZodTypeAny>(
     // Case 3: Per-event handlers
     const perEventHandlers = bindingHandler as Record<
       string,
-      PerEventHandler<z.infer<TSchema>>
+      PerEventHandler<TEnv>
     >;
     const eventsByType = groupEventsByType(sourceEvents);
 
@@ -394,33 +545,7 @@ const executeEventHandlers = async <TEnv, TSchema extends z.ZodTypeAny>(
         continue;
       }
 
-      // Case 3a: Cron handlers (event type starts with "cron/")
-      // - Handler signature: (env) => Promise<void>
-      // - Fire and forget (don't await)
-      // - Always return success immediately
-      if (eventType.startsWith("cron/")) {
-        const cronHandler = eventHandler as unknown as (
-          env: z.infer<TSchema>,
-        ) => Promise<void>;
-
-        // Fire and forget - don't await, just log errors
-        cronHandler(env).catch((error) => {
-          console.error(
-            `[Event] Cron handler error for ${eventType}:`,
-            error instanceof Error ? error.message : String(error),
-          );
-        });
-
-        // Immediately return success for all cron events
-        const results: Record<string, EventResult> = {};
-        for (const event of typedEvents) {
-          results[event.id] = { success: true };
-        }
-        promises.push(Promise.resolve({ results }));
-        continue;
-      }
-
-      // Case 3b: Regular per-event handlers
+      // Case 3: Per-event handlers
       // Call handler for each event type (handler receives all events of that type)
       promises.push(
         (async () => {
@@ -469,4 +594,5 @@ const executeEventHandlers = async <TEnv, TSchema extends z.ZodTypeAny>(
 export const Event = {
   subscriptions: eventsSubscriptions,
   execute: executeEventHandlers,
+  parseCron: parseCronEvent,
 };

package/src/index.ts

@@ -1,6 +1,6 @@
 /* oxlint-disable no-explicit-any */
 import { decodeJwt } from "jose";
-import type { z } from "zod";
+import { z } from "zod";
 import {
   BindingRegistry,
   initializeBindings,
@@ -105,6 +105,7 @@ export interface RequestContext<
   }) => User | undefined;
   callerApp?: string;
   connectionId?: string;
+  organizationId?: string;
 }
 
 const withDefaultBindings = ({
@@ -164,7 +165,7 @@ export const withBindings = <TEnv>({
   authToken,
 }: {
   env: TEnv;
-  server: MCPServer<TEnv, any>;
+  server: MCPServer<TEnv, any, any>;
   // token is x-mesh-token
   tokenOrContext?: string | RequestContext;
   // authToken is the authorization header
@@ -183,6 +184,7 @@ export const withBindings = <TEnv>({
         state?: Record<string, unknown>;
         meshUrl?: string;
         connectionId?: string;
+        organizationId?: string;
       }) ?? {};
 
     context = {
@@ -191,6 +193,8 @@ export const withBindings = <TEnv>({
       token: tokenOrContext,
       meshUrl: (decoded.meshUrl as string) ?? metadata.meshUrl,
       connectionId: (decoded.connectionId as string) ?? metadata.connectionId,
+      organizationId:
+        (decoded.organizationId as string) ?? metadata.organizationId,
       ensureAuthenticated: AUTHENTICATED(decoded.user ?? decoded.sub),
     } as RequestContext<any>;
   } else if (typeof tokenOrContext === "object") {

package/src/state.ts

@@ -8,7 +8,7 @@ export const State = {
   getStore: () => {
     return asyncLocalStorage.getStore();
   },
-  run: <TEnv extends DefaultEnv, R, TArgs extends unknown[]>(
+  run: <TEnv extends DefaultEnv<any, any>, R, TArgs extends unknown[]>(
     ctx: AppContext<TEnv>,
     f: (...args: TArgs) => R,
     ...args: TArgs

package/src/tools.ts

@@ -9,13 +9,14 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { WebStandardStreamableHTTPServerTransport as HttpServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
 import type { GetPromptResult } from "@modelcontextprotocol/sdk/types.js";
 import { z } from "zod";
-import { zodToJsonSchema } from "zod-to-json-schema";
+import type { ZodRawShape, ZodSchema, ZodTypeAny } from "zod";
 import { BindingRegistry } from "./bindings.ts";
 import { Event, type EventHandlers } from "./events.ts";
 import type { DefaultEnv } from "./index.ts";
 import { State } from "./state.ts";
 
-// Re-export EventHandlers type for external use
+// Re-export EventHandlers type and SELF constant for external use
+export { SELF } from "./events.ts";
 export type { EventHandlers } from "./events.ts";
 
 export const createRuntimeContext = (prev?: AppContext) => {
@@ -30,7 +31,7 @@ export const createRuntimeContext = (prev?: AppContext) => {
 };
 
 export interface ToolExecutionContext<
-  TSchemaIn extends z.ZodTypeAny = z.ZodTypeAny,
+  TSchemaIn extends ZodTypeAny = ZodTypeAny,
 > {
   context: z.infer<TSchemaIn>;
   runtimeContext: AppContext;
@@ -40,8 +41,8 @@ export interface ToolExecutionContext<
  * Tool interface with generic schema types for type-safe tool creation.
  */
 export interface Tool<
-  TSchemaIn extends z.ZodTypeAny = z.ZodTypeAny,
-  TSchemaOut extends z.ZodTypeAny | undefined = undefined,
+  TSchemaIn extends ZodTypeAny = ZodTypeAny,
+  TSchemaOut extends ZodTypeAny | undefined = undefined,
 > {
   id: string;
   description?: string;
@@ -49,7 +50,7 @@ export interface Tool<
   outputSchema?: TSchemaOut;
   execute(
     context: ToolExecutionContext<TSchemaIn>,
-  ): TSchemaOut extends z.ZodSchema
+  ): TSchemaOut extends ZodSchema
     ? Promise<z.infer<TSchemaOut>>
     : Promise<unknown>;
 }
@@ -57,7 +58,7 @@ export interface Tool<
 /**
  * Streamable tool interface for tools that return Response streams.
  */
-export interface StreamableTool<TSchemaIn extends z.ZodSchema = z.ZodSchema> {
+export interface StreamableTool<TSchemaIn extends ZodSchema = ZodSchema> {
   id: string;
   inputSchema: TSchemaIn;
   streamable?: true;
@@ -72,8 +73,8 @@ export interface StreamableTool<TSchemaIn extends z.ZodSchema = z.ZodSchema> {
 export type CreatedTool = {
   id: string;
   description?: string;
-  inputSchema: z.ZodTypeAny;
-  outputSchema?: z.ZodTypeAny;
+  inputSchema: ZodTypeAny;
+  outputSchema?: ZodTypeAny;
   streamable?: true;
   // Use a permissive execute signature - accepts any context shape
   execute(context: {
@@ -90,18 +91,16 @@ export type { GetPromptResult } from "@modelcontextprotocol/sdk/types.js";
  * Unlike tool arguments, prompt arguments are always strings.
  */
 export type PromptArgsRawShape = {
-  [k: string]:
-    | z.ZodType<string, z.ZodTypeDef, string>
-    | z.ZodOptional<z.ZodType<string, z.ZodTypeDef, string>>;
+  [k: string]: z.ZodType<string> | z.ZodOptional<z.ZodType<string>>;
 };
 
 /**
  * Context passed to prompt execute functions.
  */
 export interface PromptExecutionContext<
-  TArgs extends PromptArgsRawShape = PromptArgsRawShape,
+  _TArgs extends PromptArgsRawShape = PromptArgsRawShape,
 > {
-  args: z.objectOutputType<TArgs, z.ZodTypeAny>;
+  args: Record<string, string | undefined>;
   runtimeContext: AppContext;
 }
 
@@ -138,8 +137,8 @@ export type CreatedPrompt = {
  * creates a private tool that always ensure for athentication before being executed
  */
 export function createPrivateTool<
-  TSchemaIn extends z.ZodSchema = z.ZodSchema,
-  TSchemaOut extends z.ZodSchema | undefined = undefined,
+  TSchemaIn extends ZodSchema = ZodSchema,
+  TSchemaOut extends ZodSchema | undefined = undefined,
 >(opts: Tool<TSchemaIn, TSchemaOut>): Tool<TSchemaIn, TSchemaOut> {
   const execute = opts.execute;
   if (typeof execute === "function") {
@@ -154,9 +153,9 @@ export function createPrivateTool<
   return createTool(opts);
 }
 
-export function createStreamableTool<
-  TSchemaIn extends z.ZodSchema = z.ZodSchema,
->(streamableTool: StreamableTool<TSchemaIn>): StreamableTool<TSchemaIn> {
+export function createStreamableTool<TSchemaIn extends ZodSchema = ZodSchema>(
+  streamableTool: StreamableTool<TSchemaIn>,
+): StreamableTool<TSchemaIn> {
   return {
     ...streamableTool,
     execute: (input: ToolExecutionContext<TSchemaIn>) => {
@@ -173,8 +172,8 @@ export function createStreamableTool<
 }
 
 export function createTool<
-  TSchemaIn extends z.ZodSchema = z.ZodSchema,
-  TSchemaOut extends z.ZodSchema | undefined = undefined,
+  TSchemaIn extends ZodSchema = ZodSchema,
+  TSchemaOut extends ZodSchema | undefined = undefined,
 >(opts: Tool<TSchemaIn, TSchemaOut>): Tool<TSchemaIn, TSchemaOut> {
   return {
     ...opts,
@@ -321,7 +320,7 @@ type PickByType<T, Value> = {
 
 export interface CreateMCPServerOptions<
   Env = unknown,
-  TSchema extends z.ZodTypeAny = never,
+  TSchema extends ZodTypeAny = never,
   TBindings extends BindingRegistry = BindingRegistry,
   TEnv extends Env & DefaultEnv<TSchema, TBindings> = Env &
     DefaultEnv<TSchema, TBindings>,
@@ -385,12 +384,12 @@ const getEventBus = (
     : env?.MESH_REQUEST_CONTEXT.state[prop];
 };
 
-const toolsFor = <TSchema extends z.ZodTypeAny = never>({
+const toolsFor = <TSchema extends ZodTypeAny = never>({
   events,
   configuration: { state: schema, scopes, onChange } = {},
 }: CreateMCPServerOptions<any, TSchema> = {}): CreatedTool[] => {
   const jsonSchema = schema
-    ? zodToJsonSchema(schema)
+    ? z.toJSONSchema(schema)
     : { type: "object", properties: {} };
   const busProp = String(events?.bus ?? "EVENT_BUS");
   return [
@@ -409,19 +408,47 @@ const toolsFor = <TSchema extends z.ZodTypeAny = never>({
             }),
             outputSchema: z.object({}),
             execute: async (input) => {
-              const state = input.context.state as z.infer<TSchema>;
+              const state = (input.context as { state: unknown })
+                .state as z.infer<TSchema>;
               await onChange?.(input.runtimeContext.env, {
                 state,
-                scopes: input.context.scopes,
+                scopes: (input.context as { scopes: string[] }).scopes,
               });
               const bus = getEventBus(busProp, input.runtimeContext.env);
               if (events && state && bus) {
+                // Get connectionId for SELF subscriptions
+                const connectionId =
+                  input.runtimeContext.env.MESH_REQUEST_CONTEXT?.connectionId;
                 // Sync subscriptions - always call to handle deletions too
                 const subscriptions = Event.subscriptions(
                   events?.handlers ?? ({} as Record<string, never>),
                   state,
+                  connectionId,
                 );
                 await bus.EVENT_SYNC_SUBSCRIPTIONS({ subscriptions });
+
+                // Publish cron events for SELF cron subscriptions
+                // Publishing is idempotent - if cron event already exists, it returns existing
+                if (connectionId) {
+                  const cronSubscriptions = subscriptions.filter(
+                    (sub) =>
+                      sub.eventType.startsWith("cron/") &&
+                      sub.publisher === connectionId,
+                  );
+
+                  await Promise.all(
+                    cronSubscriptions.map(async (sub) => {
+                      const parsed = Event.parseCron(sub.eventType);
+                      if (parsed) {
+                        const [, cronExpression] = parsed;
+                        await bus.EVENT_PUBLISH({
+                          type: sub.eventType,
+                          cron: cronExpression,
+                        });
+                      }
+                    }),
+                  );
+                }
               }
               return Promise.resolve({});
             },
@@ -441,11 +468,14 @@ const toolsFor = <TSchema extends z.ZodTypeAny = never>({
               const env = input.runtimeContext.env;
               // Get state from MESH_REQUEST_CONTEXT - this has the binding values
               const state = env.MESH_REQUEST_CONTEXT?.state as z.infer<TSchema>;
+              // Get connectionId for SELF handlers
+              const connectionId = env.MESH_REQUEST_CONTEXT?.connectionId;
               return Event.execute(
                 events.handlers!,
                 input.context.events,
                 env,
                 state,
+                connectionId,
               );
             },
           }),
@@ -479,7 +509,7 @@ type CallTool = (opts: {
 
 export type MCPServer<
   TEnv = unknown,
-  TSchema extends z.ZodTypeAny = never,
+  TSchema extends ZodTypeAny = never,
   TBindings extends BindingRegistry = BindingRegistry,
 > = {
   fetch: Fetch<TEnv & DefaultEnv<TSchema, TBindings>>;
@@ -488,7 +518,7 @@ export type MCPServer<
 
 export const createMCPServer = <
   Env = unknown,
-  TSchema extends z.ZodTypeAny = never,
+  TSchema extends ZodTypeAny = never,
   TBindings extends BindingRegistry = BindingRegistry,
   TEnv extends Env & DefaultEnv<TSchema, TBindings> = Env &
     DefaultEnv<TSchema, TBindings>,
@@ -535,14 +565,14 @@ export const createMCPServer = <
           description: tool.description,
           inputSchema:
             tool.inputSchema && "shape" in tool.inputSchema
-              ? (tool.inputSchema.shape as z.ZodRawShape)
+              ? (tool.inputSchema.shape as ZodRawShape)
               : z.object({}).shape,
           outputSchema: isStreamableTool(tool)
             ? z.object({ bytes: z.record(z.string(), z.number()) }).shape
             : tool.outputSchema &&
                 typeof tool.outputSchema === "object" &&
                 "shape" in tool.outputSchema
-              ? (tool.outputSchema.shape as z.ZodRawShape)
+              ? (tool.outputSchema.shape as ZodRawShape)
               : z.object({}).shape,
         },
         async (args) => {