Feat: use workflow integration

examples/puppeteer-worker-example/app/ai/agents/puppeteer/workers/pdf.worker.ts

@@ -43,6 +43,20 @@ type Output = z.infer<typeof OutputSchema>;
 export const workerConfig: WorkerConfig = {
   timeout: 300, // 5 minutes
   memorySize: 1024, // 1GB
+//   schedule: [{
+//     method: 'scheduler',
+//     rate: ['cron(0 0/4 ? * MON-FRI *)'],
+//     timezone: 'America/New_York',
+//     input: { key1: 'value1' }
+//   },
+//   {
+//     rate: 'rate(10 minutes)',
+//     enabled: true,
+//     input: { key1: 'value1', key2: 'value2' }
+//   },
+//   'rate(2 hours)',
+//   { rate: 'cron(0 12 * * ? *)', enabled: false }
+// ]
 };
 
 export const pdfWorker = createWorker<typeof InputSchema, Output>({

examples/root/app/ai/agents/system/index.ts

@@ -16,15 +16,18 @@ export const systemAgent = aiRouter
     inputSchema: z.object({}),
     execute: async () => ({ result: new Date().toLocaleDateString() }),
     metadata: {
-      hideUI: true,
+      hideUI: false, // Set to false so return value is written to stream for workflow steps
     },
   })
   .agent('/current_time', async (ctx) => {
     const { format } = ctx.request.params;
+    ctx.response.write({ type: 'data-start', data: 'Getting current time...' });
+    const currentTime = new Date().toLocaleTimeString('en-US', {
+      hour12: format === '12h',
+    })
+    ctx.response.write({ type: 'data-end', data: `${currentTime}` });
     return {
-      result: new Date().toLocaleTimeString('en-US', {
-        hour12: format === '12h',
-      }),
+      result: currentTime,
     };
   })
   .actAsTool('/current_time', {

examples/root/app/ai/agents/workflows/onboarding/index.ts

@@ -0,0 +1,19 @@
+// // This file registers the workflow with ai-router.
+// // The actual workflow function is defined in workflow.ts to avoid
+// // importing from @microfox/ai-router in the workflow file (which would
+// // cause the Workflow DevKit scanner to detect Node.js dependencies).
+
+// import { createWorkflow } from '@microfox/ai-router/workflow';
+// import { onboardingWorkflowFn, onboardingInputSchema, onboardingOutputSchema } from './workflow';
+
+// export const onboardingWorkflow = createWorkflow({
+//   id: 'onboarding-workflow-v1',
+//   version: '1.0',
+//   input: onboardingInputSchema,
+//   output: onboardingOutputSchema,
+//   // External runtime entrypoint
+//   workflowFn: onboardingWorkflowFn,
+// });
+
+// // Re-export the workflow function for direct use if needed
+// export { onboardingWorkflowFn };

examples/root/app/ai/agents/workflows/onboarding/workflow.ts

@@ -0,0 +1,106 @@
+// import { z } from 'zod';
+// import { defineHook } from 'workflow';
+
+// // Define input/output schemas
+// const onboardingInputSchema = z.object({
+//   email: z.string().email(),
+//   name: z.string(),
+// });
+// const onboardingOutputSchema = z.object({ status: z.string(), userId: z.string().optional() });
+
+// // Define verification payload schema for type safety
+// const verificationPayloadSchema = z.object({
+//   type: z.enum(['email_click', 'admin_override']),
+//   verifiedAt: z.string().optional(),
+// });
+
+// // Define the hook using defineHook for type safety
+// const verificationHookSchema = defineHook({
+//   schema: verificationPayloadSchema,
+// });
+
+// // Define step functions using the official workflow package
+// // Steps must have the "use step" directive and are called via step()
+// async function createUser(email: string, name: string) {
+//   "use step";
+//   // Simulate user creation
+//   await new Promise(resolve => setTimeout(resolve, 500));
+//   const userId = `user_${Date.now()}`;
+//   console.log(`[CREATE USER] Created user ${userId} for ${email}`);
+//   return { userId, email };
+// }
+
+// async function sendVerificationEmail(userId: string, email: string, verificationUrl: string) {
+//   "use step";
+//   // Simulate email sending
+//   console.log(`[EMAIL] Sending verification to ${email}: ${verificationUrl}`);
+//   await new Promise(resolve => setTimeout(resolve, 300));
+//   return { sent: true };
+// }
+
+// async function markVerified(userId: string, method: 'email' | 'admin') {
+//   "use step";
+//   console.log(`[VERIFY] User ${userId} verified via ${method}`);
+//   await new Promise(resolve => setTimeout(resolve, 200));
+//   return { verified: true };
+// }
+
+// async function sendWelcomeEmail(userId: string, email: string) {
+//   "use step";
+//   console.log(`[EMAIL] Sending welcome email to ${email}`);
+//   await new Promise(resolve => setTimeout(resolve, 300));
+//   return { sent: true };
+// }
+
+
+// // External runtime entrypoint: `"use workflow"` function for onboarding.
+// // IMPORTANT: This function must be exported directly for the Workflow DevKit
+// // to process it at build time. The "use workflow" directive must be the first
+// // statement in the function body.
+// export async function onboardingWorkflowFn(input: z.infer<typeof onboardingInputSchema>) {
+//   "use workflow";
+
+//   const { email, name } = input;
+
+//   // Step 1: Create user - call step function directly (Workflow DevKit intercepts via "use step")
+//   const user = await createUser(email, name);
+
+//   // Step 2: Create hook for email verification HITL
+//   // Using defineHook pattern - create hook instance with custom token
+//   // Token pattern: onboarding-verification:${email}
+//   // NOTE: This will cause conflicts if multiple workflows start with same input!
+//   // For production, use a unique identifier (runId, timestamp, or UUID) in the token
+//   const hook = verificationHookSchema.create({
+//     token: `onboarding-verification:${email}`,
+//   });
+
+//   // Log the token so it can be retrieved
+//   console.log(`[HITL] Hook token: ${hook.token}`);
+
+//   // Step 3: Send verification email
+//   // Note: The actual signal URL will be constructed by the frontend using the runId
+//   // from the workflow status response. The hook token is deterministic for lookup.
+//   const verificationMessage = `Please verify your email. Use the workflow status endpoint to get the runId and call the signal endpoint.`;
+//   await sendVerificationEmail(user.userId, user.email, verificationMessage);
+
+//   // Step 4: Wait for verification (HITL pause)
+//   // Workflow pauses here until someone calls the signal endpoint with the payload
+//   // No compute resources are consumed while waiting - the workflow status should be "paused"
+//   const verification = await hook;
+//   console.log(`[HITL] Received verification for user ${user.userId}:`, verification);
+
+//   // Step 5: Mark as verified based on verification type
+//   await markVerified(user.userId, verification.type === 'email_click' ? 'email' : 'admin');
+
+//   // Step 6: Send welcome email - call step function directly
+//   await sendWelcomeEmail(user.userId, user.email);
+
+//   return {
+//     status: 'completed',
+//     userId: user.userId,
+//   };
+// }
+
+// // Export schemas for use in registration file
+// export { onboardingInputSchema, onboardingOutputSchema };
+

examples/root/app/ai/agents/workflows/research/index.ts

@@ -0,0 +1,19 @@
+// // This file registers the workflow with ai-router.
+// // The actual workflow function is defined in workflow.ts to avoid
+// // importing from @microfox/ai-router in the workflow file (which would
+// // cause the Workflow DevKit scanner to detect Node.js dependencies).
+
+// import { createWorkflow } from '@microfox/ai-router';
+// import { researchWorkflowFn, researchInputSchema, researchOutputSchema } from './workflow';
+
+// export const researchWorkflow = createWorkflow({
+//   id: 'research-workflow-v1',
+//   version: '1.0',
+//   input: researchInputSchema,
+//   output: researchOutputSchema,
+//   // External runtime entrypoint
+//   workflowFn: researchWorkflowFn,
+// });
+
+// // Re-export the workflow function for direct use if needed
+// export { researchWorkflowFn };

examples/root/app/ai/agents/workflows/research/workflow.ts

@@ -0,0 +1,118 @@
+// import { z } from 'zod';
+// import { defineHook, sleep } from 'workflow';
+
+// // Define input/output schemas
+// const researchInputSchema = z.object({
+//   topic: z.string(),
+//   email: z.string().email(),
+// });
+// const researchOutputSchema = z.object({ status: z.string(), summaryUrl: z.string().optional() });
+
+// // Define approval payload schema for type safety
+// const approvalPayloadSchema = z.object({
+//   decision: z.enum(['approve', 'reject']),
+//   comments: z.string().optional(),
+// });
+
+// // Define the hook using defineHook for type safety
+// // This creates a typed hook that can be awaited in the workflow
+// const approvalHookSchema = defineHook({
+//   schema: approvalPayloadSchema,
+// });
+
+// // Define step functions using the official workflow package
+// // Steps must have the "use step" directive and are called via step()
+// async function searchWeb(query: string) {
+//   "use step";
+//   // Simulate web search - in real app, this would call Brave Search API
+//   await new Promise(resolve => setTimeout(resolve, 1000)); // Simulate delay
+//   return [
+//     `Result 1: Comprehensive analysis of ${query}`,
+//     `Result 2: Latest trends in ${query}`,
+//     `Result 3: Expert opinions on ${query}`,
+//   ];
+// }
+
+// async function summarizeResults(results: string[]) {
+//   "use step";
+//   // Simulate summarization
+//   await new Promise(resolve => setTimeout(resolve, 500));
+//   return {
+//     summary: `Summary of ${results.length} research results`,
+//     keyPoints: results.slice(0, 3),
+//   };
+// }
+
+// async function sendEmail(body: string, recipient: string) {
+//   "use step";
+//   // Simulate email sending
+//   console.log(`[EMAIL] Sending to ${recipient}: ${body.substring(0, 50)}...`);
+//   await new Promise(resolve => setTimeout(resolve, 300));
+//   return {
+//     success: true,
+//     messageId: `msg_${Date.now()}`,
+//   };
+// }
+
+// // External runtime entrypoint: `"use workflow"` function that orchestrates steps.
+// // This will be used by the official `workflow` runtime via the adapter.
+// // IMPORTANT: This function must be exported directly for the Workflow DevKit
+// // to process it at build time. The "use workflow" directive must be the first
+// // statement in the function body.
+// export async function researchWorkflowFn(input: z.infer<typeof researchInputSchema>) {
+//   "use workflow";
+
+//   const { topic, email } = input;
+
+//   // Step 1: Search - call step function directly (Workflow DevKit intercepts via "use step")
+//   const results = await searchWeb(topic);
+
+//   if (results.length === 0) {
+//     return { status: 'failed', summaryUrl: undefined };
+//   }
+
+//   // Step 2: Summarize - call step function directly
+//   const summary = await summarizeResults(results);
+
+//   await sleep("1 min");
+
+//   // Step 3: Create hook for human approval (HITL)
+//   // Using defineHook pattern - create hook instance with custom token
+//   // The workflow will pause at await hook until the hook is resumed
+//   // Token pattern: research-approval:${topic}:${email}
+//   // NOTE: This is deterministic - the frontend can construct this token
+//   // If multiple workflows start with the same input, there will be token conflicts
+//   // For production, consider including runId or using unique identifiers
+//   const hook = approvalHookSchema.create({
+//     token: `research-approval:${topic}:${email}`,
+//   });
+
+//   console.log(`[HITL] Waiting for approval of research summary for topic: ${topic}`);
+//   console.log(`[HITL] Hook token: ${hook.token}`);
+
+//   // Step 4: Wait for human approval (HITL pause)
+//   // Workflow pauses here until someone calls the signal endpoint with approval/rejection
+//   // No compute resources are consumed while waiting - the workflow status should be "paused"
+//   const approval = await hook;
+//   console.log(`[HITL] Received approval decision:`, approval);
+
+//   if (approval.decision === 'reject') {
+//     return {
+//       status: 'rejected',
+//       summaryUrl: undefined,
+//     };
+//   }
+
+//   // Step 5: Send email with approved summary
+//   const emailBody = `${summary.summary}\n\nKey Points:\n${summary.keyPoints.map((p: string) => `- ${p}`).join('\n')}`;
+//   const emailResult = await sendEmail(emailBody, email);
+
+//   return {
+//     status: 'completed',
+//     summaryUrl: `https://example.com/summary/${emailResult.messageId}`,
+//   };
+// }
+
+// // Export schemas for use in registration file
+// export { researchInputSchema, researchOutputSchema };
+

examples/root/app/ai/agents/workflows/shared.ts

@@ -0,0 +1,22 @@
+// import { researchWorkflow } from './research';
+// import { onboardingWorkflow } from './onboarding';
+// import { AiRouter } from '@microfox/ai-router';
+
+// // Shared router instance for workflows
+// // This router will be mounted at /workflows in the main router
+// export const aiRouter = new AiRouter();
+
+// export const aiWorkflowRouter = aiRouter.useWorkflow(
+//     '/research',
+//     researchWorkflow,
+//     {
+//         exposeAsTool: true,
+//     }
+// )
+//     .useWorkflow(
+//         '/onboarding',
+//         onboardingWorkflow,
+//         {
+//             exposeAsTool: true,
+//         }
+//     )

examples/root/app/ai/index.ts

@@ -14,17 +14,21 @@ import { thinkerAgent } from './agents/thinker';
 import { contextLimiter } from './middlewares/contextLimiter';
 import { onlyTextParts } from './middlewares/onlyTextParts';
 
-const aiRouter = new AiRouter<any, any, any, any>();
+const aiRouter = new AiRouter(undefined, undefined);
 // aiRouter.setLogger(console);
 
+// import { aiWorkflowRouter as workflowRouter } from './agents/workflows/shared';
+
 const aiMainRouter = aiRouter
   .agent('/system', systemAgent)
   .agent('/summarize', summarizeAgent)
   .agent('/research', braveResearchAgent)
   .agent('/thinker', thinkerAgent)
-  .use('/', contextLimiter(5))
-  .use('/', onlyTextParts(100))
-  .agent('/', async (props) => {
+  // Mount workflow router as sub-router
+  // .agent('/workflows', workflowRouter)
+  .before('/', contextLimiter(5))
+  .before('/', onlyTextParts(100))
+  .agent('/', async (props: any) => {
     // show a loading indicator
     props.response.writeMessageMetadata({
       loader: 'Thinking...',
@@ -52,7 +56,7 @@ const aiMainRouter = aiRouter
         stepCountIs(10),
         ({ steps }) =>
           steps.some((step) =>
-            step.toolResults.some((tool) => tool.output?._isFinal),
+            step.toolResults.some((tool: any) => tool.output?._isFinal),
           ),
       ],
       onError: (error) => {
@@ -74,6 +78,7 @@ const aiMainRouter = aiRouter
 
 // console.log('--------REGISTRY--------');
 const aiRouterRegistry = aiMainRouter.registry();
+// console.log('Workflow paths:', Object.keys(aiRouterRegistry.map).filter(p => p.includes('workflow')));
 const aiRouterTools = aiRouterRegistry.tools;
 type AiRouterTools = InferUITools<typeof aiRouterTools>;
 // console.log('--------REGISTRY--------');

examples/root/app/api/studio/chat/route.ts

@@ -16,7 +16,7 @@ export async function POST(req: NextRequest) {
   const revalidatePath = lastMessage?.metadata?.revalidatePath;
 
   return aiMainRouter
-    .use(
+    .before(
       '/',
       StudioConfig.studioSettings.database.type === 'upstash-redis'
         ? chatRestoreUpstash

examples/root/app/api/studio/chat/sessions/chatSessionLocal.ts

@@ -139,10 +139,7 @@ export const sessionLocalListOut = async () => {
  * @param next - The next middleware or router
  * @returns
  */
-export const chatRestoreLocal: AiMiddleware<{
-  sessionId: string;
-  loader?: string;
-}> = async (props, next) => {
+export const chatRestoreLocal: AiMiddleware = async (props, next) => {
   try {
     const { sessionId, messages } = props.request;