Use Claude Code, Codex, VSCode, Pi, and OpenCode (and 6 other harnesses) for free (1.3B+ free tokens) from your terminal, app, IDE, or phone, and now from the browser with native browser sessions (multi-harness + multi-model) like OpenClaw (voice supported + ToS friendly)
Python
Refactor done using GLM-5
Alishahryar1539854fe7b94
diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.ymlindex 12f658e5..97df1645 100644--- a/.github/workflows/tests.yml+++ b/.github/workflows/tests.yml@@ -38,6 +38,9 @@ jobs:enable-cache: truecache-python: true+ - name: Lint+ run: uv run ruff check+- name: Type checkrun: uv run ty checkdiff --git a/api/app.py b/api/app.pyindex 4981335f..16fa3b87 100644--- a/api/app.py+++ b/api/app.py@@ -6,7 +6,6 @@ import os# Opt-in to future behavior for python-telegram-botos.environ["PTB_TIMEDELTA"] = "1"-import loggingfrom contextlib import asynccontextmanagerfrom fastapi import FastAPI, Requestfrom fastapi.responses import JSONResponse@@ -18,11 +17,12 @@ from config.logging_config import configure_logging_settings = get_settings()configure_logging(_settings.log_file)+from loguru import logger+from .routes import routerfrom .dependencies import cleanup_providerfrom providers.exceptions import ProviderError-logger = logging.getLogger(__name__)_SHUTDOWN_TIMEOUT_S = 5.0diff --git a/api/dependencies.py b/api/dependencies.pyindex b6e72903..2007b1b0 100644--- a/api/dependencies.py+++ b/api/dependencies.py@@ -1,12 +1,12 @@"""Dependency injection for FastAPI."""-import loggingfrom typing import Optional+from loguru import logger+from config.settings import Settings, get_settings as _get_settings, NVIDIA_NIM_BASE_URLfrom providers.base import BaseProvider, ProviderConfig-logger = logging.getLogger(__name__)# Global provider instance (singleton)_provider: Optional[BaseProvider] = Nonediff --git a/api/models/anthropic.py b/api/models/anthropic.pyindex b2677f4d..dbc0bb9a 100644--- a/api/models/anthropic.py+++ b/api/models/anthropic.py@@ -1,6 +1,5 @@"""Pydantic models for Anthropic-compatible requests."""-import loggingfrom enum import Enumfrom typing import List, Dict, Any, Optional, Union, Literal@@ -8,8 +7,7 @@ from pydantic import BaseModel, field_validator, model_validatorfrom config.settings import get_settingsfrom providers.model_utils import normalize_model_name--logger = logging.getLogger(__name__)+from loguru import logger# =============================================================================diff --git a/api/optimization_handlers.py b/api/optimization_handlers.pyindex 86fcd1e5..0bc1b9ea 100644--- a/api/optimization_handlers.py+++ b/api/optimization_handlers.py@@ -4,7 +4,6 @@ Each handler returns a MessagesResponse if the request matches and theoptimization is enabled, otherwise None."""-import loggingimport uuidfrom typing import Optional@@ -19,8 +18,7 @@ from .detection import ()from .command_utils import extract_command_prefix, extract_filepaths_from_commandfrom config.settings import Settings--logger = logging.getLogger(__name__)+from loguru import loggerdef try_prefix_detection(diff --git a/api/request_utils.py b/api/request_utils.pyindex 83df1946..8eee54dc 100644--- a/api/request_utils.py+++ b/api/request_utils.py@@ -4,21 +4,20 @@ Contains token counting for API requests."""import json-import logging-from typing import Any, List, Optional, Union, cast+from typing import Any, List, Optional, Unionimport tiktoken+from loguru import logger-logger = logging.getLogger(__name__)ENCODER = tiktoken.get_encoding("cl100k_base")__all__ = ["get_token_count"]-def _get_block_attr(block: object, key: str, default: Any = "") -> Any:+def _get_block_attr(block: Any, key: str, default: Any = "") -> Any:"""Get attribute from block (object or dict)."""if isinstance(block, dict):- return cast(dict[str, Any], block).get(key, default)+ return block.get(key, default)return getattr(block, key, default)diff --git a/api/routes.py b/api/routes.pyindex 60743de5..cff45d56 100644--- a/api/routes.py+++ b/api/routes.py@@ -1,15 +1,14 @@"""FastAPI route handlers."""import json-import loggingimport uuidfrom fastapi import APIRouter, Request, Depends, HTTPException-from loguru import logger as loguru_logger+from loguru import loggerfrom fastapi.responses import StreamingResponsefrom .models.anthropic import MessagesRequest, TokenCountRequest-from .models.responses import MessagesResponse, TokenCountResponse+from .models.responses import TokenCountResponsefrom .dependencies import get_provider, get_settingsfrom .request_utils import get_token_countfrom .optimization_handlers import try_optimizations@@ -18,7 +17,6 @@ from providers.base import BaseProviderfrom providers.exceptions import ProviderErrorfrom providers.logging_utils import build_request_summary, log_request_compact-logger = logging.getLogger(__name__)router = APIRouter()@@ -75,7 +73,7 @@ async def create_message(async def count_tokens(request_data: TokenCountRequest):"""Count tokens for a request."""request_id = f"req_{uuid.uuid4().hex[:12]}"- with loguru_logger.contextualize(request_id=request_id):+ with logger.contextualize(request_id=request_id):try:tokens = get_token_count(request_data.messages, request_data.system, request_data.toolsdiff --git a/cli/manager.py b/cli/manager.pyindex b60b4c81..2d24a8c5 100644--- a/cli/manager.py+++ b/cli/manager.py@@ -8,12 +8,10 @@ simultaneously in separate CLI processes.import asyncioimport uuid-import loggingfrom typing import Dict, Optional, Tuple, Listfrom .session import CLISession--logger = logging.getLogger(__name__)+from loguru import loggerclass CLISessionManager:diff --git a/cli/process_registry.py b/cli/process_registry.pyindex 5a7a1bdb..cc3510ad 100644--- a/cli/process_registry.py+++ b/cli/process_registry.py@@ -8,13 +8,12 @@ spawn so we don't accidentally kill unrelated system processes.from __future__ import annotationsimport atexit-import loggingimport osimport subprocessimport threadingfrom typing import Set+from loguru import logger-logger = logging.getLogger(__name__)_lock = threading.Lock()_pids: Set[int] = set()diff --git a/cli/session.py b/cli/session.pyindex 6ba8e4e8..334f2c7b 100644--- a/cli/session.py+++ b/cli/session.py@@ -3,12 +3,10 @@import asyncioimport osimport json-import logging-from typing import AsyncGenerator, Optional, Dict, List, Any+from typing import AsyncGenerator, Optional, List, Anyfrom .process_registry import register_pid, unregister_pid--logger = logging.getLogger(__name__)+from loguru import loggerclass CLISession:diff --git a/messaging/event_parser.py b/messaging/event_parser.pyindex 7d9ffcba..c82f96e7 100644--- a/messaging/event_parser.py+++ b/messaging/event_parser.py@@ -4,10 +4,8 @@ This parser emits an ordered stream of low-level events suitable for building aClaude Code-like transcript in messaging UIs."""-import loggingfrom typing import Dict, List, Any--logger = logging.getLogger(__name__)+from loguru import loggerdef parse_cli_event(event: Any) -> List[Dict]:diff --git a/messaging/factory.py b/messaging/factory.pyindex dcec356a..18ccc6fe 100644--- a/messaging/factory.py+++ b/messaging/factory.py@@ -6,12 +6,11 @@ To add a new platform (e.g. Discord, Slack):2. Add a case to create_messaging_platform() below"""-import loggingfrom typing import Optional-from .base import MessagingPlatform+from loguru import logger-logger = logging.getLogger(__name__)+from .base import MessagingPlatformdef create_messaging_platform(diff --git a/messaging/handler.py b/messaging/handler.pyindex 978a6bad..c21cca62 100644--- a/messaging/handler.py+++ b/messaging/handler.py@@ -8,7 +8,6 @@ Uses tree-based queuing for message ordering.import timeimport asyncio-import loggingimport osfrom typing import List, Optional, Tuple@@ -26,9 +25,8 @@ from .telegram_markdown import (format_status,render_markdown_to_mdv2,)-from loguru import logger as loguru_logger+from loguru import logger-logger = logging.getLogger(__name__)# Status message prefixes used to filter our own messages (ignore echo)STATUS_MESSAGE_PREFIXES = ("⏳", "💭", "🔧", "✅", "❌", "🚀", "🤖", "📋", "📊", "🔄")@@ -122,7 +120,7 @@ class ClaudeMessageHandler:text_preview,)- with loguru_logger.contextualize(+ with logger.contextualize(chat_id=incoming.chat_id, node_id=incoming.message_id):await self._handle_message_impl(incoming)@@ -388,7 +386,7 @@ class ClaudeMessageHandler:status_msg_id = node.status_message_idchat_id = incoming.chat_id- with loguru_logger.contextualize(node_id=node_id, chat_id=chat_id):+ with logger.contextualize(node_id=node_id, chat_id=chat_id):await self._process_node_impl(node_id, node, chat_id, status_msg_id)async def _process_node_impl(diff --git a/messaging/limiter.py b/messaging/limiter.pyindex bb512972..4057ceba 100644--- a/messaging/limiter.py+++ b/messaging/limiter.py@@ -6,13 +6,11 @@ using a strict sliding window algorithm and a task queue."""import asyncio-import loggingimport osfrom collections import dequeimport timefrom typing import Awaitable, Callable, Any, Optional, Dict--logger = logging.getLogger(__name__)+from loguru import loggerclass SlidingWindowLimiter:diff --git a/messaging/session.py b/messaging/session.pyindex d368f4a3..cc19eb8c 100644--- a/messaging/session.py+++ b/messaging/session.py@@ -7,13 +7,11 @@ and message trees for conversation continuation.import jsonimport os-import loggingfrom datetime import datetime, timezonefrom typing import Optional, Dict, List, Anyfrom dataclasses import dataclass, asdictimport threading--logger = logging.getLogger(__name__)+from loguru import logger@dataclassdiff --git a/messaging/telegram.py b/messaging/telegram.pyindex fcce494c..24f3ac4a 100644--- a/messaging/telegram.py+++ b/messaging/telegram.py@@ -5,7 +5,6 @@ Implements MessagingPlatform for Telegram using python-telegram-bot."""import asyncio-import loggingimport os# Opt-in to future behavior for python-telegram-bot (retry_after as timedelta)@@ -14,11 +13,12 @@ os.environ["PTB_TIMEDELTA"] = "1"from typing import Callable, Awaitable, Optional, Any+from loguru import logger+from .base import MessagingPlatformfrom .models import IncomingMessagefrom .telegram_markdown import escape_md_v2-logger = logging.getLogger(__name__)# Optional import - python-telegram-bot may not be installedtry:diff --git a/messaging/transcript.py b/messaging/transcript.pyindex 26e7fc5f..55da4a45 100644--- a/messaging/transcript.py+++ b/messaging/transcript.py@@ -9,14 +9,11 @@ the transcript grows over time and older content must be truncated.from __future__ import annotationsimport json-import loggingimport osfrom collections import dequefrom dataclasses import dataclass, fieldfrom typing import Any, Callable, Dict, Iterable, List, Optional---logger = logging.getLogger(__name__)+from loguru import loggerdef _safe_json_dumps(obj: Any) -> str:diff --git a/messaging/tree_data.py b/messaging/tree_data.pyindex e38f44cd..ef6a2bfb 100644--- a/messaging/tree_data.py+++ b/messaging/tree_data.py@@ -4,7 +4,6 @@ Contains MessageState, MessageNode, and MessageTree classes."""import asyncio-import loggingfrom collections import dequefrom contextlib import asynccontextmanagerfrom enum import Enum@@ -13,8 +12,7 @@ from typing import Dict, Optional, List, Any, castfrom dataclasses import dataclass, fieldfrom .models import IncomingMessage--logger = logging.getLogger(__name__)+from loguru import loggerclass MessageState(Enum):diff --git a/messaging/tree_processor.py b/messaging/tree_processor.pyindex 503176e8..9ecf09e7 100644--- a/messaging/tree_processor.py+++ b/messaging/tree_processor.py@@ -4,12 +4,10 @@ Handles the async processing lifecycle of tree nodes."""import asyncio-import loggingfrom typing import Callable, Awaitable, Optionalfrom .tree_data import MessageTree, MessageNode, MessageState--logger = logging.getLogger(__name__)+from loguru import loggerclass TreeQueueProcessor:diff --git a/messaging/tree_queue.py b/messaging/tree_queue.pyindex 354e8c0a..d58d9b25 100644--- a/messaging/tree_queue.py+++ b/messaging/tree_queue.py@@ -5,7 +5,6 @@ Uses TreeRepository for data, TreeQueueProcessor for async logic."""import asyncio-import loggingfrom datetime import datetime, timezonefrom typing import Callable, Awaitable, List, Optional@@ -13,6 +12,7 @@ from .models import IncomingMessagefrom .tree_data import MessageState, MessageNode, MessageTreefrom .tree_repository import TreeRepositoryfrom .tree_processor import TreeQueueProcessor+from loguru import logger# Backward compatibility: re-export moved classes__all__ = [@@ -22,8 +22,6 @@ __all__ = ["MessageTree",]-logger = logging.getLogger(__name__)-class TreeQueueManager:"""diff --git a/messaging/tree_repository.py b/messaging/tree_repository.pyindex 254ba703..3f3fa472 100644--- a/messaging/tree_repository.py+++ b/messaging/tree_repository.py@@ -3,12 +3,11 @@Provides data access layer for managing trees and node mappings."""-import loggingfrom typing import Dict, Optional, List-from .tree_data import MessageTree, MessageNode, MessageState+from loguru import logger-logger = logging.getLogger(__name__)+from .tree_data import MessageTree, MessageNode, MessageStateclass TreeRepository:diff --git a/providers/lmstudio/client.py b/providers/lmstudio/client.pyindex dfb9f7ff..921ff82a 100644--- a/providers/lmstudio/client.py+++ b/providers/lmstudio/client.py@@ -1,11 +1,10 @@"""LM Studio provider implementation."""import json-import loggingimport uuidfrom typing import Any, AsyncIterator-from loguru import logger as loguru_logger+from loguru import loggerfrom openai import AsyncOpenAIfrom providers.base import BaseProvider, ProviderConfig@@ -21,7 +20,6 @@ from providers.nvidia_nim.utils import (from .request import build_request_body-logger = logging.getLogger(__name__)LMSTUDIO_DEFAULT_BASE_URL = "http://localhost:1234/v1"@@ -56,7 +54,7 @@ class LMStudioProvider(BaseProvider):request_id: str | None = None,) -> AsyncIterator[str]:"""Stream response in Anthropic SSE format."""- with loguru_logger.contextualize(request_id=request_id):+ with logger.contextualize(request_id=request_id):async for event in self._stream_response_impl(request, input_tokens, request_id):@@ -266,20 +264,7 @@ class LMStudioProvider(BaseProvider):fn_delta = tc.get("function", {})incoming_name = fn_delta.get("name")if incoming_name is not None:- prev = sse.blocks.tool_names.get(tc_index, "")- if not prev:- sse.blocks.tool_names[tc_index] = incoming_name- elif prev == incoming_name:- pass- elif isinstance(prev, str) and isinstance(incoming_name, str):- if incoming_name.startswith(prev):- sse.blocks.tool_names[tc_index] = incoming_name- elif prev.startswith(incoming_name):- pass- else:- sse.blocks.tool_names[tc_index] = prev + incoming_name- else:- sse.blocks.tool_names[tc_index] = str(prev) + str(incoming_name)+ sse.blocks.register_tool_name(tc_index, incoming_name)if tc_index not in sse.blocks.tool_indices:name = sse.blocks.tool_names.get(tc_index, "")@@ -305,55 +290,14 @@ class LMStudioProvider(BaseProvider):current_name = sse.blocks.tool_names.get(tc_index, "")if current_name == "Task":- if not sse.blocks.task_args_emitted.get(tc_index, False):- buf = sse.blocks.task_arg_buffer.get(tc_index, "") + args- sse.blocks.task_arg_buffer[tc_index] = buf- try:- args_json = json.loads(buf)- except Exception:- return- if args_json.get("run_in_background") is not False:- logger.info(- "LMSTUDIO_INTERCEPT: Forcing run_in_background=False for Task %s",- tc.get("id")- or sse.blocks.tool_ids.get(tc_index, "unknown"),- )- args_json["run_in_background"] = False- sse.blocks.task_args_emitted[tc_index] = True- sse.blocks.task_arg_buffer.pop(tc_index, None)- yield sse.emit_tool_delta(tc_index, json.dumps(args_json))+ parsed = sse.blocks.buffer_task_args(tc_index, args)+ if parsed is not None:+ yield sse.emit_tool_delta(tc_index, json.dumps(parsed))returnyield sse.emit_tool_delta(tc_index, args)def _flush_task_arg_buffers(self, sse: Any):"""Emit buffered Task args as a single JSON delta (best-effort)."""- for tool_index, buf in list(sse.blocks.task_arg_buffer.items()):- if sse.blocks.task_args_emitted.get(tool_index, False):- sse.blocks.task_arg_buffer.pop(tool_index, None)- continue-- tool_id = sse.blocks.tool_ids.get(tool_index, "unknown")- out = "{}"- try:- args_json = json.loads(buf)- if args_json.get("run_in_background") is not False:- logger.info(- "LMSTUDIO_INTERCEPT: Forcing run_in_background=False for Task %s",- tool_id,- )- args_json["run_in_background"] = False- out = json.dumps(args_json)- except Exception as e:- prefix = buf[:120]- logger.warning(- "LMSTUDIO_INTERCEPT: Task args invalid JSON (id=%s len=%d prefix=%r): %s",- tool_id,- len(buf),- prefix,- e,- )-- sse.blocks.task_args_emitted[tool_index] = True- sse.blocks.task_arg_buffer.pop(tool_index, None)+ for tool_index, out in sse.blocks.flush_task_arg_buffers():yield sse.emit_tool_delta(tool_index, out)diff --git a/providers/lmstudio/request.py b/providers/lmstudio/request.pyindex 32f44a66..aac8cec6 100644--- a/providers/lmstudio/request.py+++ b/providers/lmstudio/request.py@@ -1,11 +1,10 @@"""Request builder for LM Studio provider."""-import loggingfrom typing import Any, Dictfrom providers.nvidia_nim.utils.message_converter import AnthropicToOpenAIConverter+from loguru import logger-logger = logging.getLogger(__name__)LMSTUDIO_DEFAULT_MAX_TOKENS = 81920diff --git a/providers/logging_utils.py b/providers/logging_utils.pyindex 6401cb33..aebd28a7 100644--- a/providers/logging_utils.py+++ b/providers/logging_utils.py@@ -6,12 +6,10 @@ while maintaining full traceability through request IDs and content hashes.import hashlibimport json-import loggingfrom typing import Any, Dict, Listfrom utils.text import extract_text_from_content--logger = logging.getLogger(__name__)+from loguru import loggerdef generate_request_fingerprint(messages: List[Any]) -> str:@@ -99,7 +97,7 @@ def build_request_summary(request_data: Any) -> Dict[str, Any]:def log_full_payload(- logger_instance: logging.Logger, request_id: str, payload: Dict[str, Any]+ logger_instance: Any, request_id: str, payload: Dict[str, Any]) -> None:"""Log full payload to the standard logger."""logger_instance.debug(@@ -108,7 +106,7 @@ def log_full_payload(def log_request_compact(- logger_instance: logging.Logger,+ logger_instance: Any,request_id: str,request_data: Any,prefix: str = "API_REQUEST",diff --git a/providers/nvidia_nim/client.py b/providers/nvidia_nim/client.pyindex 8ff75f66..a47c4e60 100644--- a/providers/nvidia_nim/client.py+++ b/providers/nvidia_nim/client.py@@ -1,11 +1,10 @@"""NVIDIA NIM provider implementation."""import json-import loggingimport uuidfrom typing import Any, AsyncIterator-from loguru import logger as loguru_logger+from loguru import loggerfrom openai import AsyncOpenAIfrom providers.base import BaseProvider, ProviderConfig@@ -20,8 +19,6 @@ from .utils import (ContentType,)-logger = logging.getLogger(__name__)-class NvidiaNimProvider(BaseProvider):"""NVIDIA NIM provider using official OpenAI client."""@@ -56,7 +53,7 @@ class NvidiaNimProvider(BaseProvider):request_id: str | None = None,) -> AsyncIterator[str]:"""Stream response in Anthropic SSE format."""- with loguru_logger.contextualize(request_id=request_id):+ with logger.contextualize(request_id=request_id):async for event in self._stream_response_impl(request, input_tokens, request_id):@@ -260,13 +257,7 @@ class NvidiaNimProvider(BaseProvider):yield sse.done()def _process_tool_call(self, tc: dict, sse: Any):- """Process a single tool call delta and yield SSE events.-- Args:- tc: Tool call delta info dict- sse: SSEBuilder instance- """-+ """Process a single tool call delta and yield SSE events."""tc_index = tc.get("index", 0)if tc_index < 0:tc_index = len(sse.blocks.tool_indices)@@ -274,22 +265,7 @@ class NvidiaNimProvider(BaseProvider):fn_delta = tc.get("function", {})incoming_name = fn_delta.get("name")if incoming_name is not None:- # Some providers stream tool names as fragments; others resend the full name.- # Avoid "TaskTask" while still supporting fragment streams.- prev = sse.blocks.tool_names.get(tc_index, "")- if not prev:- sse.blocks.tool_names[tc_index] = incoming_name- elif prev == incoming_name:- pass- elif isinstance(prev, str) and isinstance(incoming_name, str):- if incoming_name.startswith(prev):- sse.blocks.tool_names[tc_index] = incoming_name- elif prev.startswith(incoming_name):- pass- else:- sse.blocks.tool_names[tc_index] = prev + incoming_name- else:- sse.blocks.tool_names[tc_index] = str(prev) + str(incoming_name)+ sse.blocks.register_tool_name(tc_index, incoming_name)if tc_index not in sse.blocks.tool_indices:name = sse.blocks.tool_names.get(tc_index, "")@@ -310,65 +286,19 @@ class NvidiaNimProvider(BaseProvider):if not sse.blocks.tool_started.get(tc_index):tool_id = tc.get("id") or f"tool_{uuid.uuid4()}"name = sse.blocks.tool_names.get(tc_index, "tool_call") or "tool_call"-yield sse.start_tool_block(tc_index, tool_id, name)sse.blocks.tool_started[tc_index] = Truecurrent_name = sse.blocks.tool_names.get(tc_index, "")- # INTERCEPTION: Task args can stream in many partial chunks. Buffer until we- # have valid JSON, then emit a single delta with run_in_background forced off.if current_name == "Task":- if not sse.blocks.task_args_emitted.get(tc_index, False):- buf = sse.blocks.task_arg_buffer.get(tc_index, "") + args- sse.blocks.task_arg_buffer[tc_index] = buf- try:- args_json = json.loads(buf)- except Exception:- return- if args_json.get("run_in_background") is not False:- logger.info(- "NIM_INTERCEPT: Forcing run_in_background=False for Task %s",- (- tc.get("id")- or sse.blocks.tool_ids.get(tc_index, "unknown")- ),- )- args_json["run_in_background"] = False- sse.blocks.task_args_emitted[tc_index] = True- sse.blocks.task_arg_buffer.pop(tc_index, None)- yield sse.emit_tool_delta(tc_index, json.dumps(args_json))+ parsed = sse.blocks.buffer_task_args(tc_index, args)+ if parsed is not None:+ yield sse.emit_tool_delta(tc_index, json.dumps(parsed))returnyield sse.emit_tool_delta(tc_index, args)def _flush_task_arg_buffers(self, sse: Any):"""Emit buffered Task args as a single JSON delta (best-effort)."""- for tool_index, buf in list(sse.blocks.task_arg_buffer.items()):- if sse.blocks.task_args_emitted.get(tool_index, False):- sse.blocks.task_arg_buffer.pop(tool_index, None)- continue-- tool_id = sse.blocks.tool_ids.get(tool_index, "unknown")- out = "{}"- try:- args_json = json.loads(buf)- if args_json.get("run_in_background") is not False:- logger.info(- "NIM_INTERCEPT: Forcing run_in_background=False for Task %s",- tool_id,- )- args_json["run_in_background"] = False- out = json.dumps(args_json)- except Exception as e:- prefix = buf[:120]- logger.warning(- "NIM_INTERCEPT: Task args invalid JSON (id=%s len=%d prefix=%r): %s",- tool_id,- len(buf),- prefix,- e,- )-- sse.blocks.task_args_emitted[tool_index] = True- sse.blocks.task_arg_buffer.pop(tool_index, None)+ for tool_index, out in sse.blocks.flush_task_arg_buffers():yield sse.emit_tool_delta(tool_index, out)diff --git a/providers/nvidia_nim/request.py b/providers/nvidia_nim/request.pyindex 7f376f85..3c9901a2 100644--- a/providers/nvidia_nim/request.py+++ b/providers/nvidia_nim/request.py@@ -1,12 +1,10 @@"""Request builder for NVIDIA NIM provider."""-import loggingfrom typing import Any, Dictfrom config.nim import NimSettingsfrom .utils.message_converter import AnthropicToOpenAIConverter--logger = logging.getLogger(__name__)+from loguru import loggerdef _set_if_not_none(body: Dict[str, Any], key: str, value: Any) -> None:diff --git a/providers/nvidia_nim/response.py b/providers/nvidia_nim/response.pydeleted file mode 100644index 3ddf6539..00000000--- a/providers/nvidia_nim/response.py+++ /dev/null@@ -1,88 +0,0 @@-"""Response conversion for NVIDIA NIM provider."""--import json-import uuid-from typing import Any--from .utils import map_stop_reason, extract_think_content_interleaved---def convert_response(response_json: dict, original_request: Any) -> dict:- """Convert OpenAI response to Anthropic format."""- choice = response_json["choices"][0]- message = choice["message"]- content = []-- # Extract reasoning from various sources- reasoning = message.get("reasoning_content")- if not reasoning:- reasoning_details = message.get("reasoning_details")- if reasoning_details and isinstance(reasoning_details, list):- reasoning = "\n".join(- item.get("text", "")- for item in reasoning_details- if isinstance(item, dict)- )-- if reasoning:- content.append({"type": "thinking", "thinking": reasoning})-- # Extract text content (with think tag handling, preserving interleaving)- if message.get("content"):- raw_content = message["content"]- if isinstance(raw_content, str):- if not reasoning:- for block_type, block_content in extract_think_content_interleaved(- raw_content- ):- if block_type == "thinking":- content.append({"type": "thinking", "thinking": block_content})- else:- content.append({"type": "text", "text": block_content})- else:- if raw_content.strip():- content.append({"type": "text", "text": raw_content.strip()})- elif isinstance(raw_content, list):- for item in raw_content:- if isinstance(item, dict) and item.get("type") == "text":- content.append(item)-- # Extract tool calls- if message.get("tool_calls"):- for tc in message["tool_calls"]:- try:- args = json.loads(tc["function"]["arguments"])- except Exception:- args = tc["function"].get("arguments", {})- content.append(- {- "type": "tool_use",- "id": tc["id"],- "name": tc["function"]["name"],- "input": args,- }- )-- if not content:- # NIM models (especially Mistral-based) often require non-empty content.- # Adding a single space satisfies this requirement while avoiding- # the "(no content)" display issue in Claude Code.- content.append({"type": "text", "text": " "})-- usage = response_json.get("usage", {})-- return {- "id": response_json.get("id", f"msg_{uuid.uuid4()}"),- "type": "message",- "role": "assistant",- "model": original_request.model,- "content": content,- "stop_reason": map_stop_reason(choice.get("finish_reason")),- "stop_sequence": None,- "usage": {- "input_tokens": usage.get("prompt_tokens", 0),- "output_tokens": usage.get("completion_tokens", 0),- "cache_creation_input_tokens": 0,- "cache_read_input_tokens": 0,- },- }diff --git a/providers/nvidia_nim/utils/__init__.py b/providers/nvidia_nim/utils/__init__.pyindex 5e909b6a..634b6e51 100644--- a/providers/nvidia_nim/utils/__init__.py+++ b/providers/nvidia_nim/utils/__init__.py@@ -5,8 +5,6 @@ from .think_parser import (ThinkTagParser,ContentType,ContentChunk,- extract_think_content,- extract_think_content_interleaved,)from .heuristic_tool_parser import HeuristicToolParserfrom .message_converter import (@@ -23,8 +21,6 @@ __all__ = ["HeuristicToolParser","ContentType","ContentChunk",- "extract_think_content",- "extract_think_content_interleaved","AnthropicToOpenAIConverter","get_block_attr","get_block_type",diff --git a/providers/nvidia_nim/utils/heuristic_tool_parser.py b/providers/nvidia_nim/utils/heuristic_tool_parser.pyindex 0c9b39cc..bdc78f5e 100644--- a/providers/nvidia_nim/utils/heuristic_tool_parser.py+++ b/providers/nvidia_nim/utils/heuristic_tool_parser.py@@ -1,10 +1,9 @@import re-import loggingimport uuidfrom enum import Enumfrom typing import List, Dict, Any, Tuple+from loguru import logger-logger = logging.getLogger(__name__)# Some OpenAI-compatible backends/models occasionally leak internal sentinel tokens# into `delta.content` (e.g. "<|tool_call_end|>"). These should never be shown todiff --git a/providers/nvidia_nim/utils/sse_builder.py b/providers/nvidia_nim/utils/sse_builder.pyindex eaf864d7..80bebbb2 100644--- a/providers/nvidia_nim/utils/sse_builder.py+++ b/providers/nvidia_nim/utils/sse_builder.py@@ -1,9 +1,10 @@"""SSE event builder for Anthropic-format streaming responses."""import json-import loggingfrom dataclasses import dataclass, field-from typing import Optional, Dict, Any, Iterator+from typing import Optional, Dict, Any, Iterator, List, Tuple++from loguru import loggertry:import tiktoken@@ -12,7 +13,6 @@ try:except Exception:ENCODER = None-logger = logging.getLogger(__name__)# Map OpenAI finish_reason to Anthropic stop_reasonSTOP_REASON_MAP = {@@ -54,6 +54,76 @@ class ContentBlockManager:self.next_index += 1return idx+ def register_tool_name(self, index: int, name: str) -> None:+ """Register or merge a streaming tool name fragment.++ Handles providers that stream names as fragments and those that+ resend the full name on every chunk.+ """+ prev = self.tool_names.get(index, "")+ if not prev:+ self.tool_names[index] = name+ elif prev == name:+ pass+ elif name.startswith(prev):+ self.tool_names[index] = name+ elif prev.startswith(name):+ pass+ else:+ self.tool_names[index] = prev + name++ def buffer_task_args(self, index: int, args: str) -> Optional[dict]:+ """Buffer Task tool args and return parsed JSON when complete.++ Returns the parsed (and patched) args dict once the buffer forms+ valid JSON, or None if still accumulating.+ """+ if self.task_args_emitted.get(index, False):+ return None++ buf = self.task_arg_buffer.get(index, "") + args+ self.task_arg_buffer[index] = buf+ try:+ args_json = json.loads(buf)+ except Exception:+ return None++ if args_json.get("run_in_background") is not False:+ args_json["run_in_background"] = False++ self.task_args_emitted[index] = True+ self.task_arg_buffer.pop(index, None)+ return args_json++ def flush_task_arg_buffers(self) -> List[Tuple[int, str]]:+ """Flush any remaining Task arg buffers. Returns (tool_index, json_str) pairs."""+ results: List[Tuple[int, str]] = []+ for tool_index, buf in list(self.task_arg_buffer.items()):+ if self.task_args_emitted.get(tool_index, False):+ self.task_arg_buffer.pop(tool_index, None)+ continue++ out = "{}"+ try:+ args_json = json.loads(buf)+ if args_json.get("run_in_background") is not False:+ args_json["run_in_background"] = False+ out = json.dumps(args_json)+ except Exception as e:+ prefix = buf[:120]+ logger.warning(+ "Task args invalid JSON (id=%s len=%d prefix=%r): %s",+ self.tool_ids.get(tool_index, "unknown"),+ len(buf),+ prefix,+ e,+ )++ self.task_args_emitted[tool_index] = True+ self.task_arg_buffer.pop(tool_index, None)+ results.append((tool_index, out))+ return results+class SSEBuilder:"""Builder for Anthropic SSE streaming events."""diff --git a/providers/nvidia_nim/utils/think_parser.py b/providers/nvidia_nim/utils/think_parser.pyindex 73327876..923ad7db 100644--- a/providers/nvidia_nim/utils/think_parser.py+++ b/providers/nvidia_nim/utils/think_parser.py@@ -1,8 +1,7 @@"""Think tag parser for extracting reasoning content from responses."""-import refrom dataclasses import dataclass-from typing import List, Optional, Tuple, Iterator+from typing import Optional, Iteratorfrom enum import Enum@@ -166,44 +165,3 @@ class ThinkTagParser:"""Reset parser state."""self._buffer = ""self._in_think_tag = False---def extract_think_content(text: str) -> Tuple[Optional[str], str]:- """- Extract thinking content from text (non-streaming).-- Returns: (thinking_content, remaining_text)- Merges all think blocks and strips them from text. Use extract_think_content_interleaved- when interleaved order must be preserved.- """- think_pattern = re.compile(r"<think>(.*?)</think>", re.DOTALL)- matches = think_pattern.findall(text)-- if matches:- thinking = "\n".join(matches)- remaining = think_pattern.sub("", text).strip()- return thinking, remaining-- return None, text---def extract_think_content_interleaved(text: str) -> List[Tuple[str, str]]:- """- Parse content and return blocks in order, preserving interleaving of- <think>...</think> and text.-- Returns: [(type, content), ...] where type is "thinking" or "text".- """- blocks: List[Tuple[str, str]] = []- pattern = re.compile(r"<think>(.*?)</think>", re.DOTALL)- last_end = 0- for m in pattern.finditer(text):- before = text[last_end : m.start()].strip()- if before:- blocks.append(("text", before))- blocks.append(("thinking", m.group(1)))- last_end = m.end()- after = text[last_end:].strip()- if after:- blocks.append(("text", after))- return blocksdiff --git a/providers/open_router/client.py b/providers/open_router/client.pyindex 57bb8d56..36d8aec5 100644--- a/providers/open_router/client.py+++ b/providers/open_router/client.py@@ -1,11 +1,10 @@"""OpenRouter provider implementation."""import json-import loggingimport uuidfrom typing import Any, AsyncIterator-from loguru import logger as loguru_logger+from loguru import loggerfrom openai import AsyncOpenAIfrom providers.base import BaseProvider, ProviderConfig@@ -21,7 +20,6 @@ from providers.nvidia_nim.utils import (from .request import build_request_body-logger = logging.getLogger(__name__)OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1"@@ -56,7 +54,7 @@ class OpenRouterProvider(BaseProvider):request_id: str | None = None,) -> AsyncIterator[str]:"""Stream response in Anthropic SSE format."""- with loguru_logger.contextualize(request_id=request_id):+ with logger.contextualize(request_id=request_id):async for event in self._stream_response_impl(request, input_tokens, request_id):@@ -277,20 +275,7 @@ class OpenRouterProvider(BaseProvider):fn_delta = tc.get("function", {})incoming_name = fn_delta.get("name")if incoming_name is not None:- prev = sse.blocks.tool_names.get(tc_index, "")- if not prev:- sse.blocks.tool_names[tc_index] = incoming_name- elif prev == incoming_name:- pass- elif isinstance(prev, str) and isinstance(incoming_name, str):- if incoming_name.startswith(prev):- sse.blocks.tool_names[tc_index] = incoming_name- elif prev.startswith(incoming_name):- pass- else:- sse.blocks.tool_names[tc_index] = prev + incoming_name- else:- sse.blocks.tool_names[tc_index] = str(prev) + str(incoming_name)+ sse.blocks.register_tool_name(tc_index, incoming_name)if tc_index not in sse.blocks.tool_indices:name = sse.blocks.tool_names.get(tc_index, "")@@ -316,55 +301,14 @@ class OpenRouterProvider(BaseProvider):current_name = sse.blocks.tool_names.get(tc_index, "")if current_name == "Task":- if not sse.blocks.task_args_emitted.get(tc_index, False):- buf = sse.blocks.task_arg_buffer.get(tc_index, "") + args- sse.blocks.task_arg_buffer[tc_index] = buf- try:- args_json = json.loads(buf)- except Exception:- return- if args_json.get("run_in_background") is not False:- logger.info(- "OPENROUTER_INTERCEPT: Forcing run_in_background=False for Task %s",- tc.get("id")- or sse.blocks.tool_ids.get(tc_index, "unknown"),- )- args_json["run_in_background"] = False- sse.blocks.task_args_emitted[tc_index] = True- sse.blocks.task_arg_buffer.pop(tc_index, None)- yield sse.emit_tool_delta(tc_index, json.dumps(args_json))+ parsed = sse.blocks.buffer_task_args(tc_index, args)+ if parsed is not None:+ yield sse.emit_tool_delta(tc_index, json.dumps(parsed))returnyield sse.emit_tool_delta(tc_index, args)def _flush_task_arg_buffers(self, sse: Any):"""Emit buffered Task args as a single JSON delta (best-effort)."""- for tool_index, buf in list(sse.blocks.task_arg_buffer.items()):- if sse.blocks.task_args_emitted.get(tool_index, False):- sse.blocks.task_arg_buffer.pop(tool_index, None)- continue-- tool_id = sse.blocks.tool_ids.get(tool_index, "unknown")- out = "{}"- try:- args_json = json.loads(buf)- if args_json.get("run_in_background") is not False:- logger.info(- "OPENROUTER_INTERCEPT: Forcing run_in_background=False for Task %s",- tool_id,- )- args_json["run_in_background"] = False- out = json.dumps(args_json)- except Exception as e:- prefix = buf[:120]- logger.warning(- "OPENROUTER_INTERCEPT: Task args invalid JSON (id=%s len=%d prefix=%r): %s",- tool_id,- len(buf),- prefix,- e,- )-- sse.blocks.task_args_emitted[tool_index] = True- sse.blocks.task_arg_buffer.pop(tool_index, None)+ for tool_index, out in sse.blocks.flush_task_arg_buffers():yield sse.emit_tool_delta(tool_index, out)diff --git a/providers/open_router/request.py b/providers/open_router/request.pyindex 244749be..984b3163 100644--- a/providers/open_router/request.py+++ b/providers/open_router/request.py@@ -1,11 +1,10 @@"""Request builder for OpenRouter provider."""-import loggingfrom typing import Any, Dictfrom providers.nvidia_nim.utils.message_converter import AnthropicToOpenAIConverter+from loguru import logger-logger = logging.getLogger(__name__)OPENROUTER_DEFAULT_MAX_TOKENS = 81920diff --git a/providers/rate_limit.py b/providers/rate_limit.pyindex b343ee87..bcef02ba 100644--- a/providers/rate_limit.py+++ b/providers/rate_limit.py@@ -4,15 +4,13 @@ import asynciofrom collections import dequeimport randomimport time-import loggingfrom typing import Any, Callable, Optional, TypeVarimport openai+from loguru import loggerT = TypeVar("T")-logger = logging.getLogger(__name__)-class GlobalRateLimiter:"""diff --git a/tests/conftest.py b/tests/conftest.pyindex e4b22729..6f672116 100644--- a/tests/conftest.py+++ b/tests/conftest.py@@ -1,3 +1,4 @@+import loggingimport pytestimport asyncioimport os@@ -144,3 +145,24 @@ def incoming_message_factory():return IncomingMessage(**filtered)return _create++[email protected](autouse=True)+def _propagate_loguru_to_caplog():+ """Route loguru logs to stdlib logging so pytest caplog captures them."""+ from loguru import logger as loguru_logger++ class _PropagateHandler:+ def write(self, message):+ record = message.record+ level = record["level"].no+ stdlib_level = min(level, logging.CRITICAL)+ py_logger = logging.getLogger(record["name"])+ py_logger.log(stdlib_level, record["message"])++ handler_id = loguru_logger.add(_PropagateHandler(), format="{message}")+ yield+ try:+ loguru_logger.remove(handler_id)+ except ValueError:+ pass # Handler already removed (e.g. by test_logging_config tests)diff --git a/tests/test_api.py b/tests/test_api.pyindex 52c5f214..8c845374 100644--- a/tests/test_api.py+++ b/tests/test_api.py@@ -1,7 +1,7 @@from fastapi.testclient import TestClientfrom api.app import appfrom api.dependencies import get_provider-from unittest.mock import AsyncMock, MagicMock+from unittest.mock import MagicMockfrom providers.nvidia_nim import NvidiaNimProvider# Mock providerdiff --git a/tests/test_limiter.py b/tests/test_limiter.pyindex 35e6e17f..cacab325 100644--- a/tests/test_limiter.py+++ b/tests/test_limiter.py@@ -3,7 +3,6 @@ import pytest_asyncioimport asyncioimport timeimport os-import logging# Set environment variables relative to test executionos.environ["MESSAGING_RATE_LIMIT"] = "1"@@ -11,8 +10,6 @@ os.environ["MESSAGING_RATE_WINDOW"] = "0.5"from messaging.limiter import MessagingRateLimiter-logger = logging.getLogger(__name__)-class TestMessagingRateLimiter:"""Tests for MessagingRateLimiter."""diff --git a/tests/test_lmstudio.py b/tests/test_lmstudio.pyindex dcb1c228..60d36057 100644--- a/tests/test_lmstudio.py+++ b/tests/test_lmstudio.py@@ -539,10 +539,7 @@ class TestLMStudioProcessToolCall:flushed = list(lmstudio_provider._flush_task_arg_buffers(sse))assert len(flushed) > 0assert "{}" in "".join(flushed)- assert any(- "LMSTUDIO_INTERCEPT: Task args invalid JSON" in r.message- for r in caplog.records- )+ assert any("Task args invalid JSON" in r.message for r in caplog.records)def test_negative_tool_index_fallback(self, lmstudio_provider):"""tc_index < 0 uses len(tool_indices) as fallback."""diff --git a/tests/test_logging_config.py b/tests/test_logging_config.pyindex 9051f806..18dcc119 100644--- a/tests/test_logging_config.py+++ b/tests/test_logging_config.py@@ -4,7 +4,6 @@ import jsonimport loggingfrom pathlib import Path-import pytestfrom config.logging_config import configure_loggingdiff --git a/tests/test_messaging.py b/tests/test_messaging.pyindex 1310c2d2..f3c119c9 100644--- a/tests/test_messaging.py+++ b/tests/test_messaging.py@@ -2,7 +2,6 @@import pytestimport json-import osfrom datetime import datetime, timedelta, timezonefrom unittest.mock import patchdiff --git a/tests/test_messaging_factory.py b/tests/test_messaging_factory.pyindex 8b630a5a..16574450 100644--- a/tests/test_messaging_factory.py+++ b/tests/test_messaging_factory.py@@ -1,6 +1,5 @@"""Tests for messaging platform factory."""-import pytestfrom unittest.mock import patch, MagicMockfrom messaging.factory import create_messaging_platformdiff --git a/tests/test_nvidia_nim.py b/tests/test_nvidia_nim.pyindex 4dc0c4a9..14d967cf 100644--- a/tests/test_nvidia_nim.py+++ b/tests/test_nvidia_nim.py@@ -2,7 +2,6 @@ import pytestimport jsonfrom unittest.mock import MagicMock, AsyncMock, patchfrom providers.nvidia_nim import NvidiaNimProvider-from providers.exceptions import APIError# Mock data classesdiff --git a/tests/test_provider_rate_limit.py b/tests/test_provider_rate_limit.pyindex cd271cf7..9a328d53 100644--- a/tests/test_provider_rate_limit.py+++ b/tests/test_provider_rate_limit.py@@ -2,13 +2,9 @@ import pytestimport pytest_asyncioimport asyncioimport time-import os-import loggingfrom providers.rate_limit import GlobalRateLimiter-logger = logging.getLogger(__name__)-class TestProviderRateLimiter:"""Tests for providers.rate_limit.GlobalRateLimiter."""diff --git a/tests/test_reliability.py b/tests/test_reliability.pyindex d947b004..97847f66 100644--- a/tests/test_reliability.py+++ b/tests/test_reliability.py@@ -2,8 +2,6 @@ import pytestfrom unittest.mock import AsyncMock, MagicMock, patchfrom messaging.telegram import TelegramPlatformfrom telegram.error import NetworkError, RetryAfter, TelegramError-from messaging.handler import ClaudeMessageHandler-from messaging.telegram_markdown import format_status@pytest.fixturediff --git a/tests/test_response_conversion.py b/tests/test_response_conversion.pydeleted file mode 100644index 79693ce0..00000000--- a/tests/test_response_conversion.py+++ /dev/null@@ -1,216 +0,0 @@-"""Tests for providers/nvidia_nim/response.py response conversion."""--import pytest-from unittest.mock import MagicMock--from providers.nvidia_nim.response import convert_response---def _make_response(- content="Hello",- finish_reason="stop",- tool_calls=None,- reasoning_content=None,- reasoning_details=None,- usage=None,-):- """Helper to build a minimal OpenAI-format response dict."""- message = {"content": content, "role": "assistant"}- if tool_calls is not None:- message["tool_calls"] = tool_calls- if reasoning_content is not None:- message["reasoning_content"] = reasoning_content- if reasoning_details is not None:- message["reasoning_details"] = reasoning_details-- return {- "id": "chatcmpl-test",- "choices": [{"message": message, "finish_reason": finish_reason}],- "usage": usage or {"prompt_tokens": 10, "completion_tokens": 5},- }---def _make_request(model="test-model"):- req = MagicMock()- req.model = model- return req---class TestConvertResponse:- """Tests for convert_response function."""-- def test_simple_text_response(self):- """Simple text content is preserved."""- resp = _make_response(content="Hello world")- result = convert_response(resp, _make_request())- assert result["content"] == [{"type": "text", "text": "Hello world"}]- assert result["stop_reason"] == "end_turn"-- def test_empty_content_gets_space(self):- """Empty content produces a single space text block."""- resp = _make_response(content="")- result = convert_response(resp, _make_request())- assert result["content"] == [{"type": "text", "text": " "}]-- def test_none_content_gets_space(self):- """None content produces a single space text block."""- resp = _make_response(content=None)- result = convert_response(resp, _make_request())- assert result["content"] == [{"type": "text", "text": " "}]-- def test_reasoning_content_field(self):- """reasoning_content field is extracted as thinking block."""- resp = _make_response(content="Answer", reasoning_content="I need to think...")- result = convert_response(resp, _make_request())- types = [b["type"] for b in result["content"]]- assert "thinking" in types- assert "text" in types- thinking = [b for b in result["content"] if b["type"] == "thinking"]- assert thinking[0]["thinking"] == "I need to think..."-- def test_reasoning_details_list(self):- """reasoning_details list is joined into thinking block."""- resp = _make_response(- content="Answer",- reasoning_details=[- {"text": "Step 1"},- {"text": "Step 2"},- ],- )- result = convert_response(resp, _make_request())- thinking = [b for b in result["content"] if b["type"] == "thinking"]- assert len(thinking) == 1- assert "Step 1" in thinking[0]["thinking"]- assert "Step 2" in thinking[0]["thinking"]-- def test_content_with_think_tags(self):- """Think tags in content string are extracted when no reasoning field."""- resp = _make_response(content="<think>reasoning here</think>The answer is 42")- result = convert_response(resp, _make_request())- types = [b["type"] for b in result["content"]]- assert "thinking" in types- text_blocks = [b for b in result["content"] if b["type"] == "text"]- assert any("42" in b["text"] for b in text_blocks)-- def test_think_tags_skipped_when_reasoning_exists(self):- """When reasoning_content exists, think tags in content are NOT re-extracted."""- resp = _make_response(- content="<think>duplicate</think>Answer",- reasoning_content="Real reasoning",- )- result = convert_response(resp, _make_request())- thinking = [b for b in result["content"] if b["type"] == "thinking"]- # Only the reasoning_content should be in thinking, not duplicate extraction- assert len(thinking) == 1- assert thinking[0]["thinking"] == "Real reasoning"-- def test_content_as_list(self):- """Content as list of dicts is preserved."""- resp = _make_response(- content=[- {"type": "text", "text": "Hello"},- {"type": "text", "text": "World"},- ]- )- result = convert_response(resp, _make_request())- text_blocks = [b for b in result["content"] if b["type"] == "text"]- assert len(text_blocks) == 2-- def test_tool_call_valid_json(self):- """Tool calls with valid JSON arguments are parsed."""- resp = _make_response(- content="",- tool_calls=[- {- "id": "call_1",- "function": {- "name": "search",- "arguments": '{"query": "test"}',- },- }- ],- )- result = convert_response(resp, _make_request())- tool_blocks = [b for b in result["content"] if b["type"] == "tool_use"]- assert len(tool_blocks) == 1- assert tool_blocks[0]["input"] == {"query": "test"}- assert tool_blocks[0]["name"] == "search"-- def test_tool_call_invalid_json_fallback(self):- """Tool call with non-JSON arguments falls back to raw value."""- resp = _make_response(- content="",- tool_calls=[- {- "id": "call_2",- "function": {- "name": "test",- "arguments": "not valid json {",- },- }- ],- )- result = convert_response(resp, _make_request())- tool_blocks = [b for b in result["content"] if b["type"] == "tool_use"]- assert len(tool_blocks) == 1- assert tool_blocks[0]["input"] == "not valid json {"-- def test_usage_mapping(self):- """Usage tokens are mapped from OpenAI to Anthropic format."""- resp = _make_response(usage={"prompt_tokens": 100, "completion_tokens": 50})- result = convert_response(resp, _make_request())- assert result["usage"]["input_tokens"] == 100- assert result["usage"]["output_tokens"] == 50- assert result["usage"]["cache_creation_input_tokens"] == 0- assert result["usage"]["cache_read_input_tokens"] == 0-- def test_missing_usage(self):- """Missing usage defaults to zeros."""- resp = _make_response()- resp.pop("usage")- result = convert_response(resp, _make_request())- assert result["usage"]["input_tokens"] == 0- assert result["usage"]["output_tokens"] == 0-- @pytest.mark.parametrize(- "finish_reason,expected_stop",- [- ("stop", "end_turn"),- ("length", "max_tokens"),- ("tool_calls", "tool_use"),- ("content_filter", "end_turn"),- (None, "end_turn"),- ],- ids=["stop", "length", "tool_calls", "content_filter", "none"],- )- def test_stop_reason_mapping(self, finish_reason, expected_stop):- """Finish reasons map correctly to Anthropic stop_reasons."""- resp = _make_response(finish_reason=finish_reason)- result = convert_response(resp, _make_request())- assert result["stop_reason"] == expected_stop-- def test_model_from_request(self):- """Response model comes from original request, not provider response."""- resp = _make_response()- result = convert_response(resp, _make_request(model="claude-3"))- assert result["model"] == "claude-3"-- def test_interleaved_think_tags_in_content_preserved(self):- """Interleaved <think>...</think> and text in content should preserve order.-- Bug: extract_think_content uses findall and joins all matches, then strips- tags from content. So "<think>a</think>x<think>b</think>" becomes thinking="a\\nb", remaining="x".- Output is [thinking, text] instead of [thinking, text, thinking].- """- resp = _make_response(content="<think>first</think>middle<think>second</think>")- result = convert_response(resp, _make_request())- types = [b["type"] for b in result["content"]]- # Expected: thinking, text, thinking (interleaved order)- assert types == ["thinking", "text", "thinking"], (- f"Interleaved order lost. Got types: {types}"- )- thinking_blocks = [b for b in result["content"] if b["type"] == "thinking"]- assert thinking_blocks[0]["thinking"] == "first"- assert thinking_blocks[1]["thinking"] == "second"- text_blocks = [b for b in result["content"] if b["type"] == "text"]- assert text_blocks[0]["text"] == "middle"diff --git a/tests/test_response_models.py b/tests/test_response_models.pyindex 8f649ef3..7cbe1d8c 100644--- a/tests/test_response_models.py+++ b/tests/test_response_models.py@@ -1,7 +1,5 @@"""Tests for api/models/responses.py Pydantic response models."""-import pytest-from api.models.responses import MessagesResponse, Usage, TokenCountResponsefrom api.models.anthropic import (ContentBlockText,diff --git a/tests/test_restart_reply_restore.py b/tests/test_restart_reply_restore.pyindex d46d143a..2e20f8a7 100644--- a/tests/test_restart_reply_restore.py+++ b/tests/test_restart_reply_restore.py@@ -1,5 +1,5 @@import pytest-from unittest.mock import AsyncMock, MagicMock, patch+from unittest.mock import AsyncMock, patchfrom messaging.handler import ClaudeMessageHandlerfrom messaging.session import SessionStorediff --git a/tests/test_server_module.py b/tests/test_server_module.pyindex 386ab32b..dec79719 100644--- a/tests/test_server_module.py+++ b/tests/test_server_module.py@@ -8,7 +8,7 @@ def test_server_module_exports_app_and_create_app():def test_server_main_invokes_uvicorn_run(monkeypatch):import runpyfrom types import SimpleNamespace- from unittest.mock import MagicMock, patch+ from unittest.mock import patchimport config.settings as settings_modimport uvicorn as uvicorn_moddiff --git a/tests/test_session_store_edge_cases.py b/tests/test_session_store_edge_cases.pyindex decb00a5..ab013324 100644--- a/tests/test_session_store_edge_cases.py+++ b/tests/test_session_store_edge_cases.py@@ -1,7 +1,6 @@"""Edge case tests for messaging/session.py SessionStore."""import json-import osimport pytestfrom unittest.mock import patchdiff --git a/tests/test_sse_builder.py b/tests/test_sse_builder.pyindex f54a77b8..b4bbfe9d 100644--- a/tests/test_sse_builder.py+++ b/tests/test_sse_builder.py@@ -8,7 +8,6 @@ from providers.nvidia_nim.utils.sse_builder import (SSEBuilder,ContentBlockManager,map_stop_reason,- STOP_REASON_MAP,)diff --git a/tests/test_streaming_errors.py b/tests/test_streaming_errors.pyindex a48312ac..50bb017e 100644--- a/tests/test_streaming_errors.py+++ b/tests/test_streaming_errors.py@@ -359,9 +359,7 @@ class TestProcessToolCall:flushed = list(provider._flush_task_arg_buffers(sse))assert len(flushed) > 0assert "{}" in "".join(flushed)- assert any(- "NIM_INTERCEPT: Task args invalid JSON" in r.message for r in caplog.records- )+ assert any("Task args invalid JSON" in r.message for r in caplog.records)def test_negative_tool_index_fallback(self):"""tc_index < 0 uses len(tool_indices) as fallback."""diff --git a/tests/test_subagent_interception.py b/tests/test_subagent_interception.pyindex f05eae6f..d2fef13b 100644--- a/tests/test_subagent_interception.py+++ b/tests/test_subagent_interception.py@@ -1,8 +1,8 @@import json-import uuidimport pytest-from unittest.mock import MagicMock, AsyncMock+from unittest.mock import MagicMockfrom providers.nvidia_nim import NvidiaNimProvider+from providers.nvidia_nim.utils.sse_builder import ContentBlockManagerfrom providers.base import ProviderConfig@@ -12,18 +12,12 @@ async def test_task_tool_interception():config = ProviderConfig(api_key="test")provider = NvidiaNimProvider(config)- # Mock request and sse builder+ # Mock request and sse builder with real ContentBlockManagerrequest = MagicMock()request.model = "test-model"sse = MagicMock()- sse.blocks = MagicMock()- sse.blocks.tool_indices = {}- sse.blocks.tool_names = {}- sse.blocks.tool_started = {}- sse.blocks.task_arg_buffer = {}- sse.blocks.task_args_emitted = {}- sse.blocks.tool_ids = {}+ sse.blocks = ContentBlockManager()# Tool call data (Task tool)tc = {@@ -41,21 +35,16 @@ async def test_task_tool_interception():},}- # Remove pre-filled tool name - _process_tool_call handles it- # sse.blocks.tool_names[0] = "Task"-# Call the methodevents = []- # _process_tool_call is a synchronous generator in nvidia_nim.pyfor event in provider._process_tool_call(tc, sse):events.append(event)- # Find the start_tool_block call or check the modified state+ # Find the emit_tool_delta call and check argscalls = sse.emit_tool_delta.call_args_listassert len(calls) > 0args_passed = json.loads(calls[0][0][1])assert args_passed["run_in_background"] is False- print("Verification successful: run_in_background was forced to False")if __name__ == "__main__":diff --git a/tests/test_tree_concurrency.py b/tests/test_tree_concurrency.pyindex fb1e76df..bc63ab9a 100644--- a/tests/test_tree_concurrency.py+++ b/tests/test_tree_concurrency.py@@ -1,7 +1,6 @@"""Concurrency and race condition tests for tree data structures and queue manager."""import pytest-import pytest_asyncioimport asynciofrom messaging.models import IncomingMessage