agentnova 0.3.7__tar.gz → 0.3.8__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentnova
-Version: 0.3.7
+Version: 0.3.8
 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.8
 
 **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
 

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

@@ -1,4 +1,4 @@
-# ⚛️ AgentNova R03.7
+# ⚛️ AgentNova R03.8
 
 **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
 
@@ -349,4 +350,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.8}/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.8"
 __author__ = "VTSTech"
 __status__ = "Alpha"
 

{agentnova-0.3.7 → agentnova-0.3.8}/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.8}/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
@@ -441,6 +442,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}")
@@ -873,6 +899,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 +925,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 +935,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 +945,190 @@ 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
+        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)
 
-        # Get text chunks from backend streaming
-        text_chunks = self._generate_stream_chunks(prompt)
+                    tool_calls_found.append({
+                        "name": call.name,
+                        "arguments": call.arguments,
+                        "id": "",
+                        "final_answer": getattr(call, 'final_answer', None),
+                    })
 
-        # 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
+            # ---- 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
+
+                    # 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
+                    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
+                    else:
+                        _expecting_final_answer = True
+                        _last_successful_result = str(result)
+
+                    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
+
+            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 +1275,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 +1305,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]}...")

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

@@ -761,14 +761,22 @@ class OllamaBackend(BaseBackend):
 
     def get_model_info(self, model: str) -> dict | None:
         """
-        Get detailed model information from Ollama.
+        Get detailed model information from Ollama (with per-instance caching).
         
         Uses /api/show endpoint which returns:
         - modelfile
         - parameters (including num_ctx)
         - template
         - details (family, parameter count, etc.)
+        
+        Results are cached for the lifetime of the backend instance.
         """
+        # Check instance cache first
+        if not hasattr(self, '_model_info_cache'):
+            self._model_info_cache = {}
+        if model in self._model_info_cache:
+            return self._model_info_cache[model]
+
         import urllib.request
         import urllib.error
 
@@ -785,7 +793,9 @@ class OllamaBackend(BaseBackend):
             )
 
             with urllib.request.urlopen(req, timeout=10) as response:
-                return json.loads(response.read().decode("utf-8"))
+                data = json.loads(response.read().decode("utf-8"))
+                self._model_info_cache[model] = data
+                return data
 
         except (urllib.error.HTTPError, urllib.error.URLError):
             return None
@@ -861,54 +871,54 @@ class OllamaBackend(BaseBackend):
         """
         Get the model's maximum trained context window size.
         
-        This is the context_length from model_info, representing the model's
-        capability regardless of runtime settings.
+        Resolution order (most authoritative first):
+        1. API /api/show → model_info.<family>.context_length  (exact model data)
+        2. API /api/show → details.family → FAMILY_CONTEXT_DEFAULTS lookup
+        3. Caller-provided family → FAMILY_CONTEXT_DEFAULTS lookup
+        4. Hardcoded fallback 4096
         
         Args:
             model: Model name
-            family: Optional family name (uses default if provided)
+            family: Optional family name (fallback if API doesn't report it)
         
         Returns:
             Maximum context window size in tokens
         """
-        # Fast path: use family default
-        if family:
-            ctx = self.get_context_by_family(family)
-            if ctx:
-                return ctx
-        
-        # Slow path: get from API
+        # Primary: ask the API for the model's actual context_length
         info = self.get_model_info(model)
         
-        if not info:
-            return 4096  # Fallback
-        
-        # Check model_info for context_length
-        # Key format: "<family>.context_length" (e.g., "gemma3.context_length", "qwen2.context_length")
-        model_info = info.get("model_info", {})
-        for key, value in model_info.items():
-            if key.endswith(".context_length"):
+        if info:
+            model_info = info.get("model_info", {})
+            # Key format: "<family>.context_length" (e.g., "gemma3.context_length")
+            for key, value in model_info.items():
+                if key.endswith(".context_length"):
+                    try:
+                        return int(value)
+                    except (ValueError, TypeError):
+                        pass
+            
+            # Fallback: bare "context_length" key (some Ollama versions)
+            if "context_length" in model_info:
                 try:
-                    return int(value)
+                    return int(model_info["context_length"])
                 except (ValueError, TypeError):
                     pass
+            
+            # Try family from API details (more reliable than caller-provided)
+            details = info.get("details", {})
+            api_family = details.get("family", "")
+            if api_family:
+                ctx = self.get_context_by_family(api_family)
+                if ctx:
+                    return ctx
         
-        # Fallback: check for bare "context_length" key (some versions)
-        if "context_length" in model_info:
-            try:
-                return int(model_info["context_length"])
-            except (ValueError, TypeError):
-                pass
-        
-        # Check details for family
-        details = info.get("details", {})
-        api_family = details.get("family", "").lower()
-        
-        ctx = self.get_context_by_family(api_family)
-        if ctx:
-            return ctx
+        # Fallback: use caller-provided family or hardcoded table
+        if family:
+            ctx = self.get_context_by_family(family)
+            if ctx:
+                return ctx
         
-        return 4096  # Fallback
+        return 4096  # Ultimate fallback
 
     def get_model_context_size(self, model: str, family: str | None = None) -> int:
         """