Skip to content

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.py
index 568d6ae7..084dd8b4 100644
--- a/api/dependencies.py
+++ b/api/dependencies.py
@@ -3,12 +3,12 @@
from fastapi import HTTPException
from loguru import logger
-from config.settings import NVIDIA_NIM_BASE_URL, Settings
+from config.settings import Settings
from config.settings import get_settings as _get_settings
from providers.base import BaseProvider, ProviderConfig
from providers.exceptions import AuthenticationError
from providers.lmstudio import LMStudioProvider
-from providers.nvidia_nim import NvidiaNimProvider
+from providers.nvidia_nim import NVIDIA_NIM_BASE_URL, NvidiaNimProvider
from providers.open_router import OpenRouterProvider
from providers.open_router.client import OPENROUTER_BASE_URL
diff --git a/api/routes.py b/api/routes.py
index 1471f1e6..945f77c5 100644
--- a/api/routes.py
+++ b/api/routes.py
@@ -1,6 +1,7 @@
"""FastAPI route handlers."""
import json
+import traceback
import uuid
from fastapi import APIRouter, Depends, HTTPException, Request
@@ -66,8 +67,6 @@ async def create_message(
except ProviderError:
raise
except 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.py
index d77d2081..88e72b32 100644
--- a/config/settings.py
+++ b/config/settings.py
@@ -10,9 +10,6 @@ from .nim import NimSettings
load_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.py
index 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 3900
def _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_val
def _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_val
def _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_chars
async 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.py
index f587d73c..e2cd2bd8 100644
--- a/messaging/trees/data.py
+++ b/messaging/trees/data.py
@@ -16,27 +16,37 @@ from loguru import logger
from ..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 = None
context: 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.py
index 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 += 1
tree.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 += 1
if 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 manager
diff --git a/messaging/trees/repository.py b/messaging/trees/repository.py
index 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.py
index 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 starts
if "<parameter=" not in self._buffer:
diff --git a/providers/common/sse_builder.py b/providers/common/sse_builder.py
index 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
+
+
@dataclass
class ContentBlockManager:
"""Manages content block indices and state."""
@@ -40,14 +53,7 @@ class ContentBlockManager:
text_index: int = -1
thinking_started: bool = False
text_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 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
+ 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 + name
def 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 forms
valid 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 += args
try:
- args_json = json.loads(buf)
+ args_json = json.loads(state.task_arg_buffer)
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)
+ state.task_args_emitted = True
+ state.task_arg_buffer = ""
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)
+ for tool_index, state in list(self.tool_states.items()):
+ if not state.task_arg_buffer or state.task_args_emitted:
continue
out = "{}"
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"] = False
out = 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_index
return 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 handling
def 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 contents
tool_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) // 4
reasoning_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) * 50
return text_tokens + reasoning_tokens + tool_tokens
diff --git a/providers/nvidia_nim/__init__.py b/providers/nvidia_nim/__init__.py
index 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.py
index 714c438a..482a8539 100644
--- a/providers/nvidia_nim/client.py
+++ b/providers/nvidia_nim/client.py
@@ -8,6 +8,8 @@ from providers.openai_compat import OpenAICompatibleProvider
from .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.py
index 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__,
- )
@abstractmethod
def _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] = True
args = 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 event
except 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_occurred
and 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 event
diff --git a/tests/config/test_config.py b/tests/config/test_config.py
index 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_URL
assert 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.py
index 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 True
assert sample_tree._queue.qsize() == 1
- assert await sample_tree._queue.get() == node_id
+ assert sample_tree._queue.get_nowait() == node_id
def test_cancel_current_task(tree_processor, sample_tree):
diff --git a/tests/providers/test_sse_builder.py b/tests/providers/test_sse_builder.py
index 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 == -1
assert mgr.thinking_started is False
assert 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_states
def 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")