agentnova 0.3.4__tar.gz → 0.3.6__tar.gz

{agentnova-0.3.4 → agentnova-0.3.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentnova
-Version: 0.3.4
+Version: 0.3.6
 Summary: ⚛️ AgentNova - A minimal, hackable agentic framework for local LLM inference
 Author-email: VTSTech <veritas@vts-tech.org>
 Maintainer-email: VTSTech <veritas@vts-tech.org>
@@ -32,7 +32,7 @@ Requires-Dist: black>=23.0; extra == "dev"
 Requires-Dist: ruff>=0.1.0; extra == "dev"
 Dynamic: license-file
 
-# ⚛️ AgentNova R03.3
+# ⚛️ AgentNova R03.6
 
 **Status: Alpha**
 
@@ -49,7 +49,7 @@ Inspired by the architecture of OpenClaw, rebuilt from scratch for local-first o
 
 [![License](https://img.shields.io/badge/License-MIT-blue)](#license) [![Go to Python website](https://img.shields.io/badge/dynamic/toml?url=https%3A%2F%2Fraw.githubusercontent.com%2FVTSTech%2FAgentNova%2Frefs%2Fheads%2Fmain%2Fpyproject.toml&query=project.requires-python&label=python&logo=python&logoColor=white)](https://python.org)
 
-<img width="1400" height="1001" alt="image" src="https://github.com/user-attachments/assets/1bc8fb7a-415b-4750-9ce2-1e721bbf9149" />
+<img width="1378" height="996" alt="image" src="https://github.com/user-attachments/assets/0fe69695-73d9-4ce1-999f-08443f879971" />
 
 ## 📚 Documentation
 
@@ -71,6 +71,7 @@ Inspired by the architecture of OpenClaw, rebuilt from scratch for local-first o
 - **Soul Spec v0.5** — Persona packages with progressive disclosure
 - **ACP v1.0.5 integration** — Agent Control Panel for monitoring and control
 - **AgentSkills spec** — Skill loading with SPDX license validation
+- **Thinking models support** — Automatic handling of qwen3, deepseek-r1 thinking mode
 
 ## Installation
 

{agentnova-0.3.4 → agentnova-0.3.6}/README.md

@@ -1,4 +1,4 @@
-# ⚛️ AgentNova R03.3
+# ⚛️ AgentNova R03.6
 
 **Status: Alpha**
 
@@ -15,7 +15,7 @@ Inspired by the architecture of OpenClaw, rebuilt from scratch for local-first o
 
 [![License](https://img.shields.io/badge/License-MIT-blue)](#license) [![Go to Python website](https://img.shields.io/badge/dynamic/toml?url=https%3A%2F%2Fraw.githubusercontent.com%2FVTSTech%2FAgentNova%2Frefs%2Fheads%2Fmain%2Fpyproject.toml&query=project.requires-python&label=python&logo=python&logoColor=white)](https://python.org)
 
-<img width="1400" height="1001" alt="image" src="https://github.com/user-attachments/assets/1bc8fb7a-415b-4750-9ce2-1e721bbf9149" />
+<img width="1378" height="996" alt="image" src="https://github.com/user-attachments/assets/0fe69695-73d9-4ce1-999f-08443f879971" />
 
 ## 📚 Documentation
 
@@ -37,6 +37,7 @@ Inspired by the architecture of OpenClaw, rebuilt from scratch for local-first o
 - **Soul Spec v0.5** — Persona packages with progressive disclosure
 - **ACP v1.0.5 integration** — Agent Control Panel for monitoring and control
 - **AgentSkills spec** — Skill loading with SPDX license validation
+- **Thinking models support** — Automatic handling of qwen3, deepseek-r1 thinking mode
 
 ## Installation
 

{agentnova-0.3.4 → agentnova-0.3.6}/agentnova/__init__.py

@@ -28,7 +28,7 @@ Example Usage:
     agent = Agent(model="qwen2.5:0.5b", soul="/path/to/soul/package")
 """
 
-__version__ = "0.3.4"
+__version__ = "0.3.6"
 __author__ = "VTSTech"
 __status__ = "Alpha"
 

{agentnova-0.3.4 → agentnova-0.3.6}/agentnova/acp_plugin.py

@@ -67,6 +67,7 @@ from __future__ import annotations
 
 import base64
 import json
+import random
 import time
 import urllib.request
 import urllib.error
@@ -74,6 +75,14 @@ from contextlib import contextmanager
 from dataclasses import dataclass, field
 from typing import Any, Callable, Generator
 
+# Default retry configuration
+ACP_RETRY_CONFIG = {
+    "max_retries": 3,
+    "base_delay": 0.5,
+    "max_delay": 8.0,
+    "jitter": True,  # Add randomness to avoid thundering herd
+}
+
 # Import StepResult for type hints (optional - works without it)
 try:
     from .core.models import StepResult
@@ -369,6 +378,83 @@ class ACPPlugin:
             self._csrf_token = token if token else ""
             self._csrf_expiry = now
 
+    def _request_with_retry(
+        self,
+        endpoint: str,
+        method: str = "GET",
+        data: dict | None = None,
+        timeout: float = 5.0,
+        max_retries: int = None,
+        base_delay: float = None,
+        max_delay: float = None,
+        jitter: bool = None,
+        retryable_errors: tuple = None,
+    ) -> dict:
+        """
+        Make HTTP request with exponential backoff retry logic.
+        
+        This wraps _request() with automatic retry on transient failures,
+        implementing exponential backoff to avoid overwhelming the server.
+        
+        Args:
+            endpoint: API endpoint path
+            method: HTTP method
+            data: Request body data
+            timeout: Request timeout
+            max_retries: Maximum number of retry attempts (default: from ACP_RETRY_CONFIG)
+            base_delay: Initial delay in seconds (default: from ACP_RETRY_CONFIG)
+            max_delay: Maximum delay cap in seconds (default: from ACP_RETRY_CONFIG)
+            jitter: Add randomness to avoid thundering herd (default: from ACP_RETRY_CONFIG)
+            retryable_errors: Tuple of error types that should trigger retry
+                            Default: (502, 503, 504, connection errors)
+        
+        Returns:
+            API response dict
+        """
+        # Use config defaults if not specified
+        if max_retries is None:
+            max_retries = ACP_RETRY_CONFIG["max_retries"]
+        if base_delay is None:
+            base_delay = ACP_RETRY_CONFIG["base_delay"]
+        if max_delay is None:
+            max_delay = ACP_RETRY_CONFIG["max_delay"]
+        if jitter is None:
+            jitter = ACP_RETRY_CONFIG["jitter"]
+        
+        if retryable_errors is None:
+            # Default retryable: server errors and connection issues
+            retryable_errors = (502, 503, 504, "connection", "timeout")
+        
+        last_error = None
+        
+        for attempt in range(max_retries + 1):
+            result = self._request(endpoint, method, data, timeout)
+            
+            # Check for success
+            if result.get("success") != False or "error" not in result:
+                return result
+            
+            # Check if error is retryable
+            error_str = str(result.get("error", "")).lower()
+            is_retryable = any(
+                str(code) in error_str or str(code) in error_str.lower()
+                for code in retryable_errors
+            )
+            
+            if not is_retryable or attempt == max_retries:
+                return result
+            
+            # Calculate exponential backoff delay with optional jitter
+            delay = min(base_delay * (2 ** attempt), max_delay)
+            if jitter:
+                # Add up to 25% random jitter
+                delay = delay * (0.75 + random.random() * 0.5)
+            self._log(f"Retry {attempt + 1}/{max_retries} after {delay:.2f}s: {error_str}")
+            time.sleep(delay)
+            last_error = error_str
+        
+        return result
+
     # ------------------------------------------------------------------ #
     #  JSON-RPC 2.0 Support (1.0.4 - A2A Compliance)                          #
     # ------------------------------------------------------------------ #

{agentnova-0.3.4 → agentnova-0.3.6}/agentnova/agent.py

@@ -42,6 +42,7 @@ from .core.openresponses import (
     RequestConfig, Error,
     create_message_item, create_function_call_item, create_function_call_output,
     create_function_call_output_item,
+    stream_response_events,
 )
 from .tools import ToolRegistry, make_builtin_registry
 from .backends import BaseBackend, get_default_backend
@@ -109,6 +110,10 @@ class Agent:
         soul: str = "nova-helper",
         soul_level: int = 3,
         num_ctx: int | None = None,
+        # Generation parameters
+        temperature: float | None = None,
+        top_p: float | None = None,
+        num_predict: int | None = None,
         # OpenResponses parameters
         tool_choice: str | ToolChoice = "auto",  # Default per OpenResponses spec
         allowed_tools: list[str] | None = None,
@@ -128,6 +133,9 @@ class Agent:
             soul: Path to Soul Spec package (default: "nova-helper")
             soul_level: Progressive disclosure level for soul (1-3)
             num_ctx: Context window size in tokens (default: 4096)
+            temperature: Sampling temperature (default: model-specific)
+            top_p: Nucleus sampling probability (default: model-specific)
+            num_predict: Maximum tokens to generate (default: model-specific)
             tool_choice: Control tool invocation ("auto", "required", "none", or specific tool name)
             allowed_tools: List of tools the model is allowed to invoke (subset of tools)
             **kwargs: Additional configuration
@@ -142,6 +150,11 @@ class Agent:
             config = get_config()
             self.num_ctx = config.num_ctx if config.num_ctx else 4096
 
+        # Generation parameters (use model defaults if not specified)
+        self._temperature = temperature
+        self._top_p = top_p
+        self._num_predict = num_predict
+
         # Initialize backend
         if backend is None:
             self.backend = get_default_backend()
@@ -852,6 +865,143 @@ Final Answer: <the answer>
             success=bool(final_answer),
         )
 
+    def run_stream(self, prompt: str) -> Generator[str, None, None]:
+        """
+        Run the agent on a prompt with streaming OpenResponses SSE events.
+
+        This method implements the agentic loop with streaming output following
+        OpenResponses specification. It yields Server-Sent Events (SSE) that
+        describe the response lifecycle and content deltas.
+
+        SSE Event Sequence (per OpenResponses spec):
+            1. response.queued - Response is queued
+            2. response.in_progress - Response started
+            3. response.output_item.added - New output item added
+            4. response.content_part.added - New content part added
+            5. response.output_text.delta - Text deltas (multiple)
+            6. response.output_text.done - Text completed
+            7. response.content_part.done - Content part completed
+            8. response.output_item.done - Output item completed
+            9. response.completed - Response finished
+
+        Args:
+            prompt: User prompt
+
+        Yields:
+            SSE-formatted strings (event: ...\\ndata: ...\\n\\n)
+
+        Example:
+            agent = Agent(model="qwen2.5:0.5b")
+            for sse_event in agent.run_stream("Hello!"):
+                print(sse_event)  # SSE formatted event
+        """
+        # Create OpenResponses Response object
+        response = Response(
+            model=self.model,
+            status=ResponseStatus.QUEUED,
+            tool_choice=self.tool_choice,
+            allowed_tools=self._allowed_tools or [],
+        )
+
+        if self.debug and not self._is_comp_mode:
+            print(f"\n[OpenResponses] Response created: id={response.id}")
+            print(f"[OpenResponses] Response status: {response.status.value}")
+
+        # Add user prompt to memory
+        self.memory.add("user", prompt)
+
+        # Add input item
+        user_item = create_message_item("user", prompt)
+        response.input.append(user_item)
+
+        if self.debug and not self._is_comp_mode:
+            print(f"[OpenResponses] Input item added: id={user_item.id}, type={user_item.type}, role={user_item.role}")
+
+        if self.debug:
+            print(f"\n[AgentNova] Model: {self.model}")
+            print(f"[AgentNova] Backend: {self.backend.base_url}")
+            print(f"[AgentNova] tool_choice: {self.tool_choice.type.value}")
+            print(f"[AgentNova] Tools: {self.tools.names()}")
+            print(f"[AgentNova] Prompt (streaming): {prompt}\n")
+
+        # Get text chunks from backend streaming
+        text_chunks = self._generate_stream_chunks(prompt)
+
+        # Wrap with OpenResponses SSE events using stream_response_events()
+        for sse_event in stream_response_events(response, text_chunks, debug=self.debug):
+            yield sse_event
+
+    def _generate_stream_chunks(self, prompt: str) -> Generator[str, None, None]:
+        """
+        Generate streaming text chunks from the backend.
+
+        This is a helper method that wraps the backend's streaming functionality
+        and yields raw text chunks for the OpenResponses event generator.
+
+        Args:
+            prompt: User prompt (unused, memory already has the prompt)
+
+        Yields:
+            Text chunks from the model
+        """
+        messages = self.memory.get_messages()
+
+        if self.debug:
+            print(f"  [DEBUG] Streaming {len(messages)} messages")
+
+        # Check if model needs thinking disabled (qwen3, deepseek-r1, etc.)
+        think = None
+        if self.model_family:
+            from .core.model_family_config import needs_no_think_directive
+            if needs_no_think_directive(self.model_family):
+                think = False
+
+        # Build kwargs for backend
+        backend_kwargs = {"think": think}
+        if self.num_ctx is not None:
+            backend_kwargs["num_ctx"] = self.num_ctx
+
+        # Check if backend has streaming support
+        if hasattr(self.backend, 'generate_stream'):
+            # Use native Ollama streaming
+            for chunk in self.backend.generate_stream(
+                model=self.model,
+                messages=messages,
+                tools=self.tools.all() if self.tools and len(self.tools) > 0 else None,
+                temperature=self.model_config.default_temperature,
+                max_tokens=self.model_config.default_max_tokens,
+                **backend_kwargs,
+            ):
+                yield chunk
+        elif hasattr(self.backend, 'generate_completions_stream'):
+            # Use OpenAI-compatible streaming
+            for chunk_dict in self.backend.generate_completions_stream(
+                model=self.model,
+                messages=messages,
+                tools=self.tools.all() if self.tools and len(self.tools) > 0 else None,
+                temperature=self.model_config.default_temperature,
+                max_tokens=self.model_config.default_max_tokens,
+                **backend_kwargs,
+            ):
+                delta = chunk_dict.get("delta", "")
+                if delta:
+                    yield delta
+        else:
+            # Fallback: non-streaming with simulated streaming
+            result = self.backend.generate(
+                model=self.model,
+                messages=messages,
+                tools=self.tools.all() if self.tools and len(self.tools) > 0 else None,
+                temperature=self.model_config.default_temperature,
+                max_tokens=self.model_config.default_max_tokens,
+                **backend_kwargs,
+            )
+            content = result.get("content", "")
+            # Yield content in chunks for consistent behavior
+            chunk_size = 20
+            for i in range(0, len(content), chunk_size):
+                yield content[i:i + chunk_size]
+
     def create_response(
         self,
         input_items: list = None,
@@ -923,19 +1073,31 @@ Final Answer: <the answer>
         backend_kwargs = {"think": think}
         if self.num_ctx is not None:
             backend_kwargs["num_ctx"] = self.num_ctx
-            if self.debug:
-                print(f"  [DEBUG] num_ctx: {self.num_ctx}")
+        if self._num_predict is not None:
+            backend_kwargs["num_predict"] = self._num_predict
 
         # Pass tools for native tool calling (OpenResponses/ChatCompletions compliant)
         # ReAct parsing remains as fallback for models without native support
         tools_for_backend = self.tools.all() if self.tools and len(self.tools) > 0 else None
 
+        # Get generation parameters (use overrides or model defaults)
+        gen_temperature = self._temperature if self._temperature is not None else self.model_config.default_temperature
+        gen_max_tokens = self._num_predict if self._num_predict is not None else self.model_config.default_max_tokens
+        gen_top_p = self._top_p if self._top_p is not None else self.model_config.default_top_p
+
+        if self.debug:
+            params_str = f"temp={gen_temperature}, top_p={gen_top_p}, max_tokens={gen_max_tokens}, num_ctx={self.num_ctx}"
+            if think is not None:
+                params_str += f", think={think}"
+            print(f"  [DEBUG] Model params: {params_str}")
+
         response = self.backend.generate(
             model=self.model,
             messages=messages,
             tools=tools_for_backend,  # Native tool calling support
-            temperature=self.model_config.default_temperature,
-            max_tokens=self.model_config.default_max_tokens,
+            temperature=gen_temperature,
+            max_tokens=gen_max_tokens,
+            top_p=gen_top_p,
             **backend_kwargs,
         )
 

{agentnova-0.3.4 → agentnova-0.3.6}/agentnova/agent_mode.py

@@ -28,26 +28,7 @@ from enum import Enum
 from pathlib import Path
 from typing import Any, Callable, Optional
 
-
-# ANSI color helpers
-def dim(text: str) -> str:
-    """Return dimmed text using ANSI escape codes."""
-    return f"\033[2m{text}\033[0m"
-
-
-def green(text: str) -> str:
-    """Return green text using ANSI escape codes."""
-    return f"\033[32m{text}\033[0m"
-
-
-def yellow(text: str) -> str:
-    """Return yellow text using ANSI escape codes."""
-    return f"\033[33m{text}\033[0m"
-
-
-def cyan(text: str) -> str:
-    """Return cyan text using ANSI escape codes."""
-    return f"\033[36m{text}\033[0m"
+from .colors import dim, green, yellow, cyan
 
 
 class AgentState(Enum):
@@ -843,4 +824,4 @@ __all__ = [
     "create_shell_action",
     "format_status",
     "format_progress",
-]
+]