agstack 2.0.0__tar.gz → 2.1.0__tar.gz

{agstack-2.0.0 → agstack-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agstack
-Version: 2.0.0
+Version: 2.1.0
 Summary: Production-ready toolkit for building FastAPI and LLM applications
 Author-email: XtraVisions <gitadmin@xtravisions.com>, Chen Hao <chenhao@xtravisions.com>
 Maintainer-email: XtraVisions <gitadmin@xtravisions.com>, Chen Hao <chenhao@xtravisions.com>

{agstack-2.0.0 → agstack-2.1.0}/agstack/llm/flow/__init__.py

@@ -22,7 +22,7 @@ from .nodes import NodeHandler
 from .records import Record, Status
 from .registry import registry
 from .state import FlowState
-from .tool import Tool, ToolResult
+from .tool import Deny, Tool, ToolHook, ToolResult
 from .trace import EdgeTrace, FlowTrace, NodeTrace
 
 
@@ -32,6 +32,8 @@ __all__ = [
     # 核心抽象
     "Tool",
     "ToolResult",
+    "ToolHook",
+    "Deny",
     "Agent",
     "Flow",
     "FlowContext",

{agstack-2.0.0 → agstack-2.1.0}/agstack/llm/flow/agent.py

@@ -2,6 +2,7 @@
 
 """Agent 定义和执行"""
 
+import asyncio
 import json
 from typing import TYPE_CHECKING, Any, AsyncIterator
 from uuid import uuid4
@@ -76,6 +77,149 @@ class Agent:
                 return tool
         return None
 
+    def _group_tool_calls(self, tool_calls: list[dict[str, Any]]) -> list[list[dict[str, Any]]]:
+        """按声明分组：连续的 concurrency_safe 调用聚为一组并发执行，其余单独成组串行
+
+        未注册/未声明的工具一律按不安全处理（fail closed），
+        默认全 False 时每组恰好一个调用，行为与串行完全一致。
+        """
+        groups: list[list[dict[str, Any]]] = []
+        prev_safe = False
+        for tc in tool_calls:
+            tool = self.get_tool_by_name(tc["name"])
+            safe = bool(tool and tool.concurrency_safe)
+            if safe and prev_safe:
+                groups[-1].append(tc)
+            else:
+                groups.append([tc])
+            prev_safe = safe
+        return groups
+
+    async def _stream_tool_call(
+        self,
+        context: "FlowContext",
+        tool_call: dict[str, Any],
+        message_sink: list[dict[str, Any]] | None = None,
+    ) -> AsyncIterator[dict[str, Any]]:
+        """执行单个 tool_call，yield 其 AG-UI 事件
+
+        tool 消息默认即时写回 context；并发分组执行时传入 message_sink 收集，
+        由调用方在组完成后按 tool_call 原始顺序统一写回
+        （OpenAI 协议要求 tool 消息与 assistant.tool_calls 顺序对应）。
+        """
+
+        def _emit_message(**kwargs: Any) -> None:
+            if message_sink is None:
+                context.add_message(self.name, "tool", **kwargs)
+            else:
+                message_sink.append(kwargs)
+
+        tool = self.get_tool_by_name(tool_call["name"])
+        if not tool:
+            error_content = json.dumps({"error": f"Tool not found: {tool_call['name']}"}, ensure_ascii=False)
+            _emit_message(content=error_content, tool_call_id=tool_call["id"])
+            # AG-UI: TOOL_CALL_RESULT (错误)
+            yield event.tool_call_result(tool_call_id=tool_call["id"], content=error_content)
+            return
+
+        # 解析 LLM 返回的工具参数；解析失败作为该次调用的失败反馈给模型，由模型自行重试
+        try:
+            tool_args = json.loads(tool_call["arguments"]) if tool_call["arguments"] else {}
+        except json.JSONDecodeError as e:
+            error_content = json.dumps(
+                {
+                    "error": f"Invalid tool arguments (JSON parse failed): {e}",
+                    "raw_arguments": tool_call["arguments"][:500],
+                },
+                ensure_ascii=False,
+            )
+            _emit_message(content=error_content, tool_call_id=tool_call["id"])
+            # AG-UI: TOOL_CALL_RESULT (错误)
+            yield event.tool_call_result(tool_call_id=tool_call["id"], content=error_content)
+            return
+
+        # 执行前进度事件
+        progress_label = tool.get_progress_label(tool_args)
+        if progress_label:
+            yield event.custom(
+                name="skill_progress",
+                value={
+                    "progressId": tool_call["id"],
+                    "description": progress_label,
+                    "status": "running",
+                },
+            )
+
+        # 执行工具（传入 LLM 解析的参数作为 inputs）
+        result = await tool.execute_async(context, tool_args)
+
+        # 执行后进度事件
+        if progress_label:
+            yield event.custom(
+                name="skill_progress",
+                value={
+                    "progressId": tool_call["id"],
+                    "status": "completed" if result.success else "failed",
+                },
+            )
+
+        # 使用 result.content 作为 LLM 上下文（Tool 已计算好）
+        result_content = result.content or (
+            json.dumps(result.result, ensure_ascii=False)
+            if result.success
+            else json.dumps({"error": result.error}, ensure_ascii=False)
+        )
+        _emit_message(content=result_content, tool_call_id=tool_call["id"], summary=result.summary)
+
+        # AG-UI: TOOL_CALL_RESULT
+        yield event.tool_call_result(tool_call_id=tool_call["id"], content=result_content)
+
+        # 实时用户进度 — 有 summary 时告知前端
+        if result.summary:
+            yield event.custom(
+                name="tool_progress",
+                value={
+                    "tool_call_id": tool_call["id"],
+                    "tool_name": result.name,
+                    "success": result.success,
+                    "summary": result.summary,
+                },
+            )
+
+        # 业务自定义事件 — flush pending
+        for pending_evt in context.pop_pending_custom_events():
+            yield pending_evt
+
+    async def _gather_tool_calls(
+        self, context: "FlowContext", group: list[dict[str, Any]]
+    ) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
+        """并发执行一组 concurrency_safe 的 tool_calls
+
+        返回 (按完成顺序展平的事件列表, 按原始顺序展平的 tool 消息 kwargs 列表)。
+        组内事件先缓冲、gather 结束后统一交调用方 yield，保证单 generator 语义；
+        单个调用的意外异常兜底转失败结果，不影响组内其它调用。
+        注意：并发期间 execution_records / pending_custom_events 的追加顺序不再确定。
+        """
+        event_buffers: list[list[dict[str, Any]]] = [[] for _ in group]
+        message_buffers: list[list[dict[str, Any]]] = [[] for _ in group]
+        finish_order: list[int] = []
+
+        async def _run_one(i: int, tc: dict[str, Any]) -> None:
+            try:
+                async for evt in self._stream_tool_call(context, tc, message_sink=message_buffers[i]):
+                    event_buffers[i].append(evt)
+            except Exception as e:
+                error_content = json.dumps({"error": str(e)}, ensure_ascii=False)
+                message_buffers[i].append({"content": error_content, "tool_call_id": tc["id"]})
+                event_buffers[i].append(event.tool_call_result(tool_call_id=tc["id"], content=error_content))
+            finally:
+                finish_order.append(i)
+
+        await asyncio.gather(*[_run_one(i, tc) for i, tc in enumerate(group)])
+        events = [evt for i in finish_order for evt in event_buffers[i]]
+        messages = [msg for msgs in message_buffers for msg in msgs]
+        return events, messages
+
     async def run(self, context: "FlowContext", inputs: dict[str, Any] | None = None) -> dict[str, Any]:
         """执行 Agent 逻辑"""
         content_parts = []
@@ -122,6 +266,13 @@ class Agent:
         # Agent 循环
         assistant_content = ""
         for _ in range(self.max_turns):
+            # 协作式取消检查点：不再开始新的 LLM 轮次
+            if context.is_cancelled:
+                if not context.get_variable("_cancel_emitted"):
+                    context.set_variable("_cancel_emitted", True)
+                    yield event.run_error(message="FLOW_CANCELLED", code="CANCELLED")
+                return
+
             context.increment_turn()
 
             # 调用模型
@@ -243,97 +394,26 @@ class Agent:
                 context.set_variable("_agent_call_id", None)
                 return
 
-            # 执行工具调用
-            for tool_call in tool_calls:
-                tool = self.get_tool_by_name(tool_call["name"])
-                if not tool:
-                    error_msg = f"Tool not found: {tool_call['name']}"
-                    context.add_message(
-                        self.name,
-                        "tool",
-                        content=json.dumps({"error": error_msg}, ensure_ascii=False),
-                        tool_call_id=tool_call["id"],
-                    )
-                    # AG-UI: TOOL_CALL_RESULT (错误)
-                    yield event.tool_call_result(
-                        tool_call_id=tool_call["id"],
-                        content=json.dumps({"error": error_msg}, ensure_ascii=False),
-                    )
-                    continue
-
-                # 解析 LLM 返回的工具参数；解析失败作为该次调用的失败反馈给模型，由模型自行重试
-                try:
-                    tool_args = json.loads(tool_call["arguments"]) if tool_call["arguments"] else {}
-                except json.JSONDecodeError as e:
-                    error_content = json.dumps(
-                        {
-                            "error": f"Invalid tool arguments (JSON parse failed): {e}",
-                            "raw_arguments": tool_call["arguments"][:500],
-                        },
-                        ensure_ascii=False,
-                    )
-                    context.add_message(self.name, "tool", content=error_content, tool_call_id=tool_call["id"])
-                    # AG-UI: TOOL_CALL_RESULT (错误)
-                    yield event.tool_call_result(tool_call_id=tool_call["id"], content=error_content)
-                    continue
-
-                # 执行前进度事件
-                progress_label = tool.get_progress_label(tool_args)
-                if progress_label:
-                    yield event.custom(
-                        name="skill_progress",
-                        value={
-                            "progressId": tool_call["id"],
-                            "description": progress_label,
-                            "status": "running",
-                        },
-                    )
-
-                # 执行工具（传入 LLM 解析的参数作为 inputs）
-                result = await tool.execute_async(context, tool_args)
-
-                # 执行后进度事件
-                if progress_label:
-                    yield event.custom(
-                        name="skill_progress",
-                        value={
-                            "progressId": tool_call["id"],
-                            "status": "completed" if result.success else "failed",
-                        },
-                    )
-
-                # 使用 result.content 作为 LLM 上下文（Tool 已计算好）
-                result_content = result.content or (
-                    json.dumps(result.result, ensure_ascii=False)
-                    if result.success
-                    else json.dumps({"error": result.error}, ensure_ascii=False)
-                )
-                context.add_message(
-                    self.name,
-                    "tool",
-                    content=result_content,
-                    tool_call_id=tool_call["id"],
-                    summary=result.summary,
-                )
-
-                # AG-UI: TOOL_CALL_RESULT
-                yield event.tool_call_result(tool_call_id=tool_call["id"], content=result_content)
-
-                # 实时用户进度 — 有 summary 时告知前端
-                if result.summary:
-                    yield event.custom(
-                        name="tool_progress",
-                        value={
-                            "tool_call_id": tool_call["id"],
-                            "tool_name": result.name,
-                            "success": result.success,
-                            "summary": result.summary,
-                        },
-                    )
-
-                # 业务自定义事件 — flush pending
-                for pending_evt in context.pop_pending_custom_events():
-                    yield pending_evt
+            # 执行工具调用：连续的 concurrency_safe 调用聚组并发，其余保持串行（默认全串行）
+            for group in self._group_tool_calls(tool_calls):
+                # 协作式取消检查点：不再开始新的工具执行（不中断在途工具）
+                if context.is_cancelled:
+                    if not context.get_variable("_cancel_emitted"):
+                        context.set_variable("_cancel_emitted", True)
+                        yield event.run_error(message="FLOW_CANCELLED", code="CANCELLED")
+                    return
+
+                if len(group) == 1:
+                    # 串行路径：事件实时 yield，tool 消息即时写回
+                    async for evt in self._stream_tool_call(context, group[0]):
+                        yield evt
+                else:
+                    # 并发组：事件按完成顺序 yield，tool 消息按原始顺序写回
+                    group_events, group_messages = await self._gather_tool_calls(context, group)
+                    for evt in group_events:
+                        yield evt
+                    for msg in group_messages:
+                        context.add_message(self.name, "tool", **msg)
 
             # 更新消息列表，继续下一轮
             messages = [self.get_system_message()] + context.history + context.get_messages(self.name)

{agstack-2.0.0 → agstack-2.1.0}/agstack/llm/flow/context.py

@@ -2,6 +2,7 @@
 
 """统一的执行上下文"""
 
+import asyncio
 import uuid
 from dataclasses import dataclass, field
 from datetime import datetime
@@ -66,6 +67,9 @@ class FlowContext:
     # 业务自定义事件缓冲（tool 内部通过 context 注入，agent 循环中 flush）
     pending_custom_events: list[dict[str, Any]] = field(default_factory=list)
 
+    # 协作式取消信号（不参与序列化，恢复即未取消）
+    _cancel_event: asyncio.Event = field(default_factory=asyncio.Event, repr=False)
+
     def __post_init__(self) -> None:
         if self.trace is None:
             from .trace import FlowTrace
@@ -84,6 +88,19 @@ class FlowContext:
         """取出并移除变量"""
         return self.variables.pop(key, default)
 
+    def cancel(self) -> None:
+        """请求取消执行（幂等）
+
+        协作式取消：引擎在下一个检查点（节点执行前、agent 轮次开始、
+        tool_call 执行前）停止，不强杀在途的工具或 LLM 调用。
+        """
+        self._cancel_event.set()
+
+    @property
+    def is_cancelled(self) -> bool:
+        """是否已请求取消（长 I/O 工具可自查以提前返回）"""
+        return self._cancel_event.is_set()
+
     def update_variables(self, updates: dict[str, Any]) -> None:
         """批量更新变量"""
         self.variables.update(updates)

{agstack-2.0.0 → agstack-2.1.0}/agstack/llm/flow/flow.py

@@ -10,7 +10,7 @@ from uuid import uuid4
 
 from . import event
 from .context import Usage
-from .exceptions import NodeExecutionError
+from .exceptions import FlowExecutionError, NodeExecutionError
 
 
 if TYPE_CHECKING:
@@ -234,6 +234,12 @@ class Flow:
         last_error: Exception | None = None
 
         for attempt in range(policy.max_retries + 1):
+            # 协作式取消检查点：取消后不再开始新的重试
+            if attempt > 0 and context.is_cancelled:
+                if not context.get_variable("_cancel_emitted"):
+                    context.set_variable("_cancel_emitted", True)
+                    yield event.run_error(message="FLOW_CANCELLED", code="CANCELLED")
+                return
             try:
                 if attempt > 0:
                     wait = policy.delay * (policy.backoff ** (attempt - 1))
@@ -284,10 +290,12 @@ class Flow:
 
         stream() 的消费包装：两条路径共享同一执行引擎，重试策略、
         FlowTrace、output_mode、iterator 状态清理等行为完全一致。
-        节点失败抛 NodeExecutionError（包装原始异常）。
+        节点失败抛 NodeExecutionError（包装原始异常）；
+        取消（context.cancel()）抛 FlowExecutionError("FLOW_CANCELLED")。
         """
-        async for _ in self.stream(context):
-            pass
+        async for evt in self.stream(context):
+            if evt.get("type") == event.EventType.RUN_ERROR and evt.get("code") == "CANCELLED":
+                raise FlowExecutionError("FLOW_CANCELLED", args={"flow": self.name})
         return context.outputs
 
     async def stream(self, context: "FlowContext") -> AsyncIterator[dict[str, Any]]:
@@ -310,11 +318,22 @@ class Flow:
             context.trace.finished_at = time.time()
             context.trace.total_usage = context.usage
 
+        # 取消停止：RUN_ERROR(code=CANCELLED) 是终止事件，事件流以其结束
+        if context.get_variable("_cancel_emitted"):
+            return
+
         yield event.step_finished(step_name=f"flow:{self.name}", step_id=flow_sid)
 
     async def _stream_sequential(self, context: "FlowContext") -> AsyncIterator[dict[str, Any]]:
         """顺序流式执行"""
         for node in self.nodes:
+            # 协作式取消检查点：不再开始新的节点执行
+            if context.is_cancelled:
+                if not context.get_variable("_cancel_emitted"):
+                    context.set_variable("_cancel_emitted", True)
+                    yield event.run_error(message="FLOW_CANCELLED", code="CANCELLED")
+                return
+
             node_id = node.get("id")
             if not node_id:
                 continue
@@ -350,6 +369,13 @@ class Flow:
         visit_count: dict[str, int] = {}
 
         while current_node_id:
+            # 协作式取消检查点：不再开始新的节点执行（粒度是节点边界，不中断在途节点）
+            if context.is_cancelled:
+                if not context.get_variable("_cancel_emitted"):
+                    context.set_variable("_cancel_emitted", True)
+                    yield event.run_error(message="FLOW_CANCELLED", code="CANCELLED")
+                return
+
             node = self.get_node_config(current_node_id)
             if not node:
                 yield event.run_error(

{agstack-2.0.0 → agstack-2.1.0}/agstack/llm/flow/registry.py

@@ -8,7 +8,7 @@ import copy
 from typing import Any, cast
 
 from .agent import Agent
-from .tool import Tool
+from .tool import Tool, ToolHook, clear_tool_hooks, register_tool_hook
 
 
 class FlowRegistry:
@@ -45,6 +45,19 @@ class FlowRegistry:
         if echo:
             self._tool_echo[name] = True
 
+    def register_tool_hook(self, hook: ToolHook, *, prepend: bool = False) -> None:
+        """注册全局工具执行钩子，对所有 Tool.execute_async 生效
+
+        pre_execute 按注册顺序、post_execute 按逆序执行；
+        prepend=True 抢占链头（其 post_execute 成为最外层，适合 spill/截断类钩子）。
+        钩子链存于 tool 模块（保持 registry→tool 单向导入），此处仅转发注册。
+        """
+        register_tool_hook(hook, prepend=prepend)
+
+    def clear_tool_hooks(self) -> None:
+        """清空全局工具钩子（测试隔离用）"""
+        clear_tool_hooks()
+
     def register_agent(
         self, name: str, agent_class: type[Agent], *, label: str | None = None, echo: bool = False
     ) -> None:

{agstack-2.0.0 → agstack-2.1.0}/agstack/llm/flow/tool.py

@@ -28,6 +28,62 @@ class ToolResult:
     summary: str | None = None
 
 
+class Deny:
+    """pre_execute 的拒绝决策：工具本体不执行，reason 作为失败结果反馈给模型"""
+
+    def __init__(self, reason: str):
+        self.reason = reason
+
+
+class ToolHook:
+    """工具执行钩子基类（全局链，经 registry.register_tool_hook 注册）
+
+    子类覆写其一或两者；方法必须是 async def。
+    pre_execute 按注册顺序、post_execute 按逆序执行（洋葱模型）。
+    F3 并行工具落地后钩子会被并发调用：实现必须无状态或自行同步
+    （与 Tool 单例的既有纪律同构）。
+    """
+
+    async def pre_execute(
+        self, context: "FlowContext", tool: "Tool", inputs: dict[str, Any]
+    ) -> "dict[str, Any] | Deny":
+        """工具入参进入工具函数前调用
+
+        返回（可改写的）inputs 继续执行；返回 Deny 拒绝执行；
+        抛异常按 Deny 处理（fail closed：权限门自己出错时不放行）。
+        """
+        return inputs
+
+    async def post_execute(self, context: "FlowContext", tool: "Tool", result: "ToolResult") -> "ToolResult":
+        """结果落入上下文前调用，原样返回＝纯观察
+
+        可替换/截断/落盘换 locator；改写对 LLM 消费内容、用户摘要、
+        execution_records 三个出口同时生效。抛异常记日志并放行原结果
+        （fail open：审计钩子的 bug 不毁掉主流程）。
+        Deny 产生的失败结果同样穿过 post 链（审计要看到被拒绝的调用）。
+        """
+        return result
+
+
+_TOOL_HOOKS: list[ToolHook] = []
+
+
+def register_tool_hook(hook: ToolHook, *, prepend: bool = False) -> None:
+    """注册全局工具执行钩子，对所有 Tool.execute_async 生效
+
+    prepend=True 抢占链头（其 post_execute 成为最外层，适合 spill/截断类钩子）。
+    """
+    if prepend:
+        _TOOL_HOOKS.insert(0, hook)
+    else:
+        _TOOL_HOOKS.append(hook)
+
+
+def clear_tool_hooks() -> None:
+    """清空全局工具钩子（测试隔离用）"""
+    _TOOL_HOOKS.clear()
+
+
 class Tool:
     """工具定义"""
 
@@ -41,6 +97,7 @@ class Tool:
         label: str | None = None,
         echo: bool = False,
         category: str | None = None,
+        concurrency_safe: bool = False,
         summary_fn: Callable[["ToolResult"], str | None] | None = None,
         result_formatter: Callable[["ToolResult"], str] | None = None,
         progress_label_fn: Callable[[dict[str, Any]], str] | None = None,
@@ -54,6 +111,7 @@ class Tool:
         :param label: 面向用户的展示名称（控制 STEP/TOOL_CALL 进度事件可见性）
         :param echo: 是否转发 TEXT_MESSAGE 给用户
         :param category: 工具分类（retrieval / analysis / action / utility）
+        :param concurrency_safe: 声明该工具可与其它 concurrency_safe 工具并发执行（默认串行）
         :param summary_fn: 生成面向用户摘要的函数 (ToolResult) -> str | None
         :param result_formatter: 自定义 LLM 内容格式化函数 (ToolResult) -> str
         :param progress_label_fn: 基于调用参数生成动态进度描述 (args) -> str
@@ -65,6 +123,7 @@ class Tool:
         self.label = label
         self.echo = echo
         self.category = category
+        self.concurrency_safe = concurrency_safe
         self.summary_fn = summary_fn
         self.result_formatter = result_formatter
         self.progress_label_fn = progress_label_fn
@@ -82,10 +141,39 @@ class Tool:
         return self.label
 
     async def execute_async(self, context: "FlowContext", inputs: dict[str, Any] | None = None) -> ToolResult:
-        """异步执行工具（包含计时、摘要生成、结果格式化、可观测性记录）"""
+        """异步执行工具（包含钩子链、计时、摘要生成、结果格式化、可观测性记录）"""
         args = inputs or {}
         _t0 = time.perf_counter()
-        result = await self._execute(context, args)
+
+        # pre 钩子链（注册顺序）：可改写入参；返回 Deny 或抛异常＝拒绝执行（fail closed）
+        result: ToolResult | None = None
+        for hook in _TOOL_HOOKS:
+            try:
+                outcome = await hook.pre_execute(context, self, args)
+            except Exception as e:
+                logger.warning("Tool hook pre_execute failed for %s: %s", self.name, e, exc_info=True)
+                outcome = Deny(f"tool hook error: {e}")
+            if isinstance(outcome, Deny):
+                result = ToolResult(name=self.name, arguments=args, result={}, success=False, error=outcome.reason)
+                break
+            args = outcome
+
+        if result is None:
+            result = await self._execute(context, args)
+
+        # post 钩子链（逆序）：可改写结果；抛异常＝放行原结果（fail open）。
+        # Deny 的失败结果同样穿过 post 链，审计钩子能看到被拒绝的调用。
+        for hook in reversed(_TOOL_HOOKS):
+            try:
+                revised = await hook.post_execute(context, self, result)
+            except Exception as e:
+                logger.warning("Tool hook post_execute failed for %s: %s", self.name, e, exc_info=True)
+                continue
+            if isinstance(revised, ToolResult):
+                result = revised
+            else:
+                logger.warning("Tool hook post_execute for %s returned %r, ignored", self.name, type(revised))
+
         _duration_ms = int((time.perf_counter() - _t0) * 1000)
 
         # 计算 LLM 消费内容

{agstack-2.0.0 → agstack-2.1.0}/agstack.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agstack
-Version: 2.0.0
+Version: 2.1.0
 Summary: Production-ready toolkit for building FastAPI and LLM applications
 Author-email: XtraVisions <gitadmin@xtravisions.com>, Chen Hao <chenhao@xtravisions.com>
 Maintainer-email: XtraVisions <gitadmin@xtravisions.com>, Chen Hao <chenhao@xtravisions.com>

{agstack-2.0.0 → agstack-2.1.0}/agstack.egg-info/SOURCES.txt

@@ -68,12 +68,15 @@ agstack/messagebus/redis.py
 agstack/security/__init__.py
 agstack/security/casbin.py
 agstack/security/crypt.py
+tests/test_agent_parallel_tools.py
 tests/test_cache_memory.py
 tests/test_cache_redis.py
+tests/test_flow_cancellation.py
 tests/test_flow_error_semantics.py
 tests/test_flow_io.py
 tests/test_flow_iterator.py
 tests/test_flow_switch_subflow.py
 tests/test_llm_usage_callback.py
 tests/test_messagebus_memory.py
-tests/test_messagebus_redis.py
+tests/test_messagebus_redis.py
+tests/test_tool_hooks.py

{agstack-2.0.0 → agstack-2.1.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agstack"
-version = "2.0.0"
+version = "2.1.0"
 description = "Production-ready toolkit for building FastAPI and LLM applications"
 readme = "README.md"
 license = "MIT"