Merge pull request #3 from mdrideout/j-117-factory-functions-allow-function-params

Docs update

Author: mdrideout

docs/core_concepts.rst

@@ -159,4 +159,34 @@ A `Workflow` is the main executable component that takes a `graph_factory` and a
         )
     )
 
-    await sample_workflow.execute()
+    await sample_workflow.execute()
+
+**Passing Parameters to Factories**
+
+To provide parameters to your `graph_factory` or `store_factory` when
+you create a `Workflow`, you can wrap your factory function call in a
+`lambda`. This creates a new, argument-less factory that calls your
+function with the desired parameters when executed.
+
+This is useful for injecting dependencies like configuration objects or
+API clients into your graph at instantiation time, while preserving
+concurrency safety.
+
+.. code-block:: python
+
+    # Your factory function that requires a dependency
+    def create_graph_with_dependency(api_key: str) -> Graph:
+        # ... setup graph using the api_key
+        return Graph(...)
+
+    # Instantiate the workflow, using a lambda to create the factory
+    workflow = Workflow[MyState, MyStore](
+        name="configured_workflow",
+        graph_factory=lambda: create_graph_with_dependency(
+            api_key="your-secret-key"
+        ),
+        store_factory=lambda: MyStore(initial_state=MyState())
+    )
+
+    # The workflow can now be executed normally
+    await workflow.execute()

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "junjo"
-version = "0.50.0"
+version = "0.50.1"
 description = "A graph workflow execution library for building agentic AI workflows."
 readme = "README.md"
 requires-python = ">=3.11"

src/junjo/workflow.py

@@ -300,6 +300,41 @@ def __init__(
                 hook_manager=HookManager(verbose_logging=False, open_telemetry=True),
             )
             await workflow.execute()
+
+        .. _workflow-instantiation-params:
+
+        **Passing Parameters to Factories**
+
+        To provide parameters to your `graph_factory` or `store_factory` when
+        you create a `Workflow`, you can wrap your factory function call in a
+        `lambda`. This creates a new, argument-less factory that calls your
+        function with the desired parameters when executed.
+
+        This is useful for injecting dependencies like configuration objects or
+        API clients into your graph at instantiation time, while preserving
+        concurrency safety.
+
+        .. code-block:: python
+
+            # Your factory function that requires a dependency
+            def create_graph_with_dependency(emulator: Emulator) -> Graph:
+                # ... setup graph using the emulator
+                return Graph(...)
+
+            # An instance of the dependency
+            my_emulator = Emulator()
+
+            # Instantiate the workflow, using a lambda to create the factory
+            workflow = Workflow[MyState, MyStore](
+                name="configured_workflow",
+                graph_factory=lambda: create_graph_with_dependency(
+                    emulator=my_emulator
+                ),
+                store_factory=lambda: MyStore(initial_state=MyState())
+            )
+
+            # The workflow can now be executed normally
+            await workflow.execute()
         """
         super().__init__(
             graph_factory=graph_factory,