Failure-proof workflow orchestration for AI agents and cloud apps.

@wfr.workflow(name="request_escalation")
def request_escalation_workflow(ctx: DaprWorkflowContext, order_str: str):
   order = json.loads(order_str) if isinstance(order_str, str) else order_str
   amount = order.get("amount", 0)

   # Auto-approve orders under $1000
   if amount < 1000:
       yield ctx.call_activity(auto_approve_activity, input=order)
       return

   # Orders $1000+ require human approval (7 days max)
   approval_event = ctx.wait_for_external_event("human_approval")
   timeout = ctx.create_timer(timedelta(days=7))
   winner = yield when_any([approval_event, timeout])

   # Handle approval event or timeout
   if winner == timeout:
       yield ctx.call_activity(handle_timeout_activity, input=order)
       return

   approval_result = approval_event.get_result()
   yield ctx.call_activity(process_approval_activity, input=approval_result)

const requestEscalationWorkflow: TWorkflow = async function* (
 ctx: WorkflowContext,
 order: OrderRequest
): any {
 // Auto-approve orders under $1000
 if (order.amount < 1000) {
   yield ctx.callActivity(autoApproveActivity, order);
   return;
 }

 // Orders $1000+ require human approval (7 days max)
 const approvalEvent = ctx.waitForExternalEvent("human_approval");
 const timeout = ctx.createTimer(7 * 24 * 60 * 60);
 const winner = yield ctx.whenAny([approvalEvent, timeout]);

 // Handle approval event or timeout
 if (winner == timeout) {
   yield ctx.callActivity(handleTimeoutActivity, order);
   return;
 }

 const approvalResult = approvalEvent.getResult();
 yield ctx.callActivity(processApprovalActivity, approvalResult);
};

 // Workflow Definition
 @Component
 public static class RequestEscalationWorkflow implements Workflow {
   @Override
   public WorkflowStub create() {
     return ctx -> {
       OrderRequest order = ctx.getInput(OrderRequest.class);
      
       // Auto-approve orders under $1000
       if (order.amount < 1000) {
         ctx.callActivity("AutoApproveActivity", order).await();
         ctx.complete("approved");
         return;
       }
      
       // Orders $1000+ require human approval (7 days max)
       try {
         ApprovalResult approval = ctx.waitForExternalEvent("human_approval", Duration.ofDays(7), ApprovalResult.class).await();
         ctx.callActivity("ProcessApprovalActivity", approval).await();
       } catch (TaskCanceledException e) {
   	// Handle timeout
         ctx.callActivity("HandleTimeoutActivity", order).await();
       }
       ctx.complete("order completed");
     };
   }
 }

// Workflow Definition
func RequestEscalationWorkflow(ctx *workflow.WorkflowContext) (any, error) {
   var order OrderRequest
   if err := ctx.GetInput(&order); err != nil {
       return nil, err
   }

   // Auto-approve orders under $1000
   if order.Amount < 1000 {
       return nil, ctx.CallActivity(AutoApproveActivity, workflow.WithActivityInput(order)).Await(nil)
   }

   // Orders $1000+ require human approval (7 days max)
   var approval ApprovalResult
   err := ctx.WaitForExternalEvent("human_approval", time.Hour*24*7).Await(&approval)

   // Handle approval event or timeout
   if err == nil {
       return nil, ctx.CallActivity(ProcessApprovalActivity, workflow.WithActivityInput(approval)).Await(nil)
   }
   return nil, ctx.CallActivity(HandleTimeoutActivity, workflow.WithActivityInput(order)).Await(nil)
}