synapsekit 0.6.0__tar.gz → 0.6.2__tar.gz

{synapsekit-0.6.0 → synapsekit-0.6.2}/CHANGELOG.md

@@ -7,6 +7,49 @@ SynapseKit uses [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ---
 
+## [0.6.1] — 2026-03-13
+
+### Added
+
+- **Human-in-the-Loop** — `GraphInterrupt` exception pauses graph execution for human review; `InterruptState` holds interrupt details; `resume(updates=...)` applies human edits and continues from checkpoint
+- **Subgraphs** — `subgraph_node(compiled_graph, input_mapping, output_mapping)` nests a `CompiledGraph` as a node in a parent graph with key mapping
+- **Token-level streaming** — `llm_node(llm, stream=True)` wraps any `BaseLLM` as a graph node; `stream_tokens()` yields `{"type": "token", ...}` events for real-time output
+- **Self-Query retrieval** — `SelfQueryRetriever` uses an LLM to decompose natural-language queries into semantic search + metadata filters automatically
+- **Parent Document retrieval** — `ParentDocumentRetriever` embeds small chunks for precision search, returns full parent documents for richer context
+- **Cross-Encoder reranking** — `CrossEncoderReranker` reranks retrieval results with cross-encoder models for higher accuracy (requires `synapsekit[semantic]`)
+- **Hybrid memory** — `HybridMemory` keeps a sliding window of recent messages in full, plus an LLM-generated summary of older messages for token-efficient long conversations
+- 30 new tests (482 total)
+
+---
+
+## [0.6.0] — 2026-03-13
+
+### Added
+
+- **Built-in tools** (6 new):
+  - `HTTPRequestTool` — GET/POST/PUT/DELETE/PATCH with aiohttp, configurable timeout and max response length
+  - `FileWriteTool` — write/append files with auto-mkdir
+  - `FileListTool` — list directories with glob patterns, recursive mode
+  - `DateTimeTool` — current time, parse, format with timezone support
+  - `RegexTool` — findall, match, search, replace, split with flag support
+  - `JSONQueryTool` — dot-notation path queries on JSON data
+- **LLM providers** (3 new, all OpenAI-compatible):
+  - `OpenRouterLLM` — unified API for 200+ models (auto-detected from `/` in model name)
+  - `TogetherLLM` — Together AI fast inference
+  - `FireworksLLM` — Fireworks AI optimized serving
+- **Advanced retrieval** (2 new):
+  - `ContextualRetriever` — Anthropic-style contextual retrieval (LLM prepends context before embedding)
+  - `SentenceWindowRetriever` — sentence-level embedding with configurable window expansion at retrieval time
+- RAG facade auto-detects `openrouter` (model names with `/`), `together`, and `fireworks` providers
+- 37 new tests (452 total)
+
+### Changed
+
+- Lazy imports extended for new providers (`OpenRouterLLM`, `TogetherLLM`, `FireworksLLM`)
+- `agents/tools/__init__.py` exports 11 built-in tools (was 5)
+
+---
+
 ## [0.5.3] — 2026-03-12
 
 ### Added

{synapsekit-0.6.0 → synapsekit-0.6.2}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: synapsekit
-Version: 0.6.0
+Version: 0.6.2
 Summary: Async-native Python framework for building production-grade LLM applications. Streaming-first, 2 dependencies, fully transparent.
 Project-URL: Homepage, https://github.com/SynapseKit/SynapseKit
 Project-URL: Repository, https://github.com/SynapseKit/SynapseKit
-Author-email: Amit Nautiyal <de.amit.nautiyal@gmail.com>
+Author-email: Amit <de.amit.nautiyal@gmail.com>
 License: MIT
 License-File: LICENSE
 Keywords: ai,async,llm,rag,retrieval,streaming
@@ -43,13 +43,19 @@ Provides-Extra: chroma
 Requires-Dist: chromadb>=0.5; extra == 'chroma'
 Provides-Extra: cohere
 Requires-Dist: cohere>=5.0; extra == 'cohere'
+Provides-Extra: excel
+Requires-Dist: openpyxl>=3.1; extra == 'excel'
 Provides-Extra: faiss
 Requires-Dist: faiss-cpu>=1.7; extra == 'faiss'
 Provides-Extra: gemini
 Requires-Dist: google-generativeai>=0.7; extra == 'gemini'
+Provides-Extra: groq
+Requires-Dist: groq>=0.9; extra == 'groq'
 Provides-Extra: html
 Requires-Dist: beautifulsoup4>=4.12; extra == 'html'
 Requires-Dist: lxml>=5.0; extra == 'html'
+Provides-Extra: http
+Requires-Dist: aiohttp>=3.9; extra == 'http'
 Provides-Extra: mistral
 Requires-Dist: mistralai>=1.0; extra == 'mistral'
 Provides-Extra: ollama
@@ -60,6 +66,8 @@ Provides-Extra: pdf
 Requires-Dist: pypdf>=4.0; extra == 'pdf'
 Provides-Extra: pinecone
 Requires-Dist: pinecone>=3.0; extra == 'pinecone'
+Provides-Extra: pptx
+Requires-Dist: python-pptx>=0.6; extra == 'pptx'
 Provides-Extra: qdrant
 Requires-Dist: qdrant-client>=1.9; extra == 'qdrant'
 Provides-Extra: search

{synapsekit-0.6.0 → synapsekit-0.6.2}/pyproject.toml

@@ -4,9 +4,9 @@ build-backend = "hatchling.build"
 
 [project]
 name = "synapsekit"
-version = "0.6.0"
+version = "0.6.2"
 description = "Async-native Python framework for building production-grade LLM applications. Streaming-first, 2 dependencies, fully transparent."
-authors = [{ name = "Amit Nautiyal", email = "de.amit.nautiyal@gmail.com" }]
+authors = [{ name = "Amit", email = "de.amit.nautiyal@gmail.com" }]
 license = { text = "MIT" }
 readme = "README.md"
 requires-python = ">=3.14"
@@ -44,6 +44,10 @@ cohere = ["cohere>=5.0"]
 mistral = ["mistralai>=1.0"]
 gemini = ["google-generativeai>=0.7"]
 bedrock = ["boto3>=1.34"]
+groq = ["groq>=0.9"]
+excel = ["openpyxl>=3.1"]
+pptx = ["python-pptx>=0.6"]
+http = ["aiohttp>=3.9"]
 search = ["duckduckgo-search>=6.0"]
 all = [
     "openai>=1.0",
@@ -130,6 +134,14 @@ module = [
     "synapsekit.retrieval.faiss",
     "synapsekit.retrieval.qdrant",
     "synapsekit.retrieval.pinecone",
+    "synapsekit.llm.groq",
+    "synapsekit.llm.azure_openai",
+    "synapsekit.llm.deepseek",
+    "synapsekit.llm.openrouter",
+    "synapsekit.llm.together",
+    "synapsekit.llm.fireworks",
+    "synapsekit.loaders.excel",
+    "synapsekit.loaders.pptx",
 ]
 warn_return_any = false
 # from __future__ import annotations causes mypy to misinterpret
@@ -143,7 +155,9 @@ pep621_dev_dependency_groups = ["dev"]
 google-generativeai = "google"
 beautifulsoup4 = "bs4"
 faiss-cpu = "faiss"
+python-pptx = "pptx"
 
 [tool.deptry.per_rule_ignores]
-DEP001 = ["sqlalchemy", "pydantic"]
+DEP001 = ["sqlalchemy", "pydantic", "aiohttp"]
 DEP002 = ["numpy", "rank-bm25", "beautifulsoup4", "lxml", "faiss-cpu", "google-generativeai"]
+DEP004 = ["pydantic"]

{synapsekit-0.6.0 → synapsekit-0.6.2}/src/synapsekit/__init__.py

@@ -27,6 +27,7 @@ from .agents import (
     FileWriteTool,
     FunctionCallingAgent,
     HTTPRequestTool,
+    HumanInputTool,
     JSONQueryTool,
     PythonREPLTool,
     ReActAgent,
@@ -35,6 +36,7 @@ from .agents import (
     ToolRegistry,
     ToolResult,
     WebSearchTool,
+    WikipediaTool,
     tool,
 )
 from .embeddings.backend import SynapsekitEmbeddings
@@ -46,15 +48,19 @@ from .graph import (
     ConditionFn,
     Edge,
     GraphConfigError,
+    GraphInterrupt,
     GraphRuntimeError,
     GraphState,
     InMemoryCheckpointer,
+    InterruptState,
     Node,
     NodeFn,
     SQLiteCheckpointer,
     StateGraph,
     agent_node,
+    llm_node,
     rag_node,
+    subgraph_node,
 )
 from .llm.base import BaseLLM, LLMConfig
 from .llm.structured import generate_structured
@@ -67,6 +73,9 @@ from .loaders.pdf import PDFLoader
 from .loaders.text import StringLoader, TextLoader
 from .loaders.web import WebLoader
 from .memory.conversation import ConversationMemory
+from .memory.hybrid import HybridMemory
+from .memory.sqlite import SQLiteConversationMemory
+from .memory.summary_buffer import SummaryBufferMemory
 from .observability.tracer import TokenTracer
 from .parsers.json_parser import JSONParser
 from .parsers.list_parser import ListParser
@@ -76,8 +85,15 @@ from .rag.facade import RAG
 from .rag.pipeline import RAGConfig, RAGPipeline
 from .retrieval.base import VectorStore
 from .retrieval.contextual import ContextualRetriever
+from .retrieval.contextual_compression import ContextualCompressionRetriever
+from .retrieval.crag import CRAGRetriever
+from .retrieval.cross_encoder import CrossEncoderReranker
+from .retrieval.ensemble import EnsembleRetriever
+from .retrieval.parent_document import ParentDocumentRetriever
+from .retrieval.query_decomposition import QueryDecompositionRetriever
 from .retrieval.rag_fusion import RAGFusionRetriever
 from .retrieval.retriever import Retriever
+from .retrieval.self_query import SelfQueryRetriever
 from .retrieval.sentence_window import SentenceWindowRetriever
 from .retrieval.vectorstore import InMemoryVectorStore
 from .text_splitters import (
@@ -88,7 +104,7 @@ from .text_splitters import (
     TokenAwareSplitter,
 )
 
-__version__ = "0.6.0"
+__version__ = "0.6.2"
 __all__ = [
     # Facade
     "RAG",
@@ -117,9 +133,19 @@ __all__ = [
     "Retriever",
     "RAGFusionRetriever",
     "ContextualRetriever",
+    "ContextualCompressionRetriever",
+    "CRAGRetriever",
+    "CrossEncoderReranker",
+    "EnsembleRetriever",
+    "ParentDocumentRetriever",
+    "QueryDecompositionRetriever",
+    "SelfQueryRetriever",
     "SentenceWindowRetriever",
     # Memory / observability
     "ConversationMemory",
+    "HybridMemory",
+    "SQLiteConversationMemory",
+    "SummaryBufferMemory",
     "TokenTracer",
     # Loaders
     "Document",
@@ -160,11 +186,13 @@ __all__ = [
     "FileReadTool",
     "FileWriteTool",
     "HTTPRequestTool",
+    "HumanInputTool",
     "JSONQueryTool",
     "PythonREPLTool",
     "RegexTool",
     "SQLQueryTool",
     "WebSearchTool",
+    "WikipediaTool",
     # Text splitters
     "BaseSplitter",
     "CharacterTextSplitter",
@@ -179,7 +207,11 @@ __all__ = [
     "Node",
     "NodeFn",
     "agent_node",
+    "llm_node",
     "rag_node",
+    "subgraph_node",
+    "GraphInterrupt",
+    "InterruptState",
     "Edge",
     "ConditionalEdge",
     "ConditionFn",

{synapsekit-0.6.0 → synapsekit-0.6.2}/src/synapsekit/agents/__init__.py

@@ -12,11 +12,13 @@ from .tools import (
     FileReadTool,
     FileWriteTool,
     HTTPRequestTool,
+    HumanInputTool,
     JSONQueryTool,
     PythonREPLTool,
     RegexTool,
     SQLQueryTool,
     WebSearchTool,
+    WikipediaTool,
 )
 
 __all__ = [
@@ -40,9 +42,11 @@ __all__ = [
     "FileReadTool",
     "FileWriteTool",
     "HTTPRequestTool",
+    "HumanInputTool",
     "JSONQueryTool",
     "PythonREPLTool",
     "RegexTool",
     "SQLQueryTool",
     "WebSearchTool",
+    "WikipediaTool",
 ]

{synapsekit-0.6.0 → synapsekit-0.6.2}/src/synapsekit/agents/tools/__init__.py

@@ -4,11 +4,13 @@ from .file_list import FileListTool
 from .file_read import FileReadTool
 from .file_write import FileWriteTool
 from .http_request import HTTPRequestTool
+from .human_input import HumanInputTool
 from .json_query import JSONQueryTool
 from .python_repl import PythonREPLTool
 from .regex_tool import RegexTool
 from .sql_query import SQLQueryTool
 from .web_search import WebSearchTool
+from .wikipedia import WikipediaTool
 
 __all__ = [
     "CalculatorTool",
@@ -17,9 +19,11 @@ __all__ = [
     "FileReadTool",
     "FileWriteTool",
     "HTTPRequestTool",
+    "HumanInputTool",
     "JSONQueryTool",
     "PythonREPLTool",
     "RegexTool",
     "SQLQueryTool",
     "WebSearchTool",
+    "WikipediaTool",
 ]

{synapsekit-0.6.0 → synapsekit-0.6.2}/src/synapsekit/agents/tools/http_request.py

@@ -56,9 +56,7 @@ class HTTPRequestTool(BaseTool):
         try:
             import aiohttp
         except ImportError:
-            raise ImportError(
-                "aiohttp required for HTTPRequestTool: pip install aiohttp"
-            ) from None
+            raise ImportError("aiohttp required for HTTPRequestTool: pip install aiohttp") from None
 
         method = method.upper()
         req_headers = headers or {}

synapsekit-0.6.2/src/synapsekit/agents/tools/human_input.py

@@ -0,0 +1,63 @@
+"""Human Input Tool: allows agents to ask the user a question mid-execution."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Any
+
+from ..base import BaseTool, ToolResult
+
+
+class HumanInputTool(BaseTool):
+    """Tool that asks the user for input during agent execution.
+
+    This enables human-in-the-loop agent workflows where the agent can
+    request clarification or additional information from the user.
+
+    Usage::
+
+        tool = HumanInputTool()
+        # Or with a custom input function:
+        tool = HumanInputTool(input_fn=my_custom_input)
+
+    By default, uses Python's built-in ``input()`` function.
+    Pass a custom ``input_fn`` for non-terminal environments (web, API, etc.).
+    """
+
+    name = "human_input"
+    description = (
+        "Ask the user a question and get their response. "
+        "Use this when you need clarification, additional information, "
+        "or confirmation from the user before proceeding."
+    )
+    parameters = {
+        "type": "object",
+        "properties": {
+            "question": {
+                "type": "string",
+                "description": "The question to ask the user",
+            },
+        },
+        "required": ["question"],
+    }
+
+    def __init__(self, input_fn: Any = None) -> None:
+        self._input_fn = input_fn
+
+    async def run(self, question: str = "", **kwargs: Any) -> ToolResult:
+        prompt = question or kwargs.get("input", "")
+        if not prompt:
+            return ToolResult(output="", error="No question provided.")
+
+        try:
+            if self._input_fn is not None:
+                result = self._input_fn(prompt)
+                if asyncio.iscoroutine(result):
+                    result = await result
+            else:
+                loop = asyncio.get_event_loop()
+                result = await loop.run_in_executor(None, input, f"\n{prompt}\n> ")
+
+            return ToolResult(output=str(result))
+        except Exception as e:
+            return ToolResult(output="", error=f"Failed to get input: {e}")

{synapsekit-0.6.0 → synapsekit-0.6.2}/src/synapsekit/agents/tools/regex_tool.py

@@ -66,7 +66,9 @@ class RegexTool(BaseTool):
 
             if action == "findall":
                 matches = re.findall(pattern, text, re_flags)
-                return ToolResult(output="\n".join(str(m) for m in matches) if matches else "(no matches)")
+                return ToolResult(
+                    output="\n".join(str(m) for m in matches) if matches else "(no matches)"
+                )
 
             elif action == "match":
                 m = re.match(pattern, text, re_flags)

synapsekit-0.6.2/src/synapsekit/agents/tools/wikipedia.py

@@ -0,0 +1,103 @@
+"""Wikipedia Tool: search and fetch Wikipedia articles."""
+
+from __future__ import annotations
+
+from typing import Any
+from urllib.parse import quote_plus
+
+from ..base import BaseTool, ToolResult
+
+
+class WikipediaTool(BaseTool):
+    """Search and fetch Wikipedia article summaries.
+
+    Uses the Wikipedia REST API — no API key required, no extra dependencies.
+
+    Usage::
+
+        tool = WikipediaTool()
+        result = await tool.run(query="Python programming language")
+    """
+
+    name = "wikipedia"
+    description = (
+        "Search Wikipedia and return article summaries. "
+        "Input: a search query. "
+        "Returns: the title and summary of the most relevant Wikipedia article."
+    )
+    parameters = {
+        "type": "object",
+        "properties": {
+            "query": {
+                "type": "string",
+                "description": "The search query for Wikipedia",
+            },
+            "max_results": {
+                "type": "integer",
+                "description": "Maximum number of articles to return (default: 1)",
+                "default": 1,
+            },
+        },
+        "required": ["query"],
+    }
+
+    def __init__(self, max_chars: int = 4000) -> None:
+        self._max_chars = max_chars
+
+    async def run(self, query: str = "", max_results: int = 1, **kwargs: Any) -> ToolResult:
+        search_query = query or kwargs.get("input", "")
+        if not search_query:
+            return ToolResult(output="", error="No search query provided.")
+
+        try:
+            import urllib.request
+
+            # Search for articles
+            search_url = (
+                f"https://en.wikipedia.org/w/api.php?action=opensearch"
+                f"&search={quote_plus(search_query)}&limit={max_results}&format=json"
+            )
+
+            import asyncio
+            import json
+
+            loop = asyncio.get_event_loop()
+
+            def _fetch_search():
+                req = urllib.request.Request(search_url, headers={"User-Agent": "SynapseKit/1.0"})
+                with urllib.request.urlopen(req, timeout=10) as resp:
+                    return json.loads(resp.read().decode())
+
+            search_data = await loop.run_in_executor(None, _fetch_search)
+
+            if len(search_data) < 2 or not search_data[1]:
+                return ToolResult(output="No Wikipedia articles found.")
+
+            results = []
+            titles = search_data[1][:max_results]
+
+            for title in titles:
+                # Fetch article summary
+                summary_url = (
+                    f"https://en.wikipedia.org/api/rest_v1/page/summary/{quote_plus(title)}"
+                )
+
+                def _fetch_summary(url=summary_url):
+                    req = urllib.request.Request(url, headers={"User-Agent": "SynapseKit/1.0"})
+                    with urllib.request.urlopen(req, timeout=10) as resp:
+                        return json.loads(resp.read().decode())
+
+                summary_data = await loop.run_in_executor(None, _fetch_summary)
+
+                article_title = summary_data.get("title", title)
+                extract = summary_data.get("extract", "No summary available.")
+                url = summary_data.get("content_urls", {}).get("desktop", {}).get("page", "")
+
+                if len(extract) > self._max_chars:
+                    extract = extract[: self._max_chars] + "..."
+
+                results.append(f"**{article_title}**\n{url}\n\n{extract}")
+
+            return ToolResult(output="\n\n---\n\n".join(results))
+        except Exception as e:
+            return ToolResult(output="", error=f"Wikipedia search failed: {e}")

{synapsekit-0.6.0 → synapsekit-0.6.2}/src/synapsekit/graph/__init__.py

@@ -3,8 +3,10 @@ from .compiled import CompiledGraph
 from .edge import ConditionalEdge, ConditionFn, Edge
 from .errors import GraphConfigError, GraphRuntimeError
 from .graph import StateGraph
-from .node import Node, NodeFn, agent_node, rag_node
+from .interrupt import GraphInterrupt, InterruptState
+from .node import Node, NodeFn, agent_node, llm_node, rag_node
 from .state import END, GraphState
+from .subgraph import subgraph_node
 
 __all__ = [
     "END",
@@ -14,13 +16,17 @@ __all__ = [
     "ConditionalEdge",
     "Edge",
     "GraphConfigError",
+    "GraphInterrupt",
     "GraphRuntimeError",
     "GraphState",
     "InMemoryCheckpointer",
+    "InterruptState",
     "Node",
     "NodeFn",
     "SQLiteCheckpointer",
     "StateGraph",
     "agent_node",
+    "llm_node",
     "rag_node",
+    "subgraph_node",
 ]

{synapsekit-0.6.0 → synapsekit-0.6.2}/src/synapsekit/graph/compiled.py

@@ -7,6 +7,7 @@ from typing import TYPE_CHECKING, Any
 
 from .edge import ConditionalEdge, Edge
 from .errors import GraphRuntimeError
+from .interrupt import GraphInterrupt
 from .mermaid import get_mermaid
 from .state import END
 
@@ -71,12 +72,22 @@ class CompiledGraph:
         self,
         graph_id: str,
         checkpointer: BaseCheckpointer,
+        updates: dict[str, Any] | None = None,
     ) -> dict[str, Any]:
-        """Resume execution from a checkpointed state."""
+        """Resume execution from a checkpointed state.
+
+        Args:
+            graph_id: The graph execution ID to resume.
+            checkpointer: The checkpointer that holds the saved state.
+            updates: Optional state updates to apply before resuming
+                (e.g. human-provided edits after a ``GraphInterrupt``).
+        """
         saved = checkpointer.load(graph_id)
         if saved is None:
             raise GraphRuntimeError(f"No checkpoint found for graph_id={graph_id!r}.")
         _step, state = saved
+        if updates:
+            state.update(updates)
         return await self.run(state, checkpointer=checkpointer, graph_id=graph_id)
 
     def run_sync(
@@ -90,6 +101,62 @@ class CompiledGraph:
 
         return run_sync(self.run(state, checkpointer=checkpointer, graph_id=graph_id))
 
+    async def stream_tokens(
+        self,
+        state: dict[str, Any],
+    ) -> AsyncGenerator[dict[str, Any]]:
+        """Yield token-level events from LLM nodes.
+
+        Yields dicts with either:
+        - ``{"type": "token", "node": name, "token": str}`` for streaming tokens
+        - ``{"type": "node_complete", "node": name, "state": dict}`` for non-streaming nodes
+
+        LLM nodes are detected by checking if the node function's return dict
+        contains a ``"__stream__"`` key with an async generator.
+        """
+        state = dict(state)
+        graph = self._graph
+        current_wave: list[str] = [graph._entry_point]  # type: ignore[list-item]
+        steps = 0
+
+        while current_wave:
+            if steps >= self._max_steps:
+                raise GraphRuntimeError(
+                    f"Graph exceeded _MAX_STEPS={self._max_steps}. "
+                    "Check for infinite loops in conditional edges."
+                )
+            steps += 1
+
+            for name in current_wave:
+                node = graph._nodes.get(name)
+                if node is None:
+                    raise GraphRuntimeError(f"Node {name!r} not found in graph.")
+
+                result = node.fn(state)
+                if inspect.isawaitable(result):
+                    result = await result
+
+                if not isinstance(result, dict):
+                    raise GraphRuntimeError(
+                        f"Node {name!r} must return a dict, got {type(result).__name__!r}."
+                    )
+
+                # Check for streaming token generator
+                stream_gen = result.pop("__stream__", None)
+                if stream_gen is not None:
+                    collected: list[str] = []
+                    async for token in stream_gen:
+                        collected.append(token)
+                        yield {"type": "token", "node": name, "token": token}
+                    # Store the full text in the result
+                    if "__stream_key__" in result:
+                        result[result.pop("__stream_key__")] = "".join(collected)
+
+                state.update(result)
+                yield {"type": "node_complete", "node": name, "state": dict(state)}
+
+            current_wave = await self._next_wave(current_wave, state)
+
     def get_mermaid(self) -> str:
         return get_mermaid(self._graph)
 
@@ -116,7 +183,15 @@ class CompiledGraph:
             steps += 1
 
             # Run all nodes in this wave concurrently
-            results = await asyncio.gather(*[self._call_node(name, state) for name in current_wave])
+            try:
+                results = await asyncio.gather(
+                    *[self._call_node(name, state) for name in current_wave]
+                )
+            except GraphInterrupt as exc:
+                # Save state and raise InterruptState for the caller
+                if checkpointer is not None and graph_id is not None:
+                    checkpointer.save(graph_id, steps, dict(state))
+                raise GraphInterrupt(exc.message, exc.data) from None
 
             # Merge partial results into state and yield events
             for name, partial in zip(current_wave, results, strict=False):