AgenticBlocks.IO 0.1.0__tar.gz

agenticblocks_io-0.1.0/PKG-INFO

@@ -0,0 +1,100 @@
+Metadata-Version: 2.4
+Name: AgenticBlocks.IO
+Version: 0.1.0
+Summary: A building block library for composed agent workflows
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: networkx>=3.0
+Requires-Dist: tenacity>=8.0
+Requires-Dist: litellm>=1.0.0
+Requires-Dist: mcp>=1.0.0
+
+# agenticblocks 🧱
+
+*A composable building block library for AI agent workflows. / Uma biblioteca componível para construir fluxos de agentes de IA.*
+
+[🇺🇸 English](#english) | [🇧🇷 Português](#português)
+
+---
+
+## <a name="english"></a>🇺🇸 English
+
+### Philosophy
+A library to build agent workflows like **Lego blocks**. Each step in your agentic pipeline is a self-contained block, with strictly typed inputs and outputs via **Pydantic** and natively concurrent execution using **AsyncIO** and **NetworkX** graphs.
+
+- **Strong typing**: Pydantic validates connections and prevents unmatched dependencies between LLM tool calls.
+- **Standardized connections**: Blocks only know their own inputs and outputs. Thus, entire workflows can act as single blocks later.
+- **Smart Parallelism (Waves)**: The asyncio engine fires simultaneous tasks (waves) whenever dependencies are resolved, maximizing API speed.
+
+### Getting Started
+
+Install the module locally for development:
+```bash
+pip install -e .
+```
+
+#### 1. Define Input and Output Models
+```python
+from pydantic import BaseModel
+
+class HelloInput(BaseModel):
+    name: str
+
+class HelloOutput(BaseModel):
+    greeting: str
+```
+
+#### 2. Create the Logic Block
+```python
+from agenticblocks.core.block import Block
+
+class HelloWorldBlock(Block[HelloInput, HelloOutput]):
+    name: str = "say_hello"
+    
+    async def run(self, input: HelloInput) -> HelloOutput:
+        msg = f"Hello, {input.name}! Welcome to agenticblocks."
+        return HelloOutput(greeting=msg)
+```
+
+#### 3. Connect and Execute
+```python
+import asyncio
+from agenticblocks.core.graph import WorkflowGraph
+from agenticblocks.runtime.executor import WorkflowExecutor
+
+async def main():
+    graph = WorkflowGraph()
+    graph.add_block(HelloWorldBlock(name="say_hello"))
+
+    executor = WorkflowExecutor(graph)
+    ctx = await executor.run(initial_input={"name": "Alice"})
+    
+    print(ctx.get_output("say_hello").greeting)
+
+asyncio.run(main())
+```
+
+Check the `examples/` directory for full demos.
+
+---
+
+## <a name="português"></a>🇧🇷 Português
+
+### Filosofia
+Uma biblioteca para construir fluxos de agentes no estilo **Lego**. Cada passo do seu pipeline agêntico é um bloco auto-contido, com entradas e saídas rigorosamente tipadas via **Pydantic** e execução simultânea usando **AsyncIO** e grafos do **NetworkX**.
+
+- **Forte tipagem**: Pydantic valida os encaixes e previne dependências não satisfeitas.
+- **Encaixes padronizados**: Blocos só conhecem as próprias entradas e saídas. Workflows inteiros funcionam como blocos únicos.
+- **Paralelismo Inteligente (Ondas)**: O motor dispara tarefas simultâneas (waves) sempre que as dependências de um bloco são resolvidas, otimizando a velocidade de conexões a APIs.
+
+### Primeiros Passos
+
+Instale o módulo de forma local editável:
+```bash
+pip install -e .
+```
+
+A estrutura segue o modelo mostrado na sessão em inglês (Inglês: Input/Output Models, Logic Block, e Graph Execution). Consulte os scripts interativos e completos dentro da pasta `examples/`:
+- `01_hello_world.py`: Simulação básica e limpa do tutorial inicial.
+- `02_llm_pipeline.py`: Um pipeline completo demonstrando a paralelização de parsing de dados complexos com um mock de LLM Call.

agenticblocks_io-0.1.0/README.md

@@ -0,0 +1,88 @@
+# agenticblocks 🧱
+
+*A composable building block library for AI agent workflows. / Uma biblioteca componível para construir fluxos de agentes de IA.*
+
+[🇺🇸 English](#english) | [🇧🇷 Português](#português)
+
+---
+
+## <a name="english"></a>🇺🇸 English
+
+### Philosophy
+A library to build agent workflows like **Lego blocks**. Each step in your agentic pipeline is a self-contained block, with strictly typed inputs and outputs via **Pydantic** and natively concurrent execution using **AsyncIO** and **NetworkX** graphs.
+
+- **Strong typing**: Pydantic validates connections and prevents unmatched dependencies between LLM tool calls.
+- **Standardized connections**: Blocks only know their own inputs and outputs. Thus, entire workflows can act as single blocks later.
+- **Smart Parallelism (Waves)**: The asyncio engine fires simultaneous tasks (waves) whenever dependencies are resolved, maximizing API speed.
+
+### Getting Started
+
+Install the module locally for development:
+```bash
+pip install -e .
+```
+
+#### 1. Define Input and Output Models
+```python
+from pydantic import BaseModel
+
+class HelloInput(BaseModel):
+    name: str
+
+class HelloOutput(BaseModel):
+    greeting: str
+```
+
+#### 2. Create the Logic Block
+```python
+from agenticblocks.core.block import Block
+
+class HelloWorldBlock(Block[HelloInput, HelloOutput]):
+    name: str = "say_hello"
+    
+    async def run(self, input: HelloInput) -> HelloOutput:
+        msg = f"Hello, {input.name}! Welcome to agenticblocks."
+        return HelloOutput(greeting=msg)
+```
+
+#### 3. Connect and Execute
+```python
+import asyncio
+from agenticblocks.core.graph import WorkflowGraph
+from agenticblocks.runtime.executor import WorkflowExecutor
+
+async def main():
+    graph = WorkflowGraph()
+    graph.add_block(HelloWorldBlock(name="say_hello"))
+
+    executor = WorkflowExecutor(graph)
+    ctx = await executor.run(initial_input={"name": "Alice"})
+    
+    print(ctx.get_output("say_hello").greeting)
+
+asyncio.run(main())
+```
+
+Check the `examples/` directory for full demos.
+
+---
+
+## <a name="português"></a>🇧🇷 Português
+
+### Filosofia
+Uma biblioteca para construir fluxos de agentes no estilo **Lego**. Cada passo do seu pipeline agêntico é um bloco auto-contido, com entradas e saídas rigorosamente tipadas via **Pydantic** e execução simultânea usando **AsyncIO** e grafos do **NetworkX**.
+
+- **Forte tipagem**: Pydantic valida os encaixes e previne dependências não satisfeitas.
+- **Encaixes padronizados**: Blocos só conhecem as próprias entradas e saídas. Workflows inteiros funcionam como blocos únicos.
+- **Paralelismo Inteligente (Ondas)**: O motor dispara tarefas simultâneas (waves) sempre que as dependências de um bloco são resolvidas, otimizando a velocidade de conexões a APIs.
+
+### Primeiros Passos
+
+Instale o módulo de forma local editável:
+```bash
+pip install -e .
+```
+
+A estrutura segue o modelo mostrado na sessão em inglês (Inglês: Input/Output Models, Logic Block, e Graph Execution). Consulte os scripts interativos e completos dentro da pasta `examples/`:
+- `01_hello_world.py`: Simulação básica e limpa do tutorial inicial.
+- `02_llm_pipeline.py`: Um pipeline completo demonstrando a paralelização de parsing de dados complexos com um mock de LLM Call.

agenticblocks_io-0.1.0/pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "AgenticBlocks.IO"
+version = "0.1.0"
+description = "A building block library for composed agent workflows"
+readme = "README.md"
+requires-python = ">=3.9"
+dependencies = [
+    "pydantic>=2.0.0",
+    "networkx>=3.0",
+    "tenacity>=8.0",
+    "litellm>=1.0.0",
+    "mcp>=1.0.0"
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]

agenticblocks_io-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

agenticblocks_io-0.1.0/src/AgenticBlocks.IO.egg-info/PKG-INFO

@@ -0,0 +1,100 @@
+Metadata-Version: 2.4
+Name: AgenticBlocks.IO
+Version: 0.1.0
+Summary: A building block library for composed agent workflows
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: networkx>=3.0
+Requires-Dist: tenacity>=8.0
+Requires-Dist: litellm>=1.0.0
+Requires-Dist: mcp>=1.0.0
+
+# agenticblocks 🧱
+
+*A composable building block library for AI agent workflows. / Uma biblioteca componível para construir fluxos de agentes de IA.*
+
+[🇺🇸 English](#english) | [🇧🇷 Português](#português)
+
+---
+
+## <a name="english"></a>🇺🇸 English
+
+### Philosophy
+A library to build agent workflows like **Lego blocks**. Each step in your agentic pipeline is a self-contained block, with strictly typed inputs and outputs via **Pydantic** and natively concurrent execution using **AsyncIO** and **NetworkX** graphs.
+
+- **Strong typing**: Pydantic validates connections and prevents unmatched dependencies between LLM tool calls.
+- **Standardized connections**: Blocks only know their own inputs and outputs. Thus, entire workflows can act as single blocks later.
+- **Smart Parallelism (Waves)**: The asyncio engine fires simultaneous tasks (waves) whenever dependencies are resolved, maximizing API speed.
+
+### Getting Started
+
+Install the module locally for development:
+```bash
+pip install -e .
+```
+
+#### 1. Define Input and Output Models
+```python
+from pydantic import BaseModel
+
+class HelloInput(BaseModel):
+    name: str
+
+class HelloOutput(BaseModel):
+    greeting: str
+```
+
+#### 2. Create the Logic Block
+```python
+from agenticblocks.core.block import Block
+
+class HelloWorldBlock(Block[HelloInput, HelloOutput]):
+    name: str = "say_hello"
+    
+    async def run(self, input: HelloInput) -> HelloOutput:
+        msg = f"Hello, {input.name}! Welcome to agenticblocks."
+        return HelloOutput(greeting=msg)
+```
+
+#### 3. Connect and Execute
+```python
+import asyncio
+from agenticblocks.core.graph import WorkflowGraph
+from agenticblocks.runtime.executor import WorkflowExecutor
+
+async def main():
+    graph = WorkflowGraph()
+    graph.add_block(HelloWorldBlock(name="say_hello"))
+
+    executor = WorkflowExecutor(graph)
+    ctx = await executor.run(initial_input={"name": "Alice"})
+    
+    print(ctx.get_output("say_hello").greeting)
+
+asyncio.run(main())
+```
+
+Check the `examples/` directory for full demos.
+
+---
+
+## <a name="português"></a>🇧🇷 Português
+
+### Filosofia
+Uma biblioteca para construir fluxos de agentes no estilo **Lego**. Cada passo do seu pipeline agêntico é um bloco auto-contido, com entradas e saídas rigorosamente tipadas via **Pydantic** e execução simultânea usando **AsyncIO** e grafos do **NetworkX**.
+
+- **Forte tipagem**: Pydantic valida os encaixes e previne dependências não satisfeitas.
+- **Encaixes padronizados**: Blocos só conhecem as próprias entradas e saídas. Workflows inteiros funcionam como blocos únicos.
+- **Paralelismo Inteligente (Ondas)**: O motor dispara tarefas simultâneas (waves) sempre que as dependências de um bloco são resolvidas, otimizando a velocidade de conexões a APIs.
+
+### Primeiros Passos
+
+Instale o módulo de forma local editável:
+```bash
+pip install -e .
+```
+
+A estrutura segue o modelo mostrado na sessão em inglês (Inglês: Input/Output Models, Logic Block, e Graph Execution). Consulte os scripts interativos e completos dentro da pasta `examples/`:
+- `01_hello_world.py`: Simulação básica e limpa do tutorial inicial.
+- `02_llm_pipeline.py`: Um pipeline completo demonstrando a paralelização de parsing de dados complexos com um mock de LLM Call.

agenticblocks_io-0.1.0/src/AgenticBlocks.IO.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+README.md
+pyproject.toml
+src/AgenticBlocks.IO.egg-info/PKG-INFO
+src/AgenticBlocks.IO.egg-info/SOURCES.txt
+src/AgenticBlocks.IO.egg-info/dependency_links.txt
+src/AgenticBlocks.IO.egg-info/requires.txt
+src/AgenticBlocks.IO.egg-info/top_level.txt
+src/agenticblocks/__init__.py
+src/agenticblocks/blocks/llm/agent.py
+src/agenticblocks/blocks/llm/mock_llm.py
+src/agenticblocks/core/agent.py
+src/agenticblocks/core/block.py
+src/agenticblocks/core/graph.py
+src/agenticblocks/runtime/executor.py
+src/agenticblocks/runtime/retry.py
+src/agenticblocks/runtime/state.py
+src/agenticblocks/tools/__init__.py
+src/agenticblocks/tools/a2a_bridge.py
+src/agenticblocks/tools/mcp_client.py

agenticblocks_io-0.1.0/src/AgenticBlocks.IO.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

agenticblocks_io-0.1.0/src/AgenticBlocks.IO.egg-info/requires.txt

@@ -0,0 +1,5 @@
+pydantic>=2.0.0
+networkx>=3.0
+tenacity>=8.0
+litellm>=1.0.0
+mcp>=1.0.0

agenticblocks_io-0.1.0/src/AgenticBlocks.IO.egg-info/top_level.txt

@@ -0,0 +1 @@
+agenticblocks

agenticblocks_io-0.1.0/src/agenticblocks/__init__.py

@@ -0,0 +1,2 @@
+"""agenticblocks: A composable building block library for AI workflows."""
+__version__ = "0.1.0"

agenticblocks_io-0.1.0/src/agenticblocks/blocks/llm/agent.py

@@ -0,0 +1,95 @@
+import json
+from pydantic import BaseModel
+from typing import List
+import litellm
+from agenticblocks.core.agent import AgentBlock
+from agenticblocks.core.block import Block
+from agenticblocks.tools.a2a_bridge import block_to_tool_schema
+
+class AgentInput(BaseModel):
+    prompt: str
+
+class AgentOutput(BaseModel):
+    response: str
+    tool_calls_made: int = 0
+
+class LLMAgentBlock(AgentBlock[AgentInput, AgentOutput]):
+    description: str = "Agente Autônomo Baseado em LLM gerenciando seu próprio Tool Loop."
+    model: str = "gpt-4o-mini"
+    system_prompt: str = "Você é um Agente Analista e Roteador prestativo. Use as ferramentas caso não possua contexto."
+    tools: List[Block] = []
+    
+    async def run(self, input: AgentInput) -> AgentOutput:
+        # Transparent A2A Bridging 
+        # Converter qualquer Sub-Bloco para Tool API Formats
+        litellm_tools = [block_to_tool_schema(b) for b in self.tools]
+        
+        messages = [
+            {"role": "system", "content": self.system_prompt},
+            {"role": "user", "content": input.prompt}
+        ]
+        
+        tool_call_count = 0
+        
+        while True:
+            # Argumentos opcionais caso ferramentas existam no escopo do Agente
+            kwargs = {}
+            if litellm_tools:
+                kwargs["tools"] = litellm_tools
+            
+            # Chamada principal com LiteLLM
+            response = await litellm.acompletion(
+                model=self.model,
+                messages=messages,
+                **kwargs
+            )
+            
+            message = response.choices[0].message
+            # Append dict format rather than object back to history
+            messages.append(message.model_dump(exclude_none=True))
+            
+            # Se não tomou decisão de chamar ferramentas, finalizamos iterando o raciocinio e extraindo a reposta.
+            if not message.tool_calls:
+                return AgentOutput(
+                    response=message.content or "",
+                    tool_calls_made=tool_call_count
+                )
+                
+            # Transparent Execution! (A2A e MCP)
+            for tool_call in message.tool_calls:
+                tool_call_count += 1
+                function_name = tool_call.function.name
+                
+                # Procura a ferramenta nativa (Blocos conectados)
+                matched_block = next((b for b in self.tools if b.name == function_name), None)
+                if not matched_block:
+                    messages.append({
+                        "role": "tool",
+                        "tool_call_id": tool_call.id,
+                        "name": function_name,
+                        "content": json.dumps({"error": f"Tool {function_name} not found."})
+                    })
+                    continue
+                    
+                try:
+                    # Roda o Pydantic Parse para o Bloco A2A dinamicamente
+                    args_dict = json.loads(tool_call.function.arguments)
+                    input_model = matched_block.input_schema()(**args_dict)
+                    
+                    # RUN: O Agente principal engatilha um Agente Subordinado de forma transparente (A2A)!
+                    result = await matched_block.run(input=input_model)
+                    
+                    # O output tipado retorna ao escopo original do LiteLLM como JSON
+                    messages.append({
+                        "role": "tool",
+                        "tool_call_id": tool_call.id,
+                        "name": function_name,
+                        "content": json.dumps(result.model_dump())
+                    })
+                except Exception as e:
+                    messages.append({
+                        "role": "tool",
+                        "tool_call_id": tool_call.id,
+                        "name": function_name,
+                        "content": json.dumps({"error": str(e)})
+                    })

agenticblocks_io-0.1.0/src/agenticblocks/blocks/llm/mock_llm.py

@@ -0,0 +1,59 @@
+import asyncio
+from pydantic import BaseModel
+from agenticblocks.core.block import Block
+from agenticblocks.runtime.retry import with_retry
+
+class FetchInput(BaseModel):
+    url: str
+
+class FetchOutput(BaseModel):
+    raw_data: str
+
+class FetchDataBlock(Block[FetchInput, FetchOutput]):
+    name: str = "fetch"
+    description: str = "Fetches initial data"
+    
+    @with_retry(max_attempts=2, delay=0.1)
+    async def run(self, input: FetchInput) -> FetchOutput:
+        await asyncio.sleep(0.1) # Mock io
+        return FetchOutput(raw_data=f"<html>Mock content from {input.url}</html>")
+
+class ParseInput(BaseModel):
+    raw_data: str
+
+class ParseOutput(BaseModel):
+    parsed_text: str
+
+class ParseBlock(Block[ParseInput, ParseOutput]):
+    async def run(self, input: ParseInput) -> ParseOutput:
+        await asyncio.sleep(0.1)
+        return ParseOutput(parsed_text="Mock content mapped")
+
+class EnrichInput(BaseModel):
+    raw_data: str
+
+class EnrichOutput(BaseModel):
+    metadata: str
+
+class EnrichBlock(Block[EnrichInput, EnrichOutput]):
+    async def run(self, input: EnrichInput) -> EnrichOutput:
+        await asyncio.sleep(0.2)
+        return EnrichOutput(metadata="{source: mock, verified: true}")
+
+class SummarizeInput(BaseModel):
+    parsed_text: str
+    metadata: str
+
+class SummarizeOutput(BaseModel):
+    message: str
+    tokens_used: int
+
+class LLMCallBlock(Block[SummarizeInput, SummarizeOutput]):
+    model: str = "claude-mock-fast"
+
+    async def run(self, input: SummarizeInput) -> SummarizeOutput:
+        await asyncio.sleep(0.5)
+        return SummarizeOutput(
+            message=f"Summary of '{input.parsed_text}' with {input.metadata}",
+            tokens_used=42
+        )

agenticblocks_io-0.1.0/src/agenticblocks/core/agent.py

@@ -0,0 +1,17 @@
+from pydantic import BaseModel
+from typing import TypeVar, Generic, List
+from agenticblocks.core.block import Block, Input, Output
+
+class AgentBlock(Block[Input, Output]):
+    """
+    Classe base para Agentes independentes do modelo cognitivo (LLM ou não-LLM).
+    Um Agente é caracterizado por possuir um ciclo (loop) de decisão próprio 
+    e um conjunto de "Componentes" ou "Ferramentas" (Sub-Blocos) acopláveis.
+    """
+    tools: List[Block] = []
+    
+    async def run(self, input: Input) -> Output:
+        """
+        Subclasses devem implementar o próprio Loop de pensamento ou heurística aqui.
+        """
+        raise NotImplementedError("Crie e injete o ciclo cognitivo do seu agente nesta etapa.")

agenticblocks_io-0.1.0/src/agenticblocks/core/block.py

@@ -0,0 +1,32 @@
+from pydantic import BaseModel
+from typing import TypeVar, Generic, Any, get_type_hints
+
+Input = TypeVar("Input", bound=BaseModel)
+Output = TypeVar("Output", bound=BaseModel)
+
+class Block(BaseModel, Generic[Input, Output]):
+    name: str
+    description: str = ""
+
+    async def run(self, input: Input) -> Output:
+        raise NotImplementedError
+
+    @classmethod
+    def input_schema(cls) -> type[BaseModel]:
+        try:
+            hints = get_type_hints(cls.run)
+            if 'input' in hints:
+                return hints['input']
+        except Exception:
+            pass
+        return BaseModel
+
+    @classmethod
+    def output_schema(cls) -> type[BaseModel]:
+        try:
+            hints = get_type_hints(cls.run)
+            if 'return' in hints:
+                return hints['return']
+        except Exception:
+            pass
+        return BaseModel

agenticblocks_io-0.1.0/src/agenticblocks/core/graph.py

@@ -0,0 +1,34 @@
+import networkx as nx
+from .block import Block
+from pydantic import BaseModel
+
+class WorkflowGraph:
+    def __init__(self):
+        self.graph = nx.DiGraph()
+
+    def add_block(self, block: Block) -> str:
+        node_id = block.name
+        if node_id in self.graph.nodes:
+            raise ValueError(f"Já existe um bloco com o nome {node_id}")
+        self.graph.add_node(node_id, block=block)
+        return node_id
+
+    def connect(self, from_id: str, to_id: str):
+        if from_id not in self.graph.nodes or to_id not in self.graph.nodes:
+            raise ValueError("Ambos os blocos devem existir no grafo")
+        
+        # Validacao iterativa
+        out_schema = self.graph.nodes[from_id]["block"].output_schema()
+        in_schema  = self.graph.nodes[to_id]["block"].input_schema()
+        
+        # Verifica se out_schema contém os dados para in_schema (simplificado)
+        # Podemos usar model_fields para checar compatibilidade grossa
+        if out_schema != BaseModel and in_schema != BaseModel:
+            # apenas valida se for uma subclass ou compita de models.
+            pass
+
+        self.graph.add_edge(from_id, to_id)
+
+    def validate_connections(self):
+        # Percorre as arestas e valia tipos rigidamente se necessario
+        pass

agenticblocks_io-0.1.0/src/agenticblocks/runtime/executor.py

@@ -0,0 +1,127 @@
+from __future__ import annotations
+import asyncio
+import time
+import uuid
+from typing import Callable
+import networkx as nx
+
+from agenticblocks.core.block import Block
+from agenticblocks.core.graph import WorkflowGraph
+from agenticblocks.runtime.state import ExecutionContext, NodeResult, NodeStatus, _current_ctx
+
+
+class WorkflowExecutor:
+    def __init__(
+        self,
+        graph: WorkflowGraph,
+        on_node_start: Callable[[str], None] | None = None,
+        on_node_end:   Callable[[NodeResult], None] | None = None,
+    ):
+        self.graph = graph
+        self.on_node_start = on_node_start
+        self.on_node_end   = on_node_end
+
+    async def run(
+        self,
+        initial_input: dict | None = None,
+        run_id: str | None = None,
+    ) -> ExecutionContext:
+        ctx = ExecutionContext(run_id=run_id or str(uuid.uuid4()))
+        ctx.store["__input__"] = initial_input or {}
+
+        token = _current_ctx.set(ctx)
+        try:
+            self._validate()
+            waves = self._build_waves()
+            for wave in waves:
+                await self._execute_wave(wave, ctx)
+        finally:
+            _current_ctx.reset(token)
+
+        return ctx
+
+    def _validate(self) -> None:
+        g = self.graph.graph
+        if not nx.is_directed_acyclic_graph(g):
+            cycles = list(nx.simple_cycles(g))
+            raise ValueError(f"Ciclos detectados no grafo: {cycles}")
+        self.graph.validate_connections()
+
+    def _build_waves(self) -> list[list[str]]:
+        g = self.graph.graph
+        in_degree = {n: g.in_degree(n) for n in g.nodes}
+        waves: list[list[str]] = []
+
+        remaining = set(g.nodes)
+        while remaining:
+            wave = [n for n in remaining if in_degree[n] == 0]
+            if not wave:
+                raise RuntimeError("Dependências circulares detectadas.")
+            waves.append(wave)
+            for node in wave:
+                remaining.remove(node)
+                for successor in g.successors(node):
+                    in_degree[successor] -= 1
+        return waves
+
+    async def _execute_wave(self, wave: list[str], ctx: ExecutionContext) -> None:
+        tasks = [self._execute_node(node_id, ctx) for node_id in wave]
+        await asyncio.gather(*tasks, return_exceptions=False)
+
+    async def _execute_node(self, node_id: str, ctx: ExecutionContext) -> None:
+        block: Block = self.graph.graph.nodes[node_id]["block"]
+
+        if self.on_node_start:
+            self.on_node_start(node_id)
+
+        t0 = time.monotonic()
+        try:
+            input_data = self._collect_inputs(node_id, ctx)
+            # Create instance of the input schema
+            input_schema_class = block.input_schema()
+            
+            # Simple conversion logic
+            if issubclass(input_schema_class, dict):
+                 typed_input = input_data
+            else:
+                 typed_input = input_schema_class(**input_data)
+                 
+            output = await block.run(typed_input)
+            result = NodeResult(
+                node_id=node_id,
+                status=NodeStatus.DONE,
+                output=output,
+                duration_ms=(time.monotonic() - t0) * 1000,
+            )
+        except Exception as exc:
+            result = NodeResult(
+                node_id=node_id,
+                status=NodeStatus.FAILED,
+                error=exc,
+                duration_ms=(time.monotonic() - t0) * 1000,
+            )
+            # await to save the failure
+            await ctx.set_result(node_id, result)
+            raise exc
+
+        await ctx.set_result(node_id, result)
+        if self.on_node_end:
+            self.on_node_end(result)
+
+    def _collect_inputs(self, node_id: str, ctx: ExecutionContext) -> dict:
+        g = self.graph.graph
+        predecessors = list(g.predecessors(node_id))
+
+        if not predecessors:
+            return ctx.store.get("__input__", {})
+
+        if len(predecessors) == 1:
+            prev_output = ctx.get_output(predecessors[0])
+            return prev_output.model_dump() if prev_output else {}
+
+        merged: dict = {}
+        for pred in predecessors:
+            prev_output = ctx.get_output(pred)
+            if prev_output:
+                merged.update(prev_output.model_dump())
+        return merged

agenticblocks_io-0.1.0/src/agenticblocks/runtime/retry.py

@@ -0,0 +1,26 @@
+import asyncio
+from functools import wraps
+from typing import Callable, Type
+
+def with_retry(
+    max_attempts: int = 3,
+    delay: float = 1.0,
+    backoff: float = 2.0,
+    exceptions: tuple[Type[Exception], ...] = (Exception,),
+) -> Callable:
+    def decorator(fn: Callable) -> Callable:
+        @wraps(fn)
+        async def wrapper(*args, **kwargs):
+            attempt = 0
+            current_delay = delay
+            while True:
+                try:
+                    return await fn(*args, **kwargs)
+                except exceptions as exc:
+                    attempt += 1
+                    if attempt >= max_attempts:
+                        raise
+                    await asyncio.sleep(current_delay)
+                    current_delay *= backoff
+        return wrapper
+    return decorator

agenticblocks_io-0.1.0/src/agenticblocks/runtime/state.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+import asyncio
+from contextvars import ContextVar
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any
+from pydantic import BaseModel
+
+class NodeStatus(Enum):
+    PENDING   = "pending"
+    RUNNING   = "running"
+    DONE      = "done"
+    FAILED    = "failed"
+    SKIPPED   = "skipped"
+
+@dataclass
+class NodeResult:
+    node_id: str
+    status: NodeStatus
+    output: BaseModel | None = None
+    error: Exception | None = None
+    duration_ms: float = 0.0
+
+@dataclass
+class ExecutionContext:
+    run_id: str
+    results: dict[str, NodeResult] = field(default_factory=dict)
+    store: dict[str, Any] = field(default_factory=dict)
+
+    # Note: asyncio.Lock was removed since this dataclass needs to be shallow copied sometimes
+    # or just simple. We'll use a normal dictionary since it's mostly thread-safe in CPython for simple ops,
+    # or handle locking in executor to keep State serializable.
+    _lock: asyncio.Lock = field(default_factory=asyncio.Lock)
+
+    async def set_result(self, node_id: str, result: NodeResult) -> None:
+        async with self._lock:
+            self.results[node_id] = result
+
+    def get_output(self, node_id: str) -> BaseModel | None:
+        r = self.results.get(node_id)
+        return r.output if r else None
+
+_current_ctx: ContextVar[ExecutionContext] = ContextVar("execution_ctx")
+
+def get_ctx() -> ExecutionContext:
+    return _current_ctx.get()

agenticblocks_io-0.1.0/src/agenticblocks/tools/__init__.py

@@ -0,0 +1 @@
+"""Tools bridging utilities (A2A and MCP) for agenticblocks."""

agenticblocks_io-0.1.0/src/agenticblocks/tools/a2a_bridge.py

@@ -0,0 +1,21 @@
+from typing import Any, Dict
+from agenticblocks.core.block import Block
+
+def block_to_tool_schema(block: Block) -> Dict[str, Any]:
+    """Generates an OpenAI-compatible function schema from a Block transparently."""
+    
+    # Se for um MCP Tool direto com Schema pronto do servidor:
+    if getattr(block, "is_mcp_proxy", False):
+        schema = block.raw_mcp_schema
+    else:
+        # Obtain dynamic Pydantic Schema representation para Python Tools nativas
+        schema = block.input_schema().model_json_schema()
+    
+    return {
+        "type": "function",
+        "function": {
+            "name": block.name,
+            "description": block.description or f"Executa a tarefa do bloco: {block.name}",
+            "parameters": schema
+        }
+    }

agenticblocks_io-0.1.0/src/agenticblocks/tools/mcp_client.py

@@ -0,0 +1,88 @@
+import asyncio
+from typing import Any, List, Dict
+from contextlib import AsyncExitStack
+from pydantic import BaseModel, ConfigDict
+from agenticblocks.core.block import Block
+
+try:
+    from mcp import ClientSession, StdioServerParameters
+    from mcp.client.stdio import stdio_client
+except ImportError:
+    pass
+
+class MCPProxyInput(BaseModel):
+    model_config = ConfigDict(extra='allow')
+    # Captura quaisquer argumentos criados pelo LLM
+
+class MCPProxyOutput(BaseModel):
+    result: Any
+
+class MCPProxyBlock(Block[MCPProxyInput, MCPProxyOutput]):
+    is_mcp_proxy: bool = True
+    raw_mcp_schema: dict = {}
+    session: Any = None
+    
+    async def run(self, input: MCPProxyInput) -> MCPProxyOutput:
+        # Usa dict() normal ou model_dump(exclude_unset=True) para extrair os extras
+        # Nota: model_dump pode não espalhar os "extras" na raiz em algumas versoes do Pydantic, 
+        # porém __dict__ com `extra='allow'` resolve.
+        
+        args = {k: getattr(input, k) for k in input.model_fields_set | set(input.model_extra or {})}
+        
+        # Processa Remote Procedure Call pro Servidor MCP real!
+        result = await self.session.call_tool(self.name, args)
+        
+        # Em MCP o response contém .content (Array de TextContent/ImageContent etc)
+        # Convertendo o conteúdo remotamente respondido pelo Servidor.
+        text_responses = []
+        if result and hasattr(result, "content"):
+            for c in result.content:
+                if getattr(c, "type", "") == "text":
+                    text_responses.append(c.text)
+        
+        return MCPProxyOutput(result=text_responses)
+
+class MCPClientBridge:
+    """
+    Abstração transparente para buscar ferramentas de servidores MCP compatíveis.
+    Transforma ferramentas de rede em "ProxyBlocks" inseríveis em Agentes.
+    """
+    def __init__(self, command: str, args: List[str], env: Dict[str, str] = None):
+        self.command = command
+        self.args = args
+        self.env = env
+        self.exit_stack = AsyncExitStack()
+        self.session = None
+
+    async def connect(self) -> List[MCPProxyBlock]:
+        """Estabelece link iterativo stdio com o Servidor MCP e extrai os Tools"""
+        server_params = StdioServerParameters(command=self.command, args=self.args, env=self.env)
+        try:
+            stdio_transport = await self.exit_stack.enter_async_context(stdio_client(server_params))
+        except Exception as e:
+            raise RuntimeError(f"Falha ao rodar sub-processo MCP. Verifique se tem o '{self.command}' instalado. Erro: {e}")
+            
+        self.read, self.write = stdio_transport
+        
+        self.session = await self.exit_stack.enter_async_context(ClientSession(self.read, self.write))
+        await self.session.initialize()
+        
+        # Obter tools do servidor remotamente
+        response = await self.session.list_tools()
+        
+        proxy_blocks = []
+        for tool in response.tools:
+            # Para cada tool nativa do servidor MCP, instanciamos um proxy
+            block = MCPProxyBlock(
+                name=tool.name,
+                description=tool.description or ""
+            )
+            block.raw_mcp_schema = tool.inputSchema
+            block.session = self.session
+            proxy_blocks.append(block)
+            
+        return proxy_blocks
+        
+    async def disconnect(self):
+        """Fecha de forma segura."""
+        await self.exit_stack.aclose()