agentnova 0.3.4__tar.gz → 0.3.5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentnova
-Version: 0.3.4
+Version: 0.3.5
 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.5
 
 **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.5}/README.md

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

{agentnova-0.3.4 → agentnova-0.3.5}/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.5}/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
@@ -852,6 +853,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,

{agentnova-0.3.4 → agentnova-0.3.5}/agentnova/backends/ollama.py

@@ -296,6 +296,13 @@ class OllamaBackend(BaseBackend):
         frequency_penalty: float | None = None,
         response_format: dict | None = None,
         top_p: float | None = None,
+        # OpenAI Chat Completions API spec completeness (v1.0)
+        logprobs: bool | None = None,
+        top_logprobs: int | None = None,
+        n: int | None = None,
+        user: str | None = None,
+        # Tool choice control (OpenAI API spec)
+        tool_choice: str | dict | None = None,
         **kwargs,
     ) -> dict:
         """Generate a response using OpenAI Chat-Completions compatible API.
@@ -315,6 +322,10 @@ class OllamaBackend(BaseBackend):
             frequency_penalty: Frequency penalty (-2.0 to 2.0)
             response_format: Response format (e.g., {"type": "json_object"})
             top_p: Top-p sampling (0.0 to 1.0)
+            logprobs: Whether to return log probabilities of output tokens
+            top_logprobs: Number of most likely tokens to return at each position (requires logprobs=True)
+            n: Number of completions to generate (default: 1)
+            user: Unique identifier representing the end-user for abuse monitoring
             **kwargs: Additional options passed to Ollama
         """
         import urllib.request
@@ -343,20 +354,34 @@ class OllamaBackend(BaseBackend):
             body["response_format"] = response_format
         if top_p is not None:
             body["top_p"] = top_p
+        
+        # Add OpenAI API spec completeness parameters (v1.0)
+        if logprobs is not None:
+            body["logprobs"] = logprobs
+        if top_logprobs is not None:
+            body["top_logprobs"] = top_logprobs
+        if n is not None:
+            body["n"] = n
+        if user is not None:
+            body["user"] = user
 
         # Add tools in OpenAI format
         if tools:
             body["tools"] = [t.to_openai_schema() for t in tools]
+        
+        # Add tool_choice parameter (OpenAI API spec)
+        # Supports: "auto", "none", "required", or {"type": "function", "function": {"name": "..."}}
+        if tool_choice is not None:
+            body["tool_choice"] = tool_choice
 
-        # Add think parameter for thinking models
+        # Add think parameter for thinking models (qwen3, deepseek-r1)
+        # Ollama's OpenAI-compatible endpoint supports this in the request body
         if think is not None:
-            # Note: OpenAI-compatible endpoint may not support 'think' natively
-            # This is Ollama-specific, might need to be in extra body
-            pass
+            body["think"] = think
 
         # Debug output for request
         if os.environ.get("AGENTNOVA_DEBUG"):
-            print(f"  [OpenAI-Comp] Request: tools={len(tools) if tools else 0}")
+            print(f"  [OpenAI-Comp] Request: tools={len(tools) if tools else 0}, think={think}")
 
         # Make request
         start_time = time.time()
@@ -414,48 +439,86 @@ class OllamaBackend(BaseBackend):
                 "raw": result,
             }
 
-        choice = choices[0]
-        message = choice.get("message", {})
-        content = message.get("content", "")
-        tool_calls = message.get("tool_calls", [])
-
-        # Debug output
-        if os.environ.get("AGENTNOVA_DEBUG"):
-            print(f"  [OpenAI-Comp] Content: {content[:1024] if content else '(empty)'}")
-            print(f"  [OpenAI-Comp] Tool calls: {tool_calls}")
+        # Helper function to parse a single choice
+        def _parse_choice(choice: dict) -> dict:
+            """Parse a single choice from OpenAI format response."""
+            message = choice.get("message", {})
+            content = message.get("content", "")
+            tool_calls = message.get("tool_calls", [])
+            finish_reason = choice.get("finish_reason")
+
+            # Parse tool calls from OpenAI format
+            # OpenAI format: {"id": "...", "type": "function", "function": {"name": "...", "arguments": "{...}"}}
+            parsed_tool_calls = []
+            for tc in tool_calls:
+                func = tc.get("function", {})
+                args = func.get("arguments", "{}")
+                # OpenAI returns arguments as JSON string, parse it
+                if isinstance(args, str):
+                    try:
+                        args = json.loads(args)
+                    except json.JSONDecodeError:
+                        args = {}
+                parsed_tool_calls.append({
+                    "id": tc.get("id", ""),
+                    "name": func.get("name", ""),
+                    "arguments": args,
+                })
+
+            # Extract logprobs if present
+            choice_logprobs = None
+            if logprobs:
+                choice_logprobs = choice.get("logprobs")
 
-        # Parse tool calls from OpenAI format
-        # OpenAI format: {"id": "...", "type": "function", "function": {"name": "...", "arguments": "{...}"}}
-        parsed_tool_calls = []
-        for tc in tool_calls:
-            func = tc.get("function", {})
-            args = func.get("arguments", "{}")
-            # OpenAI returns arguments as JSON string, parse it
-            if isinstance(args, str):
-                try:
-                    args = json.loads(args)
-                except json.JSONDecodeError:
-                    args = {}
-            parsed_tool_calls.append({
-                "id": tc.get("id", ""),
-                "name": func.get("name", ""),
-                "arguments": args,
-            })
+            return {
+                "content": content,
+                "tool_calls": parsed_tool_calls,
+                "finish_reason": finish_reason,
+                "logprobs": choice_logprobs,
+            }
 
         usage = result.get("usage", {})
 
-        return {
-            "content": content,
-            "tool_calls": parsed_tool_calls,
+        # OpenAI Chat Completions API v1.0: Handle multiple completions (n > 1)
+        # When n > 1, process ALL choices and return them under "choices" (plural) key
+        # Maintain backward compatibility by also including first choice under existing keys
+        num_choices = len(choices)
+        parsed_choices = [_parse_choice(choice) for choice in choices]
+
+        # First choice for backward-compatible keys
+        first_choice = parsed_choices[0]
+        content = first_choice["content"]
+        parsed_tool_calls = first_choice["tool_calls"]
+        finish_reason = first_choice["finish_reason"]
+        logprobs_result = first_choice["logprobs"]
+
+        # Debug output
+        if os.environ.get("AGENTNOVA_DEBUG"):
+            print(f"  [OpenAI-Comp] Choices: {num_choices}")
+            print(f"  [OpenAI-Comp] Content[0]: {content[:1024] if content else '(empty)'}")
+            print(f"  [OpenAI-Comp] Tool calls[0]: {parsed_tool_calls}")
+
+        # Build response dict
+        response = {
+            "content": content,  # Backward compatible: first choice content
+            "tool_calls": parsed_tool_calls,  # Backward compatible: first choice tool calls
+            "finish_reason": finish_reason,  # OpenAI API spec: "stop", "length", "tool_calls", "content_filter"
             "usage": {
                 "prompt_tokens": usage.get("prompt_tokens", 0),
                 "completion_tokens": usage.get("completion_tokens", 0),
                 "total_tokens": usage.get("total_tokens", 0),
             },
             "latency_ms": latency_ms,
+            "logprobs": logprobs_result,
             "raw": result,
         }
 
+        # When n > 1, include all choices under "choices" key (OpenAI API spec compliance)
+        if num_choices > 1:
+            response["choices"] = parsed_choices
+
+        return response
+
     def generate_completions_stream(
         self,
         model: str,
@@ -463,11 +526,17 @@ class OllamaBackend(BaseBackend):
         tools: list[Tool] | None = None,
         temperature: float = 0.7,
         max_tokens: int = 2048,
+        think: bool | None = None,
         stop: str | list[str] | None = None,
         presence_penalty: float | None = None,
         frequency_penalty: float | None = None,
         response_format: dict | None = None,
         top_p: float | None = None,
+        # OpenAI Chat Completions API spec completeness (v1.0)
+        logprobs: bool | None = None,
+        top_logprobs: int | None = None,
+        n: int | None = None,
+        user: str | None = None,
         **kwargs,
     ) -> Generator[dict, None, None]:
         """Stream generated text using OpenAI Chat-Completions compatible API with SSE.
@@ -479,6 +548,7 @@ class OllamaBackend(BaseBackend):
             - "delta": text delta from the model
             - "finish_reason": None or "stop" when complete
             - "tool_calls": incremental tool call data (if any)
+            - "logprobs": log probability data (when logprobs=True)
         
         Args:
             model: Model name
@@ -486,15 +556,20 @@ class OllamaBackend(BaseBackend):
             tools: List of Tool objects for native tool calling
             temperature: Sampling temperature
             max_tokens: Maximum tokens to generate
+            think: For thinking models (qwen3, deepseek-r1): None=auto, False=disable thinking
             stop: Stop sequences (string or list of strings)
             presence_penalty: Presence penalty (-2.0 to 2.0)
             frequency_penalty: Frequency penalty (-2.0 to 2.0)
             response_format: Response format (e.g., {"type": "json_object"})
             top_p: Top-p sampling (0.0 to 1.0)
+            logprobs: Whether to return log probabilities of output tokens
+            top_logprobs: Number of most likely tokens to return at each position
+            n: Number of completions to generate (default: 1)
+            user: Unique identifier representing the end-user for abuse monitoring
             **kwargs: Additional options
             
         Yields:
-            Dict with "delta", "finish_reason", and optionally "tool_calls"
+            Dict with "delta", "finish_reason", and optionally "tool_calls" and "logprobs"
         """
         import urllib.request
         import urllib.error
@@ -521,12 +596,26 @@ class OllamaBackend(BaseBackend):
             body["response_format"] = response_format
         if top_p is not None:
             body["top_p"] = top_p
+        
+        # Add OpenAI API spec completeness parameters (v1.0)
+        if logprobs is not None:
+            body["logprobs"] = logprobs
+        if top_logprobs is not None:
+            body["top_logprobs"] = top_logprobs
+        if n is not None:
+            body["n"] = n
+        if user is not None:
+            body["user"] = user
 
         if tools:
             body["tools"] = [t.to_openai_schema() for t in tools]
 
+        # Add think parameter for thinking models (qwen3, deepseek-r1)
+        if think is not None:
+            body["think"] = think
+
         if os.environ.get("AGENTNOVA_DEBUG"):
-            print(f"  [OpenAI-Comp-Stream] Request: tools={len(tools) if tools else 0}")
+            print(f"  [OpenAI-Comp-Stream] Request: tools={len(tools) if tools else 0}, think={think}")
 
         try:
             req = urllib.request.Request(
@@ -538,6 +627,7 @@ class OllamaBackend(BaseBackend):
 
             with urllib.request.urlopen(req, timeout=self.config.timeout) as response:
                 buffer = ""
+                last_finish_reason = None
                 for line in response:
                     line = line.decode("utf-8")
                     
@@ -547,6 +637,13 @@ class OllamaBackend(BaseBackend):
                         
                         # Check for end of stream
                         if data_str == "[DONE]":
+                            # Yield final chunk with finish_reason if not already sent
+                            if last_finish_reason is None:
+                                yield {
+                                    "delta": "",
+                                    "finish_reason": "stop",  # Default to "stop" when [DONE] received
+                                    "tool_calls": None,
+                                }
                             break
                         
                         try:
@@ -561,18 +658,33 @@ class OllamaBackend(BaseBackend):
                         delta = choices[0].get("delta", {})
                         finish_reason = choices[0].get("finish_reason")
                         
+                        # Track last finish_reason for final chunk
+                        if finish_reason:
+                            last_finish_reason = finish_reason
+                        
                         # Extract text content from delta
                         text_delta = delta.get("content", "")
                         
                         # Extract tool calls if present
                         tool_calls_delta = delta.get("tool_calls", None)
                         
-                        yield {
+                        # Extract logprobs if present (OpenAI API spec completeness)
+                        # In streaming mode, logprobs are returned per-chunk in choices[0].logprobs
+                        logprobs_data = choices[0].get("logprobs") if logprobs else None
+                        
+                        # Build yield dict with required fields
+                        yield_chunk = {
                             "delta": text_delta,
                             "finish_reason": finish_reason,
                             "tool_calls": tool_calls_delta,
                         }
                         
+                        # Include logprobs in yield when available
+                        if logprobs_data is not None:
+                            yield_chunk["logprobs"] = logprobs_data
+                        
+                        yield yield_chunk
+                        
                         if finish_reason:
                             break
 

{agentnova-0.3.4 → agentnova-0.3.5}/agentnova/cli.py

@@ -238,7 +238,7 @@ def print_banner() -> None:
     # Convert 0.3.3 to R03.3 format for display
     parts = __version__.split('.')
     display_version = f"R{int(parts[1]):02d}.{parts[2]}" if len(parts) >= 2 else __version__    
-    version_str = f"v{display_version} [{__status__}]"
+    version_str = f"{display_version} [{__status__}]"
     if _COLOR_ENABLED:
         # Replace ANSI-colored "Status: Alpha" with version
         banner = BANNER_ATOM_BRAILLE.replace("\x1b[2mStatus:\x1b[0m \x1b[33mAlpha\x1b[0m", f"\x1b[2m{version_str}\x1b[0m")