hdsp-jupyter-extension 2.0.25__py3-none-any.whl → 2.0.27__py3-none-any.whl

agent_server/langchain/agent_factory.py

@@ -315,24 +315,24 @@ def create_main_agent(
         except Exception as e:
             logger.warning(f"Failed to add SummarizationMiddleware: {e}")
 
-    # Build system prompt - FORCE default prompt for testing
-    # TODO: Remove this override after frontend localStorage is cleared
-    # Original priority: system_prompt_override > agent_prompts.planner > default
-    # DEBUG: Log all prompt sources to find root cause of MALFORMED_FUNCTION_CALL
+    # Build system prompt with priority: system_prompt_override > agent_prompts.planner > default
     logger.info(
-        "DEBUG Main Agent prompt sources: system_prompt_override=%s, "
-        "agent_prompts.planner=%s, using=DEFAULT",
+        "Main Agent prompt sources: system_prompt_override=%s (len=%d), "
+        "agent_prompts.planner=%s",
         bool(system_prompt_override),
+        len(system_prompt_override) if system_prompt_override else 0,
         bool(agent_prompts.get("planner") if agent_prompts else None),
     )
-    if agent_prompts:
-        logger.info(
-            "DEBUG: agent_prompts keys=%s, planner prompt length=%d",
-            list(agent_prompts.keys()),
-            len(agent_prompts.get("planner", "") or ""),
-        )
-    system_prompt = PLANNER_SYSTEM_PROMPT
-    logger.info("Using PLANNER_SYSTEM_PROMPT (length=%d)", len(system_prompt))
+
+    if system_prompt_override and system_prompt_override.strip():
+        system_prompt = system_prompt_override.strip()
+        logger.info("Using system_prompt_override (length=%d)", len(system_prompt))
+    elif agent_prompts and agent_prompts.get("planner"):
+        system_prompt = agent_prompts["planner"]
+        logger.info("Using agent_prompts.planner (length=%d)", len(system_prompt))
+    else:
+        system_prompt = PLANNER_SYSTEM_PROMPT
+        logger.info("Using PLANNER_SYSTEM_PROMPT (length=%d)", len(system_prompt))
 
     # Log provider info for debugging
     provider = llm_config.get("provider", "")

agent_server/langchain/agent_prompts/planner_prompt.py

@@ -5,9 +5,10 @@ Main Agent (Supervisor) System Prompt for Multi-Agent Mode
 PLANNER_SYSTEM_PROMPT = """당신은 작업을 조율하는 Main Agent입니다. 한국어로 응답하세요.
 
 # 핵심 원칙
-2. 3단계 이상의 복잡한 작업을 요청받은 경우에만 write_todos 로 작업 목록 관리
-3. **직접 코드, 쿼리 작성 금지** - 모든 코드/쿼리 생성은 task_tool로 서브에이전트에게 위임
+1. 3단계 이상의 복잡한 작업을 요청받은 경우에만 write_todos 로 작업 목록 관리
+2. **직접 코드, 쿼리 작성 금지** - 모든 코드/쿼리 생성은 task_tool로 서브에이전트에게 위임
 3. 서브에이전트가 반환한 코드를 적절한 도구로 실행
+4. 모든 응답 content는 2~3줄 내외로 핵심만 명확하게 전달
 
 # 작업 흐름
 
@@ -55,33 +56,22 @@ PLANNER_SYSTEM_PROMPT = """당신은 작업을 조율하는 Main Agent입니다.
     - content에 도구(tool)명 언급 금지
     - **[필수] 마지막 todo는 반드시 "작업 요약 및 다음 단계 제시"**
 
-# "작업 요약 및 다음 단계 제시" todo 작업 순서 [필수]
-    1. "작업 요약 및 다음 단계 제시"를 **in_progress**로 변경 (write_todos 호출)
-    2. **같은 응답에서** 아래 JSON을 텍스트로 출력:
-    {
-    "summary": "완료된 작업 요약",
-    "next_items": [
-     {
-       "subject": "제목",
-       "description": "설명"
-     }
-    ]
-    }
-    3. JSON 출력과 함께 "작업 요약 및 다음 단계 제시"를 **completed**로 변경
-     **중요**: JSON은 반드시 in_progress 상태일 때 출력! completed 먼저 표시 금지!
-     - next_items 3개 이상 필수
-     - **summary JSON 없이 종료 금지**
-     - **주의**: JSON은 todo 항목이 아닌 일반 텍스트 응답으로 출력
-
-     
-# 도구 사용시 주의할 점
+# "작업 요약 및 다음 단계 제시" todo 완료 시 [필수]
+1. "작업 요약 및 다음 단계 제시"를 **in_progress**로 변경 (write_todos 호출)
+2. **반드시 final_summary_tool 호출**:
+   final_summary_tool(
+     summary="완료된 작업 요약",
+     next_items=[{"subject": "제목", "description": "설명"}, ...]
+   )
+   
+3. final_summary_tool 호출 후 "작업 요약 및 다음 단계 제시"를 **completed**로 변경
 
-## 서브에이전트 호출 (코드/쿼리 생성 시 필수)
-- task_tool: 서브에이전트에게 작업 위임
+- next_items 3개 이상 필수
+- **final_summary_tool 호출 없이 종료 금지**
 
-## 탐색 (⚠️ 파일 위치 모를 때: search_files_tool → list_workspace_tool → 재검색 → ask_user_tool 순서로!)
-- list_workspace_tool: 파일/디렉토리 목록
-- search_files_tool: 파일 내용 검색 (regex 지원, 예: "titanic|error|*.csv")
+# 도구 사용시 주의할 점
+## 파일 위치 모를 때 탐색 순서: search_files_tool → list_workspace_tool → 재검색 → ask_user_tool 순서로!)
+## list_workspace_tool로 전체 디렉토리 파일 목록 검색 금지! 최대한 pattern 으로 drill down 해서 검색할 것 
 
 # 금지 사항
 - 직접 코드/SQL 작성 (반드시 task_tool 사용)

agent_server/langchain/custom_middleware.py

@@ -165,6 +165,22 @@ def try_extract_tool_calls_from_additional_kwargs(
     if not raw_tool_calls:
         return None
 
+    # IMPORTANT: Only use the first tool_call to prevent parallel execution issues
+    # LLM sometimes generates multiple tool_calls despite prompt instructions
+    if len(raw_tool_calls) > 1:
+        first_tc = raw_tool_calls[0]
+        first_name = first_tc.get("function", {}).get("name", "unknown")
+        ignored_names = [
+            tc.get("function", {}).get("name", "unknown") for tc in raw_tool_calls[1:]
+        ]
+        logger.warning(
+            "Multiple tool_calls in additional_kwargs (%d), using only first one: %s. Ignored: %s",
+            len(raw_tool_calls),
+            first_name,
+            ignored_names,
+        )
+        raw_tool_calls = raw_tool_calls[:1]
+
     repaired_tool_calls = []
     for tc in raw_tool_calls:
         func = tc.get("function", {})
@@ -316,8 +332,7 @@ def create_handle_empty_response_middleware(wrap_model_call):
         summary_todo_completed = all_todos_completed and last_todo_is_summary
 
         if not summary_todo_completed and any(
-            t.get("status") == "completed"
-            and "작업 요약" in t.get("content", "")
+            t.get("status") == "completed" and "작업 요약" in t.get("content", "")
             for t in todos
         ):
             logger.debug(
@@ -439,15 +454,16 @@ def create_handle_empty_response_middleware(wrap_model_call):
                     content = " ".join(str(p) for p in content)
 
                 # Check if content contains summary JSON pattern
-                has_summary_pattern = ('"summary"' in content or "'summary'" in content) and (
-                    '"next_items"' in content or "'next_items'" in content
-                )
+                has_summary_pattern = (
+                    '"summary"' in content or "'summary'" in content
+                ) and ('"next_items"' in content or "'next_items'" in content)
 
                 if has_summary_pattern:
                     # Check if pending todos exist - if so, don't force complete
                     current_todos = request.state.get("todos", [])
                     pending_todos = [
-                        t for t in current_todos
+                        t
+                        for t in current_todos
                         if isinstance(t, dict) and t.get("status") == "pending"
                     ]
                     if pending_todos:
@@ -463,7 +479,12 @@ def create_handle_empty_response_middleware(wrap_model_call):
                         try:
                             # Try to find JSON object containing summary
                             import re
-                            json_match = re.search(r'\{[^{}]*"summary"[^{}]*"next_items"[^{}]*\}', content, re.DOTALL)
+
+                            json_match = re.search(
+                                r'\{[^{}]*"summary"[^{}]*"next_items"[^{}]*\}',
+                                content,
+                                re.DOTALL,
+                            )
                             if json_match:
                                 repaired_summary = repair_json(
                                     json_match.group(), return_objects=True
@@ -503,7 +524,9 @@ def create_handle_empty_response_middleware(wrap_model_call):
                                 )
                                 return response
                         except Exception as e:
-                            logger.debug(f"Failed to extract summary JSON from mixed content: {e}")
+                            logger.debug(
+                                f"Failed to extract summary JSON from mixed content: {e}"
+                            )
 
                         # Fallback: accept as-is if repair failed but looks like summary
                         logger.info(
@@ -543,7 +566,9 @@ def create_handle_empty_response_middleware(wrap_model_call):
                     is_summary_todo = any(
                         kw in current_todo.get("content", "") for kw in summary_keywords
                     )
-                    if is_summary_todo and ('"summary"' in content or "'summary'" in content):
+                    if is_summary_todo and (
+                        '"summary"' in content or "'summary'" in content
+                    ):
                         # This is a summary todo with summary content - accept it
                         logger.info(
                             "Summary todo with summary content detected - accepting"
@@ -785,7 +810,7 @@ def _create_synthetic_completion(request, response_message, has_content):
         logger.warning(
             "Force-completing %d pending todos that were never started: %s",
             pending_count,
-            [t.get("content") for t in todos if t.get("status") == "pending"]
+            [t.get("content") for t in todos if t.get("status") == "pending"],
         )
 
     # Mark all todos as completed
@@ -858,6 +883,31 @@ def create_limit_tool_calls_middleware(wrap_model_call):
                         )
                         msg.tool_calls = [tool_calls[0]]
 
+                    # Remove additional_kwargs["tool_calls"] entirely when
+                    # msg.tool_calls exists. ChatOpenAI duplicates tool_calls
+                    # into additional_kwargs, and leftover entries pollute the
+                    # conversation context - LLM sees them and assumes all
+                    # listed tool calls were executed.
+                    additional_kwargs = getattr(msg, "additional_kwargs", {})
+                    if msg.tool_calls and additional_kwargs.get("tool_calls"):
+                        removed_count = len(additional_kwargs["tool_calls"])
+                        del additional_kwargs["tool_calls"]
+                        logger.info(
+                            "Removed %d tool_calls from additional_kwargs "
+                            "(canonical source: msg.tool_calls)",
+                            removed_count,
+                        )
+
+                    # Clear content when tool_calls exist to avoid duplicate information
+                    # Some models return both content and tool_calls, causing redundant
+                    # "thinking" text in the conversation history
+                    if msg.tool_calls and msg.content:
+                        logger.info(
+                            "Clearing AIMessage content (len=%d) because tool_calls exist",
+                            len(msg.content),
+                        )
+                        msg.content = ""
+
         return response
 
     return limit_tool_calls_to_one
@@ -1026,29 +1076,45 @@ def create_normalize_tool_args_middleware(wrap_model_call, tools=None):
 
                                         # Validate: "작업 요약 및 다음 단계 제시" cannot be in_progress if pending todos exist
                                         # This prevents LLM from skipping pending tasks
-                                        summary_keywords = ["작업 요약", "다음 단계 제시"]
+                                        summary_keywords = [
+                                            "작업 요약",
+                                            "다음 단계 제시",
+                                        ]
                                         for i, todo in enumerate(todos):
                                             if not isinstance(todo, dict):
                                                 continue
                                             content = todo.get("content", "")
-                                            is_summary_todo = any(kw in content for kw in summary_keywords)
+                                            is_summary_todo = any(
+                                                kw in content for kw in summary_keywords
+                                            )
 
-                                            if is_summary_todo and todo.get("status") == "in_progress":
+                                            if (
+                                                is_summary_todo
+                                                and todo.get("status") == "in_progress"
+                                            ):
                                                 # Check if there are pending todos before this one
                                                 pending_before = [
-                                                    t for t in todos[:i]
-                                                    if isinstance(t, dict) and t.get("status") == "pending"
+                                                    t
+                                                    for t in todos[:i]
+                                                    if isinstance(t, dict)
+                                                    and t.get("status") == "pending"
                                                 ]
                                                 if pending_before:
                                                     # Revert summary todo to pending
                                                     todo["status"] = "pending"
                                                     # Set the first pending todo to in_progress
                                                     for t in todos:
-                                                        if isinstance(t, dict) and t.get("status") == "pending":
+                                                        if (
+                                                            isinstance(t, dict)
+                                                            and t.get("status")
+                                                            == "pending"
+                                                        ):
                                                             t["status"] = "in_progress"
                                                             logger.warning(
                                                                 "Reverted summary todo to pending, set '%s' to in_progress (pending todos exist)",
-                                                                t.get("content", "")[:30],
+                                                                t.get("content", "")[
+                                                                    :30
+                                                                ],
                                                             )
                                                             break
                                                     break

agent_server/langchain/middleware/code_history_middleware.py

@@ -12,11 +12,12 @@ Features:
 
 import logging
 import threading
-import tiktoken
 from dataclasses import dataclass, field
 from datetime import datetime
 from typing import Any, Dict, List, Optional
 
+import tiktoken
+
 logger = logging.getLogger(__name__)
 
 # Token limit for context (including system prompt)
@@ -31,7 +32,9 @@ PYTHON_DEV_SYSTEM_PROMPT_TOKENS = 2000
 class CodeHistoryEntry:
     """Represents a single code execution or file operation."""
 
-    tool_name: str  # jupyter_cell_tool, write_file_tool, edit_file_tool, multiedit_file_tool
+    tool_name: (
+        str  # jupyter_cell_tool, write_file_tool, edit_file_tool, multiedit_file_tool
+    )
     timestamp: datetime = field(default_factory=datetime.now)
 
     # For jupyter_cell_tool
@@ -50,7 +53,9 @@ class CodeHistoryEntry:
         timestamp_str = self.timestamp.strftime("%H:%M:%S")
 
         if self.tool_name == "jupyter_cell_tool":
-            output_preview = self._truncate(self.output, 500) if self.output else "(no output)"
+            output_preview = (
+                self._truncate(self.output, 500) if self.output else "(no output)"
+            )
             return f"""## Cell ({timestamp_str})
 ```python
 {self.code}
@@ -86,7 +91,7 @@ Changes: {edit_count} edits applied"""
         if self.tool_name == "jupyter_cell_tool":
             # Extract first meaningful line of code
             if self.code:
-                first_line = self.code.strip().split('\n')[0][:60]
+                first_line = self.code.strip().split("\n")[0][:60]
                 return f"- Cell: {first_line}..."
             return "- Cell: (empty)"
 
@@ -156,7 +161,9 @@ class CodeHistoryTracker:
                 output=output,
             )
             self._history.append(entry)
-            logger.info(f"CodeHistory: Added jupyter_cell (total: {len(self._history)})")
+            logger.info(
+                f"CodeHistory: Added jupyter_cell (total: {len(self._history)})"
+            )
 
     def add_write_file(self, file_path: str, content: str) -> None:
         """Track a write_file_tool execution."""
@@ -167,7 +174,9 @@ class CodeHistoryTracker:
                 content=content,
             )
             self._history.append(entry)
-            logger.info(f"CodeHistory: Added write_file {file_path} (total: {len(self._history)})")
+            logger.info(
+                f"CodeHistory: Added write_file {file_path} (total: {len(self._history)})"
+            )
 
     def add_edit_file(self, file_path: str, old_content: str, new_content: str) -> None:
         """Track an edit_file_tool execution."""
@@ -179,7 +188,9 @@ class CodeHistoryTracker:
                 new_content=new_content,
             )
             self._history.append(entry)
-            logger.info(f"CodeHistory: Added edit_file {file_path} (total: {len(self._history)})")
+            logger.info(
+                f"CodeHistory: Added edit_file {file_path} (total: {len(self._history)})"
+            )
 
     def add_multiedit_file(self, file_path: str, edits: List[Dict[str, str]]) -> None:
         """Track a multiedit_file_tool execution."""
@@ -190,7 +201,9 @@ class CodeHistoryTracker:
                 edits=edits,
             )
             self._history.append(entry)
-            logger.info(f"CodeHistory: Added multiedit_file {file_path} (total: {len(self._history)})")
+            logger.info(
+                f"CodeHistory: Added multiedit_file {file_path} (total: {len(self._history)})"
+            )
 
     def get_context_for_subagent(
         self,
@@ -216,8 +229,12 @@ class CodeHistoryTracker:
                 return existing_context or ""
 
             # Calculate available tokens for history
-            existing_tokens = self._count_tokens(existing_context) if existing_context else 0
-            available_tokens = max_tokens - system_prompt_tokens - existing_tokens - 500  # 500 buffer
+            existing_tokens = (
+                self._count_tokens(existing_context) if existing_context else 0
+            )
+            available_tokens = (
+                max_tokens - system_prompt_tokens - existing_tokens - 500
+            )  # 500 buffer
 
             # Build full history string
             full_history = self._build_full_history()
@@ -311,49 +328,110 @@ class CodeHistoryTracker:
             return len(self._history)
 
 
-# Global tracker instance (per-thread tracking could be added if needed)
-_code_history_tracker: Optional[CodeHistoryTracker] = None
+# Global tracker instances per threadId
+_code_history_trackers: Dict[str, CodeHistoryTracker] = {}
+_trackers_lock = threading.Lock()
+
+
+def get_code_history_tracker(thread_id: Optional[str] = None) -> CodeHistoryTracker:
+    """
+    Get the CodeHistoryTracker instance for the given thread_id.
+
+    Args:
+        thread_id: Thread ID for session isolation. If None, returns a temporary tracker.
 
+    Returns:
+        CodeHistoryTracker instance for the thread
+    """
+    if thread_id is None:
+        logger.warning(
+            "get_code_history_tracker called without thread_id - using temporary tracker"
+        )
+        return CodeHistoryTracker()
 
-def get_code_history_tracker() -> CodeHistoryTracker:
-    """Get the global CodeHistoryTracker instance."""
-    global _code_history_tracker
-    if _code_history_tracker is None:
-        _code_history_tracker = CodeHistoryTracker()
-    return _code_history_tracker
+    with _trackers_lock:
+        if thread_id not in _code_history_trackers:
+            _code_history_trackers[thread_id] = CodeHistoryTracker()
+            logger.info(f"CodeHistory: Created new tracker for thread_id={thread_id}")
+        return _code_history_trackers[thread_id]
 
 
-def track_jupyter_cell(code: str, output: str) -> None:
+def track_jupyter_cell(code: str, output: str, thread_id: Optional[str] = None) -> None:
     """Convenience function to track jupyter_cell_tool execution."""
-    get_code_history_tracker().add_jupyter_cell(code, output)
+    get_code_history_tracker(thread_id).add_jupyter_cell(code, output)
 
 
-def track_write_file(file_path: str, content: str) -> None:
+def track_write_file(
+    file_path: str, content: str, thread_id: Optional[str] = None
+) -> None:
     """Convenience function to track write_file_tool execution."""
-    get_code_history_tracker().add_write_file(file_path, content)
+    get_code_history_tracker(thread_id).add_write_file(file_path, content)
 
 
-def track_edit_file(file_path: str, old_content: str, new_content: str) -> None:
+def track_edit_file(
+    file_path: str,
+    old_content: str,
+    new_content: str,
+    thread_id: Optional[str] = None,
+) -> None:
     """Convenience function to track edit_file_tool execution."""
-    get_code_history_tracker().add_edit_file(file_path, old_content, new_content)
+    get_code_history_tracker(thread_id).add_edit_file(
+        file_path, old_content, new_content
+    )
 
 
-def track_multiedit_file(file_path: str, edits: List[Dict[str, str]]) -> None:
+def track_multiedit_file(
+    file_path: str,
+    edits: List[Dict[str, str]],
+    thread_id: Optional[str] = None,
+) -> None:
     """Convenience function to track multiedit_file_tool execution."""
-    get_code_history_tracker().add_multiedit_file(file_path, edits)
+    get_code_history_tracker(thread_id).add_multiedit_file(file_path, edits)
 
 
-def get_context_with_history(existing_context: Optional[str] = None) -> str:
+def get_context_with_history(
+    existing_context: Optional[str] = None,
+    thread_id: Optional[str] = None,
+) -> str:
     """Get context string with code history injected."""
-    return get_code_history_tracker().get_context_for_subagent(existing_context)
+    return get_code_history_tracker(thread_id).get_context_for_subagent(
+        existing_context
+    )
+
 
+def clear_code_history(thread_id: Optional[str] = None) -> None:
+    """
+    Clear code history for a specific thread or all threads.
 
-def clear_code_history() -> None:
-    """Clear all code history."""
-    get_code_history_tracker().clear()
+    Args:
+        thread_id: Thread ID to clear. If None, clears all threads.
+    """
+    if thread_id is None:
+        # Clear all trackers
+        with _trackers_lock:
+            for tid, tracker in _code_history_trackers.items():
+                tracker.clear()
+                logger.info(f"CodeHistory: Cleared history for thread_id={tid}")
+            _code_history_trackers.clear()
+            logger.info("CodeHistory: Cleared all thread trackers")
+    else:
+        # Clear specific thread
+        with _trackers_lock:
+            if thread_id in _code_history_trackers:
+                _code_history_trackers[thread_id].clear()
+                del _code_history_trackers[thread_id]
+                logger.info(
+                    f"CodeHistory: Cleared and removed tracker for thread_id={thread_id}"
+                )
+            else:
+                logger.info(f"CodeHistory: No tracker found for thread_id={thread_id}")
 
 
-def track_tool_execution(tool_name: str, args: Dict[str, Any]) -> None:
+def track_tool_execution(
+    tool_name: str,
+    args: Dict[str, Any],
+    thread_id: Optional[str] = None,
+) -> None:
     """
     Track a tool execution from HITL decision processing.
 
@@ -363,6 +441,7 @@ def track_tool_execution(tool_name: str, args: Dict[str, Any]) -> None:
     Args:
         tool_name: Name of the tool (jupyter_cell_tool, write_file_tool, etc.)
         args: Tool arguments including execution_result
+        thread_id: Thread ID for session isolation
     """
     if not args:
         return
@@ -371,21 +450,26 @@ def track_tool_execution(tool_name: str, args: Dict[str, Any]) -> None:
     if not execution_result:
         return
 
-    tracker = get_code_history_tracker()
+    tracker = get_code_history_tracker(thread_id)
 
     if tool_name == "jupyter_cell_tool":
         code = args.get("code", "")
         output = execution_result.get("output", "")
         if code:
             tracker.add_jupyter_cell(code, output)
-            logger.info(f"CodeHistory: Tracked jupyter_cell execution (code len={len(code)})")
+            logger.info(
+                f"CodeHistory: Tracked jupyter_cell execution "
+                f"(code len={len(code)}, thread_id={thread_id})"
+            )
 
     elif tool_name == "write_file_tool":
         file_path = args.get("path", "")
         content = args.get("content", "")
         if file_path:
             tracker.add_write_file(file_path, content)
-            logger.info(f"CodeHistory: Tracked write_file to {file_path}")
+            logger.info(
+                f"CodeHistory: Tracked write_file to {file_path} (thread_id={thread_id})"
+            )
 
     elif tool_name == "edit_file_tool":
         file_path = args.get("path", "")
@@ -393,7 +477,9 @@ def track_tool_execution(tool_name: str, args: Dict[str, Any]) -> None:
         new_string = args.get("new_string", "")
         if file_path:
             tracker.add_edit_file(file_path, old_string, new_string)
-            logger.info(f"CodeHistory: Tracked edit_file to {file_path}")
+            logger.info(
+                f"CodeHistory: Tracked edit_file to {file_path} (thread_id={thread_id})"
+            )
 
     elif tool_name == "multiedit_file_tool":
         file_path = args.get("path", "")
@@ -409,4 +495,7 @@ def track_tool_execution(tool_name: str, args: Dict[str, Any]) -> None:
                 elif isinstance(edit, dict):
                     edits_as_dicts.append(edit)
             tracker.add_multiedit_file(file_path, edits_as_dicts)
-            logger.info(f"CodeHistory: Tracked multiedit_file to {file_path} ({len(edits)} edits)")
+            logger.info(
+                f"CodeHistory: Tracked multiedit_file to {file_path} "
+                f"({len(edits)} edits, thread_id={thread_id})"
+            )

agent_server/langchain/middleware/subagent_middleware.py

@@ -12,6 +12,7 @@ Key features:
 - Subagent caching: compiled agents are cached to avoid recompilation overhead
 """
 
+import contextvars
 import hashlib
 import json
 import logging
@@ -25,6 +26,11 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger(__name__)
 
+# Context variable to track the current main agent's thread_id
+_current_thread_id: contextvars.ContextVar[Optional[str]] = contextvars.ContextVar(
+    "current_thread_id", default=None
+)
+
 # Global registry for subagent factories (set by AgentFactory)
 _subagent_factory = None
 _current_llm_config = None
@@ -92,6 +98,17 @@ def clear_subagent_cache():
     logger.info(f"Subagent cache cleared ({count} entries removed)")
 
 
+def set_current_thread_id(thread_id: str) -> None:
+    """Set the current main agent's thread_id for code history tracking."""
+    _current_thread_id.set(thread_id)
+    logger.debug(f"Set current thread_id: {thread_id}")
+
+
+def get_current_thread_id() -> Optional[str]:
+    """Get the current main agent's thread_id."""
+    return _current_thread_id.get()
+
+
 def create_task_tool(
     caller_name: str,
     allowed_subagents: Optional[List[str]] = None,
@@ -232,13 +249,18 @@ def create_task_tool(
                         get_context_with_history,
                     )
 
-                    tracker = get_code_history_tracker()
+                    # Get main agent's thread_id for session-scoped history
+                    main_thread_id = get_current_thread_id()
+                    tracker = get_code_history_tracker(main_thread_id)
                     if tracker.get_entry_count() > 0:
-                        enhanced_context = get_context_with_history(context)
+                        enhanced_context = get_context_with_history(
+                            context, main_thread_id
+                        )
                         t3 = time.time()
                         logger.info(
                             f"[TIMING] code history injection took {t3-t2:.2f}s "
                             f"(entries={tracker.get_entry_count()}, "
+                            f"thread_id={main_thread_id}, "
                             f"context_len={len(enhanced_context) if enhanced_context else 0})"
                         )
                 except Exception as e: