sync main to staging

.github/workflows/ci.yml

@@ -79,9 +79,31 @@ jobs:
       - name: Validate exported agents
         run: |
           # Check that agent exports have valid structure
-          for agent_dir in exports/*/; do
+          if [ ! -d "exports" ]; then
+            echo "No exports/ directory found, skipping validation"
+            exit 0
+          fi
+
+          shopt -s nullglob
+          agent_dirs=(exports/*/)
+          shopt -u nullglob
+
+          if [ ${#agent_dirs[@]} -eq 0 ]; then
+            echo "No agent directories in exports/, skipping validation"
+            exit 0
+          fi
+
+          validated=0
+          for agent_dir in "${agent_dirs[@]}"; do
             if [ -f "$agent_dir/agent.json" ]; then
               echo "Validating $agent_dir"
               python -c "import json; json.load(open('$agent_dir/agent.json'))"
+              validated=$((validated + 1))
             fi
           done
+
+          if [ "$validated" -eq 0 ]; then
+            echo "No agent.json files found in exports/, skipping validation"
+          else
+            echo "Validated $validated agent(s)"
+          fi

CHANGELOG.md

@@ -25,8 +25,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Removed
 - N/A
 
+
 ### Fixed
-- N/A
+- tools: Fixed web_scrape tool attempting to parse non-HTML content (PDF, JSON) as HTML (#487)
 
 ### Security
 - N/A

README.md

@@ -331,7 +331,7 @@ No. Aden is built from the ground up with no dependencies on LangChain, CrewAI,
 
 **Q: What LLM providers does Aden support?**
 
-Aden supports 100+ LLM providers through LiteLLM integration, including OpenAI (GPT-4, GPT-4o), Anthropic (Claude models), Google Gemini, Mistral, Groq, and many more. Simply set the appropriate API key environment variable and specify the model name.
+Aden supports 100+ LLM providers through LiteLLM integration, including OpenAI (GPT-4, GPT-4o), Anthropic (Claude models), Google Gemini, DeepSeek, Mistral, Groq, and many more. Simply set the appropriate API key environment variable and specify the model name.
 
 **Q: Can I use Aden with local AI models like Ollama?**
 

core/framework/graph/executor.py

@@ -9,6 +9,7 @@
 5. Returns the final result
 """
 
+import asyncio
 import logging
 from collections.abc import Callable
 from dataclasses import dataclass, field
@@ -118,11 +119,13 @@ def _validate_tools(self, graph: GraphSpec) -> list[str]:
             if node.tools:
                 missing = set(node.tools) - available_tool_names
                 if missing:
-                    avail = sorted(available_tool_names) if available_tool_names else "none"
+                    available = (
+                        sorted(available_tool_names) if available_tool_names else "none"
+                    )
                     errors.append(
                         f"Node '{node.name}' (id={node.id}) requires tools "
                         f"{sorted(missing)} but they are not registered. "
-                        f"Available tools: {avail}"
+                        f"Available tools: {available}"
                     )
 
         return errors
@@ -164,7 +167,7 @@ async def execute(
                 success=False,
                 error=(
                     f"Missing tools: {'; '.join(tool_errors)}. "
-                    "Register tools via ToolRegistry or remove tool declarations."
+                    "Register tools via ToolRegistry or remove tool declarations from nodes."
                 ),
             )
 
@@ -174,16 +177,19 @@ async def execute(
         # Restore session state if provided
         if session_state and "memory" in session_state:
             memory_data = session_state["memory"]
-            if isinstance(memory_data, dict):
-                # Restore memory from previous session
-                for key, value in memory_data.items():
-                    memory.write(key, value)
-                self.logger.info(f"📥 Restored session state with {len(memory_data)} memory keys")
-            else:
+            # [RESTORED] Type safety check
+            if not isinstance(memory_data, dict):
                 self.logger.warning(
                     f"⚠️ Invalid memory data type in session state: "
                     f"{type(memory_data).__name__}, expected dict"
                 )
+            else:
+                # Restore memory from previous session
+                for key, value in memory_data.items():
+                    memory.write(key, value)
+                self.logger.info(
+                    f"📥 Restored session state with {len(memory_data)} memory keys"
+                )
 
         # Write new input data to memory (each key individually)
         if input_data:
@@ -319,40 +325,52 @@ async def execute(
                         node_retry_counts.get(current_node_id, 0) + 1
                     )
 
-                    if node_retry_counts[current_node_id] < node_spec.max_retries:
+                    # [CORRECTED] Use node_spec.max_retries instead of hardcoded 3
+                    max_retries = getattr(node_spec, "max_retries", 3)
+
+                    if node_retry_counts[current_node_id] < max_retries:
                         # Retry - don't increment steps for retries
                         steps -= 1
+
+                        # --- EXPONENTIAL BACKOFF ---
                         retry_count = node_retry_counts[current_node_id]
+                        # Backoff formula: 1.0 * (2^(retry - 1)) -> 1s, 2s, 4s...
+                        delay = 1.0 * (2 ** (retry_count - 1))
+                        self.logger.info(f"   Using backoff: Sleeping {delay}s before retry...")
+                        await asyncio.sleep(delay)
+                        # --------------------------------------
+
                         self.logger.info(
-                            f"   ↻ Retrying ({retry_count}/{node_spec.max_retries})..."
+                            f"   ↻ Retrying ({node_retry_counts[current_node_id]}/"
+                            f"{max_retries})..."
                         )
                         continue
                     else:
                         # Max retries exceeded - fail the execution
                         self.logger.error(
-                            f"   ✗ Max retries ({node_spec.max_retries}) exceeded "
-                            f"for node {current_node_id}"
+                            f"   ✗ Max retries ({max_retries}) "
+                            f"exceeded for node {current_node_id}"
                         )
                         self.runtime.report_problem(
                             severity="critical",
                             description=(
                                 f"Node {current_node_id} failed after "
-                                f"{node_spec.max_retries} attempts: {result.error}"
+                                f"{max_retries} attempts: {result.error}"
                             ),
                         )
                         self.runtime.end_run(
                             success=False,
                             output_data=memory.read_all(),
                             narrative=(
                                 f"Failed at {node_spec.name} after "
-                                f"{node_spec.max_retries} retries: {result.error}"
+                                f"{max_retries} retries: {result.error}"
                             ),
                         )
                         return ExecutionResult(
                             success=False,
                             error=(
                                 f"Node '{node_spec.name}' failed after "
-                                f"{node_spec.max_retries} attempts: {result.error}"
+                                f"{max_retries} attempts: {result.error}"
                             ),
                             output=memory.read_all(),
                             steps_executed=steps,
@@ -557,8 +575,12 @@ def _follow_edges(
                 memory=memory.read_all(),
                 llm=self.llm,
                 goal=goal,
-                source_node_name=current_node_spec.name if current_node_spec else current_node_id,
-                target_node_name=target_node_spec.name if target_node_spec else edge.target,
+                source_node_name=current_node_spec.name
+                if current_node_spec
+                else current_node_id,
+                target_node_name=target_node_spec.name
+                if target_node_spec
+                else edge.target,
             ):
                 # Validate and clean output before mapping inputs
                 if self.cleansing_config.enabled and target_node_spec:
@@ -571,7 +593,9 @@ def _follow_edges(
                     )
 
                     if not validation.valid:
-                        self.logger.warning(f"⚠ Output validation failed: {validation.errors}")
+                        self.logger.warning(
+                            f"⚠ Output validation failed: {validation.errors}"
+                        )
 
                         # Clean the output
                         cleaned_output = self.output_cleaner.clean_output(
@@ -596,14 +620,16 @@ def _follow_edges(
                         )
 
                         if revalidation.valid:
-                            self.logger.info("✓ Output cleaned and validated successfully")
+                            self.logger.info(
+                                "✓ Output cleaned and validated successfully"
+                            )
                         else:
                             self.logger.error(
                                 f"✗ Cleaning failed, errors remain: {revalidation.errors}"
                             )
                             # Continue anyway if fallback_to_raw is True
 
-                # Map inputs
+                # Map inputsss
                 mapped = edge.map_inputs(result.output, memory.read_all())
                 for key, value in mapped.items():
                     memory.write(key, value)

core/framework/graph/node.py

@@ -19,9 +19,9 @@
 from abc import ABC, abstractmethod
 from collections.abc import Callable
 from dataclasses import dataclass, field
-from typing import Any, Type
+from typing import Any
 
-from pydantic import BaseModel, Field, ValidationError
+from pydantic import BaseModel, Field
 
 from framework.llm.provider import LLMProvider, Tool
 from framework.runtime.core import Runtime
@@ -145,9 +145,12 @@ class NodeSpec(BaseModel):
     retry_on: list[str] = Field(default_factory=list, description="Error types to retry on")
 
     # Pydantic model for output validation
-    output_model: Type[BaseModel] | None = Field(
+    output_model: type[BaseModel] | None = Field(
         default=None,
-        description="Optional Pydantic model class for validating and parsing LLM output. When set, the LLM response will be validated against this model."
+        description=(
+            "Optional Pydantic model class for validating and parsing LLM output. "
+            "When set, the LLM response will be validated against this model."
+        ),
     )
     max_validation_retries: int = Field(
         default=2,
@@ -355,7 +358,7 @@ class NodeResult:
     # Metadata
     tokens_used: int = 0
     latency_ms: int = 0
-    
+
     # Pydantic validation errors (if any)
     validation_errors: list[str] = field(default_factory=list)
 
@@ -622,10 +625,12 @@ def executor(tool_use: ToolUse) -> ToolResult:
                             "strict": True,
                         }
                     }
-                    logger.info(f"         📐 Using JSON schema from Pydantic model: {ctx.node_spec.output_model.__name__}")
+                    model_name = ctx.node_spec.output_model.__name__
+                    logger.info(f"         📐 Using JSON schema from Pydantic model: {model_name}")
 
                 # Phase 2: Retry loop for Pydantic validation
-                max_validation_retries = ctx.node_spec.max_validation_retries if ctx.node_spec.output_model else 0
+                max_retries = ctx.node_spec.max_validation_retries
+                max_validation_retries = max_retries if ctx.node_spec.output_model else 0
                 validation_attempt = 0
                 total_input_tokens = 0
                 total_output_tokens = 0
@@ -668,7 +673,8 @@ def executor(tool_use: ToolUse) -> ToolResult:
 
                             if validation_result.success:
                                 # Validation passed, break out of retry loop
-                                logger.info(f"      ✓ Pydantic validation passed for {ctx.node_spec.output_model.__name__}")
+                                model_name = ctx.node_spec.output_model.__name__
+                                logger.info(f"      ✓ Pydantic validation passed for {model_name}")
                                 break
                             else:
                                 # Validation failed
@@ -680,10 +686,11 @@ def executor(tool_use: ToolUse) -> ToolResult:
                                         validation_result, ctx.node_spec.output_model
                                     )
                                     logger.warning(
-                                        f"      ⚠ Pydantic validation failed (attempt {validation_attempt}/{max_validation_retries}): "
+                                        f"      ⚠ Pydantic validation failed "
+                                        f"(attempt {validation_attempt}/{max_validation_retries}): "
                                         f"{validation_result.error}"
                                     )
-                                    logger.info(f"      🔄 Retrying with validation feedback...")
+                                    logger.info("      🔄 Retrying with validation feedback...")
 
                                     # Add the assistant's failed response and feedback
                                     current_messages.append({
@@ -698,9 +705,10 @@ def executor(tool_use: ToolUse) -> ToolResult:
                                 else:
                                     # Max retries exceeded
                                     latency_ms = int((time.time() - start) * 1000)
+                                    err = validation_result.error
                                     logger.error(
-                                        f"      ✗ Pydantic validation failed after {max_validation_retries} retries: "
-                                        f"{validation_result.error}"
+                                        f"      ✗ Pydantic validation failed after "
+                                        f"{max_validation_retries} retries: {err}"
                                     )
                                     ctx.runtime.record_outcome(
                                         decision_id=decision_id,
@@ -709,9 +717,13 @@ def executor(tool_use: ToolUse) -> ToolResult:
                                         tokens_used=total_input_tokens + total_output_tokens,
                                         latency_ms=latency_ms,
                                     )
+                                    error_msg = (
+                                        f"Pydantic validation failed after "
+                                        f"{max_validation_retries} retries: {err}"
+                                    )
                                     return NodeResult(
                                         success=False,
-                                        error=f"Pydantic validation failed after {max_validation_retries} retries: {validation_result.error}",
+                                        error=error_msg,
                                         output=parsed,
                                         tokens_used=total_input_tokens + total_output_tokens,
                                         latency_ms=latency_ms,
@@ -760,7 +772,7 @@ def executor(tool_use: ToolUse) -> ToolResult:
                             # Use validated model's dict representation
                             if validated_model:
                                 parsed = validated_model.model_dump()
-                        
+
                         for key in ctx.node_spec.output_keys:
                             if key in parsed:
                                 value = parsed[key]