langchain-agentx-python 1.7.0__tar.gz → 1.8.0__tar.gz

{langchain-agentx-python-1.7.0/langchain_agentx_python.egg-info → langchain-agentx-python-1.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langchain-agentx-python
-Version: 1.7.0
+Version: 1.8.0
 Summary: LangChain/LangGraph-based agent utilities for CodeBaseX.
 Author-email: GoodMood2008 <GoodMood2008@users.noreply.github.com>
 License:                                  Apache License

{langchain-agentx-python-1.7.0 → langchain-agentx-python-1.8.0}/langchain_agentx/__init__.py

@@ -11,7 +11,7 @@ from langchain_agentx import create_loop_agent
 ```
 """
 
-__version__ = "1.7.0"
+__version__ = "1.8.0"
 
 from .loop import (  # noqa: F401
     create_loop_agent,

{langchain-agentx-python-1.7.0 → langchain-agentx-python-1.8.0}/langchain_agentx/workflow/base.py

@@ -47,6 +47,7 @@ from uuid import uuid4
 from langgraph.graph import StateGraph
 from langchain_core.runnables import RunnableConfig
 
+from ..loop.config.agent_config import merge_run_config
 from ..loop.hook.types import HookContext, HookEvent
 from ..loop.hook.registry import HookRegistry
 from ..loop.hook.engine import HookEngine
@@ -159,6 +160,13 @@ class BaseWorkflow(ABC):
         # 初始化 _workflow_path（在 run() 中会更新）
         self._workflow_path = workflow_id
         self._workflow_session_id = None
+        # 当前 run/stream 生效的 run_config（nested as_node 默认继承 SSOT）。
+        # 仅作父→子单向继承快照源；as_node 在 node_fn 入口即读入局部变量（快照）。
+        # 不支持同一 BaseWorkflow 实例并发 run()/astream_events()（set/restore 会互踩）。
+        # 现网拓扑：嵌套子 workflow 经 Chaining stage 顺序触发；Parallelization 并行的是
+        # AgentNode/LoopTaskNode，非同一 inner 实例并发 run()。若 parallel item 挂载同一
+        # BaseWorkflow 实例且并发执行，须改用 contextvars。
+        self._active_run_config: dict[str, Any] | None = None
 
         # === Executor 依赖：Dag/Batch/LoopTaskNode 经 _get_workflow_loop_executor() 使用 ===
         self._graph_factory = graph_factory
@@ -329,17 +337,32 @@ class BaseWorkflow(ABC):
 
         return collect_effective_structure_contract(self, workflow_structure)
 
+    def _resolve_effective_run_config(
+        self,
+        graph: Any,
+        run_config: RunnableConfig | None = None,
+        *,
+        parent_workflow: BaseWorkflow | None = None,
+    ) -> dict[str, Any]:
+        """合并 graph 绑定与 caller config；nested 默认继承 parent ``_active_run_config``。"""
+        caller = run_config
+        if caller is None and parent_workflow is not None:
+            caller = getattr(parent_workflow, "_active_run_config", None)
+        return merge_run_config(graph, caller)
+
     async def run(
         self,
         initial_state: dict,
         *,
         parent_workflow: "BaseWorkflow | None" = None,
+        run_config: RunnableConfig | None = None,
     ) -> dict:
         """执行 Workflow（对外 API，用于顶层调用）。
 
         Args:
             initial_state: 初始状态
             parent_workflow: 父 Workflow（用于构建层级关系，问题 20）
+            run_config: LangGraph 运行配置；缺省时继承 parent ``_active_run_config``
 
         Returns:
             完整的 WorkflowState，包含所有字段的状态
@@ -377,9 +400,18 @@ class BaseWorkflow(ABC):
         })
 
         graph = self.compile()
+        effective_config = self._resolve_effective_run_config(
+            graph,
+            run_config,
+            parent_workflow=parent_workflow,
+        )
+        # 写入 _active_run_config 供 nested as_node 继承；finally 恢复 previous_active。
+        # 见 __init__ 字段注释：同实例并发 run() 不在当前拓扑支持范围内。
+        previous_active = self._active_run_config
+        self._active_run_config = effective_config
 
         try:
-            result = await graph.ainvoke(initial_state)
+            result = await graph.ainvoke(initial_state, config=effective_config)
 
             await self._emit_hook(HookEvent.WORKFLOW_END, {
                 "workflow_id": self._workflow_id,
@@ -390,6 +422,7 @@ class BaseWorkflow(ABC):
             return result
 
         finally:
+            self._active_run_config = previous_active
             # === 内存提取清理（问题 16）===
             # 确保无论成功或失败都清理 pending 的 memory extraction
             # 注意：drain 与 trace_collector 无关，memory extraction 的清理永远执行
@@ -426,12 +459,21 @@ class BaseWorkflow(ABC):
             - ❌ 旧设计（错误）：手算 diff，硬编码字段名，假设 reducer 是 list append
         """
         async def node_fn(state: dict) -> dict:
+            # 入口即快照父 _active_run_config，避免 run() 内 set/restore 与父并发时读漂移。
+            inherited_run_config = getattr(parent_workflow, "_active_run_config", None)
             # === 并发控制（问题 19）===
             if outer_semaphore is not None:
                 async with outer_semaphore:
-                    return await self.run(state, parent_workflow=parent_workflow)
-            else:
-                return await self.run(state, parent_workflow=parent_workflow)
+                    return await self.run(
+                        state,
+                        parent_workflow=parent_workflow,
+                        run_config=inherited_run_config,
+                    )
+            return await self.run(
+                state,
+                parent_workflow=parent_workflow,
+                run_config=inherited_run_config,
+            )
 
         return node_fn
 
@@ -453,8 +495,8 @@ class BaseWorkflow(ABC):
                 "invocation-first nodes must build LoopInvocation and use "
                 "WorkflowAgentLoopExecutor.run_invocation instead."
             )
-        context = WorkflowNodeContext(
-            workflow_id=self._workflow_id,
+        context = WorkflowNodeContext.bound_to_owner(
+            owner_workflow_id=self._workflow_id,
             task_key=task_key,
             parent_session_id=parent_session_id,
         )
@@ -472,6 +514,7 @@ class BaseWorkflow(ABC):
         parent_workflow: "BaseWorkflow | None" = None,
         subgraphs: bool = True,
         version: str = "v2",
+        run_config: RunnableConfig | None = None,
         **kwargs
     ) -> AsyncIterator[dict]:
         """流式执行 Workflow，返回所有事件（包括嵌套子图）。
@@ -481,6 +524,7 @@ class BaseWorkflow(ABC):
             parent_workflow: 父 Workflow（用于构建层级关系）
             subgraphs: 是否包含嵌套子图事件，默认 True
             version: 事件格式版本，"v1" 或 "v2"
+            run_config: LangGraph 运行配置；缺省时 merge 为 SDK 默认 recursion_limit
             **kwargs: 传递给 LangGraph astream_events 的其他参数
 
         Yields:
@@ -521,19 +565,26 @@ class BaseWorkflow(ABC):
             "workflow_path": workflow_path,
         })
 
+        previous_active = self._active_run_config
         try:
             # === 流式执行，传递 subgraphs 参数 ===
             graph = self.compile()
 
             # 注意：不注入 workflow_path 到 configurable（经验证不会透传到事件 metadata）
             # workflow_path 由 WorkflowEventAdapter 通过 langgraph_checkpoint_ns 维护
-            config: RunnableConfig = {}
+            effective_config = self._resolve_effective_run_config(
+                graph,
+                run_config,
+                parent_workflow=parent_workflow,
+            )
+            # 供 nested as_node 继承；finally 恢复。同实例并发 streaming 见 _active_run_config 字段注释。
+            self._active_run_config = effective_config
             driver = GraphStreamDriver()
 
             async for event in driver.run(
                 graph,
                 initial_state,
-                config=config,
+                config=effective_config,
                 subgraphs=subgraphs,
                 version=version,
                 **kwargs,
@@ -548,6 +599,7 @@ class BaseWorkflow(ABC):
             })
 
         finally:
+            self._active_run_config = previous_active
             # === 内存提取清理 ===
             await self._drain_pending_memory_extractions()
 
@@ -560,6 +612,7 @@ class BaseWorkflow(ABC):
         workflow_structure: dict | None = None,
         ui_catalog: WorkflowUiCatalog | None = None,
         display_resolver: WorkflowDisplayResolver | None = None,
+        run_config: RunnableConfig | None = None,
         **kwargs,
     ) -> AsyncIterator[Any]:
         """流式执行 Workflow，返回统一的 LangchainAgentEvent 公共事件流。
@@ -573,6 +626,7 @@ class BaseWorkflow(ABC):
             workflow_structure: 结构信息（如 total_stages）
             ui_catalog: 本次调用覆盖的 Workflow UI 目录（缺省时使用实例级 catalog）
             display_resolver: 本次调用覆盖的 display 解析器（缺省时使用实例级 resolver）
+            run_config: LangGraph 运行配置，透传至 astream_events
             **kwargs: 传递给 astream_events 的其他参数
 
         Yields:
@@ -611,7 +665,12 @@ class BaseWorkflow(ABC):
         )
 
         async for event in adapter.adapt(
-            self.astream_events(initial_state, parent_workflow=parent_workflow, **kwargs)
+            self.astream_events(
+                initial_state,
+                parent_workflow=parent_workflow,
+                run_config=run_config,
+                **kwargs,
+            )
         ):
             yield event
 

{langchain-agentx-python-1.7.0 → langchain-agentx-python-1.8.0}/langchain_agentx/workflow/event_adapter/adapter.py

@@ -165,7 +165,11 @@ class WorkflowEventAdapter:
 
         elif event_type == "on_chain_end" and not node and self._stack.current_depth == 0:
             event_name = event.get("name", "")
-            if event_name and self.state.pending_starts.get("workflow"):
+            if (
+                event_name
+                and self.state.pending_starts.get("workflow")
+                and self._can_emit_root_workflow_end()
+            ):
                 events.append(self._build_event(
                     WorkflowEventType.WORKFLOW_END,
                     {"workflow_id": self.workflow_id}
@@ -308,9 +312,28 @@ class WorkflowEventAdapter:
         previous_depth = self._stack.current_depth
         if previous_depth <= 0:
             return False
+        # 只跳过无 checkpoint_ns 的内层事件（防抖栈退出 nested scope）。
+        # 带 ns 的合法 scope-exit（aggregate / 子图 / stage 的 on_chain_end）必须放行，
+        # 否则 aggregate 永不 close、栈回不到 depth 0，WORKFLOW_END 等终态事件全部发不出。
+        metadata = event.get("metadata") if isinstance(event, dict) else None
+        ckpt_ns = metadata.get("langgraph_checkpoint_ns") if isinstance(metadata, dict) else None
+        if ckpt_ns:
+            return False
         alignment = self._depth_resolver.derive_stack_alignment(event)
         return alignment.target_depth < previous_depth
 
+    def _can_emit_root_workflow_end(self) -> bool:
+        """根 workflow-end 须待全部 child structure 容器 close（防空 ns 塌栈 premature end）。"""
+        for identity in self._lifecycle_guard.open_identities:
+            if "|scope:" not in identity:
+                continue
+            owner_path, scope_key = identity.rsplit("|scope:", 1)
+            # 仅 workflow 根容器：path 与 scope_key 均为 workflow_id
+            if owner_path == self.workflow_id and scope_key == self.workflow_id:
+                continue
+            return False
+        return True
+
     def _should_emit_subworkflow_lifecycle(self, scope_path: str) -> bool:
         """仅 scope_origin=nested_workflow 时发 subworkflow-* 结构事件。"""
         from langchain_agentx.workflow.structure_collector import (

{langchain-agentx-python-1.7.0 → langchain-agentx-python-1.8.0}/langchain_agentx/workflow/event_adapter/structure_lifecycle_guard.py

@@ -4,6 +4,7 @@ structure_lifecycle_guard.py — 结构生命周期事件 open/close 幂等保
 职责：
     - 维护 open-set，同一 identity 未 close 前 suppress 重复 OPEN
     - 已 close 后 suppress 重复 CLOSE；完整 close 后允许合法 reopen
+    - CLOSE 按 scope_key 解析 open identity，容忍 START/DONE 间 workflow_path 失同步
 
 链路位置：
     - Layer 3: Workflow 事件适配器
@@ -12,7 +13,7 @@ structure_lifecycle_guard.py — 结构生命周期事件 open/close 幂等保
 当前裁剪范围：
     - 仅结构生命周期容器事件（workflow / stage / item / aggregate / branch / subworkflow）
     - 不覆盖 graph-node 等内容/调试事件
-    - identity = workflow_path|scope:scope_key
+    - OPEN identity = workflow_path|scope:scope_key；CLOSE 可匹配同 scope_key 的 open 项
 """
 
 from __future__ import annotations
@@ -46,14 +47,12 @@ _CLOSE_EVENTS = frozenset(
 )
 
 
-def build_lifecycle_identity(event: WorkflowEvent) -> str | None:
-    """构建结构容器 identity；非生命周期事件返回 None。"""
+def extract_lifecycle_scope_key(event: WorkflowEvent) -> str | None:
+    """从结构生命周期事件提取 scope_key（与 handler payload 字段一致）。"""
     if event.event_type not in _OPEN_EVENTS and event.event_type not in _CLOSE_EVENTS:
         return None
 
-    path = event.workflow_path or ""
     data = event.data if isinstance(event.data, dict) else {}
-    scope_key: str | None = None
 
     if event.event_type in (
         WorkflowEventType.WORKFLOW_START,
@@ -61,47 +60,70 @@ def build_lifecycle_identity(event: WorkflowEvent) -> str | None:
         WorkflowEventType.WORKFLOW_FAILED,
     ):
         raw = data.get("workflow_id") or event.workflow_id
-        scope_key = str(raw) if raw else None
-    elif event.event_type in (
+        return str(raw) if raw else None
+
+    if event.event_type in (
         WorkflowEventType.SUBWORKFLOW_START,
         WorkflowEventType.SUBWORKFLOW_END,
     ):
         raw = data.get("child_workflow_id")
-        scope_key = str(raw) if raw else None
-    elif event.event_type in (
+        return str(raw) if raw else None
+
+    if event.event_type in (
         WorkflowEventType.STAGE_START,
         WorkflowEventType.STAGE_DONE,
         WorkflowEventType.STAGE_FAILED,
     ):
         raw = data.get("stage_key")
-        scope_key = str(raw) if raw else None
-    elif event.event_type in (
+        return str(raw) if raw else None
+
+    if event.event_type in (
         WorkflowEventType.PARALLEL_ITEM_START,
         WorkflowEventType.PARALLEL_ITEM_DONE,
         WorkflowEventType.PARALLEL_ITEM_FAILED,
     ):
         raw = data.get("item_key")
-        scope_key = str(raw) if raw else None
-    elif event.event_type in (
+        return str(raw) if raw else None
+
+    if event.event_type in (
         WorkflowEventType.PARALLEL_AGGREGATE_START,
         WorkflowEventType.PARALLEL_AGGREGATE_DONE,
         WorkflowEventType.PARALLEL_AGGREGATE_FAILED,
     ):
         raw = data.get("aggregate_key")
-        scope_key = str(raw) if raw else None
-    elif event.event_type in (
+        return str(raw) if raw else None
+
+    if event.event_type in (
         WorkflowEventType.ROUTE_BRANCH_START,
         WorkflowEventType.ROUTE_BRANCH_DONE,
         WorkflowEventType.ROUTE_BRANCH_FAILED,
     ):
         raw = data.get("branch_key")
-        scope_key = str(raw) if raw else None
+        return str(raw) if raw else None
 
+    return None
+
+
+def build_lifecycle_identity(event: WorkflowEvent) -> str | None:
+    """构建结构容器 identity（OPEN 登记用）；非生命周期事件返回 None。"""
+    scope_key = extract_lifecycle_scope_key(event)
     if not scope_key:
         return None
+    path = event.workflow_path or ""
     return f"{path}|scope:{scope_key}"
 
 
+def paths_compatible_for_lifecycle_close(open_path: str, close_path: str) -> bool:
+    """OPEN/DONE 的 workflow_path 互为前缀或相等时，视为同一 scope 容器。"""
+    if open_path == close_path:
+        return True
+    if close_path.startswith(f"{open_path}>"):
+        return True
+    if open_path.startswith(f"{close_path}>"):
+        return True
+    return False
+
+
 class StructureLifecycleGuard:
     """结构生命周期 open-set 幂等守卫（per-adapter 实例，不跨 execution 永久 dedupe）。"""
 
@@ -113,6 +135,39 @@ class StructureLifecycleGuard:
         """当前仍 open 的 identity 集合（测试/诊断）。"""
         return frozenset(self._open_identities)
 
+    def _resolve_close_identity(
+        self,
+        event: WorkflowEvent,
+        identity: str,
+    ) -> str | None:
+        """解析 CLOSE 应对应的 open identity；容忍 path 与 OPEN 时不一致。"""
+        if identity in self._open_identities:
+            return identity
+
+        scope_key = extract_lifecycle_scope_key(event)
+        if not scope_key:
+            return None
+
+        suffix = f"|scope:{scope_key}"
+        candidates = [oid for oid in self._open_identities if oid.endswith(suffix)]
+        if not candidates:
+            return None
+        if len(candidates) == 1:
+            return candidates[0]
+
+        close_path = event.workflow_path or ""
+        prefix_matches = [
+            oid
+            for oid in candidates
+            if paths_compatible_for_lifecycle_close(
+                oid.rsplit("|scope:", 1)[0],
+                close_path,
+            )
+        ]
+        if len(prefix_matches) == 1:
+            return prefix_matches[0]
+        return None
+
     def should_emit(self, event: WorkflowEvent) -> bool:
         """返回是否应向外发射该结构生命周期事件。"""
         identity = build_lifecycle_identity(event)
@@ -126,9 +181,10 @@ class StructureLifecycleGuard:
             return True
 
         if event.event_type in _CLOSE_EVENTS:
-            if identity not in self._open_identities:
+            resolved = self._resolve_close_identity(event, identity)
+            if resolved is None:
                 return False
-            self._open_identities.discard(identity)
+            self._open_identities.discard(resolved)
             return True
 
         return True
@@ -141,4 +197,6 @@ class StructureLifecycleGuard:
 __all__ = [
     "StructureLifecycleGuard",
     "build_lifecycle_identity",
+    "extract_lifecycle_scope_key",
+    "paths_compatible_for_lifecycle_close",
 ]

{langchain-agentx-python-1.7.0 → langchain-agentx-python-1.8.0}/langchain_agentx/workflow/execution.py

@@ -60,11 +60,33 @@ class WorkflowNodeContext:
     task_key: str
     parent_session_id: str | None = None
     node_name: str | None = None
+    expected_owner_workflow_id: str | None = None
 
     @property
     def loop_session_id(self) -> str:
         return WorkflowSessionIdPolicy.build_session_id(self)
 
+    @classmethod
+    def bound_to_owner(
+        cls,
+        *,
+        owner_workflow_id: str,
+        task_key: str,
+        parent_session_id: str | None = None,
+        node_name: str | None = None,
+    ) -> WorkflowNodeContext:
+        """将 loop context 绑定到 Pattern leaf 所属 workflow 实例 id。"""
+        owner = owner_workflow_id.strip()
+        if not owner:
+            raise ValueError("owner_workflow_id must not be empty")
+        return cls(
+            workflow_id=owner,
+            task_key=task_key,
+            parent_session_id=parent_session_id,
+            node_name=node_name,
+            expected_owner_workflow_id=owner,
+        )
+
 
 class WorkflowSessionIdPolicy:
     """Workflow loop session_id 运行时 SSOT。"""
@@ -158,6 +180,53 @@ class WorkflowSessionIdPolicy:
             seen[task_key] = str(label)
 
 
+class LoopOwnerMismatchError(ValueError):
+    """invocation-first loop 缺少 owner binding 或与 expected owner 不一致。"""
+
+    def __init__(
+        self,
+        *,
+        task_key: str,
+        actual_workflow_id: str,
+        expected_owner_workflow_id: str | None = None,
+    ) -> None:
+        self.task_key = task_key
+        self.actual_workflow_id = actual_workflow_id
+        expected_owner = (
+            expected_owner_workflow_id.strip()
+            if isinstance(expected_owner_workflow_id, str)
+            else ""
+        )
+        self.missing_expected_owner = not expected_owner
+        actual_session_id = WorkflowSessionIdPolicy.build_session_id(
+            WorkflowNodeContext(workflow_id=actual_workflow_id, task_key=task_key)
+        )
+        self.actual_session_id = actual_session_id
+        if self.missing_expected_owner:
+            self.expected_owner_workflow_id = None
+            self.expected_session_id = None
+            super().__init__(
+                f"Loop owner binding required for task_key {task_key!r}: "
+                f"expected_owner_workflow_id is missing; "
+                f"got workflow_id {actual_workflow_id!r} "
+                f"(session_id {actual_session_id!r}). "
+                f"Use WorkflowNodeContext.bound_to_owner(...)."
+            )
+            return
+        self.expected_owner_workflow_id = expected_owner
+        expected_session_id = WorkflowSessionIdPolicy.build_session_id(
+            WorkflowNodeContext(workflow_id=expected_owner, task_key=task_key)
+        )
+        self.expected_session_id = expected_session_id
+        super().__init__(
+            f"Loop owner mismatch for task_key {task_key!r}: "
+            f"expected owner workflow_id {expected_owner!r} "
+            f"(session_id {expected_session_id!r}), "
+            f"got workflow_id {actual_workflow_id!r} "
+            f"(session_id {actual_session_id!r})"
+        )
+
+
 @dataclass(frozen=True)
 class LoopInvocation:
     """单次 loop graph 调用的显式描述对象。"""
@@ -264,6 +333,7 @@ class WorkflowAgentLoopExecutor:
         context: WorkflowNodeContext,
     ) -> dict[str, Any]:
         """执行已构造好的 LoopInvocation（trace / semaphore / normalize 统一入口）。"""
+        assert_loop_owner_binding(context)
         self._link_trace(invocation.session_id, context.workflow_id)
         driver = LoopStreamDriver()
         await self._drain_loop_driver(
@@ -281,6 +351,7 @@ class WorkflowAgentLoopExecutor:
         version: str = "v2",
     ) -> AsyncIterator[dict[str, Any]]:
         """流式执行 loop graph，经 LoopStreamDriver 统一 closeout 后 yield 原始事件。"""
+        assert_loop_owner_binding(context)
         self._link_trace(invocation.session_id, context.workflow_id)
         driver = LoopStreamDriver()
         async for event in self._iter_loop_driver_events(
@@ -347,6 +418,32 @@ class WorkflowAgentLoopExecutor:
         return dict(output) if isinstance(output, dict) else {"result": output}
 
 
+def loop_session_id_for_owner(*, owner_workflow_id: str, task_key: str) -> str:
+    """从 owner workflow_id + task_key 推导 loop session_id（含 owner binding 语义）。"""
+    return WorkflowNodeContext.bound_to_owner(
+        owner_workflow_id=owner_workflow_id,
+        task_key=task_key,
+    ).loop_session_id
+
+
+def assert_loop_owner_binding(context: WorkflowNodeContext) -> None:
+    """run_invocation / stream_invocation 入口：owner binding 必经校验。"""
+    actual_workflow_id = context.workflow_id.strip()
+    expected_owner = context.expected_owner_workflow_id
+    if expected_owner is None or not expected_owner.strip():
+        raise LoopOwnerMismatchError(
+            task_key=context.task_key,
+            actual_workflow_id=actual_workflow_id,
+        )
+    expected_owner_workflow_id = expected_owner.strip()
+    if actual_workflow_id != expected_owner_workflow_id:
+        raise LoopOwnerMismatchError(
+            task_key=context.task_key,
+            expected_owner_workflow_id=expected_owner_workflow_id,
+            actual_workflow_id=actual_workflow_id,
+        )
+
+
 def loop_session_id_conflict_reason(
     session_id: str,
     *,
@@ -370,8 +467,11 @@ def loop_session_id_conflict_reason(
 __all__ = [
     "DuplicateSpecTaskKeyError",
     "LoopInvocation",
+    "LoopOwnerMismatchError",
     "WorkflowAgentLoopExecutor",
     "WorkflowNodeContext",
     "WorkflowSessionIdPolicy",
+    "assert_loop_owner_binding",
     "loop_session_id_conflict_reason",
+    "loop_session_id_for_owner",
 ]

{langchain-agentx-python-1.7.0 → langchain-agentx-python-1.8.0}/langchain_agentx/workflow/node_adapter.py

@@ -123,8 +123,8 @@ class WorkflowNodeAdapter:
     ) -> Callable[..., Any]:
         async def node_fn(state: dict[str, Any]) -> dict[str, Any]:
             effective_task_key = task_key or node.task_key()
-            ctx = WorkflowNodeContext(
-                workflow_id=owner._workflow_id,
+            ctx = WorkflowNodeContext.bound_to_owner(
+                owner_workflow_id=owner._workflow_id,
                 task_key=effective_task_key,
                 node_name=getattr(node, "name", None),
             )

{langchain-agentx-python-1.7.0 → langchain-agentx-python-1.8.0/langchain_agentx_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langchain-agentx-python
-Version: 1.7.0
+Version: 1.8.0
 Summary: LangChain/LangGraph-based agent utilities for CodeBaseX.
 Author-email: GoodMood2008 <GoodMood2008@users.noreply.github.com>
 License:                                  Apache License

{langchain-agentx-python-1.7.0 → langchain-agentx-python-1.8.0}/pyproject.toml

@@ -4,7 +4,7 @@
 
  [project]
  name = "langchain-agentx-python"
- version = "1.7.0"
+ version = "1.8.0"
  description = "LangChain/LangGraph-based agent utilities for CodeBaseX."
  readme = "README.md"
  requires-python = ">=3.11"