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
Major refactor done with minimax m2.5
Alishahryar1a74ec74271da
diff --git a/api/dependencies.py b/api/dependencies.pyindex 568d6ae7..084dd8b4 100644--- a/api/dependencies.py+++ b/api/dependencies.py@@ -3,12 +3,12 @@from fastapi import HTTPExceptionfrom loguru import logger-from config.settings import NVIDIA_NIM_BASE_URL, Settings+from config.settings import Settingsfrom config.settings import get_settings as _get_settingsfrom providers.base import BaseProvider, ProviderConfigfrom providers.exceptions import AuthenticationErrorfrom providers.lmstudio import LMStudioProvider-from providers.nvidia_nim import NvidiaNimProvider+from providers.nvidia_nim import NVIDIA_NIM_BASE_URL, NvidiaNimProviderfrom providers.open_router import OpenRouterProviderfrom providers.open_router.client import OPENROUTER_BASE_URLdiff --git a/api/routes.py b/api/routes.pyindex 1471f1e6..945f77c5 100644--- a/api/routes.py+++ b/api/routes.py@@ -1,6 +1,7 @@"""FastAPI route handlers."""import json+import tracebackimport uuidfrom fastapi import APIRouter, Depends, HTTPException, Request@@ -66,8 +67,6 @@ async def create_message(except ProviderError:raiseexcept Exception as e:- import traceback-logger.error(f"Error: {e!s}\n{traceback.format_exc()}")raise HTTPException(status_code=getattr(e, "status_code", 500), detail=str(e)@@ -89,8 +88,6 @@ async def count_tokens(request_data: TokenCountRequest):logger.info("COUNT_TOKENS: %s", json.dumps(summary))return TokenCountResponse(input_tokens=tokens)except Exception as e:- import traceback-logger.error("COUNT_TOKENS_ERROR: request_id=%s error=%s\n%s",request_id,diff --git a/config/settings.py b/config/settings.pyindex d77d2081..88e72b32 100644--- a/config/settings.py+++ b/config/settings.py@@ -10,9 +10,6 @@ from .nim import NimSettingsload_dotenv()-# Fixed base URL for NVIDIA NIM-NVIDIA_NIM_BASE_URL = "https://integrate.api.nvidia.com/v1"-class Settings(BaseSettings):"""Application settings loaded from environment variables."""diff --git a/messaging/handler.py b/messaging/handler.pyindex c5088d15..98d4b4bf 100644--- a/messaging/handler.py+++ b/messaging/handler.py@@ -117,42 +117,33 @@ class ClaudeMessageHandler:queue_update_callback=self._update_queue_positions,node_started_callback=self._mark_node_processing,)+ is_discord = platform.name == "discord"+ self._format_status_fn = (+ format_status_discord if is_discord else format_status_telegram+ )+ self._parse_mode_val: str | None = None if is_discord else "MarkdownV2"+ self._render_ctx_val = RenderCtx(+ bold=discord_bold if is_discord else mdv2_bold,+ code_inline=discord_code_inline if is_discord else mdv2_code_inline,+ escape_code=escape_discord_code if is_discord else escape_md_v2_code,+ escape_text=escape_discord if is_discord else escape_md_v2,+ render_markdown=render_markdown_to_discord+ if is_discord+ else render_markdown_to_mdv2,+ )+ self._limit_chars = 1900 if is_discord else 3900def _format_status(self, emoji: str, label: str, suffix: str | None = None) -> str:- """Platform-specific status formatting."""- if self.platform.name == "discord":- return format_status_discord(emoji, label, suffix)- return format_status_telegram(emoji, label, suffix)+ return self._format_status_fn(emoji, label, suffix)def _parse_mode(self) -> str | None:- """Platform-specific parse mode (MarkdownV2 for Telegram, None for Discord)."""- if self.platform.name == "discord":- return None- return "MarkdownV2"+ return self._parse_mode_valdef _get_render_ctx(self) -> RenderCtx:- """Platform-specific render context for transcript."""- if self.platform.name == "discord":- return RenderCtx(- bold=discord_bold,- code_inline=discord_code_inline,- escape_code=escape_discord_code,- escape_text=escape_discord,- render_markdown=render_markdown_to_discord,- )- return RenderCtx(- bold=mdv2_bold,- code_inline=mdv2_code_inline,- escape_code=escape_md_v2_code,- escape_text=escape_md_v2,- render_markdown=render_markdown_to_mdv2,- )+ return self._render_ctx_valdef _get_limit_chars(self) -> int:- """Platform-specific message length limit (Discord 2000, Telegram 4096)."""- if self.platform.name == "discord":- return 1900- return 3900+ return self._limit_charsasync def handle_message(self, incoming: IncomingMessage) -> None:"""@@ -704,7 +695,7 @@ class ClaudeMessageHandler:node = tree.get_node(node_id)if node and node.state not in (MessageState.COMPLETED, MessageState.ERROR):# Used by _process_node cancellation path to render "Stopped."- node.context = {"cancel_reason": "stop"}+ node.set_context({"cancel_reason": "stop"})cancelled_nodes = await self.tree_queue.cancel_node(node_id)self._update_cancelled_nodes_ui(cancelled_nodes)@@ -973,24 +964,11 @@ class ClaudeMessageHandler:logger.debug(f"Failed to read message log for /clear: {e}")try:- data = self.tree_queue.to_dict()- trees = data.get("trees", {})- for tree_data in trees.values():- nodes = tree_data.get("nodes", {})- for node_data in nodes.values():- inc = node_data.get("incoming", {}) or {}- if str(inc.get("platform")) != str(incoming.platform):- continue- if str(inc.get("chat_id")) != str(incoming.chat_id):- continue-- mid = inc.get("message_id")- if mid is not None:- msg_ids.add(str(mid))-- sid = node_data.get("status_message_id")- if sid is not None:- msg_ids.add(str(sid))+ msg_ids.update(+ self.tree_queue.get_message_ids_for_chat(+ incoming.platform, incoming.chat_id+ )+ )except Exception as e:logger.warning(f"Failed to gather messages for /clear: {e}")diff --git a/messaging/trees/data.py b/messaging/trees/data.pyindex f587d73c..e2cd2bd8 100644--- a/messaging/trees/data.py+++ b/messaging/trees/data.py@@ -16,27 +16,37 @@ from loguru import loggerfrom ..models import IncomingMessage-class _SnapshotQueue(asyncio.Queue[str]):- """- Queue with snapshot/remove helpers.+class _SnapshotQueue:+ """Queue with snapshot/remove helpers, backed by a deque."""- Extends asyncio.Queue to expose read-only snapshot and in-place remove- without inflating _unfinished_tasks (drain/put would require task_done).- """+ def __init__(self) -> None:+ self._deque: deque[str] = deque()++ async def put(self, item: str) -> None:+ self._deque.append(item)- _queue: deque # Set by asyncio.Queue.__init__+ def put_nowait(self, item: str) -> None:+ self._deque.append(item)++ def get_nowait(self) -> str:+ if not self._deque:+ raise asyncio.QueueEmpty()+ return self._deque.popleft()++ def qsize(self) -> int:+ return len(self._deque)def get_snapshot(self) -> list[str]:"""Return current queue contents in FIFO order (read-only copy)."""- return list(self._queue)+ return list(self._deque)def remove_if_present(self, item: str) -> bool:"""Remove item from queue if present. Returns True if removed."""- if item not in self._queue:+ if item not in self._deque:return False- items = [x for x in self._queue if x != item]- self._queue.clear()- self._queue.extend(items)+ items = [x for x in self._deque if x != item]+ self._deque.clear()+ self._deque.extend(items)return True@@ -72,6 +82,9 @@ class MessageNode:error_message: str | None = Nonecontext: Any = None # Additional context if needed+ def set_context(self, context: Any) -> None:+ self.context = context+def to_dict(self) -> dict:"""Convert to dictionary for JSON serialization."""return {diff --git a/messaging/trees/queue_manager.py b/messaging/trees/queue_manager.pyindex 801f5cef..6226476a 100644--- a/messaging/trees/queue_manager.py+++ b/messaging/trees/queue_manager.py@@ -41,8 +41,9 @@ class TreeQueueManager:queue_update_callback: Callable[[MessageTree], Awaitable[None]] | None = None,node_started_callback: Callable[[MessageTree, str], Awaitable[None]]| None = None,+ _repository: TreeRepository | None = None,):- self._repository = TreeRepository()+ self._repository = _repository or TreeRepository()self._processor = TreeQueueProcessor(queue_update_callback=queue_update_callback,node_started_callback=node_started_callback,@@ -243,8 +244,7 @@ class TreeQueueManager:MessageState.COMPLETED,MessageState.ERROR,):- node.state = MessageState.ERROR- node.error_message = "Cancelled by user"+ tree._set_node_error_sync(node, "Cancelled by user")cancelled_nodes.append(node)# 2. Drain queue and mark nodes as cancelled@@ -259,8 +259,7 @@ class TreeQueueManager:node.state in (MessageState.PENDING, MessageState.IN_PROGRESS)and node.node_id not in cancelled_ids):- node.state = MessageState.ERROR- node.error_message = "Stale task cleaned up"+ tree._set_node_error_sync(node, "Stale task cleaned up")cleanup_count += 1tree.reset_processing_state()@@ -337,8 +336,7 @@ class TreeQueueManager:for tree in self._repository.all_trees():for node in tree.all_nodes():if node.state in (MessageState.PENDING, MessageState.IN_PROGRESS):- node.state = MessageState.ERROR- node.error_message = "Lost during server restart"+ tree._set_node_error_sync(node, "Lost during server restart")count += 1if count:logger.info(f"Cleaned up {count} stale nodes during startup")@@ -435,6 +433,10 @@ class TreeQueueManager:self._repository.unregister_nodes([n.node_id for n in removed])return (removed, root_id, False)+ def get_message_ids_for_chat(self, platform: str, chat_id: str) -> set[str]:+ """Get all message IDs for a given platform/chat."""+ return self._repository.get_message_ids_for_chat(platform, chat_id)+def to_dict(self) -> dict:"""Serialize all trees."""return self._repository.to_dict()@@ -448,9 +450,8 @@ class TreeQueueManager:| None = None,) -> TreeQueueManager:"""Deserialize from dictionary."""- manager = cls(+ return cls(queue_update_callback=queue_update_callback,node_started_callback=node_started_callback,+ _repository=TreeRepository.from_dict(data),)- manager._repository = TreeRepository.from_dict(data)- return managerdiff --git a/messaging/trees/repository.py b/messaging/trees/repository.pyindex c542a222..faa6da40 100644--- a/messaging/trees/repository.py+++ b/messaging/trees/repository.py@@ -149,6 +149,20 @@ class TreeRepository:logger.debug("TREE_REPO: remove_tree root_id=%s", root_id)return tree+ def get_message_ids_for_chat(self, platform: str, chat_id: str) -> set[str]:+ """Get all message IDs (incoming + status) for a given platform/chat."""+ msg_ids: set[str] = set()+ for tree in self._trees.values():+ for node in tree.all_nodes():+ if str(node.incoming.platform) == str(platform) and str(+ node.incoming.chat_id+ ) == str(chat_id):+ if node.incoming.message_id is not None:+ msg_ids.add(str(node.incoming.message_id))+ if node.status_message_id:+ msg_ids.add(str(node.status_message_id))+ return msg_ids+def to_dict(self) -> dict:"""Serialize all trees."""return {diff --git a/providers/common/heuristic_tool_parser.py b/providers/common/heuristic_tool_parser.pyindex bf5407d3..e338db52 100644--- a/providers/common/heuristic_tool_parser.py+++ b/providers/common/heuristic_tool_parser.py@@ -162,11 +162,7 @@ class HeuristicToolParser:filtered_output_parts.append(self._buffer[:idx])self._buffer = self._buffer[idx:]finished_tool_call = True- elif (- len(self._buffer) > 0- and not self._buffer.strip().startswith("<")- and not self._buffer.lstrip().startswith("<")- ):+ elif len(self._buffer) > 0 and not self._buffer.strip().startswith("<"):# We have text that doesn't look like a tag, and we already parsed some or are in param state# Let's see if we have trailing param startsif "<parameter=" not in self._buffer:diff --git a/providers/common/sse_builder.py b/providers/common/sse_builder.pyindex 4dd3adfd..d95efce7 100644--- a/providers/common/sse_builder.py+++ b/providers/common/sse_builder.py@@ -31,6 +31,19 @@ def map_stop_reason(openai_reason: str | None) -> str:)+@dataclass+class ToolCallState:+ """State for a single streaming tool call."""++ block_index: int # -1 if not yet allocated+ tool_id: str+ name: str+ contents: list[str] = field(default_factory=list)+ started: bool = False+ task_arg_buffer: str = ""+ task_args_emitted: bool = False++@dataclassclass ContentBlockManager:"""Manages content block indices and state."""@@ -40,14 +53,7 @@ class ContentBlockManager:text_index: int = -1thinking_started: bool = Falsetext_started: bool = False- tool_indices: dict[int, int] = field(default_factory=dict)- tool_contents: dict[int, list[str]] = field(default_factory=dict)- tool_names: dict[int, str] = field(default_factory=dict)- tool_ids: dict[int, str] = field(default_factory=dict)- tool_started: dict[int, bool] = field(default_factory=dict)- # Buffer streaming args for tools where we don't want to emit partial deltas.- task_arg_buffer: dict[int, str] = field(default_factory=dict)- task_args_emitted: dict[int, bool] = field(default_factory=dict)+ tool_states: dict[int, ToolCallState] = field(default_factory=dict)def allocate_index(self) -> int:"""Allocate and return the next block index."""@@ -61,17 +67,17 @@ class ContentBlockManager:Handles providers that stream names as fragments and those thatresend 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+ if index not in self.tool_states:+ self.tool_states[index] = ToolCallState(+ block_index=-1, tool_id="", name=name+ )+ return+ state = self.tool_states[index]+ prev = state.name+ if not prev or name.startswith(prev):+ state.name = name+ elif not prev.startswith(name):+ state.name = prev + namedef buffer_task_args(self, index: int, args: str) -> dict | None:"""Buffer Task tool args and return parsed JSON when complete.@@ -79,49 +85,48 @@ class ContentBlockManager:Returns the parsed (and patched) args dict once the buffer formsvalid JSON, or None if still accumulating."""- if self.task_args_emitted.get(index, False):+ state = self.tool_states.get(index)+ if state is None or state.task_args_emitted:return None- buf = self.task_arg_buffer.get(index, "") + args- self.task_arg_buffer[index] = buf+ state.task_arg_buffer += argstry:- args_json = json.loads(buf)+ args_json = json.loads(state.task_arg_buffer)except Exception:return Noneif 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)+ state.task_args_emitted = True+ state.task_arg_buffer = ""return args_jsondef 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)+ for tool_index, state in list(self.tool_states.items()):+ if not state.task_arg_buffer or state.task_args_emitted:continueout = "{}"try:- args_json = json.loads(buf)+ args_json = json.loads(state.task_arg_buffer)if args_json.get("run_in_background") is not False:args_json["run_in_background"] = Falseout = json.dumps(args_json)except Exception as e:- prefix = buf[:120]+ prefix = state.task_arg_buffer[:120]logger.warning("Task args invalid JSON (id=%s len=%d prefix=%r): %s",- self.tool_ids.get(tool_index, "unknown"),- len(buf),+ state.tool_id or "unknown",+ len(state.task_arg_buffer),prefix,e,)- self.task_args_emitted[tool_index] = True- self.task_arg_buffer.pop(tool_index, None)+ state.task_args_emitted = True+ state.task_arg_buffer = ""results.append((tool_index, out))return results@@ -277,21 +282,31 @@ class SSEBuilder:def start_tool_block(self, tool_index: int, tool_id: str, name: str) -> str:"""Start a tool_use block."""block_idx = self.blocks.allocate_index()- self.blocks.tool_indices[tool_index] = block_idx- self.blocks.tool_contents[tool_index] = []- self.blocks.tool_ids[tool_index] = tool_id- self.blocks.task_args_emitted.setdefault(tool_index, False)+ if tool_index in self.blocks.tool_states:+ state = self.blocks.tool_states[tool_index]+ state.block_index = block_idx+ state.tool_id = tool_id+ state.started = True+ else:+ self.blocks.tool_states[tool_index] = ToolCallState(+ block_index=block_idx,+ tool_id=tool_id,+ name=name,+ started=True,+ )return self.content_block_start(block_idx, "tool_use", id=tool_id, name=name)def emit_tool_delta(self, tool_index: int, partial_json: str) -> str:"""Emit tool input delta."""- self.blocks.tool_contents[tool_index].append(partial_json)- block_idx = self.blocks.tool_indices[tool_index]- return self.content_block_delta(block_idx, "input_json_delta", partial_json)+ state = self.blocks.tool_states[tool_index]+ state.contents.append(partial_json)+ return self.content_block_delta(+ state.block_index, "input_json_delta", partial_json+ )def stop_tool_block(self, tool_index: int) -> str:"""Stop a tool block."""- block_idx = self.blocks.tool_indices[tool_index]+ block_idx = self.blocks.tool_states[tool_index].block_indexreturn self.content_block_stop(block_idx)# State management helpers@@ -322,8 +337,9 @@ class SSEBuilder:yield self.stop_thinking_block()if self.blocks.text_started:yield self.stop_text_block()- for tool_index in list(self.blocks.tool_indices.keys()):- yield self.stop_tool_block(tool_index)+ for tool_index, state in list(self.blocks.tool_states.items()):+ if state.started:+ yield self.stop_tool_block(tool_index)# Error handlingdef emit_error(self, error_message: str) -> Iterator[str]:@@ -354,17 +370,16 @@ class SSEBuilder:# Tool calls are harder to tokenize exactly without reconstruction, but we can approximate# by tokenizing the json dumps of tool contentstool_tokens = 0- for idx, content_parts in self.blocks.tool_contents.items():- name = self.blocks.tool_names.get(idx, "")- tool_tokens += len(ENCODER.encode(name))- tool_tokens += len(ENCODER.encode("".join(content_parts)))+ for state in self.blocks.tool_states.values():+ tool_tokens += len(ENCODER.encode(state.name))+ tool_tokens += len(ENCODER.encode("".join(state.contents)))tool_tokens += 15 # Control tokens overhead per tool# Per-block overhead (~4 tokens per content block)block_count = ((1 if accumulated_reasoning else 0)+ (1 if accumulated_text else 0)- + len(self.blocks.tool_indices)+ + sum(1 for s in self.blocks.tool_states.values() if s.started))block_overhead = block_count * 4@@ -372,5 +387,5 @@ class SSEBuilder:text_tokens = len(accumulated_text) // 4reasoning_tokens = len(accumulated_reasoning) // 4- tool_tokens = len(self.blocks.tool_indices) * 50+ tool_tokens = sum(1 for s in self.blocks.tool_states.values() if s.started) * 50return text_tokens + reasoning_tokens + tool_tokensdiff --git a/providers/nvidia_nim/__init__.py b/providers/nvidia_nim/__init__.pyindex ee73b06b..b0a410f6 100644--- a/providers/nvidia_nim/__init__.py+++ b/providers/nvidia_nim/__init__.py@@ -1,5 +1,5 @@"""NVIDIA NIM provider package."""-from .client import NvidiaNimProvider+from .client import NVIDIA_NIM_BASE_URL, NvidiaNimProvider-__all__ = ["NvidiaNimProvider"]+__all__ = ["NVIDIA_NIM_BASE_URL", "NvidiaNimProvider"]diff --git a/providers/nvidia_nim/client.py b/providers/nvidia_nim/client.pyindex 714c438a..482a8539 100644--- a/providers/nvidia_nim/client.py+++ b/providers/nvidia_nim/client.py@@ -8,6 +8,8 @@ from providers.openai_compat import OpenAICompatibleProviderfrom .request import build_request_body+NVIDIA_NIM_BASE_URL = "https://integrate.api.nvidia.com/v1"+class NvidiaNimProvider(OpenAICompatibleProvider):"""NVIDIA NIM provider using official OpenAI client."""@@ -16,7 +18,7 @@ class NvidiaNimProvider(OpenAICompatibleProvider):super().__init__(config,provider_name="NIM",- base_url=config.base_url or "https://integrate.api.nvidia.com/v1",+ base_url=config.base_url or NVIDIA_NIM_BASE_URL,api_key=config.api_key,nim_settings=nim_settings,)diff --git a/providers/openai_compat.py b/providers/openai_compat.pyindex 05ec4c97..60e4d0c6 100644--- a/providers/openai_compat.py+++ b/providers/openai_compat.py@@ -60,13 +60,8 @@ class OpenAICompatibleProvider(BaseProvider):async def cleanup(self) -> None:"""Release HTTP client resources."""client = getattr(self, "_client", None)- if client and hasattr(client, "aclose"):+ if client is not None:await client.aclose()- elif client:- logger.warning(- "Provider client %r has no aclose(); skipping async cleanup",- type(client).__name__,- )@abstractmethoddef _build_request_body(self, request: Any) -> dict:@@ -80,36 +75,30 @@ class OpenAICompatibleProvider(BaseProvider):"""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)+ tc_index = len(sse.blocks.tool_states)fn_delta = tc.get("function", {})incoming_name = fn_delta.get("name")if incoming_name is not None: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, "")+ state = sse.blocks.tool_states.get(tc_index)+ if state is None or not state.started:+ name = state.name if state else ""if name or tc.get("id"):tool_id = tc.get("id") or f"tool_{uuid.uuid4()}"yield sse.start_tool_block(tc_index, tool_id, name)- sse.blocks.tool_started[tc_index] = True- elif not sse.blocks.tool_started.get(tc_index) and sse.blocks.tool_names.get(- tc_index- ):- tool_id = tc.get("id") or f"tool_{uuid.uuid4()}"- name = sse.blocks.tool_names[tc_index]- yield sse.start_tool_block(tc_index, tool_id, name)- sse.blocks.tool_started[tc_index] = Trueargs = fn_delta.get("arguments", "")if args:- if not sse.blocks.tool_started.get(tc_index):+ state = sse.blocks.tool_states.get(tc_index)+ if state is None or not state.started:tool_id = tc.get("id") or f"tool_{uuid.uuid4()}"- name = sse.blocks.tool_names.get(tc_index, "tool_call") or "tool_call"+ name = (state.name if state else None) or "tool_call"yield sse.start_tool_block(tc_index, tool_id, name)- sse.blocks.tool_started[tc_index] = True+ state = sse.blocks.tool_states.get(tc_index)- current_name = sse.blocks.tool_names.get(tc_index, "")+ current_name = state.name if state else ""if current_name == "Task":parsed = sse.blocks.buffer_task_args(tc_index, args)if parsed is not None:@@ -257,7 +246,6 @@ class OpenAICompatibleProvider(BaseProvider):yield eventexcept Exception as e:- req_tag = f" request_id={request_id}" if request_id else ""logger.error("%s_ERROR:%s %s: %s", tag, req_tag, type(e).__name__, e)mapped_e = map_error(e)error_occurred = True@@ -310,7 +298,7 @@ class OpenAICompatibleProvider(BaseProvider):if (not error_occurredand sse.blocks.text_index == -1- and not sse.blocks.tool_indices+ and not sse.blocks.tool_states):for event in sse.ensure_text_block():yield eventdiff --git a/tests/config/test_config.py b/tests/config/test_config.pyindex 2d533eba..397e996d 100644--- a/tests/config/test_config.py+++ b/tests/config/test_config.py@@ -52,7 +52,7 @@ class TestSettings:def test_base_url_constant(self):"""Test NVIDIA_NIM_BASE_URL is a constant."""- from config.settings import NVIDIA_NIM_BASE_URL+ from providers.nvidia_nim import NVIDIA_NIM_BASE_URLassert NVIDIA_NIM_BASE_URL == "https://integrate.api.nvidia.com/v1"diff --git a/tests/messaging/test_tree_processor.py b/tests/messaging/test_tree_processor.pyindex 0c0ff62d..e6a3a037 100644--- a/tests/messaging/test_tree_processor.py+++ b/tests/messaging/test_tree_processor.py@@ -104,7 +104,7 @@ async def test_enqueue_and_start_when_busy(tree_processor, sample_tree):assert was_queued is Trueassert sample_tree._queue.qsize() == 1- assert await sample_tree._queue.get() == node_id+ assert sample_tree._queue.get_nowait() == node_iddef test_cancel_current_task(tree_processor, sample_tree):diff --git a/tests/providers/test_sse_builder.py b/tests/providers/test_sse_builder.pyindex 03c19d28..7bdb37fb 100644--- a/tests/providers/test_sse_builder.py+++ b/tests/providers/test_sse_builder.py@@ -63,7 +63,7 @@ class TestContentBlockManager:assert mgr.text_index == -1assert mgr.thinking_started is Falseassert mgr.text_started is False- assert mgr.tool_indices == {}+ assert mgr.tool_states == {}class TestSSEBuilderMessageLifecycle:@@ -230,7 +230,7 @@ class TestSSEBuilderHighLevelHelpers:assert data["content_block"]["type"] == "tool_use"assert data["content_block"]["id"] == "tool_abc"assert data["content_block"]["name"] == "Grep"- assert 0 in builder.blocks.tool_indices+ assert 0 in builder.blocks.tool_statesdef test_emit_tool_delta(self):builder = SSEBuilder("msg_1", "model")@@ -239,7 +239,7 @@ class TestSSEBuilderHighLevelHelpers:sse = builder.emit_tool_delta(0, '{"pattern":')data = _parse_sse(sse)assert data["delta"]["partial_json"] == '{"pattern":'- assert "".join(builder.blocks.tool_contents[0]) == '{"pattern":'+ assert "".join(builder.blocks.tool_states[0].contents) == '{"pattern":'def test_stop_tool_block(self):builder = SSEBuilder("msg_1", "model")