@agentuity/runtime 0.0.103 → 0.0.105

package/src/router.ts

@@ -1,300 +1,77 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-/* eslint-disable @typescript-eslint/no-empty-object-type */
-import {
-	type Context,
-	Hono,
-	type Input,
-	type MiddlewareHandler,
-	type Schema,
-	type Env as HonoEnv,
-} from 'hono';
-import { stream as honoStream, streamSSE as honoStreamSSE } from 'hono/streaming';
-import { upgradeWebSocket } from 'hono/bun';
-import { hash, returnResponse } from './_util';
+import { type Context, Hono, type Schema, type Env as HonoEnv } from 'hono';
+import { returnResponse } from './_util';
 import type { Env } from './app';
-import { getAgentAsyncLocalStorage } from './_context';
-import { parseEmail, type Email } from './io/email';
 
 // Re-export both Env types
 export type { Env };
 export type { HonoEnv };
 
-type AgentHandler<E extends Env = Env, P extends string = string, I extends Input = {}> = (
-	c: Context<E, P, I>
-) => any | Promise<any>;
+// Re-export WebSocketConnection from handlers
+export type { WebSocketConnection } from './handlers/websocket';
 
-type EmailHandler<E extends Env = Env, P extends string = string, I extends Input = {}> = (
-	email: Email,
-	c: Context<E, P, I>
-) => any | Promise<any>;
-
-type StreamHandler<E extends Env = Env, P extends string = string, I extends Input = {}> = (
-	c: Context<E, P, I>
-) => ReadableStream<any> | Promise<ReadableStream<any>>;
-
-export interface WebSocketConnection {
-	onOpen: (handler: (event: any) => void | Promise<void>) => void;
-	onMessage: (handler: (event: any) => void | Promise<void>) => void;
-	onClose: (handler: (event: any) => void | Promise<void>) => void;
-	send: (data: string | ArrayBuffer | Uint8Array) => void;
-}
-
-type WebSocketHandler<E extends Env = Env, P extends string = string, I extends Input = {}> = (
-	c: Context<E, P, I>
-) => (ws: WebSocketConnection) => void | Promise<void>;
-
-type SSEHandler<E extends Env = Env, P extends string = string, I extends Input = {}> = (
-	c: Context<E, P, I>
-) => (stream: any) => void | Promise<void>;
-
-// Module augmentation to add custom methods to Hono
-// This avoids wrapper types and type instantiation depth issues
-// Use simplified signatures to avoid type instantiation depth issues
+// Module augmentation to add deprecated methods to Hono
+// These stubs throw errors with migration instructions
 declare module 'hono' {
 	interface Hono {
 		/**
-		 * Register a route to handle incoming emails at a specific address.
-		 *
-		 * @param address - The email address to handle (e.g., 'support@example.com')
-		 * @param handler - Handler function receiving parsed email and context
-		 *
-		 * @example
-		 * ```typescript
-		 * router.email('support@example.com', (email, c) => {
-		 *   console.log('From:', email.fromEmail());
-		 *   console.log('Subject:', email.subject());
-		 *   console.log('Body:', email.text());
-		 *   return c.text('Email received');
-		 * });
-		 * ```
-		 */
-		email(address: string, handler: (email: Email, c: Context) => any): this;
-
-		/**
-		 * Register a route to handle incoming emails with middleware.
-		 *
-		 * @param address - The email address to handle
-		 * @param middleware - Middleware to run before the handler
-		 * @param handler - Handler function receiving parsed email and context
-		 *
-		 * @example
-		 * ```typescript
-		 * router.email('support@example.com', authMiddleware, (email, c) => {
-		 *   return c.json({ received: email.subject() });
-		 * });
-		 * ```
-		 */
-		email(
-			address: string,
-			middleware: MiddlewareHandler,
-			handler: (email: Email, c: Context) => any
-		): this;
-
-		/**
-		 * Register a route to handle incoming SMS messages to a phone number.
-		 *
-		 * @param params - Configuration object with phone number
-		 * @param params.number - Phone number to handle (e.g., '+1234567890')
-		 * @param handler - Handler function receiving context
-		 *
-		 * @example
-		 * ```typescript
-		 * router.sms({ number: '+1234567890' }, (c) => {
-		 *   const message = c.req.query('message');
-		 *   console.log('SMS received:', message);
-		 *   return c.text('SMS received');
-		 * });
-		 * ```
-		 */
-		sms(params: { number: string }, handler: (c: Context) => any): this;
-
-		/**
-		 * Schedule a handler to run at specific intervals using cron syntax.
-		 *
-		 * @param schedule - Cron expression (e.g., '0 0 * * *' for daily at midnight)
-		 * @param handler - Handler function to run on schedule
-		 *
-		 * @example
-		 * ```typescript
-		 * // Run daily at midnight
-		 * router.cron('0 0 * * *', (c) => {
-		 *   console.log('Daily cleanup running');
-		 *   return c.text('Cleanup complete');
-		 * });
-		 *
-		 * // Run every hour
-		 * router.cron('0 * * * *', (c) => {
-		 *   console.log('Hourly health check');
-		 *   return c.text('OK');
-		 * });
-		 * ```
-		 */
-		cron(schedule: string, handler: (c: Context) => any): this;
-
-		/**
-		 * Create a streaming route that returns a ReadableStream.
-		 *
-		 * @param path - The route path
-		 * @param handler - Handler returning a ReadableStream
-		 *
-		 * @example
+		 * @deprecated Use the `websocket` middleware instead:
 		 * ```typescript
-		 * router.stream('/events', (c) => {
-		 *   return new ReadableStream({
-		 *     start(controller) {
-		 *       controller.enqueue('event 1\n');
-		 *       controller.enqueue('event 2\n');
-		 *       controller.close();
-		 *     }
-		 *   });
-		 * });
+		 * import { websocket } from '@agentuity/runtime';
+		 * router.get('/ws', websocket((c, ws) => { ... }));
 		 * ```
 		 */
-		stream(
-			path: string,
-			handler: (c: Context) => ReadableStream<any> | Promise<ReadableStream<any>>
-		): this;
+		websocket(path: string, ...args: any[]): this;
 
 		/**
-		 * Create a streaming route with middleware.
-		 *
-		 * @param path - The route path
-		 * @param middleware - Middleware to run before streaming
-		 * @param handler - Handler returning a ReadableStream
-		 *
-		 * @example
+		 * @deprecated Use the `sse` middleware instead:
 		 * ```typescript
-		 * router.stream('/protected-stream', authMiddleware, (c) => {
-		 *   return new ReadableStream({
-		 *     start(controller) {
-		 *       controller.enqueue('secure data\n');
-		 *       controller.close();
-		 *     }
-		 *   });
-		 * });
+		 * import { sse } from '@agentuity/runtime';
+		 * router.get('/events', sse((c, stream) => { ... }));
 		 * ```
 		 */
-		stream(
-			path: string,
-			middleware: MiddlewareHandler,
-			handler: (c: Context) => ReadableStream<any> | Promise<ReadableStream<any>>
-		): this;
+		sse(path: string, ...args: any[]): this;
 
 		/**
-		 * Create a WebSocket route for real-time bidirectional communication.
-		 *
-		 * @param path - The route path
-		 * @param handler - Setup function that registers WebSocket event handlers
-		 *
-		 * @example
+		 * @deprecated Use the `stream` middleware instead:
 		 * ```typescript
-		 * router.websocket('/ws', (c) => (ws) => {
-		 *   ws.onOpen((event) => {
-		 *     console.log('WebSocket opened');
-		 *     ws.send('Welcome!');
-		 *   });
-		 *
-		 *   ws.onMessage((event) => {
-		 *     console.log('Received:', event.data);
-		 *     ws.send('Echo: ' + event.data);
-		 *   });
-		 *
-		 *   ws.onClose((event) => {
-		 *     console.log('WebSocket closed');
-		 *   });
-		 * });
+		 * import { stream } from '@agentuity/runtime';
+		 * router.post('/data', stream((c) => new ReadableStream({ ... })));
 		 * ```
 		 */
-		websocket(path: string, handler: (c: Context) => (ws: WebSocketConnection) => void): this;
+		stream(path: string, ...args: any[]): this;
 
 		/**
-		 * Create a WebSocket route with middleware.
-		 *
-		 * @param path - The route path
-		 * @param middleware - Middleware to run before WebSocket upgrade
-		 * @param handler - Setup function that registers WebSocket event handlers
-		 *
-		 * @example
+		 * @deprecated Use the `cron` middleware instead:
 		 * ```typescript
-		 * router.websocket('/ws', authMiddleware, (c) => (ws) => {
-		 *   ws.onMessage((event) => {
-		 *     ws.send('Authenticated echo: ' + event.data);
-		 *   });
-		 * });
+		 * import { cron } from '@agentuity/runtime';
+		 * router.post('/job', cron('0 0 * * *', (c) => { ... }));
 		 * ```
 		 */
-		websocket(
-			path: string,
-			middleware: MiddlewareHandler,
-			handler: (c: Context) => (ws: WebSocketConnection) => void
-		): this;
-
-		/**
-		 * Create a Server-Sent Events (SSE) route for streaming updates to clients.
-		 *
-		 * @param path - The route path
-		 * @param handler - Handler receiving SSE stream writer
-		 *
-		 * @example
-		 * ```typescript
-		 * router.sse('/notifications', (c) => async (stream) => {
-		 *   let count = 0;
-		 *   const interval = setInterval(() => {
-		 *     stream.writeSSE({
-		 *       data: `Notification ${++count}`,
-		 *       event: 'notification'
-		 *     });
-		 *     if (count >= 10) {
-		 *       clearInterval(interval);
-		 *       stream.close();
-		 *     }
-		 *   }, 1000);
-		 * });
-		 * ```
-		 */
-		sse(path: string, handler: (c: Context) => (stream: any) => void): this;
-
-		/**
-		 * Create an SSE route with middleware.
-		 *
-		 * @param path - The route path
-		 * @param middleware - Middleware to run before SSE streaming
-		 * @param handler - Handler receiving SSE stream writer
-		 *
-		 * @example
-		 * ```typescript
-		 * router.sse('/protected-events', authMiddleware, (c) => async (stream) => {
-		 *   stream.writeSSE({ data: 'Secure event', event: 'update' });
-		 *   stream.close();
-		 * });
-		 * ```
-		 */
-		sse(
-			path: string,
-			middleware: MiddlewareHandler,
-			handler: (c: Context) => (stream: any) => void
-		): this;
+		cron(schedule: string, ...args: any[]): this;
 	}
 }
 
 /**
  * Creates a Hono router with extended methods for Agentuity-specific routing patterns.
  *
- * In addition to standard HTTP methods (get, post, put, delete, patch), the router includes:
- * - **stream()** - Stream responses with ReadableStream
- * - **websocket()** - WebSocket connections
- * - **sse()** - Server-Sent Events
- * - **email()** - Email handler routing
- * - **sms()** - SMS handler routing
- * - **cron()** - Scheduled task routing
+ * Standard HTTP methods (get, post, put, delete, patch) are available, plus middleware
+ * functions for specialized protocols:
+ *
+ * - **websocket()** - WebSocket connections (import { websocket } from '@agentuity/runtime')
+ * - **sse()** - Server-Sent Events (import { sse } from '@agentuity/runtime')
+ * - **stream()** - Streaming responses (import { stream } from '@agentuity/runtime')
+ * - **cron()** - Scheduled tasks (import { cron } from '@agentuity/runtime')
  *
  * @template E - Environment type (Hono Env)
  * @template S - Schema type for route definitions
  *
- * @returns Extended Hono router with custom methods
+ * @returns Extended Hono router
  *
  * @example
  * ```typescript
+ * import { createRouter, websocket, sse, stream, cron } from '@agentuity/runtime';
+ *
  * const router = createRouter();
  *
  * // Standard HTTP routes
@@ -304,54 +81,32 @@ declare module 'hono' {
  *   return c.json({ received: body });
  * });
  *
- * // Streaming response
- * router.stream('/events', (c) => {
- *   return new ReadableStream({
- *     start(controller) {
- *       controller.enqueue('event 1\n');
- *       controller.enqueue('event 2\n');
- *       controller.close();
- *     }
- *   });
- * });
- *
  * // WebSocket connection
- * router.websocket('/ws', (c) => (ws) => {
+ * router.get('/ws', websocket((c, ws) => {
  *   ws.onMessage((event) => {
- *     console.log('Received:', event.data);
  *     ws.send('Echo: ' + event.data);
  *   });
- * });
+ * }));
  *
  * // Server-Sent Events
- * router.sse('/notifications', (c) => async (stream) => {
- *   let count = 0;
- *   const interval = setInterval(() => {
- *     stream.writeSSE({ data: `Message ${++count}` });
- *     if (count >= 10) {
- *       clearInterval(interval);
- *       stream.close();
- *     }
- *   }, 1000);
- * });
+ * router.get('/events', sse((c, stream) => {
+ *   stream.writeSSE({ data: 'Hello', event: 'message' });
+ * }));
  *
- * // Email routing
- * router.email('support@example.com', (email, c) => {
- *   console.log('From:', email.fromEmail());
- *   console.log('Subject:', email.subject());
- *   return c.text('Email received');
- * });
- *
- * // SMS routing
- * router.sms({ number: '+1234567890' }, (c) => {
- *   return c.text('SMS received');
- * });
+ * // Streaming response
+ * router.post('/stream', stream((c) => {
+ *   return new ReadableStream({
+ *     start(controller) {
+ *       controller.enqueue('data\n');
+ *       controller.close();
+ *     }
+ *   });
+ * }));
  *
- * // Scheduled cron
- * router.cron('0 0 * * *', (c) => {
- *   console.log('Daily task running');
- *   return c.text('OK');
- * });
+ * // Cron job
+ * router.post('/daily', cron('0 0 * * *', (c) => {
+ *   return { status: 'complete' };
+ * }));
  * ```
  */
 export const createRouter = <E extends Env = Env, S extends Schema = Schema>(): Hono<E, S> => {
@@ -405,314 +160,72 @@ export const createRouter = <E extends Env = Env, S extends Schema = Schema>():
 		};
 	}
 
-	// shim in special routes
-	_router.email = (address: string, ...args: any[]) => {
-		let middleware: MiddlewareHandler | undefined;
-		let handler: EmailHandler;
-
-		if (args.length === 1) {
-			handler = args[0];
-		} else {
-			middleware = args[0];
-			handler = args[1];
-		}
-
-		const id = hash(address);
-		const path = `/${id}`;
-		// registerEmailHandler(address)
-		const wrapper = async (c: Context): Promise<Response> => {
-			const contentType = (c.req.header('content-type') || '').trim().toLowerCase();
-			if (!contentType.includes('message/rfc822')) {
-				return c.text('Bad Request: Content-Type must be message/rfc822', 400);
-			}
-
-			const arrayBuffer = await c.req.arrayBuffer();
-			const buffer = Buffer.from(arrayBuffer);
-
-			const email = await parseEmail(buffer);
-
-			let result = handler(email, c);
-			if (result instanceof Promise) result = await result;
-
-			if (result === undefined) {
-				return c.text('OK', 200);
-			}
-			return returnResponse(c, result);
-		};
-
-		if (middleware) {
-			return router.post(path, middleware, wrapper);
-		} else {
-			return router.post(path, wrapper);
-		}
+	// Deprecated stubs that throw errors with migration instructions
+	_router.websocket = (path: string, ..._args: any[]) => {
+		throw new Error(
+			`router.websocket() is deprecated and has been removed.\n\n` +
+				`Migration: Use the websocket middleware instead:\n\n` +
+				`  import { createRouter, websocket } from '@agentuity/runtime';\n\n` +
+				`  const router = createRouter();\n\n` +
+				`  // Before (deprecated):\n` +
+				`  // router.websocket('${path}', (c) => (ws) => { ... });\n\n` +
+				`  // After:\n` +
+				`  router.get('${path}', websocket((c, ws) => {\n` +
+				`    ws.onMessage((event) => {\n` +
+				`      ws.send('Echo: ' + event.data);\n` +
+				`    });\n` +
+				`  }));`
+		);
 	};
 
-	_router.sms = ({ number }: { number: string }, handler: AgentHandler) => {
-		const id = hash(number);
-		const path = `/${id}`;
-		// registerSMSHandler(number)
-		const wrapper = async (c: Context): Promise<Response> => {
-			let result = handler(c);
-			if (result instanceof Promise) result = await result;
-			return returnResponse(c, result);
-		};
-		return router.post(path, wrapper);
+	_router.sse = (path: string, ..._args: any[]) => {
+		throw new Error(
+			`router.sse() is deprecated and has been removed.\n\n` +
+				`Migration: Use the sse middleware instead:\n\n` +
+				`  import { createRouter, sse } from '@agentuity/runtime';\n\n` +
+				`  const router = createRouter();\n\n` +
+				`  // Before (deprecated):\n` +
+				`  // router.sse('${path}', (c) => async (stream) => { ... });\n\n` +
+				`  // After:\n` +
+				`  router.get('${path}', sse((c, stream) => {\n` +
+				`    stream.writeSSE({ data: 'Hello', event: 'message' });\n` +
+				`  }));`
+		);
 	};
 
-	_router.cron = (schedule: string, handler: AgentHandler) => {
-		const id = hash(schedule);
-		const path = `/${id}`;
-		// registerCronHandler(schedule)
-		const wrapper = async (c: Context): Promise<Response> => {
-			let result = handler(c);
-			if (result instanceof Promise) result = await result;
-			return returnResponse(c, result);
-		};
-		return router.post(path, wrapper);
+	_router.stream = (path: string, ..._args: any[]) => {
+		throw new Error(
+			`router.stream() is deprecated and has been removed.\n\n` +
+				`Migration: Use the stream middleware instead:\n\n` +
+				`  import { createRouter, stream } from '@agentuity/runtime';\n\n` +
+				`  const router = createRouter();\n\n` +
+				`  // Before (deprecated):\n` +
+				`  // router.stream('${path}', (c) => new ReadableStream({ ... }));\n\n` +
+				`  // After:\n` +
+				`  router.post('${path}', stream((c) => {\n` +
+				`    return new ReadableStream({\n` +
+				`      start(controller) {\n` +
+				`        controller.enqueue('data\\n');\n` +
+				`        controller.close();\n` +
+				`      }\n` +
+				`    });\n` +
+				`  }));`
+		);
 	};
 
-	_router.stream = (path: string, ...args: any[]) => {
-		let middleware: MiddlewareHandler | undefined;
-		let handler: StreamHandler;
-
-		if (args.length === 1) {
-			handler = args[0];
-		} else {
-			middleware = args[0];
-			handler = args[1];
-		}
-
-		const wrapper = (c: Context) => {
-			// Capture the AgentContext from the request
-			const asyncLocalStorage = getAgentAsyncLocalStorage();
-			const capturedContext = asyncLocalStorage.getStore();
-
-			// Set Content-Type header for streaming response detection by clients
-			c.header('Content-Type', 'application/octet-stream');
-
-			return honoStream(c, async (s: any) => {
-				const runInContext = async () => {
-					try {
-						let streamResult = handler(c);
-						if (streamResult instanceof Promise) streamResult = await streamResult;
-						await s.pipe(streamResult);
-					} catch (err) {
-						c.var.logger.error('Stream error:', err);
-						throw err;
-					}
-				};
-
-				if (capturedContext) {
-					await asyncLocalStorage.run(capturedContext, runInContext);
-				} else {
-					await runInContext();
-				}
-			});
-		};
-
-		// Use POST for stream routes - allows accepting request body
-		// (validators will handle input validation if present)
-		if (middleware) {
-			return router.post(path, middleware, wrapper);
-		} else {
-			return router.post(path, wrapper);
-		}
-	};
-
-	_router.websocket = (path: string, ...args: any[]) => {
-		let middleware: MiddlewareHandler | undefined;
-		let handler: WebSocketHandler;
-
-		if (args.length === 1) {
-			handler = args[0];
-		} else {
-			middleware = args[0];
-			handler = args[1];
-		}
-
-		// Use upgradeWebSocket directly from hono/bun
-		const wrapper = upgradeWebSocket((c: Context) => {
-			let openHandler: ((event: any) => void | Promise<void>) | undefined;
-			let messageHandler: ((event: any) => void | Promise<void>) | undefined;
-			let closeHandler: ((event: any) => void | Promise<void>) | undefined;
-			let initialized = false;
-
-			// Capture the AgentContext from the upgrade request
-			const asyncLocalStorage = getAgentAsyncLocalStorage();
-			const capturedContext = asyncLocalStorage.getStore();
-
-			const wsConnection: WebSocketConnection = {
-				onOpen: (h) => {
-					openHandler = h;
-				},
-				onMessage: (h) => {
-					messageHandler = h;
-				},
-				onClose: (h) => {
-					closeHandler = h;
-				},
-				send: (_data: string | ArrayBuffer | Uint8Array) => {
-					// This will be bound to the actual ws in the handlers
-				},
-			};
-
-			const setupResult = handler(c);
-			const setupFn = typeof setupResult === 'function' ? setupResult : null;
-
-			// Call setup IMMEDIATELY during upgrade, not in onOpen
-			// This allows the user's code to register handlers before events fire
-			if (setupFn) {
-				if (capturedContext) {
-					asyncLocalStorage.run(capturedContext, () => setupFn(wsConnection));
-				} else {
-					setupFn(wsConnection);
-				}
-				initialized = true;
-			}
-
-			return {
-				onOpen: async (event: any, ws: any) => {
-					try {
-						// Bind the real ws.send now that we have the actual websocket
-						wsConnection.send = (data) => ws.send(data);
-
-						if (openHandler) {
-							// Run handler in captured context
-							const handler = openHandler;
-							if (capturedContext) {
-								await asyncLocalStorage.run(capturedContext, () => handler(event));
-							} else {
-								await handler(event);
-							}
-						}
-					} catch (err) {
-						c.var.logger?.error('WebSocket onOpen error:', err);
-						throw err;
-					}
-				},
-				onMessage: async (event: any, ws: any) => {
-					try {
-						// Lazy initialization fallback (shouldn't normally happen)
-						if (!initialized && setupFn) {
-							wsConnection.send = (data) => ws.send(data);
-							if (capturedContext) {
-								await asyncLocalStorage.run(capturedContext, async () => {
-									const result = setupFn(wsConnection);
-									if (result instanceof Promise) await result;
-								});
-							} else {
-								const result = setupFn(wsConnection);
-								if (result instanceof Promise) await result;
-							}
-							initialized = true;
-						}
-						if (messageHandler) {
-							// Run handler in captured context
-							const handler = messageHandler;
-							if (capturedContext) {
-								await asyncLocalStorage.run(capturedContext, () => handler(event));
-							} else {
-								await handler(event);
-							}
-						}
-					} catch (err) {
-						c.var.logger?.error('WebSocket onMessage error:', err);
-						throw err;
-					}
-				},
-				onClose: async (event: any, _ws: any) => {
-					try {
-						if (closeHandler) {
-							// Run handler in captured context
-							const handler = closeHandler;
-							if (capturedContext) {
-								await asyncLocalStorage.run(capturedContext, () => handler(event));
-							} else {
-								await handler(event);
-							}
-						}
-					} catch (err) {
-						c.var.logger?.error('WebSocket onClose error:', err);
-					}
-				},
-			};
-		});
-
-		// wrapper is what upgradeWebSocket(...) returned. Force arity=2 so our get shim
-		// recognizes it as middleware and does not wrap/convert undefined -> 200.
-		const wsMiddleware: MiddlewareHandler = (c, next) =>
-			(wrapper as unknown as MiddlewareHandler)(c, next);
-
-		if (middleware) {
-			// Compose into a single middleware to avoid the 3-arg route which treats the
-			// second function as a handler and wraps it.
-			const composed: MiddlewareHandler = async (c, next) => {
-				return middleware(c, async () => {
-					await wsMiddleware(c, next);
-				});
-			};
-			return router.get(path, composed);
-		} else {
-			return router.get(path, wsMiddleware);
-		}
-	};
-
-	_router.sse = (path: string, ...args: any[]) => {
-		let middleware: MiddlewareHandler | undefined;
-		let handler: SSEHandler;
-
-		if (args.length === 1) {
-			handler = args[0];
-		} else {
-			middleware = args[0];
-			handler = args[1];
-		}
-
-		const wrapper = (c: Context) => {
-			// Capture the AgentContext from the request
-			const asyncLocalStorage = getAgentAsyncLocalStorage();
-			const capturedContext = asyncLocalStorage.getStore();
-
-			return honoStreamSSE(c, async (stream: any) => {
-				// Wrap the stream to intercept write() calls
-				const wrappedStream = {
-					...stream,
-					write: async (data: any) => {
-						// Convert simple write to writeSSE format
-						if (
-							typeof data === 'string' ||
-							typeof data === 'number' ||
-							typeof data === 'boolean'
-						) {
-							return stream.writeSSE({ data: String(data) });
-						} else if (typeof data === 'object' && data !== null) {
-							// If it's already an SSE message object, pass it through
-							return stream.writeSSE(data);
-						}
-						return stream.writeSSE({ data: String(data) });
-					},
-					writeSSE: stream.writeSSE.bind(stream),
-					onAbort: stream.onAbort.bind(stream),
-					close: stream.close?.bind(stream),
-				};
-
-				const runInContext = async () => {
-					await handler(c)(wrappedStream);
-				};
-
-				if (capturedContext) {
-					await asyncLocalStorage.run(capturedContext, runInContext);
-				} else {
-					await runInContext();
-				}
-			});
-		};
-
-		if (middleware) {
-			return router.get(path, middleware, wrapper);
-		} else {
-			return router.get(path, wrapper);
-		}
+	_router.cron = (schedule: string, ..._args: any[]) => {
+		throw new Error(
+			`router.cron() is deprecated and has been removed.\n\n` +
+				`Migration: Use the cron middleware instead:\n\n` +
+				`  import { createRouter, cron } from '@agentuity/runtime';\n\n` +
+				`  const router = createRouter();\n\n` +
+				`  // Before (deprecated):\n` +
+				`  // router.cron('${schedule}', (c) => { ... });\n\n` +
+				`  // After:\n` +
+				`  router.post('/your-cron-path', cron('${schedule}', (c) => {\n` +
+				`    return { status: 'complete' };\n` +
+				`  }));`
+		);
 	};
 
 	return router;