run-llama/workflows-py
1
0
Fork 0
mirror of https://github.com/run-llama/workflows-py.git synced 2026-07-19 08:46:21 -04:00
Code Issues 18 Packages Projects Releases 10 Wiki Activity

[Feature Request] Improve how state is shared between workflows #7

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

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

Today, each workflow is completely decoupled from another. And furthermore, the Context ensures each .run() is also isolated.

If you run a workflow inside another workflow, you end up with

  • two context objects
  • two states
  • two event streams

I think it'd be useful to explore a UX where we actually share information from an outer workflow to an inner workflow.

For example, here's a scenario

@step
async def run_some_step(self, ctx: Context[SomeState], ev: SomeEvent) -> OtherEvent:
  some_val = await ctx.store.get("some_val")
  inner_workflow = InnerWorkflow()
  
  handler = inner_workflow.run(some_val=some_val)
  async for inner_ev in handler.stream_events():
    ctx.write_event_to_stream(inner_ev)

  result = await handler
  await ctx.store.set("some_other_value", result)
  return OtherEvent()

Notice that

  1. Need to propagate events through outer context
  2. Need to pass any state from the outer state to the inner workflow
  3. Need to propagate any state changes from inner workflow to outer state

This gets infinitely more complicated (or even impossible?) if the inner workflow involves human-in-the-loop.

However, its also an option that maybe we don't share state, but if we don't, we should be principled and outline proper development practices.

Originally created by @logan-markewich on GitHub (Jul 29, 2025). Today, each workflow is completely decoupled from another. And furthermore, the `Context` ensures each `.run()` is also isolated. If you run a workflow inside another workflow, you end up with - two context objects - two states - two event streams I think it'd be useful to explore a UX where we actually share information from an outer workflow to an inner workflow. For example, here's a scenario ``` @step async def run_some_step(self, ctx: Context[SomeState], ev: SomeEvent) -> OtherEvent: some_val = await ctx.store.get("some_val") inner_workflow = InnerWorkflow() handler = inner_workflow.run(some_val=some_val) async for inner_ev in handler.stream_events(): ctx.write_event_to_stream(inner_ev) result = await handler await ctx.store.set("some_other_value", result) return OtherEvent() ``` Notice that 1. Need to propagate events through outer context 2. Need to pass any state from the outer state to the inner workflow 3. Need to propagate any state changes from inner workflow to outer state This gets infinitely more complicated (or even impossible?) if the inner workflow involves human-in-the-loop. However, its also an option that maybe we don't share state, but if we don't, we should be principled and outline proper development practices.
yindo added the enhancement label 2026-02-16 02:16:03 -05:00
Sign in to join this conversation.
No Branch/Tag Specified
Branches Tags
Labels
Clear labels
bug
enhancement
enhancement
good first issue
pull-request
Mirrored from GitHub Pull Request
 question
No Label enhancement
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-py#7
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?