hdsp-jupyter-extension 2.0.19__py3-none-any.whl → 2.0.21__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

@@ -42,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로 오류 확인 필수
 
 # 사용자 입력 요청 [중요]

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.19.data → hdsp_jupyter_extension-2.0.21.data}/data/share/jupyter/labextensions/hdsp-agent/build_log.json

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

{hdsp_jupyter_extension-2.0.19.data → hdsp_jupyter_extension-2.0.21.data}/data/share/jupyter/labextensions/hdsp-agent/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hdsp-agent",
-  "version": "2.0.19",
+  "version": "2.0.21",
   "description": "HDSP Agent JupyterLab Extension - Thin client for Agent Server",
   "keywords": [
     "jupyter",
@@ -132,7 +132,7 @@
       }
     },
     "_build": {
-      "load": "static/remoteEntry.d686ab71eb65b5ef8f15.js",
+      "load": "static/remoteEntry.93b1c499786ecd47b837.js",
       "extension": "./extension",
       "style": "./style"
     }

jupyter_ext/labextension/static/lib_index_js.1917fbaea37d75dc69b3.js → hdsp_jupyter_extension-2.0.21.data/data/share/jupyter/labextensions/hdsp-agent/static/lib_index_js.90f80cb80187de8c5ae5.js

@@ -2295,7 +2295,7 @@ const ChatPanel = (0,react__WEBPACK_IMPORTED_MODULE_0__.forwardRef)(({ apiServic
             }
         }
         const formatted = files.map((file) => {
-            const icon = file.isDir ? _utils_icons__WEBPACK_IMPORTED_MODULE_8__.Icons.folder : _utils_icons__WEBPACK_IMPORTED_MODULE_8__.Icons.file;
+            const icon = file.isDir ? '[DIR]' : '[FILE]';
             const sizeInfo = file.isDir ? '' : ` (${file.size} bytes)`;
             return `${icon} ${file.path}${file.isDir ? '/' : sizeInfo}`;
         }).join('\n');
@@ -4240,6 +4240,8 @@ const SettingsPanel = ({ onClose, onSave, currentConfig }) => {
     const [vllmEndpoint, setVllmEndpoint] = (0,react__WEBPACK_IMPORTED_MODULE_0__.useState)(initConfig.vllm?.endpoint || 'http://localhost:8000/v1');
     const [vllmApiKey, setVllmApiKey] = (0,react__WEBPACK_IMPORTED_MODULE_0__.useState)(initConfig.vllm?.apiKey || '');
     const [vllmModel, setVllmModel] = (0,react__WEBPACK_IMPORTED_MODULE_0__.useState)(initConfig.vllm?.model || 'meta-llama/Llama-2-7b-chat-hf');
+    const [vllmUseResponsesApi, setVllmUseResponsesApi] = (0,react__WEBPACK_IMPORTED_MODULE_0__.useState)(Boolean(initConfig.vllm?.useResponsesApi));
+    const [vllmTemperature, setVllmTemperature] = (0,react__WEBPACK_IMPORTED_MODULE_0__.useState)(initConfig.vllm?.temperature ?? 0.0);
     // OpenAI settings
     const [openaiApiKey, setOpenaiApiKey] = (0,react__WEBPACK_IMPORTED_MODULE_0__.useState)(initConfig.openai?.apiKey || '');
     const [openaiModel, setOpenaiModel] = (0,react__WEBPACK_IMPORTED_MODULE_0__.useState)(initConfig.openai?.model || 'gpt-4');
@@ -4282,6 +4284,8 @@ const SettingsPanel = ({ onClose, onSave, currentConfig }) => {
             setVllmEndpoint(currentConfig.vllm?.endpoint || 'http://localhost:8000/v1');
             setVllmApiKey(currentConfig.vllm?.apiKey || '');
             setVllmModel(currentConfig.vllm?.model || 'meta-llama/Llama-2-7b-chat-hf');
+            setVllmUseResponsesApi(Boolean(currentConfig.vllm?.useResponsesApi));
+            setVllmTemperature(currentConfig.vllm?.temperature ?? 0.0);
             setOpenaiApiKey(currentConfig.openai?.apiKey || '');
             setOpenaiModel(currentConfig.openai?.model || 'gpt-4');
             setSystemPrompt(currentConfig.systemPrompt || (0,_services_ApiKeyManager__WEBPACK_IMPORTED_MODULE_10__.getDefaultLLMConfig)().systemPrompt || '');
@@ -4310,7 +4314,9 @@ const SettingsPanel = ({ onClose, onSave, currentConfig }) => {
         vllm: {
             endpoint: vllmEndpoint,
             apiKey: vllmApiKey,
-            model: vllmModel
+            model: vllmModel,
+            useResponsesApi: vllmUseResponsesApi,
+            temperature: vllmTemperature
         },
         openai: {
             apiKey: openaiApiKey,
@@ -4472,7 +4478,16 @@ const SettingsPanel = ({ onClose, onSave, currentConfig }) => {
                         react__WEBPACK_IMPORTED_MODULE_0___default().createElement("input", { type: "password", className: "jp-agent-settings-input", value: vllmApiKey, onChange: (e) => setVllmApiKey(e.target.value), placeholder: "API \uD0A4\uAC00 \uD544\uC694\uD55C \uACBD\uC6B0 \uC785\uB825" })),
                     react__WEBPACK_IMPORTED_MODULE_0___default().createElement("div", { className: "jp-agent-settings-group" },
                         react__WEBPACK_IMPORTED_MODULE_0___default().createElement("label", { className: "jp-agent-settings-label" }, "\uBAA8\uB378 \uC774\uB984"),
-                        react__WEBPACK_IMPORTED_MODULE_0___default().createElement("input", { type: "text", className: "jp-agent-settings-input", value: vllmModel, onChange: (e) => setVllmModel(e.target.value), placeholder: "meta-llama/Llama-2-7b-chat-hf" })))),
+                        react__WEBPACK_IMPORTED_MODULE_0___default().createElement("input", { type: "text", className: "jp-agent-settings-input", value: vllmModel, onChange: (e) => setVllmModel(e.target.value), placeholder: "meta-llama/Llama-2-7b-chat-hf" })),
+                    react__WEBPACK_IMPORTED_MODULE_0___default().createElement("div", { className: "jp-agent-settings-group" },
+                        react__WEBPACK_IMPORTED_MODULE_0___default().createElement("label", { className: "jp-agent-settings-label" }, "Temperature"),
+                        react__WEBPACK_IMPORTED_MODULE_0___default().createElement("input", { type: "number", className: "jp-agent-settings-input", value: vllmTemperature, onChange: (e) => setVllmTemperature(Math.max(0, Math.min(2, parseFloat(e.target.value) || 0))), min: 0, max: 2, step: 0.1, style: { width: '100px' } }),
+                        react__WEBPACK_IMPORTED_MODULE_0___default().createElement("small", { style: { color: '#666', marginLeft: '8px' } }, "0.0 = \uACB0\uC815\uC801, 1.0+ = \uCC3D\uC758\uC801")),
+                    react__WEBPACK_IMPORTED_MODULE_0___default().createElement("div", { className: "jp-agent-settings-group" },
+                        react__WEBPACK_IMPORTED_MODULE_0___default().createElement("label", { className: "jp-agent-settings-checkbox" },
+                            react__WEBPACK_IMPORTED_MODULE_0___default().createElement("input", { type: "checkbox", checked: vllmUseResponsesApi, onChange: (e) => setVllmUseResponsesApi(e.target.checked) }),
+                            react__WEBPACK_IMPORTED_MODULE_0___default().createElement("span", null, "Use Responses API (/v1/responses)")),
+                        react__WEBPACK_IMPORTED_MODULE_0___default().createElement("small", { style: { color: '#666', display: 'block', marginTop: '4px' } }, "OpenAI Responses API\uB97C \uC9C0\uC6D0\uD558\uB294 \uC5D4\uB4DC\uD3EC\uC778\uD2B8\uC5D0\uC11C \uC0AC\uC6A9")))),
                 provider === 'openai' && (react__WEBPACK_IMPORTED_MODULE_0___default().createElement("div", { className: "jp-agent-settings-provider" },
                     react__WEBPACK_IMPORTED_MODULE_0___default().createElement("h3", null, "OpenAI \uC124\uC815"),
                     react__WEBPACK_IMPORTED_MODULE_0___default().createElement("div", { className: "jp-agent-settings-group" },
@@ -9338,7 +9353,34 @@ class ApiService {
                             }
                             // Handle token events (streaming LLM response)
                             if (data.content) {
-                                onChunk(data.content);
+                                // Filter out raw todos JSON that shouldn't be displayed to users
+                                // Pattern: {"todos": [{"content": "...", "status": "..."}, ...]}
+                                const contentStr = String(data.content).trim();
+                                const isSummaryJson = contentStr.includes('"summary"') && contentStr.includes('"next_items"');
+                                // Check if this is a raw todos JSON object (not summary JSON)
+                                let isRawTodosJson = false;
+                                if (!isSummaryJson && contentStr.includes('"todos"')) {
+                                    try {
+                                        const parsed = JSON.parse(contentStr);
+                                        // Check structure: {todos: [{content, status}, ...]}
+                                        if (parsed && Array.isArray(parsed.todos) && parsed.todos.length > 0) {
+                                            const firstTodo = parsed.todos[0];
+                                            if (firstTodo && 'content' in firstTodo && 'status' in firstTodo) {
+                                                isRawTodosJson = true;
+                                            }
+                                        }
+                                    }
+                                    catch {
+                                        // Not valid JSON, check for partial pattern
+                                        isRawTodosJson = /"todos"\s*:\s*\[\s*\{[^}]*"content"\s*:/.test(contentStr);
+                                    }
+                                }
+                                if (isRawTodosJson) {
+                                    console.log('[ApiService] Filtered raw todos JSON from display');
+                                }
+                                else {
+                                    onChunk(data.content);
+                                }
                             }
                             // Handle tool_call events - pass to handler for cell creation
                             if (currentEventType === 'tool_call' && data.tool && onToolCall) {
@@ -9508,7 +9550,30 @@ class ApiService {
                             }
                             // Content chunks
                             if (data.content && onChunk) {
-                                onChunk(data.content);
+                                // Filter out raw todos JSON that shouldn't be displayed to users
+                                const contentStr = String(data.content).trim();
+                                const isSummaryJson = contentStr.includes('"summary"') && contentStr.includes('"next_items"');
+                                let isRawTodosJson = false;
+                                if (!isSummaryJson && contentStr.includes('"todos"')) {
+                                    try {
+                                        const parsed = JSON.parse(contentStr);
+                                        if (parsed && Array.isArray(parsed.todos) && parsed.todos.length > 0) {
+                                            const firstTodo = parsed.todos[0];
+                                            if (firstTodo && 'content' in firstTodo && 'status' in firstTodo) {
+                                                isRawTodosJson = true;
+                                            }
+                                        }
+                                    }
+                                    catch {
+                                        isRawTodosJson = /"todos"\s*:\s*\[\s*\{[^}]*"content"\s*:/.test(contentStr);
+                                    }
+                                }
+                                if (isRawTodosJson) {
+                                    console.log('[ApiService] Filtered raw todos JSON from display');
+                                }
+                                else {
+                                    onChunk(data.content);
+                                }
                             }
                             // Tool call events during resume
                             if (currentEventType === 'tool_call' && data.tool && onToolCall) {
@@ -11813,4 +11878,4 @@ __webpack_require__.r(__webpack_exports__);
 /***/ }
 
 }]);
-//# sourceMappingURL=lib_index_js.1917fbaea37d75dc69b3.js.map
+//# sourceMappingURL=lib_index_js.90f80cb80187de8c5ae5.js.map