Upload 6 files

app.py

@@ -205,6 +205,123 @@ def _recompute_out_and_state_from_tokens(model_name: str, model_tokens: List[int
     return out, model_state
 
 
+def resolve_request_flags(request, detection):
+    """Resolve effective booleans for web_search, file_tool, tools, and reasoning
+    based on request flags (explicit), sampler overrides, model defaults and detection.
+    Returns dict with keys: web_search_enabled, file_tool_enabled, tools_enabled, reasoning_enabled.
+    """
+    # Web search
+    web_search_enabled = (
+        True
+        if (request.enable_web_search is not None and request.enable_web_search)
+        else (
+            request.web_search
+            or (request.auto_web_search if request.auto_web_search is not None else (getattr(CONFIG, 'AUTO_ENABLE_WEB_SEARCH', True) and detection.get('need_web_search')))
+        )
+    )
+    if not getattr(CONFIG, 'ENABLE_WEB_SEARCH_BY_DEFAULT', True) and request.enable_web_search is None and not (request.web_search or False):
+        web_search_enabled = False
+    try:
+        if request.sampler and getattr(request.sampler, 'ALLOW_WEB_SEARCH', None) is not None:
+            web_search_enabled = bool(request.sampler.ALLOW_WEB_SEARCH)
+        elif hasattr(request, 'sampler_allow_web_search') and request.sampler_allow_web_search is not None:
+            web_search_enabled = bool(request.sampler_allow_web_search)
+        else:
+            ms = MODEL_STORAGE.get(request.model)
+            if ms and ms.MODEL_CONFIG:
+                if hasattr(ms.MODEL_CONFIG, 'DEFAULT_SAMPLER') and getattr(ms.MODEL_CONFIG.DEFAULT_SAMPLER, 'ALLOW_WEB_SEARCH', None) is not None:
+                    web_search_enabled = bool(ms.MODEL_CONFIG.DEFAULT_SAMPLER.ALLOW_WEB_SEARCH)
+                elif hasattr(ms.MODEL_CONFIG, 'ALLOW_WEB_SEARCH') and not ms.MODEL_CONFIG.ALLOW_WEB_SEARCH:
+                    web_search_enabled = False
+    except Exception:
+        pass
+
+    # File tool decision
+    if request.enable_file_tool is not None:
+        file_tool_enabled = bool(request.enable_file_tool)
+    else:
+        auto_file_flag = request.auto_file_tool if request.auto_file_tool is not None else getattr(CONFIG, 'AUTO_ENABLE_TOOLS', True)
+        file_tool_enabled = bool((request.file_ids and len(request.file_ids) > 0) or (auto_file_flag and request.file_ids))
+    if not getattr(CONFIG, 'ALLOW_FILE_TOOL_BY_DEFAULT', True) and request.enable_file_tool is None:
+        file_tool_enabled = False
+    try:
+        if request.sampler and getattr(request.sampler, 'ALLOW_FILE_TOOL', None) is not None:
+            file_tool_enabled = bool(request.sampler.ALLOW_FILE_TOOL)
+        elif hasattr(request, 'sampler_allow_file_tool') and request.sampler_allow_file_tool is not None:
+            file_tool_enabled = bool(request.sampler_allow_file_tool)
+        else:
+            ms = MODEL_STORAGE.get(request.model)
+            if ms and ms.MODEL_CONFIG:
+                if hasattr(ms.MODEL_CONFIG, 'DEFAULT_SAMPLER') and getattr(ms.MODEL_CONFIG.DEFAULT_SAMPLER, 'ALLOW_FILE_TOOL', None) is not None:
+                    file_tool_enabled = bool(ms.MODEL_CONFIG.DEFAULT_SAMPLER.ALLOW_FILE_TOOL)
+                elif hasattr(ms.MODEL_CONFIG, 'ALLOW_FILE_TOOL') and not ms.MODEL_CONFIG.ALLOW_FILE_TOOL:
+                    file_tool_enabled = False
+    except Exception:
+        pass
+
+    # Tools decision
+    if request.enable_tools is not None:
+        tools_enabled = bool(request.enable_tools)
+    else:
+        auto_tools_flag = request.auto_tools if request.auto_tools is not None else getattr(CONFIG, 'AUTO_ENABLE_TOOLS', True)
+        tools_enabled = bool(request.tools) or getattr(CONFIG, 'ENABLE_TOOLS_BY_DEFAULT', False) or (auto_tools_flag and (detection.get('need_calc') or detection.get('need_web_search')))
+    try:
+        if request.sampler and getattr(request.sampler, 'ALLOW_TOOLS', None) is not None:
+            tools_enabled = bool(request.sampler.ALLOW_TOOLS)
+        elif hasattr(request, 'sampler_allow_tools') and request.sampler_allow_tools is not None:
+            tools_enabled = bool(request.sampler_allow_tools)
+        else:
+            ms = MODEL_STORAGE.get(request.model)
+            if ms and ms.MODEL_CONFIG:
+                if hasattr(ms.MODEL_CONFIG, 'DEFAULT_SAMPLER') and getattr(ms.MODEL_CONFIG.DEFAULT_SAMPLER, 'ALLOW_TOOLS', None) is not None:
+                    if not ms.MODEL_CONFIG.DEFAULT_SAMPLER.ALLOW_TOOLS:
+                        tools_enabled = False
+                elif hasattr(ms.MODEL_CONFIG, 'ALLOW_TOOLS') and not ms.MODEL_CONFIG.ALLOW_TOOLS:
+                    tools_enabled = False
+    except Exception:
+        pass
+
+    # Reasoning decision
+    reasoning_enabled = bool(
+        True
+        if (request.enable_reasoning is not None and request.enable_reasoning)
+        else (
+            bool(False) or bool(request.auto_reasoning if request.auto_reasoning is not None else (getattr(CONFIG, 'AUTO_ENABLE_REASONING', True) and bool(detection.get('need_reasoning'))))
+        )
+    )
+    if not getattr(CONFIG, 'ENABLE_REASONING_BY_DEFAULT', True) and request.enable_reasoning is None:
+        reasoning_enabled = False
+    try:
+        if request.sampler and getattr(request.sampler, 'ALLOW_REASONING', None) is not None:
+            reasoning_enabled = bool(request.sampler.ALLOW_REASONING)
+        elif hasattr(request, 'sampler_allow_reasoning') and request.sampler_allow_reasoning is not None:
+            reasoning_enabled = bool(request.sampler_allow_reasoning)
+        else:
+            ms = MODEL_STORAGE.get(request.model)
+            if ms and ms.MODEL_CONFIG:
+                if hasattr(ms.MODEL_CONFIG, 'DEFAULT_SAMPLER') and getattr(ms.MODEL_CONFIG.DEFAULT_SAMPLER, 'ALLOW_REASONING', None) is not None:
+                    if not ms.MODEL_CONFIG.DEFAULT_SAMPLER.ALLOW_REASONING:
+                        reasoning_enabled = False
+                elif hasattr(ms.MODEL_CONFIG, 'ALLOW_REASONING') and not ms.MODEL_CONFIG.ALLOW_REASONING:
+                    reasoning_enabled = False
+    except Exception:
+        pass
+    # Also apply model-level disable
+    try:
+        ms = MODEL_STORAGE.get(request.model)
+        if ms and ms.MODEL_CONFIG and hasattr(ms.MODEL_CONFIG, 'ALLOW_REASONING') and not ms.MODEL_CONFIG.ALLOW_REASONING:
+            reasoning_enabled = False
+    except Exception:
+        pass
+
+    return {
+        'web_search_enabled': web_search_enabled,
+        'file_tool_enabled': file_tool_enabled,
+        'tools_enabled': tools_enabled,
+        'reasoning_enabled': reasoning_enabled,
+    }
+
+
 
 # Move ChatCompletionRequest definition above fallback apply_model_tags_to_request
 
@@ -335,12 +452,16 @@ class ChatCompletionRequest(BaseModel):
     include_usage: Optional[bool] = Field(default=False)
     stop: Optional[list[str]] = Field(["\n\n"])
     stop_tokens: Optional[list[int]] = Field([0])
-    web_search: Optional[bool] = Field(default=True, description="Whether to perform a web search and append results to the prompt")
-    enable_web_search: Optional[bool] = Field(default=True, description="Explicitly enable web search (overrides auto/web_search) if set")
+    # Note: these defaults are intentionally None so the model may decide
+    # autonomously whether to use web search based on prompt detection unless
+    # the client explicitly sets flags. `auto_web_search` will be consulted
+    # when `enable_web_search` and `web_search` are None.
+    web_search: Optional[bool] = Field(default=None, description="Whether to perform a web search and append results to the prompt; if None, auto-detection is used")
+    enable_web_search: Optional[bool] = Field(default=None, description="Explicitly enable web search (overrides auto/web_search) if set; if None, auto-detection controls it")
     auto_web_search: Optional[bool] = Field(default=True, description="Whether to enable web_search based on auto-detected intent")
     enable_tools: Optional[bool] = Field(default=None, description="Explicitly enable tools (overrides auto detection)")
     auto_tools: Optional[bool] = Field(default=True, description="Whether to enable tools based on auto-detected intent")
-    enable_reasoning: Optional[bool] = Field(default=True, description="Explicitly override reasoning enablement")
+    enable_reasoning: Optional[bool] = Field(default=None, description="Explicitly override reasoning enablement; if None, auto-detection controls it")
     auto_reasoning: Optional[bool] = Field(default=True, description="Whether to enable reasoning based on auto detection")
     enable_universal: Optional[bool] = Field(default=None, description="Explicitly enable the universal tool execution")
     auto_universal: Optional[bool] = Field(default=True, description="Whether to auto enable universal tool execution")
@@ -544,112 +665,18 @@ async def chatResponse(
 
     createTimestamp = time.time()
 
-    def decide_web_search_enabled(request, detection):
-        web_search_enabled = (
-            True
-            if (request.enable_web_search is not None and request.enable_web_search)
-            else (
-                request.web_search
-                or (request.auto_web_search if request.auto_web_search is not None else CONFIG.AUTO_ENABLE_WEB_SEARCH and detection.get('need_web_search'))
-            )
-        )
-        if not getattr(CONFIG, 'ENABLE_WEB_SEARCH_BY_DEFAULT', True) and request.enable_web_search is None and not request.web_search:
-            web_search_enabled = False
-        try:
-            if request.sampler and getattr(request.sampler, 'ALLOW_WEB_SEARCH', None) is not None:
-                web_search_enabled = bool(request.sampler.ALLOW_WEB_SEARCH)
-            elif hasattr(request, 'sampler_allow_web_search') and request.sampler_allow_web_search is not None:
-                web_search_enabled = bool(request.sampler_allow_web_search)
-            else:
-                ms = MODEL_STORAGE.get(request.model)
-                if ms and ms.MODEL_CONFIG:
-                    if hasattr(ms.MODEL_CONFIG, 'DEFAULT_SAMPLER') and getattr(ms.MODEL_CONFIG.DEFAULT_SAMPLER, 'ALLOW_WEB_SEARCH', None) is not None:
-                        web_search_enabled = bool(ms.MODEL_CONFIG.DEFAULT_SAMPLER.ALLOW_WEB_SEARCH)
-                    elif hasattr(ms.MODEL_CONFIG, 'ALLOW_WEB_SEARCH') and not ms.MODEL_CONFIG.ALLOW_WEB_SEARCH:
-                        web_search_enabled = False
-        except Exception:
-            pass
-        return web_search_enabled
+    # use global resolve_request_flags
 
     def decide_file_tool_enabled(request):
-        if request.enable_file_tool is not None:
-            file_tool_enabled = bool(request.enable_file_tool)
-        else:
-            auto_file_flag = request.auto_file_tool if request.auto_file_tool is not None else CONFIG.AUTO_ENABLE_TOOLS
-            file_tool_enabled = bool((request.file_ids and len(request.file_ids) > 0) or (auto_file_flag and request.file_ids))
-        if not getattr(CONFIG, 'ALLOW_FILE_TOOL_BY_DEFAULT', True) and request.enable_file_tool is None:
-            file_tool_enabled = False
-        try:
-            if request.sampler and getattr(request.sampler, 'ALLOW_FILE_TOOL', None) is not None:
-                file_tool_enabled = bool(request.sampler.ALLOW_FILE_TOOL)
-            elif hasattr(request, 'sampler_allow_file_tool') and request.sampler_allow_file_tool is not None:
-                file_tool_enabled = bool(request.sampler_allow_file_tool)
-            else:
-                ms = MODEL_STORAGE.get(request.model)
-                if ms and ms.MODEL_CONFIG:
-                    if hasattr(ms.MODEL_CONFIG, 'DEFAULT_SAMPLER') and getattr(ms.MODEL_CONFIG.DEFAULT_SAMPLER, 'ALLOW_FILE_TOOL', None) is not None:
-                        file_tool_enabled = bool(ms.MODEL_CONFIG.DEFAULT_SAMPLER.ALLOW_FILE_TOOL)
-                    elif hasattr(ms.MODEL_CONFIG, 'ALLOW_FILE_TOOL') and not ms.MODEL_CONFIG.ALLOW_FILE_TOOL:
-                        file_tool_enabled = False
-        except Exception:
-            pass
-        return file_tool_enabled
+        return resolve_request_flags(request, detection)['file_tool_enabled']
 
     def decide_tools_enabled(request, detection):
-        if request.enable_tools is not None:
-            tools_enabled = bool(request.enable_tools)
-        else:
-            auto_tools_flag = request.auto_tools if request.auto_tools is not None else CONFIG.AUTO_ENABLE_TOOLS
-            tools_enabled = bool(request.tools) or CONFIG.ENABLE_TOOLS_BY_DEFAULT or (auto_tools_flag and (detection.get('need_calc') or detection.get('need_web_search')))
-        try:
-            if request.sampler and getattr(request.sampler, 'ALLOW_TOOLS', None) is not None:
-                tools_enabled = bool(request.sampler.ALLOW_TOOLS)
-            elif hasattr(request, 'sampler_allow_tools') and request.sampler_allow_tools is not None:
-                tools_enabled = bool(request.sampler_allow_tools)
-            else:
-                ms = MODEL_STORAGE.get(request.model)
-                if ms and ms.MODEL_CONFIG:
-                    if hasattr(ms.MODEL_CONFIG, 'DEFAULT_SAMPLER') and getattr(ms.MODEL_CONFIG.DEFAULT_SAMPLER, 'ALLOW_TOOLS', None) is not None:
-                        if not ms.MODEL_CONFIG.DEFAULT_SAMPLER.ALLOW_TOOLS:
-                            tools_enabled = False
-                    elif hasattr(ms.MODEL_CONFIG, 'ALLOW_TOOLS') and not ms.MODEL_CONFIG.ALLOW_TOOLS:
-                        tools_enabled = False
-        except Exception:
-            pass
-        return tools_enabled
+        return resolve_request_flags(request, detection)['tools_enabled']
 
     def decide_reasoning_enabled(request, detection, enableReasoning):
-        reasoning_enabled = bool(
-            True
-            if (request.enable_reasoning is not None and request.enable_reasoning)
-            else (
-                bool(enableReasoning) or bool(request.auto_reasoning if request.auto_reasoning is not None else (CONFIG.AUTO_ENABLE_REASONING and bool(detection.get('need_reasoning'))))
-            )
-        )
-        if not getattr(CONFIG, 'ENABLE_REASONING_BY_DEFAULT', True) and request.enable_reasoning is None:
-            reasoning_enabled = False
-        try:
-            if request.sampler and getattr(request.sampler, 'ALLOW_REASONING', None) is not None:
-                reasoning_enabled = bool(request.sampler.ALLOW_REASONING)
-            elif hasattr(request, 'sampler_allow_reasoning') and request.sampler_allow_reasoning is not None:
-                reasoning_enabled = bool(request.sampler_allow_reasoning)
-            else:
-                ms = MODEL_STORAGE.get(request.model)
-                if ms and ms.MODEL_CONFIG:
-                    if hasattr(ms.MODEL_CONFIG, 'DEFAULT_SAMPLER') and getattr(ms.MODEL_CONFIG.DEFAULT_SAMPLER, 'ALLOW_REASONING', None) is not None:
-                        if not ms.MODEL_CONFIG.DEFAULT_SAMPLER.ALLOW_REASONING:
-                            reasoning_enabled = False
-                    elif hasattr(ms.MODEL_CONFIG, 'ALLOW_REASONING') and not ms.MODEL_CONFIG.ALLOW_REASONING:
-                        reasoning_enabled = False
-        except Exception:
-            pass
-        try:
-            ms = MODEL_STORAGE.get(request.model)
-            if ms and ms.MODEL_CONFIG and hasattr(ms.MODEL_CONFIG, 'ALLOW_REASONING') and not ms.MODEL_CONFIG.ALLOW_REASONING:
-                reasoning_enabled = False
-        except Exception:
-            pass
-        return reasoning_enabled
+        # resolve_request_flags ignores the enableReasoning baseline, so compute flags then
+        flags = resolve_request_flags(request, detection)
+        return flags['reasoning_enabled']
 
     def execute_tools(request, detection, prompt, executed_tool_calls, web_search_enabled, tools_enabled, file_tool_enabled, raw_prompt):
         """Helper to execute tools and update prompt and executed_tool_calls."""
@@ -730,6 +757,33 @@ async def chatResponse(
     detection = detect_tools_and_reasoning(raw_prompt)
     prompt = raw_prompt if request.prompt is not None else f"{cleanMessages(request.messages or [])}\n\nAssistant:{' <think' if enableReasoning else ''}"
 
+    def decide_web_search_enabled(request, detection):
+        web_search_enabled = (
+            True
+            if (request.enable_web_search is not None and request.enable_web_search)
+            else (
+                request.web_search
+                or (request.auto_web_search if request.auto_web_search is not None else (getattr(CONFIG, 'AUTO_ENABLE_WEB_SEARCH', True) and detection.get('need_web_search')))
+            )
+        )
+        if not getattr(CONFIG, 'ENABLE_WEB_SEARCH_BY_DEFAULT', True) and request.enable_web_search is None and not (request.web_search or False):
+            web_search_enabled = False
+        try:
+            if request.sampler and getattr(request.sampler, 'ALLOW_WEB_SEARCH', None) is not None:
+                web_search_enabled = bool(request.sampler.ALLOW_WEB_SEARCH)
+            elif hasattr(request, 'sampler_allow_web_search') and request.sampler_allow_web_search is not None:
+                web_search_enabled = bool(request.sampler_allow_web_search)
+            else:
+                ms = MODEL_STORAGE.get(request.model)
+                if ms and ms.MODEL_CONFIG:
+                    if hasattr(ms.MODEL_CONFIG, 'DEFAULT_SAMPLER') and getattr(ms.MODEL_CONFIG.DEFAULT_SAMPLER, 'ALLOW_WEB_SEARCH', None) is not None:
+                        web_search_enabled = bool(ms.MODEL_CONFIG.DEFAULT_SAMPLER.ALLOW_WEB_SEARCH)
+                    elif hasattr(ms.MODEL_CONFIG, 'ALLOW_WEB_SEARCH') and not ms.MODEL_CONFIG.ALLOW_WEB_SEARCH:
+                        web_search_enabled = False
+        except Exception:
+            pass
+        return web_search_enabled
+
     web_search_enabled = decide_web_search_enabled(request, detection)
     file_tool_enabled = decide_file_tool_enabled(request)
     tools_enabled = decide_tools_enabled(request, detection)
@@ -964,28 +1018,12 @@ async def chatResponseStream(
     # Intent detection and defaults: check whether to auto-enable tools, web_search, reasoning
     detection = detect_tools_and_reasoning(raw_prompt)
 
-    web_search_enabled = (
-        True
-        if (request.enable_web_search is not None and request.enable_web_search)
-        else (
-            request.web_search
-            or (request.auto_web_search if request.auto_web_search is not None else CONFIG.AUTO_ENABLE_WEB_SEARCH and detection.get('need_web_search'))
-        )
-    )
-
-    if request.enable_tools is not None:
-        tools_enabled = bool(request.enable_tools)
-    else:
-        auto_tools_flag = request.auto_tools if request.auto_tools is not None else CONFIG.AUTO_ENABLE_TOOLS
-        tools_enabled = bool(request.tools) or CONFIG.ENABLE_TOOLS_BY_DEFAULT or (auto_tools_flag and (detection.get('need_calc') or detection.get('need_web_search')))
-
-    reasoning_enabled = bool(
-        True
-        if (request.enable_reasoning is not None and request.enable_reasoning)
-        else (
-            bool(enableReasoning) or bool(request.auto_reasoning if request.auto_reasoning is not None else (CONFIG.AUTO_ENABLE_REASONING and bool(detection.get('need_reasoning'))))
-        )
-    )
+    # Resolve flags via central helper (request defaults to None -> auto-detect)
+    flags = resolve_request_flags(request, detection)
+    web_search_enabled = flags['web_search_enabled']
+    tools_enabled = flags['tools_enabled']
+    file_tool_enabled = flags['file_tool_enabled']
+    reasoning_enabled = flags['reasoning_enabled']
     enableReasoning = reasoning_enabled
     try:
         ms_cfg = MODEL_STORAGE.get(request.model)
@@ -993,28 +1031,7 @@ async def chatResponseStream(
             enableReasoning = False
     except Exception:
         pass
-    # Decide whether file tools should be used for streaming variant
-    if request.enable_file_tool is not None:
-        file_tool_enabled = bool(request.enable_file_tool)
-    else:
-        auto_file_flag = request.auto_file_tool if request.auto_file_tool is not None else CONFIG.AUTO_ENABLE_TOOLS
-        file_tool_enabled = bool((request.file_ids and len(request.file_ids) > 0) or (auto_file_flag and request.file_ids))
-    if not getattr(CONFIG, 'ALLOW_FILE_TOOL_BY_DEFAULT', True) and request.enable_file_tool is None:
-        file_tool_enabled = False
-    try:
-        if request.sampler and getattr(request.sampler, 'ALLOW_FILE_TOOL', None) is not None:
-            file_tool_enabled = bool(request.sampler.ALLOW_FILE_TOOL)
-        elif hasattr(request, 'sampler_allow_file_tool') and request.sampler_allow_file_tool is not None:
-            file_tool_enabled = bool(request.sampler_allow_file_tool)
-        else:
-            ms2 = MODEL_STORAGE.get(request.model)
-            if ms2 and ms2.MODEL_CONFIG:
-                if hasattr(ms2.MODEL_CONFIG, 'DEFAULT_SAMPLER') and getattr(ms2.MODEL_CONFIG.DEFAULT_SAMPLER, 'ALLOW_FILE_TOOL', None) is not None:
-                    file_tool_enabled = bool(ms2.MODEL_CONFIG.DEFAULT_SAMPLER.ALLOW_FILE_TOOL)
-                elif hasattr(ms2.MODEL_CONFIG, 'ALLOW_FILE_TOOL') and not ms2.MODEL_CONFIG.ALLOW_FILE_TOOL:
-                    file_tool_enabled = False
-    except Exception:
-        pass
+    # file_tool_enabled is derived from resolve_request_flags as well
     # Build final prompt after deciding enableReasoning
     prompt = raw_prompt if request.prompt is not None else f"{cleanMessages(request.messages or [], enableReasoning)}\n\nAssistant:{' <think' if enableReasoning else ''}"