stravinsky 0.2.40__py3-none-any.whl → 0.3.4__py3-none-any.whl

mcp_bridge/server.py

@@ -98,7 +98,6 @@ async def list_tools() -> list[Tool]:
 @server.call_tool()
 async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
     """Handle tool calls with deep lazy loading of implementations."""
-    logger.info(f"Tool call: {name}")
     hook_manager = get_hook_manager_lazy()
     token_store = get_token_store()
 
@@ -115,7 +114,7 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
             result_content = await invoke_gemini(
                 token_store=token_store,
                 prompt=arguments["prompt"],
-                model=arguments.get("model", "gemini-2.0-flash-exp"),
+                model=arguments.get("model", "gemini-3-flash"),
                 temperature=arguments.get("temperature", 0.7),
                 max_tokens=arguments.get("max_tokens", 8192),
                 thinking_budget=arguments.get("thinking_budget", 0),
@@ -127,7 +126,7 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
             result_content = await invoke_openai(
                 token_store=token_store,
                 prompt=arguments["prompt"],
-                model=arguments.get("model", "gpt-4o"),
+                model=arguments.get("model", "gpt-5.2-codex"),
                 temperature=arguments.get("temperature", 0.7),
                 max_tokens=arguments.get("max_tokens", 4096),
                 thinking_budget=arguments.get("thinking_budget", 0),
@@ -144,6 +143,19 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
 
             result_content = await get_system_health()
 
+        elif name == "semantic_health":
+            from .tools.semantic_search import semantic_health
+
+            result_content = await semantic_health(
+                project_path=arguments.get("project_path", "."),
+                provider=arguments.get("provider", "ollama"),
+            )
+
+        elif name == "lsp_health":
+            from .tools.lsp.tools import lsp_health
+
+            result_content = await lsp_health()
+
         # --- SEARCH DISPATCH ---
         elif name == "grep_search":
             from .tools.code_search import grep_search
@@ -223,10 +235,7 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
             )
 
         elif name == "stravinsky_version":
-            from . import __version__
-            import sys
-            import os
-
+            # sys and os already imported at module level
             result_content = [
                 TextContent(
                     type="text",
@@ -380,11 +389,141 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
                 character=arguments["character"],
             )
 
+        elif name == "lsp_code_action_resolve":
+            from .tools.lsp import lsp_code_action_resolve
+
+            result_content = await lsp_code_action_resolve(
+                file_path=arguments["file_path"],
+                action_code=arguments["action_code"],
+                line=arguments.get("line"),
+            )
+
+        elif name == "lsp_extract_refactor":
+            from .tools.lsp import lsp_extract_refactor
+
+            result_content = await lsp_extract_refactor(
+                file_path=arguments["file_path"],
+                start_line=arguments["start_line"],
+                start_char=arguments["start_char"],
+                end_line=arguments["end_line"],
+                end_char=arguments["end_char"],
+                new_name=arguments["new_name"],
+                kind=arguments.get("kind", "function"),
+            )
+
         elif name == "lsp_servers":
             from .tools.lsp import lsp_servers
 
             result_content = await lsp_servers()
 
+        elif name == "lsp_diagnostics":
+            from .tools.code_search import lsp_diagnostics
+
+            result_content = await lsp_diagnostics(
+                file_path=arguments["file_path"],
+                severity=arguments.get("severity", "all"),
+            )
+
+        elif name == "semantic_search":
+            from .tools.semantic_search import semantic_search
+
+            result_content = await semantic_search(
+                query=arguments["query"],
+                project_path=arguments.get("project_path", "."),
+                n_results=arguments.get("n_results", 10),
+                language=arguments.get("language"),
+                node_type=arguments.get("node_type"),
+                provider=arguments.get("provider", "ollama"),
+            )
+
+        elif name == "hybrid_search":
+            from .tools.semantic_search import hybrid_search
+
+            result_content = await hybrid_search(
+                query=arguments["query"],
+                pattern=arguments.get("pattern"),
+                project_path=arguments.get("project_path", "."),
+                n_results=arguments.get("n_results", 10),
+                language=arguments.get("language"),
+                provider=arguments.get("provider", "ollama"),
+            )
+
+        elif name == "semantic_index":
+            from .tools.semantic_search import index_codebase
+
+            result_content = await index_codebase(
+                project_path=arguments.get("project_path", "."),
+                force=arguments.get("force", False),
+                provider=arguments.get("provider", "ollama"),
+            )
+
+        elif name == "semantic_stats":
+            from .tools.semantic_search import semantic_stats
+
+            result_content = await semantic_stats(
+                project_path=arguments.get("project_path", "."),
+                provider=arguments.get("provider", "ollama"),
+            )
+
+        elif name == "start_file_watcher":
+            from .tools.semantic_search import start_file_watcher
+
+            result_content = await start_file_watcher(
+                project_path=arguments.get("project_path", "."),
+                provider=arguments.get("provider", "ollama"),
+                debounce_seconds=arguments.get("debounce_seconds", 2.0),
+            )
+
+        elif name == "stop_file_watcher":
+            from .tools.semantic_search import stop_file_watcher
+
+            result_content = await stop_file_watcher(
+                project_path=arguments.get("project_path", "."),
+            )
+
+        elif name == "list_file_watchers":
+            from .tools.semantic_search import list_file_watchers
+
+            result_content = await list_file_watchers()
+
+        elif name == "multi_query_search":
+            from .tools.semantic_search import multi_query_search
+
+            result_content = await multi_query_search(
+                query=arguments["query"],
+                project_path=arguments.get("project_path", "."),
+                n_results=arguments.get("n_results", 10),
+                num_expansions=arguments.get("num_expansions", 3),
+                language=arguments.get("language"),
+                node_type=arguments.get("node_type"),
+                provider=arguments.get("provider", "ollama"),
+            )
+
+        elif name == "decomposed_search":
+            from .tools.semantic_search import decomposed_search
+
+            result_content = await decomposed_search(
+                query=arguments["query"],
+                project_path=arguments.get("project_path", "."),
+                n_results=arguments.get("n_results", 10),
+                language=arguments.get("language"),
+                node_type=arguments.get("node_type"),
+                provider=arguments.get("provider", "ollama"),
+            )
+
+        elif name == "enhanced_search":
+            from .tools.semantic_search import enhanced_search
+
+            result_content = await enhanced_search(
+                query=arguments["query"],
+                project_path=arguments.get("project_path", "."),
+                n_results=arguments.get("n_results", 10),
+                mode=arguments.get("mode", "auto"),
+                language=arguments.get("language"),
+                node_type=arguments.get("node_type"),
+                provider=arguments.get("provider", "ollama"),
+            )
+
         else:
             result_content = f"Unknown tool: {name}"
 
@@ -398,7 +537,10 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
                 processed_text = await hook_manager.execute_post_tool_call(
                     name, arguments, result_content[0].text
                 )
-                result_content[0].text = processed_text
+                # Only update if processed_text is non-empty to avoid empty text blocks
+                # (API error: cache_control cannot be set for empty text blocks)
+                if processed_text:
+                    result_content[0].text = processed_text
             elif isinstance(result_content, str):
                 result_content = await hook_manager.execute_post_tool_call(
                     name, arguments, result_content
@@ -410,8 +552,11 @@ async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
         return [TextContent(type="text", text=str(result_content))]
 
     except Exception as e:
-        logger.error(f"Error calling tool {name}: {e}")
-        return [TextContent(type="text", text=f"Error: {str(e)}")]
+        import traceback
+
+        tb = traceback.format_exc()
+        logger.error(f"Error calling tool {name}: {e}\n{tb}")
+        return [TextContent(type="text", text=f"Error: {str(e)}\n\nTraceback:\n{tb}")]
 
 
 @server.list_prompts()
@@ -464,6 +609,15 @@ async def async_main():
     except Exception as e:
         logger.error(f"Failed to initialize hooks: {e}")
 
+    # Start background token refresh scheduler
+    try:
+        from .auth.token_refresh import background_token_refresh
+
+        asyncio.create_task(background_token_refresh(get_token_store()))
+        logger.info("Background token refresh scheduler started")
+    except Exception as e:
+        logger.warning(f"Failed to start token refresh scheduler: {e}")
+
     try:
         async with stdio_server() as (read_stream, write_stream):
             await server.run(
@@ -474,6 +628,12 @@ async def async_main():
     except Exception as e:
         logger.critical("Server process crashed in async_main", exc_info=True)
         sys.exit(1)
+    finally:
+        logger.info("Initiating shutdown sequence...")
+        from .tools.lsp.manager import get_lsp_manager
+
+        lsp_manager = get_lsp_manager()
+        await lsp_manager.shutdown()
 
 
 def main():