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

agent_server/langchain/models/gpt_oss_chat.py

@@ -200,19 +200,20 @@ class ChatGPTOSS(BaseChatModel):
         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:
+            # IMPORTANT: Only use the first tool_call to prevent parallel execution issues
+            # LLM sometimes generates multiple tool_calls despite prompt instructions
+            tool_calls_to_use = message.tool_calls[:1]
+            if len(message.tool_calls) > 1:
+                logger.warning(
+                    "Multiple tool_calls detected (%d), using only first one: %s. Ignored: %s",
+                    len(message.tool_calls),
+                    message.tool_calls[0].function.name,
+                    [tc.function.name for tc in message.tool_calls[1:]],
+                )
+
+            # Convert to LangChain tool_calls format only
+            # Do NOT put tool_calls in additional_kwargs to avoid duplicate/conflicting data
+            for tc in tool_calls_to_use:
                 try:
                     args = json.loads(tc.function.arguments)
                 except json.JSONDecodeError:
@@ -327,9 +328,21 @@ class ChatGPTOSS(BaseChatModel):
             tool_call_chunks = []
 
             # Handle tool calls in streaming
+            # IMPORTANT: Only process the first tool_call (index 0) to prevent parallel execution
             if delta.tool_calls:
                 for tc in delta.tool_calls:
                     idx = tc.index
+                    # Only accumulate the first tool_call (index 0)
+                    if idx > 0:
+                        if idx == 1 and tc.function and tc.function.name:
+                            # Log warning only once when we first see index 1
+                            logger.warning(
+                                "Multiple tool_calls in stream, ignoring index %d: %s",
+                                idx,
+                                tc.function.name,
+                            )
+                        continue
+
                     if idx not in tool_calls_accum:
                         tool_calls_accum[idx] = {
                             "id": tc.id or "",

agent_server/langchain/prompts.py

@@ -31,12 +31,12 @@ DEFAULT_SYSTEM_PROMPT = """You are an expert Python data scientist and Jupyter n
 - **[중요] "작업 요약 및 다음 단계 제시"는 summary JSON 출력 후에만 completed 표시**
 
 # 모든 작업 완료 후 [필수]
-마지막 todo "작업 요약 및 다음 단계 제시"를 completed로 변경한 후,
-**텍스트 응답으로** 아래 JSON을 출력하세요 (todo content가 아님!):
-{"summary": "완료된 작업 요약", "next_items": [{"subject": "제목", "description": "설명"}]}
+마지막 todo "작업 요약 및 다음 단계 제시"를 완료할 때:
+**반드시 final_summary_tool을 호출**하여 요약과 다음 단계를 제시하세요.
+- final_summary_tool(summary="완료된 작업 요약", next_items=[{"subject": "제목", "description": "설명"}, ...])
 - next_items 3개 이상 필수
-- **summary JSON 없이 종료 금지**
-- **주의**: JSON은 todo 항목이 아닌 일반 텍스트 응답으로 출력
+- **final_summary_tool 호출 없이 종료 금지**
+- **주의**: 텍스트로 JSON 출력하지 말고, 반드시 도구 호출로!
 
 # 도구 사용
 - check_resource_tool: 대용량 파일/데이터프레임 작업 전 필수
@@ -94,9 +94,9 @@ TODO_LIST_TOOL_DESCRIPTION = """Todo 리스트 관리 도구.
 - in_progress 상태는 **동시에 1개만** 허용
 - **[필수] 마지막 todo는 반드시 "작업 요약 및 다음 단계 제시"로 생성**
 - **🔴 [실행 순서]**: todo는 반드시 리스트 순서대로 실행하고, "작업 요약 및 다음 단계 제시"는 맨 마지막에 실행
-- 이 "작업 요약 및 다음 단계 제시" todo 에서는 전체 작업 요약과 다음 단계를 제시하는 내용을 JSON 형태로 출력:
-  {"summary": "완료 요약", "next_items": [{"subject": "...", "description": "..."}]}
-  (next_items 3개 이상 필수)
+- 이 "작업 요약 및 다음 단계 제시" todo 완료 시 **반드시 final_summary_tool 호출**:
+  final_summary_tool(summary="완료 요약", next_items=[{"subject": "...", "description": "..."}])
+  (next_items 3개 이상 필수, 텍스트 JSON 출력 금지!)
 """
 
 # List of tools available to the agent
@@ -104,6 +104,7 @@ TOOL_LIST = [
     "jupyter_cell_tool",
     "markdown_tool",
     "ask_user_tool",
+    "final_summary_tool",
     "write_todos",
     "read_file_tool",
     "write_file_tool",
@@ -128,6 +129,8 @@ NON_HITL_TOOLS = {
     "search_notebook_cells_tool",
     "search_notebook_cells",
     "write_todos",
+    "final_summary_tool",
+    "final_summary",
     # LSP tools (read-only)
     "diagnostics_tool",
     "diagnostics",

agent_server/langchain/tools/jupyter_tools.py

@@ -172,9 +172,52 @@ def ask_user_tool(
     }
 
 
+class NextItem(BaseModel):
+    """Schema for a next step item"""
+
+    subject: str = Field(description="다음 단계 제목")
+    description: str = Field(description="다음 단계 설명")
+
+
+class FinalSummaryInput(BaseModel):
+    """Input schema for final_summary tool"""
+
+    summary: str = Field(description="완료된 작업에 대한 요약 (한국어)")
+    next_items: List[NextItem] = Field(
+        description="다음 단계 제안 목록 (3개 이상)", min_length=3
+    )
+
+
+@tool(args_schema=FinalSummaryInput)
+def final_summary_tool(
+    summary: str,
+    next_items: List[Dict[str, str]],
+) -> Dict[str, Any]:
+    """
+    모든 작업이 완료된 후 최종 요약과 다음 단계를 제시하는 도구.
+
+    이 도구는 반드시 모든 todo가 완료된 후, 마지막 "작업 요약 및 다음 단계 제시" todo를 처리할 때만 호출하세요.
+
+    Args:
+        summary: 완료된 작업에 대한 요약 (한국어로 작성)
+        next_items: 다음 단계 제안 목록 (각각 subject와 description 포함, 3개 이상)
+
+    Returns:
+        Dict containing the summary and next items for frontend display
+    """
+    return {
+        "tool": "final_summary",
+        "summary": summary,
+        "next_items": next_items,
+        "status": "completed",
+        "message": "작업 요약이 완료되었습니다.",
+    }
+
+
 # Export all tools
 JUPYTER_TOOLS = [
     jupyter_cell_tool,
     markdown_tool,
     ask_user_tool,
+    final_summary_tool,
 ]

agent_server/routers/langchain_agent.py

@@ -695,6 +695,19 @@ async def stream_agent(request: AgentRequest):
         thread_id,
     )
 
+    # Handle @reset command
+    if "@reset" in request.request:
+        logger.info(f"@reset command detected for thread: {thread_id}")
+        from agent_server.langchain.middleware.code_history_middleware import (
+            clear_code_history,
+        )
+
+        # Clear code history and checkpointer for this thread
+        clear_code_history(thread_id)
+        if thread_id in _simple_agent_checkpointers:
+            del _simple_agent_checkpointers[thread_id]
+        logger.info(f"Session reset complete for thread: {thread_id}")
+
     async def event_generator():
         try:
             # Use simple agent with HITL
@@ -739,6 +752,15 @@ async def stream_agent(request: AgentRequest):
                 len(_simple_agent_checkpointers),
             )
 
+            # Clear code history for new threads
+            if not is_existing_thread:
+                from agent_server.langchain.middleware.code_history_middleware import (
+                    clear_code_history,
+                )
+
+                clear_code_history(thread_id)
+                logger.info(f"Code history cleared for new thread: {thread_id}")
+
             resolved_workspace_root = _resolve_workspace_root(request.workspaceRoot)
 
             # Get agent mode (single or multi)
@@ -746,20 +768,31 @@ async def stream_agent(request: AgentRequest):
             logger.info("Agent mode: %s", agent_mode)
 
             # Get agent prompts (for multi-agent mode)
-            # ROOT CAUSE FOUND: Frontend sends both systemPrompt AND agentPrompts
-            # which creates different cache keys and causes MALFORMED_FUNCTION_CALL
-            # FIX: Ignore all custom prompts for multi-agent mode until frontend is fixed
             agent_prompts = None
             if agent_mode == "multi":
-                # For multi-agent mode, always use default prompts
+                # Multi-agent mode: Use agentPrompts for per-agent customization
+                # systemPrompt is for single-agent mode only (DEFAULT_SYSTEM_PROMPT)
                 if request.llmConfig and request.llmConfig.agent_prompts:
-                    logger.warning(
-                        "Multi-agent mode: Ignoring frontend agentPrompts to ensure consistent behavior"
+                    agent_prompts = {
+                        "planner": request.llmConfig.agent_prompts.planner,
+                        "python_developer": (
+                            request.llmConfig.agent_prompts.python_developer
+                        ),
+                        "researcher": request.llmConfig.agent_prompts.researcher,
+                        "athena_query": request.llmConfig.agent_prompts.athena_query,
+                    }
+                    agent_prompts = {k: v for k, v in agent_prompts.items() if v}
+                    logger.info(
+                        "Multi-agent mode: Using agentPrompts (%s)",
+                        list(agent_prompts.keys()),
                     )
-                # Also ignore system_prompt_override for multi-agent mode
+                # In multi-agent mode, DON'T use systemPrompt as override
+                # (systemPrompt = single-agent prompt, not planner prompt)
+                # Use agentPrompts.planner instead (handled by agent_factory)
                 if system_prompt_override:
-                    logger.warning(
-                        "Multi-agent mode: Ignoring systemPrompt override (len=%d)",
+                    logger.info(
+                        "Multi-agent mode: Ignoring systemPrompt override (len=%d) - "
+                        "use agentPrompts.planner instead",
                         len(system_prompt_override),
                     )
                     system_prompt_override = None
@@ -827,6 +860,13 @@ async def stream_agent(request: AgentRequest):
             # Prepare config with thread_id
             config = {"configurable": {"thread_id": thread_id}}
 
+            # Set current thread_id for code history tracking
+            from agent_server.langchain.middleware.subagent_middleware import (
+                set_current_thread_id,
+            )
+
+            set_current_thread_id(thread_id)
+
             # Check existing state and ALWAYS reset todos for new request
             # Each new user request starts a fresh todo list
             should_reset_todos = False
@@ -903,7 +943,6 @@ async def stream_agent(request: AgentRequest):
             produced_output = False
             last_finish_reason = None
             last_signature = None
-            latest_todos: Optional[List[Dict[str, Any]]] = None
             # Initialize emitted contents set for this thread (clear any stale data)
             emitted_contents: set = set()
             _simple_agent_emitted_contents[thread_id] = emitted_contents
@@ -957,12 +996,10 @@ async def stream_agent(request: AgentRequest):
                 if isinstance(step, dict) and "todos" in step:
                     todos = step["todos"]
                     if todos:
-                        latest_todos = todos
                         yield {"event": "todos", "data": json.dumps({"todos": todos})}
                 elif isinstance(step, dict):
                     todos = _extract_todos(step)
                     if todos:
-                        latest_todos = todos
                         yield {"event": "todos", "data": json.dumps({"todos": todos})}
 
                 # Process messages (no continue statements to ensure interrupt check always runs)
@@ -1012,7 +1049,6 @@ async def stream_agent(request: AgentRequest):
                             )
                             todos = _extract_todos(last_message.content)
                             if todos:
-                                latest_todos = todos
                                 yield {
                                     "event": "todos",
                                     "data": json.dumps({"todos": todos}),
@@ -1270,7 +1306,6 @@ async def stream_agent(request: AgentRequest):
                                         "SSE: Emitting todos event from AIMessage tool_calls: %d items",
                                         len(todos),
                                     )
-                                    latest_todos = todos
                                     yield {
                                         "event": "todos",
                                         "data": json.dumps({"todos": todos}),
@@ -1286,7 +1321,7 @@ async def stream_agent(request: AgentRequest):
                                             "다음단계",
                                             "다음 단계",
                                         ]
-                                        has_summary_todo = any(
+                                        any(
                                             any(
                                                 kw in t.get("content", "")
                                                 for kw in summary_keywords
@@ -1461,6 +1496,22 @@ async def stream_agent(request: AgentRequest):
                                                 }
                                             ),
                                         }
+                                    elif tool_name in (
+                                        "final_summary_tool",
+                                        "final_summary",
+                                    ):
+                                        # Final summary - emit summary event for frontend
+                                        produced_output = True
+                                        summary_data = {
+                                            "summary": tool_args.get("summary", ""),
+                                            "next_items": tool_args.get(
+                                                "next_items", []
+                                            ),
+                                        }
+                                        yield {
+                                            "event": "summary",
+                                            "data": json.dumps(summary_data),
+                                        }
 
                             # Only display content if it's not empty and not a JSON tool response
                             if (
@@ -1504,6 +1555,31 @@ async def stream_agent(request: AgentRequest):
                                         and content_stripped.startswith("{")
                                     )
                                 )
+
+                                # Check if this is summary/next_items with tool_calls (premature summary)
+                                has_summary_pattern = (
+                                    '"summary"' in content or "'summary'" in content
+                                ) and (
+                                    '"next_items"' in content
+                                    or "'next_items'" in content
+                                )
+                                tool_calls = (
+                                    getattr(last_message, "tool_calls", []) or []
+                                )
+                                # Check if any tool_call is NOT write_todos (work still in progress)
+                                has_non_todo_tool_calls = any(
+                                    tc.get("name")
+                                    not in ("write_todos", "write_todos_tool")
+                                    for tc in tool_calls
+                                )
+                                # Skip summary if non-write_todos tool_calls exist (work still in progress)
+                                if has_summary_pattern and has_non_todo_tool_calls:
+                                    logger.info(
+                                        "Initial: SKIPPING premature summary (has non-todo tool_calls): %s",
+                                        content[:100],
+                                    )
+                                    content = None  # Skip this content
+
                                 if (
                                     content
                                     and isinstance(content, str)
@@ -1709,6 +1785,39 @@ async def stream_agent(request: AgentRequest):
                     }
                     produced_output = True
                     fallback_response = None
+                if isinstance(fallback_response, AIMessage):
+                    # LLM Response - structured JSON format
+                    print(LOG_RESPONSE_START, flush=True)
+                    response_data = {
+                        "type": "AIMessage",
+                        "content": fallback_response.content or "",
+                        "tool_calls": fallback_response.tool_calls
+                        if hasattr(fallback_response, "tool_calls")
+                        else [],
+                        "additional_kwargs": getattr(
+                            fallback_response, "additional_kwargs", {}
+                        )
+                        or {},
+                        "response_metadata": getattr(
+                            fallback_response, "response_metadata", {}
+                        )
+                        or {},
+                        "usage_metadata": getattr(
+                            fallback_response, "usage_metadata", {}
+                        )
+                        or {},
+                    }
+                    print(
+                        json.dumps(
+                            response_data,
+                            indent=2,
+                            ensure_ascii=False,
+                            default=str,
+                        ),
+                        flush=True,
+                    )
+                    print(LOG_RESPONSE_END, flush=True)
+
                 if isinstance(fallback_response, AIMessage) and getattr(
                     fallback_response, "tool_calls", None
                 ):
@@ -1771,6 +1880,17 @@ async def stream_agent(request: AgentRequest):
                                     }
                                 ),
                             }
+                        elif tool_name in ("final_summary_tool", "final_summary"):
+                            # Final summary - emit summary event for frontend
+                            produced_output = True
+                            summary_data = {
+                                "summary": tool_args.get("summary", ""),
+                                "next_items": tool_args.get("next_items", []),
+                            }
+                            yield {
+                                "event": "summary",
+                                "data": json.dumps(summary_data),
+                            }
                         elif tool_name == "read_file_tool":
                             # For file operations, generate code with the LLM
                             logger.info(
@@ -1959,14 +2079,28 @@ async def resume_agent(request: ResumeRequest):
             logger.info("Resume: Agent mode: %s", agent_mode)
 
             # Get agent prompts (for multi-agent mode)
-            # ROOT CAUSE: Frontend sends both systemPrompt AND agentPrompts
-            # FIX: Ignore all custom prompts for multi-agent mode
             agent_prompts = None
             if agent_mode == "multi":
                 if request.llmConfig and request.llmConfig.agent_prompts:
-                    logger.warning("Resume: Multi-agent mode - ignoring agentPrompts")
+                    agent_prompts = {
+                        "planner": request.llmConfig.agent_prompts.planner,
+                        "python_developer": (
+                            request.llmConfig.agent_prompts.python_developer
+                        ),
+                        "researcher": request.llmConfig.agent_prompts.researcher,
+                        "athena_query": request.llmConfig.agent_prompts.athena_query,
+                    }
+                    agent_prompts = {k: v for k, v in agent_prompts.items() if v}
+                    logger.info(
+                        "Resume: Multi-agent mode - using agentPrompts (%s)",
+                        list(agent_prompts.keys()),
+                    )
+                # In multi-agent mode, DON'T use systemPrompt as override
                 if system_prompt_override:
-                    logger.warning("Resume: Multi-agent mode - ignoring systemPrompt")
+                    logger.info(
+                        "Resume: Multi-agent mode - ignoring systemPrompt (len=%d)",
+                        len(system_prompt_override),
+                    )
                     system_prompt_override = None
 
             agent_cache_key = _get_agent_cache_key(
@@ -2011,6 +2145,13 @@ async def resume_agent(request: ResumeRequest):
             # Prepare config with thread_id
             config = {"configurable": {"thread_id": request.threadId}}
 
+            # Set current thread_id for code history tracking
+            from agent_server.langchain.middleware.subagent_middleware import (
+                set_current_thread_id,
+            )
+
+            set_current_thread_id(request.threadId)
+
             pending_actions = _simple_agent_pending_actions.get(request.threadId, [])
 
             # Convert decisions to LangChain format
@@ -2047,7 +2188,7 @@ async def resume_agent(request: ResumeRequest):
                         "edit_file_tool",
                         "multiedit_file_tool",
                     ):
-                        track_tool_execution(tool_name, args)
+                        track_tool_execution(tool_name, args, request.threadId)
                     langgraph_decisions.append(
                         {
                             "type": "edit",
@@ -2341,7 +2482,39 @@ async def resume_agent(request: ResumeRequest):
                             # ToolMessage processing continues (no final_answer_tool)
 
                         # Handle AIMessage (use elif to avoid processing after ToolMessage)
-                        elif hasattr(last_message, "content") and last_message.content:
+                        elif isinstance(last_message, AIMessage):
+                            # LLM Response - structured JSON format
+                            print(LOG_RESPONSE_START, flush=True)
+                            response_data = {
+                                "type": "AIMessage",
+                                "content": last_message.content or "",
+                                "tool_calls": last_message.tool_calls
+                                if hasattr(last_message, "tool_calls")
+                                else [],
+                                "additional_kwargs": getattr(
+                                    last_message, "additional_kwargs", {}
+                                )
+                                or {},
+                                "response_metadata": getattr(
+                                    last_message, "response_metadata", {}
+                                )
+                                or {},
+                                "usage_metadata": getattr(
+                                    last_message, "usage_metadata", {}
+                                )
+                                or {},
+                            }
+                            print(
+                                json.dumps(
+                                    response_data,
+                                    indent=2,
+                                    ensure_ascii=False,
+                                    default=str,
+                                ),
+                                flush=True,
+                            )
+                            print(LOG_RESPONSE_END, flush=True)
+
                             content = last_message.content
 
                             # Handle list content (e.g., multimodal responses)
@@ -2375,6 +2548,28 @@ async def resume_agent(request: ResumeRequest):
                                     and content_stripped.startswith("{")
                                 )
                             )
+
+                            # Check if this is summary/next_items with tool_calls (premature summary)
+                            has_summary_pattern = (
+                                '"summary"' in content or "'summary'" in content
+                            ) and (
+                                '"next_items"' in content or "'next_items'" in content
+                            )
+                            tool_calls = getattr(last_message, "tool_calls", []) or []
+                            # Check if any tool_call is NOT write_todos (work still in progress)
+                            has_non_todo_tool_calls = any(
+                                tc.get("name")
+                                not in ("write_todos", "write_todos_tool")
+                                for tc in tool_calls
+                            )
+                            # Skip summary if non-write_todos tool_calls exist (work still in progress)
+                            if has_summary_pattern and has_non_todo_tool_calls:
+                                logger.info(
+                                    "Resume: SKIPPING premature summary (has non-todo tool_calls): %s",
+                                    content[:100],
+                                )
+                                content = None  # Skip this content
+
                             if (
                                 content
                                 and isinstance(content, str)
@@ -2452,7 +2647,7 @@ async def resume_agent(request: ResumeRequest):
                                             "다음단계",
                                             "다음 단계",
                                         ]
-                                        has_summary_todo = any(
+                                        any(
                                             any(
                                                 kw in t.get("content", "")
                                                 for kw in summary_keywords
@@ -2626,6 +2821,21 @@ async def resume_agent(request: ResumeRequest):
                                                 }
                                             ),
                                         }
+                                    elif tool_name in (
+                                        "final_summary_tool",
+                                        "final_summary",
+                                    ):
+                                        # Final summary - emit summary event for frontend
+                                        summary_data = {
+                                            "summary": tool_args.get("summary", ""),
+                                            "next_items": tool_args.get(
+                                                "next_items", []
+                                            ),
+                                        }
+                                        yield {
+                                            "event": "summary",
+                                            "data": json.dumps(summary_data),
+                                        }
 
                 # Drain and emit any subagent events (tool calls from subagents)
                 for subagent_event in get_subagent_debug_events():
@@ -2888,5 +3098,7 @@ async def reset_agent_thread(request: ResetRequest) -> Dict[str, Any]:
         "status": "ok",
         "thread_id": thread_id,
         "cleared": cleared,
-        "message": f"Thread {thread_id} has been reset" if cleared else f"Thread {thread_id} had no state to clear",
+        "message": f"Thread {thread_id} has been reset"
+        if cleared
+        else f"Thread {thread_id} had no state to clear",
     }

{hdsp_jupyter_extension-2.0.25.data → hdsp_jupyter_extension-2.0.27.data}/data/share/jupyter/labextensions/hdsp-agent/build_log.json

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

{hdsp_jupyter_extension-2.0.25.data → hdsp_jupyter_extension-2.0.27.data}/data/share/jupyter/labextensions/hdsp-agent/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hdsp-agent",
-  "version": "2.0.25",
+  "version": "2.0.27",
   "description": "HDSP Agent JupyterLab Extension - Thin client for Agent Server",
   "keywords": [
     "jupyter",
@@ -132,7 +132,7 @@
       }
     },
     "_build": {
-      "load": "static/remoteEntry.ffc2b4bc8e6cb300e1e1.js",
+      "load": "static/remoteEntry.4ab73bb5068405670214.js",
       "extension": "./extension",
       "style": "./style"
     }

hdsp_jupyter_extension-2.0.25.data/data/share/jupyter/labextensions/hdsp-agent/static/remoteEntry.ffc2b4bc8e6cb300e1e1.js → hdsp_jupyter_extension-2.0.27.data/data/share/jupyter/labextensions/hdsp-agent/static/remoteEntry.4ab73bb5068405670214.js

@@ -281,7 +281,7 @@ __webpack_require__.d(exports, {
 /******/ 					register("@emotion/react", "11.14.0", () => (Promise.all([__webpack_require__.e("vendors-node_modules_emotion_cache_dist_emotion-cache_browser_development_esm_js"), __webpack_require__.e("vendors-node_modules_babel_runtime_helpers_esm_extends_js-node_modules_emotion_serialize_dist-051195"), __webpack_require__.e("vendors-node_modules_emotion_react_dist_emotion-react_browser_development_esm_js"), __webpack_require__.e("webpack_sharing_consume_default_react"), __webpack_require__.e("node_modules_emotion_use-insertion-effect-with-fallbacks_dist_emotion-use-insertion-effect-wi-3ba6b80")]).then(() => (() => (__webpack_require__(/*! ./node_modules/@emotion/react/dist/emotion-react.browser.development.esm.js */ "./node_modules/@emotion/react/dist/emotion-react.browser.development.esm.js"))))));
 /******/ 					register("@emotion/styled", "11.14.1", () => (Promise.all([__webpack_require__.e("vendors-node_modules_babel_runtime_helpers_esm_extends_js-node_modules_emotion_serialize_dist-051195"), __webpack_require__.e("vendors-node_modules_emotion_styled_dist_emotion-styled_browser_development_esm_js"), __webpack_require__.e("webpack_sharing_consume_default_react"), __webpack_require__.e("webpack_sharing_consume_default_emotion_react_emotion_react")]).then(() => (() => (__webpack_require__(/*! ./node_modules/@emotion/styled/dist/emotion-styled.browser.development.esm.js */ "./node_modules/@emotion/styled/dist/emotion-styled.browser.development.esm.js"))))));
 /******/ 					register("@mui/material", "5.18.0", () => (Promise.all([__webpack_require__.e("vendors-node_modules_emotion_cache_dist_emotion-cache_browser_development_esm_js"), __webpack_require__.e("vendors-node_modules_babel_runtime_helpers_esm_extends_js-node_modules_emotion_serialize_dist-051195"), __webpack_require__.e("vendors-node_modules_mui_material_index_js"), __webpack_require__.e("vendors-node_modules_mui_material_utils_createSvgIcon_js"), __webpack_require__.e("webpack_sharing_consume_default_react"), __webpack_require__.e("webpack_sharing_consume_default_emotion_react_emotion_react-webpack_sharing_consume_default_e-5f41bf")]).then(() => (() => (__webpack_require__(/*! ./node_modules/@mui/material/index.js */ "./node_modules/@mui/material/index.js"))))));
-/******/ 					register("hdsp-agent", "2.0.25", () => (Promise.all([__webpack_require__.e("vendors-node_modules_emotion_cache_dist_emotion-cache_browser_development_esm_js"), __webpack_require__.e("vendors-node_modules_babel_runtime_helpers_esm_extends_js-node_modules_emotion_serialize_dist-051195"), __webpack_require__.e("vendors-node_modules_mui_material_utils_createSvgIcon_js"), __webpack_require__.e("webpack_sharing_consume_default_react"), __webpack_require__.e("webpack_sharing_consume_default_emotion_react_emotion_react-webpack_sharing_consume_default_e-5f41bf"), __webpack_require__.e("lib_index_js")]).then(() => (() => (__webpack_require__(/*! ./lib/index.js */ "./lib/index.js"))))));
+/******/ 					register("hdsp-agent", "2.0.27", () => (Promise.all([__webpack_require__.e("vendors-node_modules_emotion_cache_dist_emotion-cache_browser_development_esm_js"), __webpack_require__.e("vendors-node_modules_babel_runtime_helpers_esm_extends_js-node_modules_emotion_serialize_dist-051195"), __webpack_require__.e("vendors-node_modules_mui_material_utils_createSvgIcon_js"), __webpack_require__.e("webpack_sharing_consume_default_react"), __webpack_require__.e("webpack_sharing_consume_default_emotion_react_emotion_react-webpack_sharing_consume_default_e-5f41bf"), __webpack_require__.e("lib_index_js")]).then(() => (() => (__webpack_require__(/*! ./lib/index.js */ "./lib/index.js"))))));
 /******/ 				}
 /******/ 				break;
 /******/ 			}
@@ -622,4 +622,4 @@ __webpack_require__.d(exports, {
 /******/ 	
 /******/ })()
 ;
-//# sourceMappingURL=remoteEntry.ffc2b4bc8e6cb300e1e1.js.map
+//# sourceMappingURL=remoteEntry.4ab73bb5068405670214.js.map