hdsp-jupyter-extension 2.0.10__py3-none-any.whl → 2.0.11__py3-none-any.whl

agent_server/routers/langchain_agent.py

@@ -909,6 +909,26 @@ async def stream_agent(request: AgentRequest):
                                         "event": "todos",
                                         "data": json.dumps({"todos": todos}),
                                     }
+                                    # Check if all todos are completed - terminate early
+                                    all_completed = all(
+                                        t.get("status") == "completed" for t in todos
+                                    )
+                                    if all_completed and len(todos) > 0:
+                                        logger.info(
+                                            "All %d todos completed in AIMessage tool_calls, auto-terminating",
+                                            len(todos),
+                                        )
+                                        yield {
+                                            "event": "debug_clear",
+                                            "data": json.dumps({}),
+                                        }
+                                        yield {
+                                            "event": "done",
+                                            "data": json.dumps(
+                                                {"reason": "all_todos_completed"}
+                                            ),
+                                        }
+                                        return  # Exit before executing more tool calls
                                 for tool_call in tool_calls:
                                     tool_name = tool_call.get("name", "unknown")
                                     tool_args = tool_call.get("args", {})
@@ -1032,16 +1052,31 @@ async def stream_agent(request: AgentRequest):
                                     content = "\n".join(text_parts)
 
                                 # Filter out raw JSON tool responses
+                                content_stripped = content.strip() if content else ""
+
+                                # Filter out tool call JSON (but allow summary/next_items JSON for frontend rendering)
+                                is_json_tool_response = (
+                                    content_stripped.startswith('{"tool":')
+                                    or content_stripped.startswith('{ "tool":')
+                                    or content_stripped.startswith('{"tool" :')
+                                    or content_stripped.startswith('{"status":')
+                                    or '"pending_execution"' in content
+                                    or '"status": "complete"' in content
+                                    or (
+                                        '"tool"' in content
+                                        and '"write_todos"' in content
+                                    )
+                                    or (
+                                        '"tool"' in content
+                                        and '"arguments"' in content
+                                        and content_stripped.startswith("{")
+                                    )
+                                )
                                 if (
                                     content
                                     and isinstance(content, str)
                                     and not has_final_answer_tool
-                                    and not (
-                                        content.strip().startswith('{"tool":')
-                                        or content.strip().startswith('{"status":')
-                                        or '"pending_execution"' in content
-                                        or '"status": "complete"' in content
-                                    )
+                                    and not is_json_tool_response
                                 ):
                                     # Check if we've already emitted this content (prevents duplicates)
                                     content_hash = hash(content)
@@ -1814,16 +1849,27 @@ async def resume_agent(request: ResumeRequest):
                                 content = "\n".join(text_parts)
 
                             # Filter out raw JSON tool responses
+                            content_stripped = content.strip() if content else ""
+                            # Filter out tool call JSON (but allow summary/next_items JSON for frontend rendering)
+                            is_json_tool_response = (
+                                content_stripped.startswith('{"tool":')
+                                or content_stripped.startswith('{ "tool":')
+                                or content_stripped.startswith('{"tool" :')
+                                or content_stripped.startswith('{"status":')
+                                or '"pending_execution"' in content
+                                or '"status": "complete"' in content
+                                or ('"tool"' in content and '"write_todos"' in content)
+                                or (
+                                    '"tool"' in content
+                                    and '"arguments"' in content
+                                    and content_stripped.startswith("{")
+                                )
+                            )
                             if (
                                 content
                                 and isinstance(content, str)
                                 and not has_final_answer_tool
-                                and not (
-                                    content.strip().startswith('{"tool":')
-                                    or content.strip().startswith('{"status":')
-                                    or '"pending_execution"' in content
-                                    or '"status": "complete"' in content
-                                )
+                                and not is_json_tool_response
                             ):
                                 # Check if we've already emitted this content (prevents duplicates)
                                 content_hash = hash(content)
@@ -1874,6 +1920,26 @@ async def resume_agent(request: ResumeRequest):
                                         "event": "todos",
                                         "data": json.dumps({"todos": todos}),
                                     }
+                                    # Check if all todos are completed - terminate early
+                                    all_completed = all(
+                                        t.get("status") == "completed" for t in todos
+                                    )
+                                    if all_completed and len(todos) > 0:
+                                        logger.info(
+                                            "Resume: All %d todos completed in AIMessage tool_calls, auto-terminating",
+                                            len(todos),
+                                        )
+                                        yield {
+                                            "event": "debug_clear",
+                                            "data": json.dumps({}),
+                                        }
+                                        yield {
+                                            "event": "done",
+                                            "data": json.dumps(
+                                                {"reason": "all_todos_completed"}
+                                            ),
+                                        }
+                                        return  # Exit before executing more tool calls
 
                                 # Process tool calls
                                 for tool_call in new_tool_calls:

hdsp_agent_core/__init__.py

@@ -15,77 +15,76 @@ Modules:
 __version__ = "1.0.0"
 
 # Models
+# Knowledge
+from hdsp_agent_core.knowledge import (
+    LIBRARY_DESCRIPTIONS,
+    DocumentChunker,
+    KnowledgeBase,
+    KnowledgeLoader,
+    LibraryDetector,
+    chunk_file,
+    get_knowledge_base,
+    get_knowledge_loader,
+    get_library_detector,
+)
+
+# LLM
+from hdsp_agent_core.llm import (
+    LLMService,
+    call_llm,
+    call_llm_stream,
+)
+
+# Managers
+from hdsp_agent_core.managers import (
+    ConfigManager,
+    SessionManager,
+    get_config_manager,
+    get_session_manager,
+)
 from hdsp_agent_core.models import (
     # Common
     APIResponse,
+    # Chat
+    ChatRequest,
+    ChatResponse,
+    # RAG
+    ChunkingConfig,
+    EmbeddingConfig,
     ErrorInfo,
+    # Agent
+    ExecutionPlan,
     GeminiConfig,
+    IndexStatusResponse,
     LLMConfig,
     NotebookContext,
     OpenAIConfig,
-    ToolCall,
-    VLLMConfig,
-    # Agent
-    ExecutionPlan,
     PlanRequest,
     PlanResponse,
     PlanStep,
-    RefineRequest,
-    RefineResponse,
-    ReplanRequest,
-    ReplanResponse,
-    ValidationIssue,
-    # Chat
-    ChatRequest,
-    ChatResponse,
-    StreamChunk,
-    # RAG
-    ChunkingConfig,
-    EmbeddingConfig,
-    IndexStatusResponse,
     QdrantConfig,
     RAGConfig,
+    RefineRequest,
+    RefineResponse,
     ReindexRequest,
     ReindexResponse,
+    ReplanRequest,
+    ReplanResponse,
     SearchRequest,
     SearchResponse,
+    StreamChunk,
+    ToolCall,
+    ValidationIssue,
+    VLLMConfig,
     WatchdogConfig,
 )
 
-# Managers
-from hdsp_agent_core.managers import (
-    ConfigManager,
-    SessionManager,
-    get_config_manager,
-    get_session_manager,
-)
-
-# LLM
-from hdsp_agent_core.llm import (
-    LLMService,
-    call_llm,
-    call_llm_stream,
-)
-
-# Knowledge
-from hdsp_agent_core.knowledge import (
-    DocumentChunker,
-    KnowledgeBase,
-    KnowledgeLoader,
-    LibraryDetector,
-    chunk_file,
-    get_knowledge_base,
-    get_knowledge_loader,
-    get_library_detector,
-    LIBRARY_DESCRIPTIONS,
-)
-
 # Prompts
 from hdsp_agent_core.prompts import (
-    PLAN_GENERATION_PROMPT,
+    ADAPTIVE_REPLAN_PROMPT,
     CODE_GENERATION_PROMPT,
     ERROR_REFINEMENT_PROMPT,
-    ADAPTIVE_REPLAN_PROMPT,
+    PLAN_GENERATION_PROMPT,
     format_plan_prompt,
     format_refine_prompt,
     format_replan_prompt,

hdsp_agent_core/factory.py

@@ -21,8 +21,9 @@ logger = logging.getLogger(__name__)
 
 class AgentMode(Enum):
     """Agent execution mode"""
+
     EMBEDDED = "embedded"  # Direct in-process execution
-    PROXY = "proxy"        # HTTP proxy to external server
+    PROXY = "proxy"  # HTTP proxy to external server
 
 
 class ServiceFactory:
@@ -84,9 +85,7 @@ class ServiceFactory:
         elif mode_str == "proxy":
             return AgentMode.PROXY
         else:
-            logger.warning(
-                f"Unknown HDSP_AGENT_MODE '{mode_str}', defaulting to proxy"
-            )
+            logger.warning(f"Unknown HDSP_AGENT_MODE '{mode_str}', defaulting to proxy")
             return AgentMode.PROXY
 
     @property
@@ -164,16 +163,13 @@ class ServiceFactory:
 
         # Create proxy service instances
         self._agent_service = ProxyAgentService(
-            base_url=self._server_url,
-            timeout=self._timeout
+            base_url=self._server_url, timeout=self._timeout
         )
         self._chat_service = ProxyChatService(
-            base_url=self._server_url,
-            timeout=self._timeout
+            base_url=self._server_url, timeout=self._timeout
         )
         self._rag_service = ProxyRAGService(
-            base_url=self._server_url,
-            timeout=self._timeout
+            base_url=self._server_url, timeout=self._timeout
         )
 
         # Optionally validate connectivity

hdsp_agent_core/interfaces.py

@@ -73,7 +73,9 @@ class IAgentService(ABC):
         ...
 
     @abstractmethod
-    async def validate_code(self, code: str, notebook_context: Optional[Dict] = None) -> Dict[str, Any]:
+    async def validate_code(
+        self, code: str, notebook_context: Optional[Dict] = None
+    ) -> Dict[str, Any]:
         """
         Validate code before execution.
 
@@ -154,7 +156,7 @@ class IRAGService(ABC):
         self,
         query: str,
         detected_libraries: Optional[List[str]] = None,
-        max_results: int = 5
+        max_results: int = 5,
     ) -> Optional[str]:
         """
         Get formatted context for a query (for prompt injection).

hdsp_agent_core/knowledge/__init__.py

@@ -4,18 +4,18 @@ HDSP Agent Core - Knowledge Base
 Deterministic library detection and API guide management.
 """
 
+from .chunking import (
+    DocumentChunker,
+    chunk_file,
+)
 from .loader import (
+    LIBRARY_DESCRIPTIONS,
     KnowledgeBase,
     KnowledgeLoader,
     LibraryDetector,
     get_knowledge_base,
     get_knowledge_loader,
     get_library_detector,
-    LIBRARY_DESCRIPTIONS,
-)
-from .chunking import (
-    DocumentChunker,
-    chunk_file,
 )
 
 __all__ = [

hdsp_agent_core/knowledge/chunking.py

@@ -9,10 +9,10 @@ Provides intelligent chunking strategies:
 Each strategy preserves context and adds relevant metadata.
 """
 
-import re
 import logging
-from typing import List, Dict, Any, Optional, TYPE_CHECKING
+import re
 from pathlib import Path
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
 
 if TYPE_CHECKING:
     from hdsp_agent_core.models.rag import ChunkingConfig
@@ -36,13 +36,14 @@ class DocumentChunker:
 
     def __init__(self, config: Optional["ChunkingConfig"] = None):
         from hdsp_agent_core.models.rag import ChunkingConfig
+
         self._config = config or ChunkingConfig()
 
     def chunk_document(
         self,
         content: str,
         metadata: Optional[Dict[str, Any]] = None,
-        file_type: Optional[str] = None
+        file_type: Optional[str] = None,
     ) -> List[Dict[str, Any]]:
         """
         Chunk document based on content type.
@@ -75,13 +76,12 @@ class DocumentChunker:
         for chunk in chunks:
             chunk_content = chunk["content"].strip()
             if len(chunk_content) >= self._config.min_chunk_size:
-                result.append({
-                    "content": chunk_content,
-                    "metadata": {
-                        **metadata,
-                        **chunk.get("metadata", {})
+                result.append(
+                    {
+                        "content": chunk_content,
+                        "metadata": {**metadata, **chunk.get("metadata", {})},
                     }
-                })
+                )
 
         logger.debug(f"Chunked document into {len(result)} chunks (type={file_type})")
         return result
@@ -108,9 +108,9 @@ class DocumentChunker:
         - Respect max chunk size with sub-splitting
         """
         # Pattern for markdown headers
-        header_pattern = r'^(#{1,6})\s+(.+)$'
+        header_pattern = r"^(#{1,6})\s+(.+)$"
 
-        lines = content.split('\n')
+        lines = content.split("\n")
         chunks = []
         current_chunk_lines = []
         current_headers = []  # Stack of (level, text)
@@ -121,13 +121,19 @@ class DocumentChunker:
             if header_match:
                 # Save current chunk if it has content
                 if current_chunk_lines:
-                    chunk_content = '\n'.join(current_chunk_lines).strip()
+                    chunk_content = "\n".join(current_chunk_lines).strip()
                     if chunk_content:
-                        section_path = ' > '.join(h[1] for h in current_headers) if current_headers else "Introduction"
-                        chunks.append({
-                            "content": chunk_content,
-                            "metadata": {"section": section_path}
-                        })
+                        section_path = (
+                            " > ".join(h[1] for h in current_headers)
+                            if current_headers
+                            else "Introduction"
+                        )
+                        chunks.append(
+                            {
+                                "content": chunk_content,
+                                "metadata": {"section": section_path},
+                            }
+                        )
 
                 # Update header stack
                 level = len(header_match.group(1))
@@ -143,26 +149,35 @@ class DocumentChunker:
                 current_chunk_lines.append(line)
 
                 # Check chunk size limit
-                chunk_text = '\n'.join(current_chunk_lines)
+                chunk_text = "\n".join(current_chunk_lines)
                 if len(chunk_text) >= self._config.max_chunk_size:
-                    section_path = ' > '.join(h[1] for h in current_headers) if current_headers else "Content"
-                    chunks.append({
-                        "content": chunk_text.strip(),
-                        "metadata": {"section": section_path}
-                    })
+                    section_path = (
+                        " > ".join(h[1] for h in current_headers)
+                        if current_headers
+                        else "Content"
+                    )
+                    chunks.append(
+                        {
+                            "content": chunk_text.strip(),
+                            "metadata": {"section": section_path},
+                        }
+                    )
                     # Keep overlap for context continuity
                     overlap_lines = self._get_overlap_lines(current_chunk_lines)
                     current_chunk_lines = overlap_lines
 
         # Save final chunk
         if current_chunk_lines:
-            chunk_content = '\n'.join(current_chunk_lines).strip()
+            chunk_content = "\n".join(current_chunk_lines).strip()
             if chunk_content:
-                section_path = ' > '.join(h[1] for h in current_headers) if current_headers else "Content"
-                chunks.append({
-                    "content": chunk_content,
-                    "metadata": {"section": section_path}
-                })
+                section_path = (
+                    " > ".join(h[1] for h in current_headers)
+                    if current_headers
+                    else "Content"
+                )
+                chunks.append(
+                    {"content": chunk_content, "metadata": {"section": section_path}}
+                )
 
         return chunks
 
@@ -176,9 +191,9 @@ class DocumentChunker:
         - Preserve import statements and module docstrings
         """
         # Pattern for class and function definitions (top-level only)
-        def_pattern = r'^(class|def|async\s+def)\s+(\w+)'
+        def_pattern = r"^(class|def|async\s+def)\s+(\w+)"
 
-        lines = content.split('\n')
+        lines = content.split("\n")
         chunks = []
         current_chunk_lines = []
         current_def = None
@@ -193,15 +208,21 @@ class DocumentChunker:
             def_match = re.match(def_pattern, line)
 
             # Check if this is a top-level definition (not indented)
-            if def_match and not line.startswith((' ', '\t')) and not in_multiline_string:
+            if (
+                def_match
+                and not line.startswith((" ", "\t"))
+                and not in_multiline_string
+            ):
                 # Save current chunk
                 if current_chunk_lines:
-                    chunk_content = '\n'.join(current_chunk_lines).strip()
+                    chunk_content = "\n".join(current_chunk_lines).strip()
                     if chunk_content:
-                        chunks.append({
-                            "content": chunk_content,
-                            "metadata": {"definition": current_def or "module"}
-                        })
+                        chunks.append(
+                            {
+                                "content": chunk_content,
+                                "metadata": {"definition": current_def or "module"},
+                            }
+                        )
 
                 current_def = f"{def_match.group(1)} {def_match.group(2)}"
                 current_chunk_lines = [line]
@@ -209,22 +230,26 @@ class DocumentChunker:
                 current_chunk_lines.append(line)
 
                 # Check max chunk size
-                if len('\n'.join(current_chunk_lines)) >= self._config.max_chunk_size:
-                    chunks.append({
-                        "content": '\n'.join(current_chunk_lines).strip(),
-                        "metadata": {"definition": current_def or "module"}
-                    })
+                if len("\n".join(current_chunk_lines)) >= self._config.max_chunk_size:
+                    chunks.append(
+                        {
+                            "content": "\n".join(current_chunk_lines).strip(),
+                            "metadata": {"definition": current_def or "module"},
+                        }
+                    )
                     overlap_lines = self._get_overlap_lines(current_chunk_lines)
                     current_chunk_lines = overlap_lines
 
         # Save final chunk
         if current_chunk_lines:
-            chunk_content = '\n'.join(current_chunk_lines).strip()
+            chunk_content = "\n".join(current_chunk_lines).strip()
             if chunk_content:
-                chunks.append({
-                    "content": chunk_content,
-                    "metadata": {"definition": current_def or "module"}
-                })
+                chunks.append(
+                    {
+                        "content": chunk_content,
+                        "metadata": {"definition": current_def or "module"},
+                    }
+                )
 
         return chunks
 
@@ -251,10 +276,12 @@ class DocumentChunker:
             if end >= len(content):
                 chunk_content = content[start:].strip()
                 if chunk_content:
-                    chunks.append({
-                        "content": chunk_content,
-                        "metadata": {"chunk_index": chunk_index}
-                    })
+                    chunks.append(
+                        {
+                            "content": chunk_content,
+                            "metadata": {"chunk_index": chunk_index},
+                        }
+                    )
                 break
 
             # Try to find a good break point
@@ -263,10 +290,9 @@ class DocumentChunker:
 
             chunk_content = content[start:end].strip()
             if chunk_content:
-                chunks.append({
-                    "content": chunk_content,
-                    "metadata": {"chunk_index": chunk_index}
-                })
+                chunks.append(
+                    {"content": chunk_content, "metadata": {"chunk_index": chunk_index}}
+                )
 
             # Move start with overlap
             start = max(end - overlap, start + 1)
@@ -288,12 +314,12 @@ class DocumentChunker:
         search_start = start + (end - start) // 2  # Search in latter half
 
         # Try paragraph break (double newline)
-        para_break = content.rfind('\n\n', search_start, end)
+        para_break = content.rfind("\n\n", search_start, end)
         if para_break > search_start:
             return para_break + 2
 
         # Try sentence break (. or ! or ? followed by space or newline)
-        sentence_pattern = r'[.!?]\s'
+        sentence_pattern = r"[.!?]\s"
         for match in re.finditer(sentence_pattern, content[search_start:end]):
             last_match_end = search_start + match.end()
         else:
@@ -301,15 +327,15 @@ class DocumentChunker:
 
         # Find last sentence break
         for i in range(end - 1, search_start, -1):
-            if i + 1 < len(content) and content[i] in '.!?' and content[i + 1] in ' \n':
+            if i + 1 < len(content) and content[i] in ".!?" and content[i + 1] in " \n":
                 return i + 1
 
         # Try word break (space or newline)
-        space_break = content.rfind(' ', search_start, end)
+        space_break = content.rfind(" ", search_start, end)
         if space_break > search_start:
             return space_break + 1
 
-        newline_break = content.rfind('\n', search_start, end)
+        newline_break = content.rfind("\n", search_start, end)
         if newline_break > search_start:
             return newline_break + 1
 
@@ -333,7 +359,7 @@ class DocumentChunker:
 def chunk_file(
     file_path: Path,
     config: Optional["ChunkingConfig"] = None,
-    base_metadata: Optional[Dict[str, Any]] = None
+    base_metadata: Optional[Dict[str, Any]] = None,
 ) -> List[Dict[str, Any]]:
     """
     Convenience function to chunk a file directly.