agentnova 0.3.8__tar.gz → 0.3.9__tar.gz

{agentnova-0.3.8 → agentnova-0.3.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentnova
-Version: 0.3.8
+Version: 0.3.9
 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.8
+# ⚛️ AgentNova R03.9
 
 **Status: Alpha**
 
@@ -77,12 +77,10 @@ Inspired by the architecture of OpenClaw, rebuilt from scratch for local-first o
 ## Installation
 
 ```bash
-# From source
-git clone https://github.com/VTSTech/AgentNova.git
-cd AgentNova
-pip install -e .
+# Latest Development Release
+pip install git+https://github.com/VTSTech/AgentNova.git --force-reinstall
 
-# Or from PyPI (when published)
+# Last Stable (as stable as Alpha can be) Release
 pip install agentnova
 ```
 

{agentnova-0.3.8 → agentnova-0.3.9}/README.md

@@ -1,4 +1,4 @@
-# ⚛️ AgentNova R03.8
+# ⚛️ AgentNova R03.9
 
 **Status: Alpha**
 
@@ -43,12 +43,10 @@ Inspired by the architecture of OpenClaw, rebuilt from scratch for local-first o
 ## Installation
 
 ```bash
-# From source
-git clone https://github.com/VTSTech/AgentNova.git
-cd AgentNova
-pip install -e .
+# Latest Development Release
+pip install git+https://github.com/VTSTech/AgentNova.git --force-reinstall
 
-# Or from PyPI (when published)
+# Last Stable (as stable as Alpha can be) Release
 pip install agentnova
 ```
 

{agentnova-0.3.8 → agentnova-0.3.9}/agentnova/__init__.py

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

{agentnova-0.3.8 → agentnova-0.3.9}/agentnova/agent.py

@@ -226,7 +226,7 @@ class Agent:
         self.memory = Memory(memory_config or MemoryConfig())
 
         # Get model configuration (for temperature, max_tokens defaults)
-        from .core.model_config import get_model_config
+        from .core.model_family_config import get_model_config
         self.model_config = get_model_config(model)
 
         # Detect model family (for backend-specific settings like think=False)
@@ -414,8 +414,11 @@ Final Answer: <the answer>
         # No synthesis or fallback mechanisms are used.
         
         # Track when we're expecting a Final Answer (after successful tool use)
+        # Only enforced for terminal tools (calculator, get_time, etc.) to avoid
+        # breaking multi-step workflows that need multiple tool calls.
         _expecting_final_answer = False
         _last_successful_result = None
+        _last_tool_name = None
         
         # Reset error tracker for new run
         self._error_tracker.reset()
@@ -584,9 +587,6 @@ Final Answer: <the answer>
                             self.memory.add("user", f"Observation: Error: {error_msg}")
                         continue
 
-                    # Fuzzy match tool name
-                    tool_name = self._parser._fuzzy_match_tool(tool_name)
-
                     # Create FunctionCallItem
                     fc_item = create_function_call_item(tool_name, tool_args, tool_call_id)
                     fc_item.status = ItemStatus.IN_PROGRESS
@@ -616,6 +616,9 @@ Final Answer: <the answer>
                             fc_item.status = ItemStatus.FAILED
                             response.mark_failed({"message": "Too many tool failures", "type": "error_recovery"})
                             break
+                    else:
+                        # Record success to reset consecutive failure counter
+                        self._error_tracker.record_success(tool_name)
 
                     # Update FunctionCallItem status
                     fc_item.status = ItemStatus.COMPLETED
@@ -648,15 +651,25 @@ Final Answer: <the answer>
                         )
                         
                         # Update expecting_final_answer flag
+                        # Only enforce for terminal tools (simple, direct-answer tools)
+                        # to avoid breaking multi-step workflows
                         if is_error:
                             _expecting_final_answer = False
+                            _last_tool_name = None
                         else:
-                            _expecting_final_answer = True
-                            _last_successful_result = str(result)
+                            from .core.error_recovery import _is_simple_result
+                            if _is_simple_result(str(result), tool_name):
+                                _expecting_final_answer = True
+                                _last_successful_result = str(result)
+                                _last_tool_name = tool_name
+                            else:
+                                # Complex/intermediate result — allow more tool calls
+                                _expecting_final_answer = False
+                                _last_tool_name = None
                         
                         self.memory.add("user", observation_msg)
 
-                    if not str(result).startswith("Error"):
+                    if not is_error:
                         successful_results.append(f"{tool_name}: {result}")
 
                     steps.append(StepResult(
@@ -956,6 +969,7 @@ Final Answer: <the answer>
         # Stream model output, check for tool calls, execute them, repeat.
         _expecting_final_answer = False
         _last_successful_result = None
+        _last_tool_name = None
         tool_call_count = 0
 
         for step_num in range(self.max_steps):
@@ -1030,9 +1044,6 @@ Final Answer: <the answer>
                         self.memory.add("user", f"Observation: Error: {error_msg}")
                         continue
 
-                    # Fuzzy match
-                    tool_name = self._parser._fuzzy_match_tool(tool_name)
-
                     # Create FunctionCallItem and emit SSE events
                     fc_item = create_function_call_item(tool_name, tool_args)
                     fc_item.status = ItemStatus.IN_PROGRESS
@@ -1075,9 +1086,16 @@ Final Answer: <the answer>
 
                     if is_error:
                         _expecting_final_answer = False
+                        _last_tool_name = None
                     else:
-                        _expecting_final_answer = True
-                        _last_successful_result = str(result)
+                        from .core.error_recovery import _is_simple_result
+                        if _is_simple_result(str(result), tool_name):
+                            _expecting_final_answer = True
+                            _last_successful_result = str(result)
+                            _last_tool_name = tool_name
+                        else:
+                            _expecting_final_answer = False
+                            _last_tool_name = None
 
                     self.memory.add("user", observation_msg)
 
@@ -1330,12 +1348,7 @@ Final Answer: <the answer>
         OpenResponses: Tool execution is straightforward - no synthesis.
         Arguments must come from the model.
         """
-        from .core.tool_parse import _fuzzy_match_tool_name
-        matched_name = _fuzzy_match_tool_name(name, self.tools.names())
-        if matched_name:
-            name = matched_name
-        
-        tool = self.tools.get_fuzzy(name)
+        tool = self.tools.get(name)
 
         if tool is None:
             return f"Error: Unknown tool '{name}'. Available tools: {self.tools.names()}"

{agentnova-0.3.8 → agentnova-0.3.9}/agentnova/backends/ollama.py

@@ -978,6 +978,9 @@ class OllamaBackend(BaseBackend):
         Key insight: "native" requires ACTUAL native tool_calls structure in API response.
         Models that output JSON as text are "react", not "native".
 
+        Results are automatically cached after each live test. If force_test is False,
+        the cache is checked first before returning UNTESTED.
+
         Args:
             model: Model name
             family: Optional family hint (unused, kept for API compatibility)
@@ -986,9 +989,16 @@ class OllamaBackend(BaseBackend):
         Returns:
             ToolSupportLevel (NATIVE, REACT, NONE, or UNTESTED if force_test=False)
         """
+        from ..core.tool_cache import get_cached_tool_support, cache_tool_support
+
+        # Determine API mode for cache namespacing
+        api_mode = self._api_mode.value if hasattr(self, "_api_mode") else "openre"
+
         if not force_test:
-            # Without force_test, we don't know - return UNTESTED
-            # The caller should use cache or show "untested"
+            # Check cache first, even without force_test
+            cached = get_cached_tool_support(model, api_mode=api_mode)
+            if cached is not None:
+                return cached
             return ToolSupportLevel.UNTESTED
 
         # Test tool: Weather (simple, commonly supported)
@@ -1032,20 +1042,33 @@ class OllamaBackend(BaseBackend):
                     if func_name == "get_weather":
                         # Check for reasonable arguments
                         if isinstance(args, dict) and ("location" in args or "city" in args or len(args) > 0):
-                            return ToolSupportLevel.NATIVE
+                            result = ToolSupportLevel.NATIVE
+                            break
                     # Native tool_calls exist but wrong function - still native capability
                     # (model might be confused but HAS native support)
                     elif func_name:  # Any function name = native structure
-                        return ToolSupportLevel.NATIVE
+                        result = ToolSupportLevel.NATIVE
+                        break
+                else:
+                    # tool_calls existed but no valid function found
+                    result = ToolSupportLevel.REACT
+            else:
+                result = None  # No native tool calls
+
+            if result is not None:
+                cache_tool_support(model, result, family=family or "", api_mode=api_mode)
+                return result
 
             # 3. Check for text-based tool calls in content
             # Models that output JSON like {"name": "get_weather", ...} as TEXT
             if self._contains_text_tool_call(content):
+                cache_tool_support(model, ToolSupportLevel.REACT, family=family or "", api_mode=api_mode)
                 return ToolSupportLevel.REACT
 
             # 4. API succeeded, no explicit rejection, no native tool_calls
             # Model accepted tools parameter but didn't use native calling
             # This is the "react" case - can still parse text-based tool calls
+            cache_tool_support(model, ToolSupportLevel.REACT, family=family or "", api_mode=api_mode)
             return ToolSupportLevel.REACT
 
         except Exception as e:
@@ -1053,9 +1076,13 @@ class OllamaBackend(BaseBackend):
 
             # 1. Check for explicit "does not support tools" rejection
             if "does not support tools" in error_str.lower():
+                cache_tool_support(model, ToolSupportLevel.NONE, family=family or "",
+                                   error=error_str[:100], api_mode=api_mode)
                 return ToolSupportLevel.NONE
 
             # Other HTTP errors or connection issues
+            cache_tool_support(model, ToolSupportLevel.REACT, family=family or "",
+                               error=error_str[:100], api_mode=api_mode)
             return ToolSupportLevel.REACT
 
         finally:

{agentnova-0.3.8 → agentnova-0.3.9}/agentnova/core/__init__.py

@@ -6,9 +6,9 @@ that form the foundation of the AgentNova framework.
 """
 
 from .types import StepResultType, ToolSupportLevel, BackendType, ApiMode
-from .models import StepResult, AgentRun, Tool, ToolParam
+from .models import StepResult, AgentRun, Tool, ToolParam, ToolCall
 from .memory import Memory, MemoryConfig
-from .tool_parse import ToolParser, ToolCall
+from .tool_parse import ToolParser
 from .helpers import (
     fuzzy_match, normalize_args, validate_path, is_safe_url,
     strip_tool_prefix, is_simple_answered_query, is_greeting_or_simple,
@@ -19,18 +19,18 @@ from .prompts import (
     TOOL_ARG_ALIASES, FEW_SHOT_SUFFIX, FEW_SHOT_COMPACT,
     PLATFORM_DIR_CMD,
 )
-from .model_config import ModelFamilyConfig, get_model_config
-from .args_normal import (
-    normalize_args as normalize_args_full,
-    fix_calculator_args, synthesize_missing_args, generate_helpful_error_message,
-)
 from .model_family_config import (
+    ModelFamilyConfig, get_model_config,
     get_family_config, get_stop_tokens, supports_tools,
     get_tool_format, get_no_tools_system_prompt, get_preferred_temperature,
     should_use_few_shot, get_few_shot_style, has_known_issues,
     get_react_system_suffix, get_native_tool_hints,
     FAMILY_CONFIGS,
 )
+from .args_normal import (
+    normalize_args as normalize_args_full,
+    fix_calculator_args, synthesize_missing_args, generate_helpful_error_message,
+)
 # OpenResponses types
 from .openresponses import (
     Response, ResponseStatus, ItemStatus,

{agentnova-0.3.8 → agentnova-0.3.9}/agentnova/core/helpers.py

@@ -131,10 +131,40 @@ def normalize_args(args: dict[str, Any], expected_params: list[str], tool_name:
     power_parts = {}
     
     # Import tool-specific aliases
-    from .prompts import TOOL_ARG_ALIASES
+    from .prompts import TOOL_ARG_ALIASES, CONTEXTUAL_ALIASES
     
     # Get tool-specific aliases
     tool_aliases = TOOL_ARG_ALIASES.get(tool_name, {}) if tool_name else {}
+    contextual_aliases = CONTEXTUAL_ALIASES.get(tool_name, set()) if tool_name else set()
+
+    # First pass: identify which keys map to expected params via non-ambiguous means
+    # (direct match, case-insensitive match, or non-contextual alias)
+    matched_keys = set()
+
+    for key, value in args.items():
+        key_lower = key.lower().replace("-", "_")
+
+        # Direct match
+        if key in expected_set:
+            matched_keys.add(key_lower)
+            continue
+
+        # Case-insensitive match
+        for param in expected_params:
+            if param.lower() == key_lower:
+                matched_keys.add(key_lower)
+                break
+
+        # Non-contextual alias (safe to apply always)
+        if key_lower not in matched_keys and key_lower in tool_aliases:
+            alias_target = tool_aliases[key_lower]
+            if alias_target != "_combine_power" and alias_target in expected_set:
+                if key_lower not in contextual_aliases:
+                    matched_keys.add(key_lower)
+
+    # Second pass: build normalized dict with full resolution
+    normalized = {}
+    power_parts = {}
 
     for key, value in args.items():
         key_lower = key.lower().replace("-", "_")
@@ -148,8 +178,13 @@ def normalize_args(args: dict[str, Any], expected_params: list[str], tool_name:
                 power_parts[key_lower] = value
                 continue
             elif alias_target in expected_set:
-                target_param = alias_target
-                target_pname = alias_target
+                # Contextual validation: only apply ambiguous aliases when
+                # no other key has already matched an expected param
+                if key_lower in contextual_aliases and matched_keys:
+                    pass  # Skip this ambiguous alias
+                else:
+                    target_param = alias_target
+                    target_pname = alias_target
         
         # Strategy 2: Direct match
         if target_param is None and key in expected_set:

agentnova-0.3.9/agentnova/core/model_config.py

@@ -0,0 +1,36 @@
+"""
+AgentNova — Model Configuration (DEPRECATED)
+
+This module is deprecated. All model family configuration has been merged into
+model_family_config.py. This module re-exports ModelFamilyConfig and
+get_model_config from there for backward compatibility.
+
+Please import from model_family_config instead:
+    from agentnova.core.model_family_config import ModelFamilyConfig, get_model_config
+
+Written by VTSTech — https://www.vts-tech.org
+"""
+
+from __future__ import annotations
+
+import warnings
+
+# Re-export from the unified module for backward compatibility
+from .model_family_config import ModelFamilyConfig, get_model_config
+
+# Legacy MODEL_CONFIGS dict — maps to FAMILY_CONFIGS entries
+from .model_family_config import FAMILY_CONFIGS as MODEL_CONFIGS
+
+
+def list_supported_families() -> list[str]:
+    """List all supported model families."""
+    return [k for k in MODEL_CONFIGS.keys()]
+
+
+# Emit deprecation warning on import
+warnings.warn(
+    "model_config.py is deprecated. Use model_family_config.py instead. "
+    "Import ModelFamilyConfig and get_model_config from agentnova.core.model_family_config.",
+    DeprecationWarning,
+    stacklevel=2,
+)

{agentnova-0.3.8 → agentnova-0.3.9}/agentnova/core/model_family_config.py

@@ -21,26 +21,50 @@ _PLATFORM_DIR_CMD = "cd" if _IS_WINDOWS else "pwd"
 
 @dataclass
 class ModelFamilyConfig:
-    """Configuration for a specific model family."""
+    """Configuration for a specific model family.
+    
+    Unified configuration combining prompting, formatting, tool handling,
+    and generation defaults. Single source of truth for all model-family-
+    specific settings.
+    """
     family: str
+    # Prompting & formatting
     start_tokens: dict = field(default_factory=dict)
     stop_tokens: list[str] = field(default_factory=list)
     tool_format: Literal["native", "xml", "json", "none"] = "native"
     tool_call_start: str = ""
     tool_call_end: str = ""
     supports_native_tools: bool = True
-    system_prompt_style: Literal["separate", "first_user", "template"] = "separate"
+    system_prompt_style: Literal["separate", "first_user", "template", "default", "react", "minimal"] = "separate"
+    # Generation defaults
     preferred_temperature: float = 0.7
+    default_temperature: float = 0.7  # Used by agent.py for generation
+    default_top_p: float = 0.9
+    default_max_tokens: int = 8192
+    # Model behavior
     needs_think_directive: bool = False
     prefers_few_shot: bool = True
     few_shot_style: Literal["react", "native", "compact"] = "react"
     reasoning_hints: list[str] = field(default_factory=list)
+    # Streaming / capabilities
+    supports_streaming: bool = True
+    supports_vision: bool = False
+    # Think tag handling (e.g., <think/> for DeepSeek)
+    think_tag: str | None = None
+    strip_think_tags: bool = False
     # Special behaviors
     has_schema_dump_issue: bool = False  # Some models dump tool schema as text
     truncate_json_args: bool = False  # Some models truncate JSON in ReAct
+    needs_empty_system: bool = False  # Some models break with empty system
+    prefers_user_system: bool = False  # Put system prompt in first user message
     # Override system prompt for models without tool support (pure reasoning)
     no_tools_system_prompt: str | None = None
 
+    def get_stop_sequences(self) -> list[str]:
+        """Get stop sequences for this model family."""
+        stops = list(self.stop_tokens)
+        return stops
+
 
 # ═══════════════════════════════════════════════════════════════════════════════
 # FAMILY CONFIGURATIONS
@@ -57,6 +81,7 @@ FAMILY_CONFIGS: dict[str, ModelFamilyConfig] = {
         supports_native_tools=False,
         system_prompt_style="first_user",
         preferred_temperature=0.7,
+        needs_empty_system=True,
         prefers_few_shot=False,
         few_shot_style="compact",
         reasoning_hints=["Think step by step", "Show your work"],
@@ -262,6 +287,8 @@ Keep answers brief. One word when possible.""",
         preferred_temperature=0.6,
         needs_think_directive=True,  # DeepSeek-R1 has thinking mode
         prefers_few_shot=True,
+        think_tag="think",
+        strip_think_tags=True,
         few_shot_style="react",
         reasoning_hints=["Think step by step", "Show your reasoning"],
     ),
@@ -284,6 +311,8 @@ Keep answers brief. One word when possible.""",
         needs_think_directive=False,  # Standard DeepSeek models don't have thinking mode
         prefers_few_shot=True,
         few_shot_style="react",
+        think_tag="think",
+        strip_think_tags=True,
     ),
 }
 
@@ -441,6 +470,25 @@ def detect_family(model_name: str) -> str | None:
     return None
 
 
+def get_model_config(model_name: str) -> ModelFamilyConfig:
+    """
+    Get unified configuration for a model.
+    
+    This replaces the separate get_model_config() from model_config.py.
+    Uses detect_family() for consistent family resolution.
+    
+    Args:
+        model_name: Name of the model (e.g., "qwen2.5:7b")
+    
+    Returns:
+        ModelFamilyConfig for the model
+    """
+    family = detect_family(model_name)
+    if family and family in FAMILY_CONFIGS:
+        return FAMILY_CONFIGS[family]
+    return ModelFamilyConfig(family=family or "unknown")
+
+
 __all__ = [
     "ModelFamilyConfig",
     "FAMILY_CONFIGS",
@@ -456,5 +504,6 @@ __all__ = [
     "get_native_tool_hints",
     "get_no_tools_system_prompt",
     "detect_family",
+    "get_model_config",
     "needs_no_think_directive",
 ]

{agentnova-0.3.8 → agentnova-0.3.9}/agentnova/core/models.py

@@ -87,11 +87,16 @@ class Tool:
 
 @dataclass
 class ToolCall:
-    """Represents a parsed tool call from model output."""
+    """Represents a parsed tool call from model output.
+    
+    OpenResponses Enhancement: Includes thought capture for ReasoningItem.
+    """
     name: str
     arguments: dict[str, Any]
     raw: str = ""  # Original text that was parsed
     confidence: float = 1.0  # Confidence of parsing (for fuzzy matches)
+    final_answer: str | None = None  # OpenResponses: Final answer if present in same content
+    thought: str | None = None  # OpenResponses: Captured reasoning for ReasoningItem
 
 
 @dataclass

{agentnova-0.3.8 → agentnova-0.3.9}/agentnova/core/prompts.py

@@ -25,7 +25,7 @@ TOOL_ARG_ALIASES = {
     "calculator": {
         # Common hallucinations for expression
         "a": "expression", "b": "expression", "x": "expression", "y": "expression",
-        "num": "expression", "number": "expression", "value": "expression",
+        "num": "expression", "number": "expression",
         "input": "expression", "formula": "expression", "math": "expression",
         "expr": "expression", "calc": "expression", "result": "expression",
         # Power operations - combine into expression
@@ -89,6 +89,19 @@ TOOL_ARG_ALIASES = {
     },
 }
 
+# Aliases that are too generic and should only be applied when the args dict
+# has no other parameters that already matched a real expected param.
+# These are the aliases most likely to misinterpret legitimate model output.
+CONTEXTUAL_ALIASES = {
+    "calculator": {"value", "input", "result", "n", "p", "exp"},
+    "shell": {"text", "input", "arg", "args", "str", "value"},
+    "write_file": {"value", "string"},
+    "read_file": {"input"},
+    "web-search": {"text", "input"},
+    "python_repl": {"input", "expression", "expr"},
+    "convert_currency": {"value"},
+}
+
 # ------------------------------------------------------------------ #
 #  Few-shot prompting suffix for small models                         #
 # ------------------------------------------------------------------ #