hdsp-jupyter-extension 2.0.18__py3-none-any.whl → 2.0.20__py3-none-any.whl

agent_server/langchain/models/gpt_oss_chat.py

@@ -0,0 +1,351 @@
+"""
+ChatGPTOSS: Custom ChatModel for gpt-oss (Harmony format).
+
+gpt-oss uses a different instruction hierarchy:
+- developer: behavioral rules/instructions (highest priority)
+- system: metadata (date, cutoff, tools)
+- user: actual questions
+
+LangChain's ChatOpenAI sends everything as 'system', which gpt-oss treats as low-priority metadata.
+This class converts SystemMessage to 'developer' role for proper instruction following.
+"""
+
+import json
+import logging
+import uuid
+from typing import Any, Dict, Iterator, List, Optional, Union
+
+from langchain_core.callbacks import CallbackManagerForLLMRun
+from langchain_core.language_models.chat_models import BaseChatModel
+from langchain_core.messages import (
+    AIMessage,
+    AIMessageChunk,
+    BaseMessage,
+    HumanMessage,
+    SystemMessage,
+    ToolMessage,
+)
+from langchain_core.outputs import ChatGeneration, ChatGenerationChunk, ChatResult
+from langchain_core.tools import BaseTool
+from openai import OpenAI
+from pydantic import Field
+
+logger = logging.getLogger(__name__)
+
+
+class ChatGPTOSS(BaseChatModel):
+    """ChatModel for gpt-oss with developer role support.
+
+    Converts SystemMessage to 'developer' role for proper instruction hierarchy
+    in gpt-oss (Harmony format) models.
+    """
+
+    client: Any = Field(default=None, exclude=True)
+    model: str = Field(default="openai/gpt-oss-120b")
+    base_url: str = Field(default="http://localhost:8000/v1")
+    api_key: str = Field(default="dummy")
+    temperature: float = Field(default=0.0)
+    max_tokens: int = Field(default=8192)
+    streaming: bool = Field(default=False)
+
+    # Tool-related fields (private, not exposed to pydantic)
+    _tools: Optional[List[Dict[str, Any]]] = None
+    _tool_choice: Optional[Union[str, Dict[str, Any]]] = None
+
+    def __init__(self, callbacks=None, **kwargs):
+        # Remove callbacks from kwargs before super().__init__ if present
+        # BaseChatModel handles callbacks through its own mechanism
+        super().__init__(callbacks=callbacks, **kwargs)
+        # Initialize OpenAI client
+        self.client = OpenAI(
+            base_url=self.base_url,
+            api_key=self.api_key,
+        )
+        self._tools = None
+        self._tool_choice = None
+
+    @property
+    def _llm_type(self) -> str:
+        return "gpt-oss"
+
+    @property
+    def _identifying_params(self) -> Dict[str, Any]:
+        return {
+            "model": self.model,
+            "base_url": self.base_url,
+            "temperature": self.temperature,
+            "max_tokens": self.max_tokens,
+        }
+
+    def bind_tools(
+        self,
+        tools: List[Union[BaseTool, Dict[str, Any]]],
+        *,
+        tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
+        **kwargs,
+    ) -> "ChatGPTOSS":
+        """Bind tools to the model.
+
+        Returns a new instance with tools bound.
+        """
+        # Convert tools to OpenAI format
+        formatted_tools = []
+        for tool in tools:
+            if isinstance(tool, BaseTool):
+                # Convert LangChain tool to OpenAI format
+                tool_schema = {
+                    "type": "function",
+                    "function": {
+                        "name": tool.name,
+                        "description": tool.description or "",
+                        "parameters": tool.args_schema.schema() if tool.args_schema else {"type": "object", "properties": {}},
+                    },
+                }
+                formatted_tools.append(tool_schema)
+            elif isinstance(tool, dict):
+                # Already in dict format, ensure it has correct structure
+                if "type" not in tool:
+                    tool = {"type": "function", "function": tool}
+                formatted_tools.append(tool)
+
+        # Create new instance with tools bound
+        new_instance = ChatGPTOSS(
+            model=self.model,
+            base_url=self.base_url,
+            api_key=self.api_key,
+            temperature=self.temperature,
+            max_tokens=self.max_tokens,
+            streaming=self.streaming,
+        )
+        new_instance._tools = formatted_tools
+        new_instance._tool_choice = tool_choice
+        return new_instance
+
+    def _convert_messages(self, messages: List[BaseMessage]) -> List[Dict[str, Any]]:
+        """Convert LangChain messages to OpenAI format with developer role.
+
+        Key conversion: SystemMessage -> role=developer
+        """
+        result = []
+
+        for msg in messages:
+            if isinstance(msg, SystemMessage):
+                # Convert system to developer for gpt-oss instruction hierarchy
+                result.append({
+                    "role": "developer",
+                    "content": msg.content,
+                })
+            elif isinstance(msg, HumanMessage):
+                result.append({
+                    "role": "user",
+                    "content": msg.content,
+                })
+            elif isinstance(msg, AIMessage):
+                ai_msg: Dict[str, Any] = {
+                    "role": "assistant",
+                    "content": msg.content or "",
+                }
+                # Include tool calls if present
+                tool_calls = getattr(msg, "tool_calls", None)
+                if tool_calls:
+                    ai_msg["tool_calls"] = [
+                        {
+                            "id": tc.get("id", str(uuid.uuid4())[:8]),
+                            "type": "function",
+                            "function": {
+                                "name": tc["name"],
+                                "arguments": json.dumps(tc["args"]) if isinstance(tc["args"], dict) else tc["args"],
+                            },
+                        }
+                        for tc in tool_calls
+                    ]
+                result.append(ai_msg)
+            elif isinstance(msg, ToolMessage):
+                result.append({
+                    "role": "tool",
+                    "tool_call_id": msg.tool_call_id,
+                    "content": msg.content,
+                })
+            else:
+                # Fallback for other message types
+                role = getattr(msg, "role", "user")
+                result.append({
+                    "role": role,
+                    "content": msg.content,
+                })
+
+        return result
+
+    def _create_chat_result(self, response) -> ChatResult:
+        """Convert OpenAI response to LangChain ChatResult."""
+        choice = response.choices[0]
+        message = choice.message
+
+        # Build AIMessage
+        content = message.content or ""
+        additional_kwargs: Dict[str, Any] = {}
+        tool_calls_list = []
+
+        if message.tool_calls:
+            additional_kwargs["tool_calls"] = [
+                {
+                    "id": tc.id,
+                    "type": "function",
+                    "function": {
+                        "name": tc.function.name,
+                        "arguments": tc.function.arguments,
+                    },
+                }
+                for tc in message.tool_calls
+            ]
+            # Also convert to LangChain tool_calls format
+            for tc in message.tool_calls:
+                try:
+                    args = json.loads(tc.function.arguments)
+                except json.JSONDecodeError:
+                    args = {"raw": tc.function.arguments}
+                tool_calls_list.append({
+                    "name": tc.function.name,
+                    "args": args,
+                    "id": tc.id,
+                    "type": "tool_call",
+                })
+
+        ai_message = AIMessage(
+            content=content,
+            additional_kwargs=additional_kwargs,
+            tool_calls=tool_calls_list if tool_calls_list else [],
+            response_metadata={
+                "model_name": response.model,
+                "finish_reason": choice.finish_reason,
+                "id": response.id,
+            },
+        )
+
+        # Add usage metadata if available
+        if response.usage:
+            ai_message.usage_metadata = {
+                "input_tokens": response.usage.prompt_tokens,
+                "output_tokens": response.usage.completion_tokens,
+                "total_tokens": response.usage.total_tokens,
+            }
+
+        generation = ChatGeneration(message=ai_message)
+        return ChatResult(generations=[generation])
+
+    def _generate(
+        self,
+        messages: List[BaseMessage],
+        stop: Optional[List[str]] = None,
+        run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs,
+    ) -> ChatResult:
+        """Generate a response from the model."""
+        openai_messages = self._convert_messages(messages)
+
+        # Build request kwargs
+        request_kwargs: Dict[str, Any] = {
+            "model": self.model,
+            "messages": openai_messages,
+            "temperature": self.temperature,
+            "max_tokens": self.max_tokens,
+        }
+
+        if stop:
+            request_kwargs["stop"] = stop
+
+        if self._tools:
+            request_kwargs["tools"] = self._tools
+            if self._tool_choice:
+                request_kwargs["tool_choice"] = self._tool_choice
+
+        # Make API call
+        logger.debug(f"ChatGPTOSS request: model={self.model}, messages_count={len(openai_messages)}")
+        response = self.client.chat.completions.create(**request_kwargs)
+
+        return self._create_chat_result(response)
+
+    def _stream(
+        self,
+        messages: List[BaseMessage],
+        stop: Optional[List[str]] = None,
+        run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs,
+    ) -> Iterator[ChatGenerationChunk]:
+        """Stream responses from the model."""
+        openai_messages = self._convert_messages(messages)
+
+        # Build request kwargs
+        request_kwargs: Dict[str, Any] = {
+            "model": self.model,
+            "messages": openai_messages,
+            "temperature": self.temperature,
+            "max_tokens": self.max_tokens,
+            "stream": True,
+        }
+
+        if stop:
+            request_kwargs["stop"] = stop
+
+        if self._tools:
+            request_kwargs["tools"] = self._tools
+            if self._tool_choice:
+                request_kwargs["tool_choice"] = self._tool_choice
+
+        # Make streaming API call
+        response = self.client.chat.completions.create(**request_kwargs)
+
+        # Accumulate tool calls across chunks
+        tool_calls_accum: Dict[int, Dict[str, Any]] = {}
+
+        for chunk in response:
+            if not chunk.choices:
+                continue
+
+            choice = chunk.choices[0]
+            delta = choice.delta
+
+            content = delta.content or ""
+            additional_kwargs: Dict[str, Any] = {}
+            tool_call_chunks = []
+
+            # Handle tool calls in streaming
+            if delta.tool_calls:
+                for tc in delta.tool_calls:
+                    idx = tc.index
+                    if idx not in tool_calls_accum:
+                        tool_calls_accum[idx] = {
+                            "id": tc.id or "",
+                            "name": "",
+                            "arguments": "",
+                        }
+                    if tc.id:
+                        tool_calls_accum[idx]["id"] = tc.id
+                    if tc.function:
+                        if tc.function.name:
+                            tool_calls_accum[idx]["name"] = tc.function.name
+                        if tc.function.arguments:
+                            tool_calls_accum[idx]["arguments"] += tc.function.arguments
+
+                    # Build tool call chunk for LangChain
+                    tool_call_chunks.append({
+                        "index": idx,
+                        "id": tool_calls_accum[idx]["id"],
+                        "name": tool_calls_accum[idx]["name"],
+                        "args": tool_calls_accum[idx]["arguments"],
+                    })
+
+            # Create chunk message
+            chunk_message = AIMessageChunk(
+                content=content,
+                additional_kwargs=additional_kwargs,
+                tool_call_chunks=tool_call_chunks if tool_call_chunks else [],
+            )
+
+            # Add finish reason on last chunk
+            if choice.finish_reason:
+                chunk_message.response_metadata = {
+                    "finish_reason": choice.finish_reason,
+                }
+
+            yield ChatGenerationChunk(message=chunk_message)

agent_server/langchain/prompts.py

@@ -19,14 +19,15 @@ DEFAULT_SYSTEM_PROMPT = """You are an expert Python data scientist and Jupyter n
 # write_todos 규칙 [필수]
 - 한국어로 작성
 - **🔴 기존 todo 절대 삭제 금지**: 전체 리스트를 항상 포함하고 status만 변경
-  - 잘못된 예: [{"content": "작업 요약", "status": "completed"}] ← 기존 todo 삭제됨!
-  - 올바른 예: [{"content": "기존 작업1", "status": "completed"}, {"content": "기존 작업2", "status": "completed"}, {"content": "작업 요약", "status": "completed"}]
-- **일괄 업데이트**: 연속 완료된 todo는 한 번의 write_todos 호출로 처리
-- in_progress는 **1개만** 유지
+- **🔴 상태 전환 순서 필수**: pending → in_progress → completed (건너뛰기 금지!)
+- **🔴 초기 생성 규칙**: 첫 write_todos 호출 시 첫 번째 todo만 in_progress, 나머지는 모두 pending
+  - 올바른 초기 예: [{"content": "작업1", "status": "in_progress"}, {"content": "작업2", "status": "pending"}, {"content": "작업 요약 및 다음 단계 제시", "status": "pending"}]
+  - 잘못된 초기 예: [{"content": "작업1", "status": "completed"}, ...] ← 실제 작업 없이 completed 금지!
+- **🔴 completed 전환 조건**: 실제 도구로 작업 수행 후에만 completed로 변경
+- in_progress는 **동시에 1개만** 유지
 - **[필수] 마지막 todo는 반드시 "작업 요약 및 다음 단계 제시"로 생성**
 - **🔴 [실행 순서 필수]**: "작업 요약 및 다음 단계 제시"는 **반드시 가장 마지막에 실행**
   - 다른 모든 todo가 completed 상태가 된 후에만 이 todo를 in_progress로 변경
-  - 비슷한 이름의 다른 작업(보고서 검토, 결과 정리 등)과 혼동 금지
 - **[중요] "작업 요약 및 다음 단계 제시"는 summary JSON 출력 후에만 completed 표시**
 
 # 모든 작업 완료 후 [필수]
@@ -41,6 +42,7 @@ DEFAULT_SYSTEM_PROMPT = """You are an expert Python data scientist and Jupyter n
 - check_resource_tool: 대용량 파일/데이터프레임 작업 전 필수
 - read_file_tool: 대용량 파일은 limit=100으로 먼저 확인
 - jupyter_cell_tool: 차트 라벨은 영어로
+  - **KeyboardInterrupt 발생 시**: ask_user_tool로 중단 사유를 사용자에게 확인 (예: "코드 실행이 중단되었습니다. 중단 사유를 알려주시면 도움이 됩니다.")
 - **파일 수정 후**: diagnostics_tool로 오류 확인 필수
 
 # 사용자 입력 요청 [중요]
@@ -85,8 +87,11 @@ TODO_LIST_TOOL_DESCRIPTION = """Todo 리스트 관리 도구.
 - 진행 상황 추적이 필요할 때
 
 규칙:
-- in_progress는 1개만
-- 완료 즉시 completed로 변경
+- **🔴 기존 todo 삭제 금지**: status만 변경하고 전체 리스트 유지
+- **🔴 상태 전환 순서 필수**: pending → in_progress → completed (건너뛰기 금지!)
+- **🔴 초기 생성**: 첫 호출 시 첫 번째만 in_progress, 나머지는 pending
+- **🔴 completed 조건**: 실제 도구로 작업 수행 후에만 completed로 변경
+- in_progress 상태는 **동시에 1개만** 허용
 - **[필수] 마지막 todo는 반드시 "작업 요약 및 다음 단계 제시"로 생성**
 - **🔴 [실행 순서]**: todo는 반드시 리스트 순서대로 실행하고, "작업 요약 및 다음 단계 제시"는 맨 마지막에 실행
 - 이 "작업 요약 및 다음 단계 제시" todo 에서는 전체 작업 요약과 다음 단계를 제시하는 내용을 JSON 형태로 출력:

agent_server/routers/langchain_agent.py

@@ -1082,6 +1082,11 @@ async def stream_agent(request: AgentRequest):
 
                         # Handle AIMessage
                         elif isinstance(last_message, AIMessage):
+                            # LLM Response separator for easy log reading
+                            print("\n" + "🔵" * 48, flush=True)
+                            print("=" * 96, flush=True)
+                            print("  ✨ LLM RESPONSE", flush=True)
+                            print("=" * 96, flush=True)
                             logger.info(
                                 "SimpleAgent AIMessage content: %s",
                                 last_message.content or "",
@@ -1115,6 +1120,11 @@ async def stream_agent(request: AgentRequest):
                                     ensure_ascii=False,
                                 ),
                             )
+                            # LLM Response end separator
+                            print("=" * 96, flush=True)
+                            print("  ✅ LLM RESPONSE END", flush=True)
+                            print("=" * 96, flush=True)
+                            print("🔵" * 48 + "\n", flush=True)
                             last_finish_reason = (
                                 getattr(last_message, "response_metadata", {}) or {}
                             ).get("finish_reason")

{hdsp_jupyter_extension-2.0.18.data → hdsp_jupyter_extension-2.0.20.data}/data/share/jupyter/labextensions/hdsp-agent/build_log.json

@@ -722,7 +722,7 @@
             "@mui/material": {},
             "react-markdown": {},
             "hdsp-agent": {
-              "version": "2.0.18",
+              "version": "2.0.20",
               "singleton": true,
               "import": "/Users/a421721/Desktop/hdsp/hdsp_agent/extensions/jupyter/lib/index.js"
             }

{hdsp_jupyter_extension-2.0.18.data → hdsp_jupyter_extension-2.0.20.data}/data/share/jupyter/labextensions/hdsp-agent/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hdsp-agent",
-  "version": "2.0.18",
+  "version": "2.0.20",
   "description": "HDSP Agent JupyterLab Extension - Thin client for Agent Server",
   "keywords": [
     "jupyter",
@@ -132,7 +132,7 @@
       }
     },
     "_build": {
-      "load": "static/remoteEntry.5099145cc2b28312d170.js",
+      "load": "static/remoteEntry.586bf5521d043cdd37b8.js",
       "extension": "./extension",
       "style": "./style"
     }