agentnova 0.3.7__tar.gz → 0.3.9__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentnova
-Version: 0.3.7
+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.7
+# ⚛️ AgentNova R03.9
 
 **Status: Alpha**
 
@@ -49,7 +49,8 @@ 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="1378" height="996" alt="image" src="https://github.com/user-attachments/assets/0fe69695-73d9-4ce1-999f-08443f879971" />
+<img width="1314" height="993" alt="image" src="https://github.com/user-attachments/assets/586b1a44-441e-41ae-85c2-b65b6a0816b9" />
+<img width="1063" height="574" alt="image" src="https://github.com/user-attachments/assets/eab6f4ad-810c-4741-b637-e120f9ccb974" />
 
 ## 📚 Documentation
 
@@ -76,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.7 → agentnova-0.3.9}/README.md

@@ -1,4 +1,4 @@
-# ⚛️ AgentNova R03.7
+# ⚛️ AgentNova R03.9
 
 **Status: Alpha**
 
@@ -15,7 +15,8 @@ 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="1378" height="996" alt="image" src="https://github.com/user-attachments/assets/0fe69695-73d9-4ce1-999f-08443f879971" />
+<img width="1314" height="993" alt="image" src="https://github.com/user-attachments/assets/586b1a44-441e-41ae-85c2-b65b6a0816b9" />
+<img width="1063" height="574" alt="image" src="https://github.com/user-attachments/assets/eab6f4ad-810c-4741-b637-e120f9ccb974" />
 
 ## 📚 Documentation
 
@@ -42,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
 ```
 
@@ -349,4 +348,4 @@ Contributions welcome! Please read the contributing guidelines first.
 
 - Built for local inference with [Ollama](https://ollama.ai)
 - Optimized for small, efficient models
-- Inspired by ReAct and other agentic frameworks
+- Inspired by ReAct and other agentic frameworks

{agentnova-0.3.7 → 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.7"
+__version__ = "0.3.9"
 __author__ = "VTSTech"
 __status__ = "Alpha"
 

{agentnova-0.3.7 → agentnova-0.3.9}/agentnova/acp_plugin.py

@@ -281,6 +281,10 @@ class ACPPlugin:
             "get_note": "READ",
             "list_notes": "READ",
             "list_directory": "READ",
+            # ACP v1.0.4: A2A agent-to-agent communication
+            "a2a_send": "A2A",
+            "a2a_request": "A2A",
+            "a2a_response": "A2A",
         }
 
         # v1.0.4: Auto-derive capabilities from tool action map if not explicitly provided
@@ -1089,11 +1093,11 @@ class ACPPlugin:
         """Format tool arguments as a target string for ACP."""
         # Tool-specific formatting
         if tool_name == "read_file":
-            return args.get("path", "unknown")
+            return args.get("file_path", args.get("path", "unknown"))
         elif tool_name == "write_file":
-            return args.get("path", "unknown")
+            return args.get("file_path", args.get("path", "unknown"))
         elif tool_name == "edit_file":
-            return args.get("path", "unknown")
+            return args.get("file_path", args.get("path", "unknown"))
         elif tool_name == "shell":
             return args.get("command", "")[:100]
         elif tool_name == "calculator":

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

@@ -40,6 +40,7 @@ from .core.openresponses import (
     MessageItem, FunctionCallItem, FunctionCallOutputItem, ReasoningItem,
     OutputText, InputText,
     RequestConfig, Error,
+    EventType, ResponseEvent, OutputItemEvent,
     create_message_item, create_function_call_item, create_function_call_output,
     create_function_call_output_item,
     stream_response_events,
@@ -132,7 +133,7 @@ class Agent:
             system_prompt: Custom system prompt (overrides soul)
             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)
+            num_ctx: Context window size in tokens (default: 8192)
             temperature: Sampling temperature (default: model-specific)
             top_p: Nucleus sampling probability (default: model-specific)
             num_predict: Maximum tokens to generate (default: model-specific)
@@ -143,12 +144,12 @@ class Agent:
         self.model = model
         self.max_steps = max_steps
         self.debug = debug
-        # Get num_ctx from: explicit param > config/env > default 4096
+        # Get num_ctx from: explicit param > config/env > default 8192
         if num_ctx is not None:
             self.num_ctx = num_ctx
         else:
             config = get_config()
-            self.num_ctx = config.num_ctx if config.num_ctx else 4096
+            self.num_ctx = config.num_ctx if config.num_ctx else 8192
 
         # Generation parameters (use model defaults if not specified)
         self._temperature = temperature
@@ -225,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)
@@ -413,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()
@@ -441,6 +445,31 @@ Final Answer: <the answer>
             tokens = gen_response.get("usage", {}).get("total_tokens", 0)
             total_tokens += tokens
 
+            # OpenResponses: Handle finish_reason from backend
+            finish_reason = gen_response.get("_finish_reason", "stop")
+            if finish_reason == "length":
+                # Token budget exhausted — response is incomplete
+                if self.debug:
+                    print(f"  [OpenResponses] finish_reason='length' — marking incomplete")
+                steps.append(StepResult(
+                    type=StepResultType.MAX_STEPS,
+                    content="Response truncated: token limit reached",
+                    tokens_used=tokens,
+                ))
+                response.mark_incomplete()
+                break
+            elif finish_reason == "content_filter":
+                # Content was filtered — response failed
+                if self.debug:
+                    print(f"  [OpenResponses] finish_reason='content_filter' — marking failed")
+                steps.append(StepResult(
+                    type=StepResultType.ERROR,
+                    error="Response blocked by content filter",
+                    tokens_used=tokens,
+                ))
+                response.mark_failed({"message": "Content filtered by provider", "type": "content_filter"})
+                break
+
             if self.debug:
                 print(f"  Content: {content[:200] if content else '(empty)'}...")
                 print(f"  Native tool calls: {native_tool_calls}")
@@ -558,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
@@ -590,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
@@ -622,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(
@@ -873,6 +912,10 @@ Final Answer: <the answer>
         OpenResponses specification. It yields Server-Sent Events (SSE) that
         describe the response lifecycle and content deltas.
 
+        IMPORTANT: The agentic loop is fully supported during streaming.
+        When the model produces a tool call, it is executed and the loop
+        continues, streaming the next model response.
+
         SSE Event Sequence (per OpenResponses spec):
             1. response.queued - Response is queued
             2. response.in_progress - Response started
@@ -895,6 +938,8 @@ Final Answer: <the answer>
             for sse_event in agent.run_stream("Hello!"):
                 print(sse_event)  # SSE formatted event
         """
+        start_time = time.time()
+
         # Create OpenResponses Response object
         response = Response(
             model=self.model,
@@ -903,9 +948,8 @@ Final Answer: <the answer>
             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}")
+        if self.debug:
+            print(f"\n[OpenResponses stream] Response created: id={response.id}")
 
         # Add user prompt to memory
         self.memory.add("user", prompt)
@@ -914,22 +958,195 @@ Final Answer: <the answer>
         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")
+            print(f"\n[AgentNova stream] Model: {self.model}")
+            print(f"[AgentNova stream] Backend: {self.backend.base_url}")
+            print(f"[AgentNova stream] tool_choice: {self.tool_choice.type.value}")
+            print(f"[AgentNova stream] Tools: {self.tools.names()}")
+            print(f"[AgentNova stream] Prompt: {prompt}\n")
+
+        # OpenResponses: Agentic Loop (streaming variant)
+        # 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):
+            if self.debug:
+                print(f"[Stream Step {step_num + 1}]")
+
+            # Collect the full streamed response
+            full_content = ""
+
+            # Stream model response, collecting content for tool-call detection
+            try:
+                for chunk in self._generate_stream_chunks(prompt):
+                    full_content += chunk
+            except Exception as e:
+                if self.debug:
+                    print(f"  [Stream] ERROR: {e}")
+                # Emit failure event
+                response.mark_failed({"message": str(e), "type": "stream_error"})
+                fail_event = ResponseEvent(
+                    type=EventType.RESPONSE_FAILED,
+                    response=response,
+                )
+                yield fail_event.to_sse()
+                return
+
+            # Parse for tool calls (ReAct format)
+            tool_calls_found = []
+
+            if full_content:
+                parsed_calls = self._parser.parse(full_content)
+                for call in parsed_calls:
+                    if hasattr(call, 'thought') and call.thought:
+                        reasoning_item = ReasoningItem(
+                            content=[OutputText(text=call.thought)]
+                        )
+                        reasoning_item.status = ItemStatus.COMPLETED
+                        response.add_output_item(reasoning_item)
+
+                    tool_calls_found.append({
+                        "name": call.name,
+                        "arguments": call.arguments,
+                        "id": "",
+                        "final_answer": getattr(call, 'final_answer', None),
+                    })
 
-        # Get text chunks from backend streaming
-        text_chunks = self._generate_stream_chunks(prompt)
+            # ---- Execute tool calls if found ----
+            if tool_calls_found:
+                # Final Answer enforcement (same logic as run())
+                if _expecting_final_answer and _last_successful_result is not None:
+                    text_chunks_gen = iter([_last_successful_result])
+                    for sse_event in stream_response_events(
+                        Response(model=self.model, status=ResponseStatus.IN_PROGRESS,
+                                tool_choice=self.tool_choice, allowed_tools=self._allowed_tools or []),
+                        text_chunks_gen, debug=self.debug,
+                    ):
+                        yield sse_event
+                    return
+
+                pending_final_answer = None
+                self.memory.add("assistant", full_content)
+
+                for tc in tool_calls_found:
+                    tool_name = tc["name"]
+                    tool_args = tc["arguments"]
+
+                    if tc.get("final_answer"):
+                        pending_final_answer = tc["final_answer"]
+
+                    # Check allowed_tools
+                    if self._allowed_tools and tool_name not in self._allowed_tools:
+                        error_msg = f"Tool '{tool_name}' not in allowed_tools: {self._allowed_tools}"
+                        self.memory.add("user", f"Observation: Error: {error_msg}")
+                        continue
+
+                    # Create FunctionCallItem and emit SSE events
+                    fc_item = create_function_call_item(tool_name, tool_args)
+                    fc_item.status = ItemStatus.IN_PROGRESS
+                    response.add_output_item(fc_item)
+                    output_index = len(response.output) - 1
+
+                    fc_added = OutputItemEvent(
+                        type=EventType.OUTPUT_ITEM_ADDED,
+                        item=fc_item,
+                        output_index=output_index,
+                    )
+                    yield fc_added.to_sse()
+
+                    # Execute the tool
+                    result = self._execute_tool(tool_name, tool_args, prompt)
+                    tool_call_count += 1
+
+                    fc_item.status = ItemStatus.COMPLETED
+
+                    fc_done = OutputItemEvent(
+                        type=EventType.OUTPUT_ITEM_DONE,
+                        item=fc_item,
+                        output_index=output_index,
+                    )
+                    yield fc_done.to_sse()
+
+                    # Create function_call_output
+                    fco_item = create_function_call_output(fc_item.call_id, str(result))
+                    response.add_output_item(fco_item)
+
+                    # Build observation and add to memory
+                    is_error = is_error_result(str(result))
+                    observation_msg = build_enhanced_observation(
+                        tool_name=tool_name,
+                        result=str(result),
+                        tracker=self._error_tracker,
+                        available_tools=self.tools.names(),
+                        is_error=is_error,
+                    )
+
+                    if is_error:
+                        _expecting_final_answer = False
+                        _last_tool_name = None
+                    else:
+                        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)
+
+                # Check for pending final answer
+                if pending_final_answer:
+                    text_chunks_gen = iter([pending_final_answer])
+                    for sse_event in stream_response_events(
+                        Response(model=self.model, status=ResponseStatus.IN_PROGRESS,
+                                tool_choice=self.tool_choice, allowed_tools=self._allowed_tools or []),
+                        text_chunks_gen, debug=self.debug,
+                    ):
+                        yield sse_event
+                    return
+
+                # Continue the agentic loop (next streaming iteration)
+                continue
+
+            # ---- No tool calls — stream final response ----
+            # Check for Final Answer format
+            if self._parser.is_final_answer(full_content):
+                answer = self._parser.extract_final_answer(full_content)
+                text_chunks_gen = iter([answer])
+            else:
+                text_chunks_gen = iter([full_content])
+
+            # Stream the final response with proper OpenResponses events
+            final_response = Response(
+                model=self.model,
+                status=ResponseStatus.IN_PROGRESS,
+                tool_choice=self.tool_choice,
+                allowed_tools=self._allowed_tools or [],
+            )
+            # Carry over any items from previous loop iterations
+            final_response.output = response.output
+            final_response.input = response.input
+            final_response.usage = response.usage
 
-        # 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
+            for sse_event in stream_response_events(final_response, text_chunks_gen, debug=self.debug):
+                yield sse_event
+
+            # Only one pass needed when there are no tool calls
+            return
+
+        else:
+            # Max steps reached
+            response.mark_incomplete()
+            incomplete_event = ResponseEvent(
+                type=EventType.RESPONSE_INCOMPLETE,
+                response=response,
+            )
+            yield incomplete_event.to_sse()
 
     def _generate_stream_chunks(self, prompt: str) -> Generator[str, None, None]:
         """
@@ -1076,6 +1293,11 @@ Final Answer: <the answer>
         if self._num_predict is not None:
             backend_kwargs["num_predict"] = self._num_predict
 
+        # OpenResponses: Forward tool_choice to backend API
+        # This allows the backend to enforce tool invocation constraints natively
+        if self.tool_choice and self.tool_choice.type != ToolChoiceType.AUTO:
+            backend_kwargs["tool_choice"] = self.tool_choice.to_dict()
+
         # 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
@@ -1101,6 +1323,17 @@ Final Answer: <the answer>
             **backend_kwargs,
         )
 
+        # OpenResponses / Chat Completions: Handle finish_reason
+        # Per spec, finish_reason affects response status:
+        #   "stop"      → normal completion (default)
+        #   "length"    → incomplete — token budget exhausted
+        #   "content_filter" → failed — content was filtered
+        finish_reason = response.get("finish_reason", "stop")
+        if self.debug:
+            print(f"  [DEBUG] finish_reason: {finish_reason}")
+        # Store for caller to consume
+        response["_finish_reason"] = finish_reason
+
         if self.debug:
             print(f"  [DEBUG] Response keys: {list(response.keys())}")
             print(f"  [DEBUG] Content: {response.get('content', '')[:100]}...")
@@ -1115,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()}"