run-llama/workflows-ts
1
0
Fork 0
mirror of https://github.com/run-llama/workflows-ts.git synced 2026-07-10 23:34:00 -04:00
Code Issues 9 Packages Projects Releases 10 Wiki Activity

Workflow Strict validation not working #12

New Issue
Open
opened 2026-02-16 03:15:54 -05:00 by yindo · 0 comments
yindo commented 2026-02-16 03:15:54 -05:00
Owner
Copy Link
Copy Source

Originally created by @logan-markewich on GitHub (Jul 17, 2025).

Was trying to run an example from the docs

import { createWorkflow, workflowEvent } from "@llamaindex/workflow-core";
import { withValidation } from "@llamaindex/workflow-core/middleware/validation";

// Define events with explicit types
const inputEvent = workflowEvent<string>();
const validateEvent = workflowEvent<string>();
const processEvent = workflowEvent<string>();
const resultEvent = workflowEvent<string>();
const errorEvent = workflowEvent<Error>({
  debugLabel: "errorEvent", // Add debug labels for better error messages
});

// Define the allowed event flow paths
const workflow = withValidation(createWorkflow(), [
  [[inputEvent], [validateEvent, errorEvent]], // inputEvent can lead to validateEvent or errorEvent
  [[validateEvent], [processEvent, errorEvent]], // validateEvent can lead to processEvent or errorEvent
  [[processEvent], [resultEvent, errorEvent]], // processEvent can lead to resultEvent or errorEvent
  [[errorEvent], [resultEvent]], // errorEvent can lead to resultEvent
]);

// Now use strictHandle to get compile-time validation
workflow.strictHandle([inputEvent], (sendEvent, event) => {
    if (!event.data || event.data.trim().length === 0) {
        throw new Error("Empty input");
    }
    // This is allowed by our validation rules
    console.log("Sending validate event from input event");
    sendEvent(validateEvent.with(event.data.trim()));

    // This would cause a compile-time error:
    console.log("Sending result event from input event");
    sendEvent(resultEvent.with("Result")); // ❌ Not allowed by validation rules
});

// The rest of the workflow with strict validation
workflow.strictHandle([validateEvent], (sendEvent, event) => {
  console.log("Sending process event from validate event");
  // Validation logic here
  sendEvent(processEvent.with(event.data));
});

workflow.strictHandle([processEvent], (sendEvent, event) => {
  console.log("Sending result event from process event");
  // Processing logic here
  sendEvent(resultEvent.with(`Processed: ${event.data}`));
});

workflow.strictHandle([errorEvent], (sendEvent, event) => {
  console.log("Sending result event from error event");
  // Error handling logic here
  sendEvent(resultEvent.with(`Error handled: ${event.data.message}`));
});

const main = async () => {
  const { sendEvent } = workflow.createContext();

  // Cause a validation error
  sendEvent(inputEvent.with("test1"));
}

void main().catch(console.error);

I added extra logs to see what was happening, here's the output

Sending validate event from input event
Invalid input detected [test1]
Sending process event from validate event
Invalid input detected [test1]
Sending result event from process event
Invalid input detected [Processed: test1]
Sending result event from input event
Invalid input detected [Result]

It seems like all handlers are being restricted by the strict handler, like none of the steps are really running properly?

Also, shouldn't this raise an error instead of printing logs or nah?

Originally created by @logan-markewich on GitHub (Jul 17, 2025). Was trying to run an example [from the docs](https://ts.llamaindex.ai/docs/workflows/advanced-events#advanced-validation-and-type-safety) ```ts import { createWorkflow, workflowEvent } from "@llamaindex/workflow-core"; import { withValidation } from "@llamaindex/workflow-core/middleware/validation"; // Define events with explicit types const inputEvent = workflowEvent<string>(); const validateEvent = workflowEvent<string>(); const processEvent = workflowEvent<string>(); const resultEvent = workflowEvent<string>(); const errorEvent = workflowEvent<Error>({ debugLabel: "errorEvent", // Add debug labels for better error messages }); // Define the allowed event flow paths const workflow = withValidation(createWorkflow(), [ [[inputEvent], [validateEvent, errorEvent]], // inputEvent can lead to validateEvent or errorEvent [[validateEvent], [processEvent, errorEvent]], // validateEvent can lead to processEvent or errorEvent [[processEvent], [resultEvent, errorEvent]], // processEvent can lead to resultEvent or errorEvent [[errorEvent], [resultEvent]], // errorEvent can lead to resultEvent ]); // Now use strictHandle to get compile-time validation workflow.strictHandle([inputEvent], (sendEvent, event) => { if (!event.data || event.data.trim().length === 0) { throw new Error("Empty input"); } // This is allowed by our validation rules console.log("Sending validate event from input event"); sendEvent(validateEvent.with(event.data.trim())); // This would cause a compile-time error: console.log("Sending result event from input event"); sendEvent(resultEvent.with("Result")); // ❌ Not allowed by validation rules }); // The rest of the workflow with strict validation workflow.strictHandle([validateEvent], (sendEvent, event) => { console.log("Sending process event from validate event"); // Validation logic here sendEvent(processEvent.with(event.data)); }); workflow.strictHandle([processEvent], (sendEvent, event) => { console.log("Sending result event from process event"); // Processing logic here sendEvent(resultEvent.with(`Processed: ${event.data}`)); }); workflow.strictHandle([errorEvent], (sendEvent, event) => { console.log("Sending result event from error event"); // Error handling logic here sendEvent(resultEvent.with(`Error handled: ${event.data.message}`)); }); const main = async () => { const { sendEvent } = workflow.createContext(); // Cause a validation error sendEvent(inputEvent.with("test1")); } void main().catch(console.error); ``` I added extra logs to see what was happening, here's the output ``` Sending validate event from input event Invalid input detected [test1] Sending process event from validate event Invalid input detected [test1] Sending result event from process event Invalid input detected [Processed: test1] Sending result event from input event Invalid input detected [Result] ``` It seems like all handlers are being restricted by the strict handler, like none of the steps are really running properly? Also, shouldn't this raise an error instead of printing logs or nah?
Sign in to join this conversation.
No Branch/Tag Specified
Branches Tags
Labels
Clear labels
enhancement
good first issue
help wanted
pull-request
Mirrored from GitHub Pull Request
No Label
Milestone
No items
No Milestone
Projects
Clear projects
No project
Assignees
Clear assignees
yindo
No Assignees
1 Participants
Notifications
Due Date
No due date set.
Dependencies

No dependencies set.

Reference: run-llama/workflows-ts#12
Delete Branch "%!s()"

Deleting a branch is permanent. Although the deleted branch may continue to exist for a short time before it actually gets removed, it CANNOT be undone in most cases. Continue?