langchain-agentx-python 1.9.2__tar.gz → 1.9.4__tar.gz

{langchain-agentx-python-1.9.2/langchain_agentx_python.egg-info → langchain-agentx-python-1.9.4}/PKG-INFO

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

{langchain-agentx-python-1.9.2 → langchain-agentx-python-1.9.4}/langchain_agentx/__init__.py

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

{langchain-agentx-python-1.9.2 → langchain-agentx-python-1.9.4}/langchain_agentx/loop/run_context.py

@@ -10,6 +10,8 @@ run_context.py — Workflow/Agent 结构化并发上下文（parent → child ca
 
 当前裁剪范围：
     asyncio 为主；thread 仅 bounded join（无法强制中断 LLM）；anyio/trio 不保证 context 传播。
+    P1：reset 失败时在仍可见 owner 的 derived logical context 内 force-clear；
+    宿主 detached ingest 用 create_task_with_copied_context / run_context_scope。
 """
 
 from __future__ import annotations
@@ -18,12 +20,15 @@ import asyncio
 import logging
 import threading
 import time
-from contextvars import ContextVar, Token
+from contextlib import asynccontextmanager
+from contextvars import ContextVar, Token, copy_context
 from dataclasses import dataclass, field
-from typing import Optional
+from typing import AsyncIterator, Awaitable, Optional, TypeVar
 
 logger = logging.getLogger(__name__)
 
+T = TypeVar("T")
+
 _current_run_context: ContextVar[Optional["RunContext"]] = ContextVar(
     "run_ctx", default=None
 )
@@ -124,8 +129,77 @@ def install_run_context(
     return ctx, token
 
 
-def reset_run_context(token: Token) -> None:
-    _current_run_context.reset(token)
+def reset_run_context(token: Token, *, owner: RunContext | None = None) -> None:
+    """恢复 RunContext ContextVar；跨 logical context 时 force-clear 或降级 warn。
+
+    P0：token.reset 失败不抛未捕获异常。
+    P1：若当前 logical context 仍可见 ``owner``（derived context 继承值但 token 无效），
+    显式 ``set(None)`` 清理本层，避免 workflow finally 后 run_ctx 悬挂。
+    """
+    try:
+        _current_run_context.reset(token)
+        return
+    except ValueError:
+        pass
+
+    current = get_run_context()
+    if owner is not None and current is owner:
+        _current_run_context.set(None)
+        logger.warning(
+            "run_ctx force-cleared: token reset failed in derived logical context "
+            "(task=%r)",
+            owner.root_task.get_name(),
+        )
+        return
+
+    if owner is not None and owner.root_task.done():
+        logger.debug(
+            "run_ctx reset skipped: owner task %r already done; context discarded",
+            owner.root_task.get_name(),
+        )
+        return
+
+    logger.warning(
+        "run_ctx reset skipped: token created in a different context",
+        exc_info=True,
+    )
+
+
+@asynccontextmanager
+async def run_context_scope(*, parent: RunContext | None = None):
+    """显式 bracket RunContext install/reset（宿主非 generator 路径）。"""
+    ctx, token = install_run_context(parent=parent)
+    try:
+        yield ctx
+    finally:
+        reset_run_context(token, owner=ctx)
+
+
+def create_task_with_copied_context(
+    coro: Awaitable[T],
+    *,
+    context=None,
+    name: str | None = None,
+) -> asyncio.Task[T]:
+    """在显式 context 快照中 spawn task（宿主 POST → 后台 ingest 正模式）。
+
+    默认 ``copy_context()``，保证 detached task 与创建点 contextvars 一致。
+    仍需在同一 task 内完整消费 workflow 流，避免跨 task aclose generator。
+    """
+    if context is None:
+        context = copy_context()
+    return asyncio.create_task(coro, context=context, name=name)
+
+
+async def drive_async_iterator_in_current_task(
+    iterator: AsyncIterator[T],
+) -> AsyncIterator[T]:
+    """在当前 asyncio task 内驱动 async iterator（禁止把 aclose 交给子 task）。
+
+    用于宿主 ingest 需额外并发但仍须保证 generator finally 与 install 同 task 的场景。
+    """
+    async for item in iterator:
+        yield item
 
 
 def register_spawned_task(
@@ -165,9 +239,12 @@ def register_spawned_thread(
 
 __all__ = [
     "RunContext",
+    "create_task_with_copied_context",
+    "drive_async_iterator_in_current_task",
     "get_run_context",
     "install_run_context",
     "register_spawned_task",
     "register_spawned_thread",
     "reset_run_context",
+    "run_context_scope",
 ]

{langchain-agentx-python-1.9.2 → langchain-agentx-python-1.9.4}/langchain_agentx/loop/stream/loop_driver.py

@@ -24,7 +24,7 @@ from ..exit.reason_codes import (
     TERMINAL_REASON_GRAPH_RUNTIME_ERROR,
     TERMINAL_REASON_RUNTIME_BUDGET_EXHAUSTED,
 )
-from ..exit.terminal import apply_terminal_reason_projection, build_loop_terminal
+from ..exit.terminal import apply_terminal_reason_projection, build_loop_terminal, read_terminal_reason
 from langchain_agentx.observability.events.tool_call_id_resolver import ToolCallIdResolver
 
 from .result import StreamDriverResult
@@ -60,82 +60,95 @@ class LoopStreamDriver:
         self._assistant_turn_count = 0
         self._last_tool_use_count = 0
         self._pending_tool_calls.clear()
+        self.result.raw_events_consumed = 0
+        self.result.last_raw_event = None
+        self.result.saw_chat_model_end_last_turn = False
         try:
-            async for event in graph.astream_events(
-                graph_input,
-                config=config,
-                version=version,
-            ):
-                self._observe_event(event)
-                yield event
-            self.result.graph_completed = True
-            self._log_missing_root_chain_end_anomaly()
-        except asyncio.CancelledError as exc:
-            self.result.final_error = exc
-            for repair in self._orphan_tool_result_repairs(closeout_kind="cancelled"):
-                yield repair
-            raise
-        except GraphRecursionError as exc:
-            self.result.final_error = exc
-            self._log_catch_error(exc)
-            for repair in self._orphan_tool_result_repairs(closeout_kind="interrupted"):
-                yield repair
-            if not self.result.saw_error_visible_surface:
-                self.result.saw_error_visible_surface = True
-                yield build_synthetic_error_visible_event(
-                    message="Runtime budget exhausted (recursion limit reached)",
-                    error_kind="graph_recursion_error",
-                )
-            if not self.result.saw_finish_surface:
-                terminal = build_loop_terminal(
-                    reason=TERMINAL_REASON_RUNTIME_BUDGET_EXHAUSTED,
-                    error_kind="graph_recursion_error",
-                    step=(self.result.last_loop_snapshot or {}).get("step"),
-                    turn_count=(self.result.last_loop_snapshot or {}).get("turn_count"),
-                    provider_finish_reason=(self.result.last_loop_snapshot or {}).get("finish_reason"),
-                    errors=[str(exc)],
-                    metadata={
-                        "langgraph_error_type": "GraphRecursionError",
-                    },
-                )
-                self.result.terminal = terminal
-                synthetic_output = self._build_synthetic_graph_output(terminal)
-                self.result.graph_output = synthetic_output
-                self.result.saw_finish_surface = True
-                yield build_synthetic_root_chain_end(graph_output=synthetic_output)
-            self._log_catch_error_diagnostic(exc)
-            raise
-        except Exception as exc:
-            self.result.final_error = exc
-            # CC catch 协议 §5.3.3：先记录日志 / 观测，再补 stream surface，最后 re-raise
-            self._log_catch_error(exc)
-            for repair in self._orphan_tool_result_repairs(closeout_kind="interrupted"):
-                yield repair
-            if not self.result.saw_error_visible_surface:
-                self.result.saw_error_visible_surface = True
-                yield build_synthetic_error_visible_event(
-                    message=str(exc),
-                    error_kind="graph_runtime_error",
-                )
-            if not self.result.saw_finish_surface:
-                terminal = build_loop_terminal(
-                    reason=TERMINAL_REASON_GRAPH_RUNTIME_ERROR,
-                    error_kind="graph_runtime_error",
-                    step=(self.result.last_loop_snapshot or {}).get("step"),
-                    turn_count=(self.result.last_loop_snapshot or {}).get("turn_count"),
-                    provider_finish_reason=(self.result.last_loop_snapshot or {}).get("finish_reason"),
-                    errors=[str(exc)],
-                )
-                self.result.terminal = terminal
-                synthetic_output = self._build_synthetic_graph_output(terminal)
-                self.result.graph_output = synthetic_output
-                self.result.saw_finish_surface = True
-                yield build_synthetic_root_chain_end(graph_output=synthetic_output)
-            self._log_catch_error_diagnostic(exc)
-            raise
+            try:
+                async for event in graph.astream_events(
+                    graph_input,
+                    config=config,
+                    version=version,
+                ):
+                    self._observe_event(event)
+                    yield event
+                self.result.graph_completed = True
+                self._log_missing_root_chain_end_anomaly()
+            except asyncio.CancelledError as exc:
+                self.result.final_error = exc
+                for repair in self._orphan_tool_result_repairs(closeout_kind="cancelled"):
+                    yield repair
+                raise
+            except GraphRecursionError as exc:
+                self.result.final_error = exc
+                self._log_catch_error(exc)
+                for repair in self._orphan_tool_result_repairs(closeout_kind="interrupted"):
+                    yield repair
+                if not self.result.saw_error_visible_surface:
+                    self.result.saw_error_visible_surface = True
+                    yield build_synthetic_error_visible_event(
+                        message="Runtime budget exhausted (recursion limit reached)",
+                        error_kind="graph_recursion_error",
+                    )
+                if not self.result.saw_finish_surface:
+                    terminal = build_loop_terminal(
+                        reason=TERMINAL_REASON_RUNTIME_BUDGET_EXHAUSTED,
+                        error_kind="graph_recursion_error",
+                        step=(self.result.last_loop_snapshot or {}).get("step"),
+                        turn_count=(self.result.last_loop_snapshot or {}).get("turn_count"),
+                        provider_finish_reason=(self.result.last_loop_snapshot or {}).get("finish_reason"),
+                        errors=[str(exc)],
+                        metadata={
+                            "langgraph_error_type": "GraphRecursionError",
+                        },
+                    )
+                    self.result.terminal = terminal
+                    synthetic_output = self._build_synthetic_graph_output(terminal)
+                    self.result.graph_output = synthetic_output
+                    self.result.saw_finish_surface = True
+                    yield build_synthetic_root_chain_end(graph_output=synthetic_output)
+                self._log_catch_error_diagnostic(exc)
+                raise
+            except Exception as exc:
+                self.result.final_error = exc
+                # CC catch 协议 §5.3.3：先记录日志 / 观测，再补 stream surface，最后 re-raise
+                self._log_catch_error(exc)
+                for repair in self._orphan_tool_result_repairs(closeout_kind="interrupted"):
+                    yield repair
+                if not self.result.saw_error_visible_surface:
+                    self.result.saw_error_visible_surface = True
+                    yield build_synthetic_error_visible_event(
+                        message=str(exc),
+                        error_kind="graph_runtime_error",
+                    )
+                if not self.result.saw_finish_surface:
+                    terminal = build_loop_terminal(
+                        reason=TERMINAL_REASON_GRAPH_RUNTIME_ERROR,
+                        error_kind="graph_runtime_error",
+                        step=(self.result.last_loop_snapshot or {}).get("step"),
+                        turn_count=(self.result.last_loop_snapshot or {}).get("turn_count"),
+                        provider_finish_reason=(self.result.last_loop_snapshot or {}).get("finish_reason"),
+                        errors=[str(exc)],
+                    )
+                    self.result.terminal = terminal
+                    synthetic_output = self._build_synthetic_graph_output(terminal)
+                    self.result.graph_output = synthetic_output
+                    self.result.saw_finish_surface = True
+                    yield build_synthetic_root_chain_end(graph_output=synthetic_output)
+                self._log_catch_error_diagnostic(exc)
+                raise
+        finally:
+            self._log_stream_closeout_summary()
 
     def _observe_event(self, event: dict[str, Any]) -> None:
-        event_name = event.get("event")
+        event_name = str(event.get("event") or "")
+        name = str(event.get("name") or "")
+        self.result.raw_events_consumed += 1
+        self.result.last_raw_event = f"{event_name}:{name}" if event_name or name else None
+        if event_name == "on_chat_model_start":
+            self.result.saw_chat_model_end_last_turn = False
+        elif event_name == "on_chat_model_end":
+            self.result.saw_chat_model_end_last_turn = True
         if event_name == "on_chain_end" and event.get("name") == "LangGraph":
             self.result.saw_root_chain_end = True
             self.result.saw_finish_surface = True
@@ -240,15 +253,64 @@ class LoopStreamDriver:
             "saw_finish_surface": self.result.saw_finish_surface,
             "saw_root_chain_end": self.result.saw_root_chain_end,
             "graph_completed": self.result.graph_completed,
+            "raw_events_consumed": self.result.raw_events_consumed,
+            "last_raw_event": self.result.last_raw_event,
+            "saw_chat_model_end_last_turn": self.result.saw_chat_model_end_last_turn,
+            "terminal_reason": self._resolve_terminal_reason(),
         }
 
+    def _resolve_terminal_reason(self) -> str | None:
+        terminal = self.result.terminal
+        if isinstance(terminal, dict):
+            reason = read_terminal_reason(terminal)
+            if reason:
+                return reason
+        snap = self.result.last_loop_snapshot or {}
+        snap_terminal = snap.get("terminal")
+        if isinstance(snap_terminal, dict):
+            return read_terminal_reason(snap_terminal)
+        projected = snap.get("terminal_reason")
+        if isinstance(projected, str) and projected:
+            return projected
+        return None
+
+    def _log_stream_closeout_summary(self) -> None:
+        """每次 stream 结束 INFO 摘要（正常/异常均打，便于定因）。"""
+        evidence = self._build_closeout_evidence()
+        logger.info(
+            "Loop stream closeout: saw_root_chain_end=%s graph_completed=%s "
+            "finish_reason=%s terminal_reason=%s last_raw_event=%s "
+            "raw_events_consumed=%s saw_chat_model_end_last_turn=%s pending_tool_calls=%s",
+            evidence.get("saw_root_chain_end"),
+            evidence.get("graph_completed"),
+            evidence.get("finish_reason"),
+            evidence.get("terminal_reason"),
+            evidence.get("last_raw_event"),
+            evidence.get("raw_events_consumed"),
+            evidence.get("saw_chat_model_end_last_turn"),
+            evidence.get("pending_tool_calls"),
+            extra={"loop_stream_closeout": evidence},
+        )
+
     def _log_missing_root_chain_end_anomaly(self) -> None:
         """astream_events 正常结束但未见 root on_chain_end(LangGraph) 时的诊断 WARNING。"""
         if not self.result.graph_completed or self.result.saw_root_chain_end:
             return
         evidence = self._build_closeout_evidence()
         logger.warning(
-            "loop stream ended without root chain_end",
+            "Loop stream ended without root chain_end: saw_root_chain_end=%s "
+            "graph_completed=%s assistant_turn_count=%s last_raw_event=%s "
+            "saw_chat_model_end_last_turn=%s terminal_reason=%s finish_reason=%s "
+            "pending_tool_calls=%s raw_events_consumed=%s",
+            evidence.get("saw_root_chain_end"),
+            evidence.get("graph_completed"),
+            evidence.get("assistant_turn_count"),
+            evidence.get("last_raw_event"),
+            evidence.get("saw_chat_model_end_last_turn"),
+            evidence.get("terminal_reason"),
+            evidence.get("finish_reason"),
+            evidence.get("pending_tool_calls"),
+            evidence.get("raw_events_consumed"),
             extra={"loop_stream_closeout_anomaly": evidence},
         )
 

{langchain-agentx-python-1.9.2 → langchain-agentx-python-1.9.4}/langchain_agentx/loop/stream/result.py

@@ -27,6 +27,9 @@ class StreamDriverResult:
     last_loop_snapshot: dict[str, Any] | None = None
     terminal: dict[str, Any] | None = None
     final_error: Exception | None = None
+    raw_events_consumed: int = 0
+    last_raw_event: str | None = None
+    saw_chat_model_end_last_turn: bool = False
 
 
 __all__ = ["StreamDriverResult"]

{langchain-agentx-python-1.9.2 → langchain-agentx-python-1.9.4}/langchain_agentx/observability/events/agent_event_projector.py

@@ -208,8 +208,55 @@ class AgentEventProjector:
         )
         self._finish_payload_composer = FinishEventPayloadComposer()
         self._model_end_text_backfill = ModelEndTextBackfillPolicy()
+        self._closeout_raw_events_consumed = 0
+        self._closeout_saw_finish_emitted = False
+        self._closeout_model_turn_open = False
+        self._closeout_saw_model_end_last_turn = False
+
+    def reset_stream_closeout_diagnostics(self) -> None:
+        """adapt() 开始时重置流级 closeout 诊断计数（不修改 EventAdapterState）。"""
+        self._closeout_raw_events_consumed = 0
+        self._closeout_saw_finish_emitted = False
+        self._closeout_model_turn_open = False
+        self._closeout_saw_model_end_last_turn = False
+
+    def log_stream_closeout_diagnostics(self) -> None:
+        """raw 流耗尽后只打 WARNING，不 emit 补帧（Phase 1 定因）。"""
+        if self.state.is_text_active:
+            logger.warning(
+                "Text stream ended without text-end: session_id=%s step_index=%s "
+                "accumulated_len=%d saw_model_end_last_turn=%s saw_finish_emitted=%s "
+                "raw_events_consumed=%d",
+                self.state.session_id,
+                self.state.step_index,
+                len(self.state.accumulated_answer),
+                self._closeout_saw_model_end_last_turn,
+                self._closeout_saw_finish_emitted,
+                self._closeout_raw_events_consumed,
+            )
+        if self.state.is_graph_started and not self._closeout_saw_finish_emitted:
+            logger.warning(
+                "Agent event stream ended without finish emission: session_id=%s "
+                "step_index=%s is_text_active=%s saw_model_end_last_turn=%s "
+                "raw_events_consumed=%d last_loop_terminal_reason=%s",
+                self.state.session_id,
+                self.state.step_index,
+                self.state.is_text_active,
+                self._closeout_saw_model_end_last_turn,
+                self._closeout_raw_events_consumed,
+                read_terminal_reason(self.state.last_loop_snapshot.get("terminal")),
+            )
+        if self._closeout_model_turn_open:
+            logger.warning(
+                "Model stream ended without chat_model_end: session_id=%s step_index=%s "
+                "raw_events_consumed=%d",
+                self.state.session_id,
+                self.state.step_index,
+                self._closeout_raw_events_consumed,
+            )
 
     async def consume(self, event: Dict[str, Any]) -> AsyncIterator[LangchainAgentEvent]:
+        self._closeout_raw_events_consumed += 1
         event_type = event.get("event")
         name = event.get("name", "") or ""
         data = event.get("data", {}) or {}
@@ -782,6 +829,7 @@ class AgentEventProjector:
                 loop_snapshot=self.state.last_loop_snapshot,
                 messages=messages if isinstance(messages, list) else None,
             )
+            self._closeout_saw_finish_emitted = True
             yield self._event(
                 event_type=LangchainAgentEventType.FINISH,
                 data=finish_data,
@@ -794,6 +842,8 @@ class AgentEventProjector:
     async def _handle_model_start(
         self, name: str, data: Dict[str, Any]
     ) -> AsyncGenerator[Optional[LangchainAgentEvent], None]:
+        self._closeout_model_turn_open = True
+        self._closeout_saw_model_end_last_turn = False
         self.state.is_model_started = True
         self.state.accumulated_answer = ""
         self.state.accumulated_reasoning = ""
@@ -979,6 +1029,8 @@ class AgentEventProjector:
             )
             self.state.is_text_active = False
 
+        self._closeout_model_turn_open = False
+        self._closeout_saw_model_end_last_turn = True
         self.state.is_model_started = False
 
     async def _handle_tool_start(

{langchain-agentx-python-1.9.2 → langchain-agentx-python-1.9.4}/langchain_agentx/observability/events/langchain_agentx_event_adapter.py

@@ -52,9 +52,13 @@ class LangGraphToLangchainAgentEventAdapter:
         self, events: AsyncIterator[Dict[str, Any]]
     ) -> AsyncIterator[LangchainAgentEvent]:
         """主转换函数：将 LangGraph 事件流转换为 LangChain AgentX 风格事件流。"""
-        async for event in events:
-            async for oc_event in self._projector.consume(event):
-                yield oc_event
+        self._projector.reset_stream_closeout_diagnostics()
+        try:
+            async for event in events:
+                async for oc_event in self._projector.consume(event):
+                    yield oc_event
+        finally:
+            self._projector.log_stream_closeout_diagnostics()
 
     def _event(
         self,

{langchain-agentx-python-1.9.2 → langchain-agentx-python-1.9.4}/langchain_agentx/session/agent_session.py

@@ -324,45 +324,61 @@ class AgentSession:
         run_config = merge_run_config(self._graph, config)
         driver = LoopStreamDriver()
         try:
-            async for event in driver.run(
-                self._graph,
-                {
-                    "messages": list(self._messages),
-                    "_session_id": self._session_id,
-                },
-                config=run_config,
-                version="v2",
-            ):
-                if event.get("event") == "on_chain_end" and event.get("name") == "LangGraph":
-                    data = event.get("data", {}) or {}
-                    output = data.get("output")
-                    if isinstance(output, dict):
-                        graph_output = dict(output)
-                    if isinstance(output, dict) and isinstance(output.get("messages"), list):
-                        output_messages = list(output["messages"])
-                yield event
-        except Exception:
-            partial = finish_outcome_from_stream_driver_result(driver.result)
-            if partial is not None:
-                self._last_finish_outcome = partial
-            if self._messages and self._messages[-1] is appended_message:
-                self._messages.pop()
-            raise
-        finally:
-            if graph_output is None:
+            try:
+                async for event in driver.run(
+                    self._graph,
+                    {
+                        "messages": list(self._messages),
+                        "_session_id": self._session_id,
+                    },
+                    config=run_config,
+                    version="v2",
+                ):
+                    if event.get("event") == "on_chain_end" and event.get("name") == "LangGraph":
+                        data = event.get("data", {}) or {}
+                        output = data.get("output")
+                        if isinstance(output, dict):
+                            graph_output = dict(output)
+                        if isinstance(output, dict) and isinstance(output.get("messages"), list):
+                            output_messages = list(output["messages"])
+                    yield event
+            except Exception:
                 partial = finish_outcome_from_stream_driver_result(driver.result)
                 if partial is not None:
                     self._last_finish_outcome = partial
-        if output_messages is not None:
-            self._messages = output_messages
-            self._append_transcript_message(appended_message)
-            for message in output_messages[baseline_count:]:
-                self._append_transcript_message(message)
-        if graph_output is not None:
-            self._last_finish_outcome = finish_outcome_from_graph_output(graph_output)
-            if isinstance(graph_output.get("_accessed_files"), list):
-                self._active_files.extend(
-                    [item for item in graph_output["_accessed_files"] if isinstance(item, str)]
+                if self._messages and self._messages[-1] is appended_message:
+                    self._messages.pop()
+                raise
+            finally:
+                if graph_output is None:
+                    partial = finish_outcome_from_stream_driver_result(driver.result)
+                    if partial is not None:
+                        self._last_finish_outcome = partial
+            if output_messages is not None:
+                self._messages = output_messages
+                self._append_transcript_message(appended_message)
+                for message in output_messages[baseline_count:]:
+                    self._append_transcript_message(message)
+            if graph_output is not None:
+                self._last_finish_outcome = finish_outcome_from_graph_output(graph_output)
+                if isinstance(graph_output.get("_accessed_files"), list):
+                    self._active_files.extend(
+                        [item for item in graph_output["_accessed_files"] if isinstance(item, str)]
+                    )
+        finally:
+            outcome = self._last_finish_outcome
+            if isinstance(outcome, dict):
+                logger.info(
+                    "Stream closeout: session_id=%s terminal_reason=%s is_error=%s answer_length=%s",
+                    self._session_id,
+                    outcome.get("terminal_reason"),
+                    outcome.get("is_error"),
+                    len(str(outcome.get("answer") or "")),
+                )
+            else:
+                logger.info(
+                    "Stream closeout: session_id=%s last_finish_outcome=missing",
+                    self._session_id,
                 )
 
     @property

{langchain-agentx-python-1.9.2 → langchain-agentx-python-1.9.4}/langchain_agentx/workflow/base.py

@@ -416,13 +416,13 @@ class BaseWorkflow(ABC):
             "workflow_path": workflow_path,
         }
         parent_ctx = get_run_context() if parent_workflow is not None else None
-        _, run_ctx_token = install_run_context(parent=parent_ctx)
+        run_ctx, run_ctx_token = install_run_context(parent=parent_ctx)
 
         try:
             return await graph.ainvoke(initial_state, config=effective_config)
         finally:
             try:
-                reset_run_context(run_ctx_token)
+                reset_run_context(run_ctx_token, owner=run_ctx)
             finally:
                 try:
                     await self._emit_workflow_end_best_effort(workflow_end_ctx)
@@ -576,7 +576,7 @@ class BaseWorkflow(ABC):
             "workflow_path": workflow_path,
         }
         parent_ctx = get_run_context() if parent_workflow is not None else None
-        _, run_ctx_token = install_run_context(parent=parent_ctx)
+        run_ctx, run_ctx_token = install_run_context(parent=parent_ctx)
         try:
             graph = self.compile()
             effective_config = self._resolve_effective_run_config(
@@ -598,7 +598,7 @@ class BaseWorkflow(ABC):
                 yield event
         finally:
             try:
-                reset_run_context(run_ctx_token)
+                reset_run_context(run_ctx_token, owner=run_ctx)
             finally:
                 try:
                     await self._emit_workflow_end_best_effort(workflow_end_ctx)

{langchain-agentx-python-1.9.2 → langchain-agentx-python-1.9.4/langchain_agentx_python.egg-info}/PKG-INFO

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

{langchain-agentx-python-1.9.2 → langchain-agentx-python-1.9.4}/pyproject.toml

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