langchain-agentx-python 1.5.5__tar.gz → 1.5.7__tar.gz

{langchain-agentx-python-1.5.5/langchain_agentx_python.egg-info → langchain-agentx-python-1.5.7}/PKG-INFO

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

{langchain-agentx-python-1.5.5 → langchain-agentx-python-1.5.7}/langchain_agentx/__init__.py

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

{langchain-agentx-python-1.5.5 → langchain-agentx-python-1.5.7}/langchain_agentx/loop/exit/query_source.py

@@ -50,5 +50,14 @@ class QuerySource:
             return query_source.strip()
         return cls.MAIN_THREAD
 
+    @classmethod
+    def for_agent(cls, agent_type: str | None, *, is_builtin: bool) -> str:
+        """前台 subagent query_source（对齐 CC getQuerySourceForAgent）。"""
+        if is_builtin:
+            if isinstance(agent_type, str) and agent_type.strip():
+                return f"{cls.AGENT_PREFIX}builtin:{agent_type.strip()}"
+            return f"{cls.AGENT_PREFIX}default"
+        return f"{cls.AGENT_PREFIX}custom"
+
 
 __all__ = ["QuerySource"]

{langchain-agentx-python-1.5.5 → langchain-agentx-python-1.5.7}/langchain_agentx/loop/subagent/context.py

@@ -29,7 +29,8 @@ from collections.abc import Callable
 from dataclasses import dataclass, field
 from typing import Any, Literal
 
-from langchain_agentx.loop.context.query_source import LoopCompilationContext, QuerySource
+from langchain_agentx.loop.context.query_source import LoopCompilationContext
+from langchain_agentx.loop.exit.query_source import QuerySource
 from langchain_agentx.loop.runtime.subagent_execution_paths import (
     PreparedSubagentPaths,
     resolve_subagent_effective_cwd,
@@ -142,6 +143,8 @@ def create_subagent_context(
     fork_worktree_path: str | None = None,
     available_tools: list[Any] | None = None,
     thinking_generation_enabled: bool = True,
+    query_source: str | None = None,
+    is_builtin_subagent: bool = False,
 ) -> SubagentContext:
     """工厂函数：从父上下文创建子 Agent 上下文
 
@@ -266,6 +269,12 @@ def create_subagent_context(
         is_async=is_async,
     )
 
+    resolved_query_source = (
+        query_source
+        if isinstance(query_source, str) and query_source.strip()
+        else QuerySource.for_agent(subagent_type, is_builtin=is_builtin_subagent)
+    )
+
     return SubagentContext(
         agent_id=agent_id,
         initial_messages=initial_messages,
@@ -296,6 +305,7 @@ def create_subagent_context(
         runnable_config=getattr(parent_ctx, "runnable_config", None),
         available_tools=list(available_tools or []),
         thinking_generation_enabled=thinking_generation_enabled,
+        query_source=resolved_query_source,
     )
 
 

{langchain-agentx-python-1.5.5 → langchain-agentx-python-1.5.7}/langchain_agentx/loop/subagent/orchestrator.py

@@ -210,6 +210,7 @@ class SubagentOrchestrator:
                 fork_worktree_path=prepared.worktree_dir,
                 available_tools=runtime_tools,
                 thinking_generation_enabled=thinking_generation_enabled,
+                is_builtin_subagent=getattr(subagent_config, "is_builtin", False),
             )
             scope = propagate_subagent_tool_scope(
                 parent_ctx=ctx,
@@ -408,6 +409,7 @@ class SubagentOrchestrator:
                 fork_worktree_path=prepared.worktree_dir,
                 available_tools=runtime_tools,
                 thinking_generation_enabled=thinking_generation_enabled,
+                is_builtin_subagent=getattr(subagent_config, "is_builtin", False),
             )
             scope = propagate_subagent_tool_scope(
                 parent_ctx=ctx,

{langchain-agentx-python-1.5.5 → langchain-agentx-python-1.5.7}/langchain_agentx/loop/subagent/progress.py

@@ -1,11 +1,14 @@
 """Subagent Progress Event 数据结构
 
-职责：进度事件载荷（Channel B）
-在整体链路中的位置：runner.py 构造 → AgentRuntimeTool.invoke() 的 on_progress 回调消费
+职责：进度事件载荷（teaser lane + transcript lane）
+在整体链路中的位置：runner.py 构造 → progress_dispatcher → adapter 映射
 CC 对照：src/agent/subagent/progress.ts onProgress 回调参数类型
-当前裁剪范围：v1 基础事件类型，无 async 路径
+当前裁剪范围：teaser（tool_use/tool_result）+ transcript_message lane；model_step 仅 trace
 """
 
+# transcript lane 在 tool_progress custom event 上的 phase 值（与 adapter mapper 冻结一致）
+SUBAGENT_TRANSCRIPT_PHASE = "transcript_message"
+
 from dataclasses import dataclass, field
 from typing import Any, Literal
 
@@ -126,21 +129,38 @@ class SubagentExecutionTrace:
         ]
 
 
+@dataclass
+class SubagentTranscriptMessage:
+    """transcript lane 负载：完整规范化 message（非裸 token 流）。"""
+
+    message_kind: Literal["assistant", "user"]
+    message: dict[str, Any]
+
+
 @dataclass
 class SubagentProgressEvent:
     """子 Agent 进度事件（runner 内部 + trace 记录）。
 
     type 枚举：
-    - tool_use / tool_result: 对外 SSE 冒泡（经 _emit_progress → tool_progress）
+    - tool_use / tool_result: teaser lane → subagent-tool-call/result
+    - transcript_message: transcript lane → subagent-transcript-message
     - model_step: internal/trace-only，不 emit 到父 SSE（CC：Thinking 不折叠）
     - hint: 后台化提示（v2）
     - completed / error: internal/trace-only；边界由 adapter SUBAGENT_END 表达
 
     与 CC 对齐：
     - CC AgentTool.tsx 仅 forward tool_use/tool_result（L1106-1108）
-    - 本 SDK 通过 tool_call_detail 携带工具调用的详细信息（present_for_display / trace）
+    - transcript lane 承载规范化 assistant/user message（Capability C）
     """
-    type: Literal["tool_use", "tool_result", "model_step", "hint", "completed", "error"]
+    type: Literal[
+        "tool_use",
+        "tool_result",
+        "transcript_message",
+        "model_step",
+        "hint",
+        "completed",
+        "error",
+    ]
     subagent_type: str = ""
     agent_id: str = ""
     step: int = 0
@@ -148,4 +168,5 @@ class SubagentProgressEvent:
     summary: str = ""
     meta: dict[str, Any] = field(default_factory=dict)
     tool_call_detail: SubagentToolCall | None = None
+    transcript_message: SubagentTranscriptMessage | None = None
     trace: SubagentExecutionTrace | None = None

langchain-agentx-python-1.5.7/langchain_agentx/loop/subagent/progress_dispatcher.py

@@ -0,0 +1,109 @@
+"""
+loop/subagent/progress_dispatcher.py — 子 Agent tool_progress 冒泡
+
+职责：将 runner 侧 teaser / transcript lane 同步派发到父 graph 回调链。
+链路位置：runner._emit_progress / _emit_transcript_progress → SubagentProgressDispatcher
+当前裁剪范围：并行线程池 / _run_coroutine_sync 子线程内同步 dispatch 优先；
+              phase ∈ {tool_use, tool_result, transcript_message}；同桶不同 lane。
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from langchain_agentx.loop.subagent.context import SubagentContext
+from langchain_agentx.loop.subagent.progress import (
+    SUBAGENT_TRANSCRIPT_PHASE,
+    SubagentProgressEvent,
+)
+
+logger = logging.getLogger(__name__)
+
+_EVENT_NAME = "tool_progress"
+
+
+class SubagentProgressDispatcher:
+    """子 Agent progress → 父 graph custom event 派发器。"""
+
+    @staticmethod
+    def build_teaser_payload(
+        ctx: SubagentContext,
+        event: SubagentProgressEvent,
+    ) -> dict[str, Any]:
+        event_data: dict[str, Any] = {
+            "tool_name": event.tool_name,
+            "tool_call_id": ctx.parent_tool_call_id,
+            "agent_id": event.agent_id,
+            "phase": event.type,
+            "step": event.step,
+            "summary": event.summary,
+            "data": {
+                "subagent_type": event.subagent_type,
+            },
+        }
+        if event.tool_call_detail and isinstance(event.tool_call_detail.tool_input, dict):
+            event_data["tool_input"] = dict(event.tool_call_detail.tool_input)
+        return event_data
+
+    @staticmethod
+    def build_transcript_payload(
+        ctx: SubagentContext,
+        event: SubagentProgressEvent,
+    ) -> dict[str, Any]:
+        transcript = event.transcript_message
+        if transcript is None:
+            raise ValueError("transcript_message required for transcript lane dispatch")
+        return {
+            "tool_call_id": ctx.parent_tool_call_id,
+            "agent_id": event.agent_id,
+            "phase": SUBAGENT_TRANSCRIPT_PHASE,
+            "step": event.step,
+            "tool_name": event.tool_name,
+            "message_kind": transcript.message_kind,
+            "message": dict(transcript.message),
+            "data": {
+                "subagent_type": event.subagent_type,
+            },
+        }
+
+    @classmethod
+    def dispatch_sync(cls, parent_config: Any, payload: dict[str, Any]) -> bool:
+        """同步派发；在线程池 worker 内可达父 astream_events（须带 runnable_config）。"""
+        if parent_config is None:
+            return False
+        from langchain_core.callbacks import dispatch_custom_event
+
+        try:
+            dispatch_custom_event(_EVENT_NAME, payload, config=parent_config)
+            return True
+        except RuntimeError as exc:
+            logger.debug(
+                "dispatch_custom_event sync path unavailable (will try async): %s",
+                exc,
+            )
+            return False
+        except Exception:
+            logger.debug("dispatch_custom_event failed in subagent progress", exc_info=True)
+            return False
+
+    @classmethod
+    async def dispatch_async(cls, parent_config: Any, payload: dict[str, Any]) -> bool:
+        """异步派发兜底（同线程 asyncio 上下文）。"""
+        if parent_config is None:
+            return False
+        from langchain_core.callbacks import adispatch_custom_event
+
+        try:
+            await adispatch_custom_event(
+                name=_EVENT_NAME,
+                data=payload,
+                config=parent_config,
+            )
+            return True
+        except Exception:
+            logger.debug("adispatch_custom_event failed in subagent progress", exc_info=True)
+            return False
+
+
+__all__ = ["SubagentProgressDispatcher"]

{langchain-agentx-python-1.5.5 → langchain-agentx-python-1.5.7}/langchain_agentx/loop/subagent/runner.py

@@ -63,6 +63,11 @@ from langchain_agentx.observability.events.tool_outcome_resolver import (
 from langchain_agentx.loop.subagent.progress import (
     SubagentExecutionTrace,
     SubagentProgressEvent,
+    SubagentTranscriptMessage,
+)
+from langchain_agentx.loop.subagent.progress_dispatcher import SubagentProgressDispatcher
+from langchain_agentx.loop.subagent.transcript_message_builder import (
+    SubagentTranscriptMessageBuilder,
 )
 from langchain_agentx.loop.subagent.subagent_termination_classifier import (
     SubagentTerminationClassifier,
@@ -209,9 +214,9 @@ async def _emit_progress(
     ctx: SubagentContext,
     event: SubagentProgressEvent,
 ) -> None:
-    """发射子 Agent 工具进度到父 graph（CC 对齐：仅 tool_use / tool_result）。
+    """发射子 Agent teaser lane 到父 graph（CC 对齐：仅 tool_use / tool_result）。
 
-    通过 adispatch_custom_event 将子 agent 事件冒泡到父 graph 的 astream_events 流。
+    同步 dispatch 优先：并行线程池 / _run_coroutine_sync 子线程内 adispatch 无法触达父回调链。
     父 graph 的 config 通过 ctx.runnable_config 传递（在 _collect_subagent_events 中合并）。
     """
     if event.type not in ("tool_use", "tool_result"):
@@ -224,34 +229,34 @@ async def _emit_progress(
         )
         return
 
-    from langchain_core.callbacks import adispatch_custom_event
+    parent_config = getattr(ctx, "runnable_config", None)
+    if parent_config is None:
+        return
+
+    payload = SubagentProgressDispatcher.build_teaser_payload(ctx, event)
+    if SubagentProgressDispatcher.dispatch_sync(parent_config, payload):
+        return
+    await SubagentProgressDispatcher.dispatch_async(parent_config, payload)
+
+
+async def _emit_transcript_progress(
+    ctx: SubagentContext,
+    event: SubagentProgressEvent,
+) -> None:
+    """发射子 Agent transcript lane（Capability C：规范化 assistant/user message）。"""
+    if event.type != "transcript_message" or event.transcript_message is None:
+        return
+    if not event.tool_name:
+        return
 
     parent_config = getattr(ctx, "runnable_config", None)
     if parent_config is None:
         return
 
-    try:
-        event_data: dict[str, Any] = {
-            "tool_name": event.tool_name,
-            "tool_call_id": ctx.parent_tool_call_id,
-            "agent_id": event.agent_id,
-            "phase": event.type,
-            "step": event.step,
-            "summary": event.summary,
-            "data": {
-                "subagent_type": event.subagent_type,
-            },
-        }
-        # G5: 携带 tool_input 以支持 CLI 端 Bash(command) 等进度行显示
-        if event.tool_call_detail and isinstance(event.tool_call_detail.tool_input, dict):
-            event_data["tool_input"] = dict(event.tool_call_detail.tool_input)
-        await adispatch_custom_event(
-            name="tool_progress",
-            data=event_data,
-            config=parent_config,
-        )
-    except Exception:
-        logger.debug("adispatch_custom_event failed in subagent progress", exc_info=True)
+    payload = SubagentProgressDispatcher.build_transcript_payload(ctx, event)
+    if SubagentProgressDispatcher.dispatch_sync(parent_config, payload):
+        return
+    await SubagentProgressDispatcher.dispatch_async(parent_config, payload)
 
 
 async def _handle_tool_start_event(
@@ -287,6 +292,10 @@ async def _handle_tool_start_event(
     if trace:
         trace.add_tool_call(tool_call)
 
+    tool_call_id = ToolCallIdResolver.resolve_from_langgraph_tool_event(event)
+    if not tool_call_id:
+        tool_call_id = f"{SYNTHETIC_TRANSCRIPT_TOOL_ID_PREFIX}{ctx.agent_id}:{next_step}"
+
     await _emit_progress(
         ctx,
         SubagentProgressEvent(
@@ -300,6 +309,26 @@ async def _handle_tool_start_event(
             trace=trace,
         ),
     )
+
+    message_kind, normalized = SubagentTranscriptMessageBuilder.build_tool_use(
+        tool_name=tool_name,
+        tool_input=tool_input if isinstance(tool_input, dict) else None,
+        tool_call_id=tool_call_id,
+    )
+    await _emit_transcript_progress(
+        ctx,
+        SubagentProgressEvent(
+            type="transcript_message",
+            subagent_type=ctx.subagent_type,
+            agent_id=ctx.agent_id,
+            step=next_step,
+            tool_name=tool_name,
+            transcript_message=SubagentTranscriptMessage(
+                message_kind=message_kind,
+                message=normalized,
+            ),
+        ),
+    )
     return next_step, tool_name
 
 
@@ -376,6 +405,27 @@ async def _handle_tool_end_event(
         ),
     )
 
+    message_kind, normalized = SubagentTranscriptMessageBuilder.build_tool_result(
+        tool_name=tool_name,
+        content=transcript_text,
+        tool_call_id=tool_call_id,
+        synthetic=synthetic,
+    )
+    await _emit_transcript_progress(
+        ctx,
+        SubagentProgressEvent(
+            type="transcript_message",
+            subagent_type=ctx.subagent_type,
+            agent_id=ctx.agent_id,
+            step=step,
+            tool_name=tool_name,
+            transcript_message=SubagentTranscriptMessage(
+                message_kind=message_kind,
+                message=normalized,
+            ),
+        ),
+    )
+
 
 async def _handle_chat_model_end_event(
     *,

langchain-agentx-python-1.5.7/langchain_agentx/loop/subagent/transcript_message_builder.py

@@ -0,0 +1,62 @@
+"""
+loop/subagent/transcript_message_builder.py — 子 Agent transcript lane 规范化 message 构造
+
+职责：在工具开始/结束点构造 CC 对齐的 assistant / user 规范化 message。
+链路位置：runner._handle_tool_* → SubagentTranscriptMessageBuilder → progress_dispatcher
+当前裁剪范围：仅 tool_use / tool_result；不承载纯 text / thinking 流。
+"""
+
+from __future__ import annotations
+
+from typing import Any, Literal
+
+from langchain_agentx.loop.message_contract import get_message_contract
+
+MessageKind = Literal["assistant", "user"]
+
+
+class SubagentTranscriptMessageBuilder:
+    """构造 transcript lane 用的规范化 message（对齐 CC agent_progress.data.message）。"""
+
+    @staticmethod
+    def build_tool_use(
+        *,
+        tool_name: str,
+        tool_input: dict[str, Any] | None,
+        tool_call_id: str,
+    ) -> tuple[MessageKind, dict[str, Any]]:
+        """工具开始：assistant message，content 含 tool_use（LangChain tool_calls）。"""
+        args = dict(tool_input) if isinstance(tool_input, dict) else {}
+        record: dict[str, Any] = {
+            "role": "assistant",
+            "content": "",
+            "tool_calls": [
+                {
+                    "id": tool_call_id,
+                    "name": tool_name,
+                    "args": args,
+                }
+            ],
+        }
+        normalized = get_message_contract().to_transcript_row(record)
+        return "assistant", normalized
+
+    @staticmethod
+    def build_tool_result(
+        *,
+        tool_name: str,
+        content: str,
+        tool_call_id: str,
+        synthetic: bool = False,
+    ) -> tuple[MessageKind, dict[str, Any]]:
+        """工具结束：user 侧 tool result message（经 transcript codec 规范化）。"""
+        row = get_message_contract().to_transcript_tool_row(
+            content=content,
+            tool_call_id=tool_call_id,
+            name=tool_name,
+            synthetic=synthetic,
+        )
+        return "user", row
+
+
+__all__ = ["MessageKind", "SubagentTranscriptMessageBuilder"]

{langchain-agentx-python-1.5.5 → langchain-agentx-python-1.5.7}/langchain_agentx/observability/events/agent_event_projector.py

@@ -115,6 +115,7 @@ class LangchainAgentEventType(Enum):
     SUBAGENT_END = "subagent-end"
     SUBAGENT_TOOL_CALL = "subagent-tool-call"
     SUBAGENT_TOOL_RESULT = "subagent-tool-result"
+    SUBAGENT_TRANSCRIPT_MESSAGE = "subagent-transcript-message"
     SUBAGENT_MODEL_STEP = "subagent-model-step"
     ERROR = "error"
     TOOL_ARTIFACT = "tool-artifact"
@@ -267,58 +268,6 @@ class AgentEventProjector:
     def reset_state(self) -> None:
         self.state = EventAdapterState()
 
-    def emit_subagent_event(self, progress_event: Any) -> LangchainAgentEvent | None:
-        from langchain_agentx.loop.subagent.progress import SubagentProgressEvent
-
-        if not isinstance(progress_event, SubagentProgressEvent):
-            return None
-
-        event_type = getattr(progress_event, "type", "")
-        if not event_type:
-            return None
-
-        type_mapping = {
-            "tool_use": LangchainAgentEventType.TOOL_CALL,
-            "tool_result": LangchainAgentEventType.TOOL_RESULT,
-            "model_step": LangchainAgentEventType.TEXT_DELTA,
-            "completed": None,
-            "hint": None,
-        }
-
-        target_type = type_mapping.get(event_type)
-        if target_type is None:
-            return None
-
-        data: Dict[str, Any] = {}
-        if event_type == "tool_use":
-            data = {
-                "tool_name": getattr(progress_event, "tool_name", ""),
-                "status": "running",
-            }
-            detail = getattr(progress_event, "tool_call_detail", None)
-            if detail is not None:
-                data["input"] = getattr(detail, "tool_input", None)
-                data["step"] = getattr(detail, "step", None)
-        elif event_type == "tool_result":
-            data = {
-                "tool_name": getattr(progress_event, "tool_name", ""),
-                "summary": getattr(progress_event, "summary", "")[:200],
-            }
-        elif event_type == "model_step":
-            data = {"text": getattr(progress_event, "summary", "")}
-
-        parent_id = getattr(progress_event, "parent_tool_use_id", None)
-        if parent_id:
-            data["parent_tool_use_id"] = parent_id
-
-        return self._event(
-            event_type=target_type,
-            data=data,
-            step_index=self.state.step_index or None,
-            tool_name=getattr(progress_event, "tool_name", None),
-            session_id=self.state.session_id,
-        )
-
     async def _handle_chain_start(
         self, name: str, data: Dict[str, Any]
     ) -> AsyncGenerator[LangchainAgentEvent, None]:
@@ -1373,11 +1322,8 @@ class AgentEventProjector:
                         tool_name=mapped.tool_name,
                     )
                     return
-                agent_id = data.get("agent_id")
-                if isinstance(agent_id, str) and agent_id.strip():
-                    phase = data.get("phase")
-                    if phase == "model_step":
-                        return
+                if SubagentProgressEventMapper.should_suppress_tool_progress_fallback(data):
+                    return
 
             yield self._event(
                 event_type=LangchainAgentEventType.TOOL_PROGRESS,

{langchain-agentx-python-1.5.5 → langchain-agentx-python-1.5.7}/langchain_agentx/observability/events/langchain_agentx_event_adapter.py

@@ -76,9 +76,6 @@ class LangGraphToLangchainAgentEventAdapter:
     def _reset_state(self) -> None:
         self._projector.reset_state()
 
-    def emit_subagent_event(self, progress_event: Any) -> LangchainAgentEvent | None:
-        return self._projector.emit_subagent_event(progress_event)
-
     async def _handle_chain_start(
         self, name: str, data: Dict[str, Any]
     ) -> AsyncGenerator[LangchainAgentEvent, None]: