unique_toolkit 2026.32.0__tar.gz → 2026.32.0.dev1__tar.gz

{unique_toolkit-2026.32.0 → unique_toolkit-2026.32.0.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: unique-toolkit
-Version: 2026.32.0
+Version: 2026.32.0.dev1
 Summary: 
 Author: Cedric Klinkert, Martin Fadler, Sadique Sheik, Fabian Schläpfer, Pascal Hauri, Ejiroghene Oki-Peter, Rami Azouz, Ricardo Visini, Sanzio Monti
 Author-email: Cedric Klinkert <cedric.klinkert@unique.ch>, Martin Fadler <martin.fadler@unique.ch>, Sadique Sheik <sadique@unique.ch>, Fabian Schläpfer <fabian@unique.ch>, Pascal Hauri <pascal@unique.ch>, Ejiroghene Oki-Peter <oki-peter.ejiroghene@unique.ai>, Rami Azouz <rami.ext@unique.ch>, Ricardo Visini <ricardo.visini@unique.ch>, Sanzio Monti <sanzio.monti@unique.ai>
@@ -16,7 +16,7 @@ Requires-Dist: sseclient>=0.0.27,<0.0.28
 Requires-Dist: openai>=1.105.0,<3
 Requires-Dist: platformdirs>=4.0.0,<5
 Requires-Dist: pillow>=12.1.1
-Requires-Dist: unique-sdk>=2026.32.0
+Requires-Dist: unique-sdk>=2026.32.0.dev1,<2026.32.0rc0
 Requires-Dist: jambo>=0.1.2,<0.2
 Requires-Dist: jinja2>=3.1.6,<4
 Requires-Dist: docxtpl>=0.20.1,<0.21
@@ -33,9 +33,8 @@ Requires-Dist: tenacity>=9.1.4
 Requires-Dist: pydantic-core>=2.41.5
 Requires-Dist: cachetools>=5.0,<6
 Requires-Dist: rapidfuzz>=3.0,<4
-Requires-Dist: pyyaml>=6.0.3
-Requires-Dist: fastapi>=0.133.0,<1.0.0 ; extra == 'fastapi'
-Requires-Dist: starlette>=1.3.1,<2.0.0 ; extra == 'fastapi'
+Requires-Dist: fastapi>=0.121.0,<0.122 ; extra == 'fastapi'
+Requires-Dist: starlette>=0.49.1 ; extra == 'fastapi'
 Requires-Dist: uvicorn>=0.37.0,<0.38 ; extra == 'fastapi'
 Requires-Dist: openai>=1.105.0,<3 ; extra == 'langchain'
 Requires-Dist: langchain>=1.0.0,<2 ; extra == 'langchain'

{unique_toolkit-2026.32.0 → unique_toolkit-2026.32.0.dev1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "unique_toolkit"
-version = "2026.32.0"
+version = "2026.32.0.dev1"
 description = ""
 readme = "README.md"
 requires-python = ">=3.12"
@@ -28,7 +28,7 @@ dependencies = [
     "openai>=1.105.0,<3",
     "platformdirs>=4.0.0,<5",
     "pillow>=12.1.1",
-    "unique-sdk>=2026.32.0",
+    "unique-sdk>=2026.32.0.dev1,<2026.32.0rc0",
     "jambo>=0.1.2,<0.2",
     "jinja2>=3.1.6,<4",
     "docxtpl>=0.20.1,<0.21",
@@ -45,7 +45,6 @@ dependencies = [
     "pydantic-core>=2.41.5",
     "cachetools>=5.0,<6",
     "rapidfuzz>=3.0,<4",
-    "pyyaml>=6.0.3",
 ]
 
 [project.optional-dependencies]
@@ -56,8 +55,8 @@ langchain = [
     "langchain-core>=1.0.0,<2",
 ]
 fastapi = [
-    "fastapi>=0.133.0,<1.0.0",
-    "starlette>=1.3.1,<2.0.0",
+    "fastapi>=0.121.0,<0.122",
+    "starlette>=0.49.1",
     "uvicorn>=0.37.0,<0.38",
 ]
 monitoring = [
@@ -78,6 +77,7 @@ dev = [
 [tool.uv]
 exclude-newer = "2 weeks"
 constraint-dependencies = [
+    "starlette>=0.49.1",
     "lxml>=6.1.0",
 ]
 

{unique_toolkit-2026.32.0 → unique_toolkit-2026.32.0.dev1}/unique_toolkit/agentic/debug_info_manager/debug_info_manager.py

@@ -1,4 +1,3 @@
-from collections import defaultdict
 from typing import Any, Required, TypedDict
 
 from unique_toolkit.agentic.tools.openai_builtin import OpenAICodeInterpreterTool
@@ -8,10 +7,8 @@ from unique_toolkit.agentic.tools.openai_builtin.code_interpreter.postprocessors
 )
 from unique_toolkit.agentic.tools.schemas import ToolCallResponse
 from unique_toolkit.agentic.tools.tool_manager import ToolManager
-from unique_toolkit.language_model.invocation_stats import LanguageModelInvocationStats
 from unique_toolkit.language_model.schemas import (
     LanguageModelStreamResponse,
-    LanguageModelTokenUsage,
     ResponsesLanguageModelStreamResponse,
 )
 
@@ -43,29 +40,11 @@ class AnalyticsToolName(TypedDict):
     display_name: str
 
 
-class AnalyticsConsumption(TypedDict):
-    completion_tokens: int | None
-    prompt_tokens: int | None
-    total_tokens: int | None
-    reasoning_tokens: int | None
-    cached_tokens: int | None
-    cache_write_tokens: int | None
-    cost_usd: float | None
-
-
-class AnalyticsConsumptionByLlm(AnalyticsConsumption):
-    model_name: str
-
-
 class Analytics(TypedDict):
     answer_length: int
     artifacts_created_count: int | None
     artifacts_created_filetype: list[str] | None
     context_memory_updated: bool | None
-    # Sum of all model usages this turn. None when no invocations reported usage.
-    consumption: AnalyticsConsumption | None
-    # Per-model usage totals, sorted by model_name.
-    consumption_by_llm: list[AnalyticsConsumptionByLlm]
     language_model: AnalyticsLanguageModel
     loop_iteration_count: int
     mcp_tool_names_used: list[AnalyticsToolName]
@@ -136,7 +115,6 @@ class DebugInfoManager:
         total_time_to_answer_ms: int | None = None,
         artifacts: ArtifactsDebugInfo | None = None,
         context_memory_updated: bool | None = None,
-        invocations: list[LanguageModelInvocationStats] | None = None,
     ) -> None:
         """Add a stable 'analytics' snapshot for downstream ROI/usage reporting.
 
@@ -156,7 +134,6 @@ class DebugInfoManager:
         # DisplayCodeInterpreterFilesPostProcessor) into debug_info["artifacts"].
         # Absent when no Code Interpreter ran this turn → artifact fields stay
         # None, preserving the always-present, null-when-unknown contract.
-        consumption_by_llm = _aggregate_consumption_by_llm(invocations or [])
         analytics = Analytics(
             tools_used=analytics_tools,
             tool_call_count=len(analytics_tools),
@@ -175,8 +152,6 @@ class DebugInfoManager:
             loop_iteration_count=loop_iteration_count,
             subagent_names_used=_unique_tool_names(analytics_tools, "is_sub_agent"),
             mcp_tool_names_used=_unique_tool_names(analytics_tools, "is_mcp"),
-            consumption_by_llm=consumption_by_llm,
-            consumption=_aggregate_consumption(invocations or []),
             total_time_to_answer_ms=total_time_to_answer_ms,
             artifacts_created_count=artifacts["count"] if artifacts else None,
             artifacts_created_filetype=artifacts["filetypes"] if artifacts else None,
@@ -188,71 +163,6 @@ class DebugInfoManager:
         self.add("analytics", analytics)
 
 
-def _sum_invocation_costs(
-    invocations: list[LanguageModelInvocationStats],
-) -> float | None:
-    """Sum costs only when every invocation has a known cost; else None."""
-    costs = [invocation.cost_usd for invocation in invocations]
-    if not costs or any(cost is None for cost in costs):
-        return None
-    return sum(cost for cost in costs if cost is not None)
-
-
-def _to_analytics_consumption(
-    usage: LanguageModelTokenUsage,
-    cost_usd: float | None,
-) -> AnalyticsConsumption:
-    return AnalyticsConsumption(
-        completion_tokens=usage.completion_tokens,
-        prompt_tokens=usage.prompt_tokens,
-        total_tokens=usage.total_tokens,
-        reasoning_tokens=usage.reasoning_tokens,
-        cached_tokens=usage.cached_tokens,
-        cache_write_tokens=usage.cache_write_tokens,
-        cost_usd=cost_usd,
-    )
-
-
-def _aggregate_consumption(
-    invocations: list[LanguageModelInvocationStats],
-) -> AnalyticsConsumption | None:
-    """Aggregate token usage and cost across all models for this turn."""
-    usage = LanguageModelTokenUsage.sum_usages(
-        invocation.token_usage for invocation in invocations
-    )
-    if usage is None:
-        return None
-    return _to_analytics_consumption(usage, _sum_invocation_costs(invocations))
-
-
-def _aggregate_consumption_by_llm(
-    invocations: list[LanguageModelInvocationStats],
-) -> list[AnalyticsConsumptionByLlm]:
-    invocations_by_model: dict[str, list[LanguageModelInvocationStats]] = defaultdict(
-        list
-    )
-    for invocation in invocations:
-        invocations_by_model[str(invocation.model_name)].append(invocation)
-
-    totals: list[AnalyticsConsumptionByLlm] = []
-    for model_name in sorted(invocations_by_model):
-        model_invocations = invocations_by_model[model_name]
-        usage = LanguageModelTokenUsage.sum_usages(
-            invocation.token_usage for invocation in model_invocations
-        )
-        if usage is None:
-            continue
-        totals.append(
-            AnalyticsConsumptionByLlm(
-                model_name=model_name,
-                **_to_analytics_consumption(
-                    usage, _sum_invocation_costs(model_invocations)
-                ),
-            )
-        )
-    return totals
-
-
 def _unique_tool_names(
     analytics_tools: list[AnalyticsTool], flag: str
 ) -> list[AnalyticsToolName]:

{unique_toolkit-2026.32.0 → unique_toolkit-2026.32.0.dev1}/unique_toolkit/agentic/postprocessor/postprocessor_manager.py

@@ -41,17 +41,6 @@ class Postprocessor(ABC):
         """Override in subclasses whose `run()` makes its own LLM call(s)."""
         return []
 
-    def take_pending_invocation_stats(self) -> list[LanguageModelInvocationStats]:
-        """Pop usage incurred before this turn's `run()` was reached.
-
-        Called unconditionally at the start of every turn so usage from work
-        done ahead of postprocessing (e.g. a load-time LLM call) is still
-        reported on turns that exit before `run()` executes. Override in
-        subclasses that do such work; must clear the pending stats so `run()`
-        does not report them a second time.
-        """
-        return []
-
 
 class ResponsesApiPostprocessor(ABC):
     def __init__(self, name: str):
@@ -85,13 +74,6 @@ class ResponsesApiPostprocessor(ABC):
         """
         return []
 
-    def take_pending_invocation_stats(self) -> list[LanguageModelInvocationStats]:
-        """Pop usage incurred before this turn's `run()` was reached.
-
-        See `Postprocessor.take_pending_invocation_stats` for why this exists.
-        """
-        return []
-
 
 class PostprocessorManager:
     """
@@ -214,19 +196,6 @@ class PostprocessorManager:
         """Per-LLM-call stats from every postprocessor that made its own LLM call(s)."""
         return list(self._invocation_stats)
 
-    def take_pending_invocation_stats(self) -> list[LanguageModelInvocationStats]:
-        """Pop pre-`run()` usage (e.g. load-time calls) from every postprocessor.
-
-        Call this unconditionally at the start of a turn, before it's known
-        whether `run_postprocessors` will even be reached this turn, so that
-        usage is never silently dropped on turns that exit early.
-        """
-        return [
-            invocation
-            for postprocessor in self._get_all_postprocessors()
-            for invocation in postprocessor.take_pending_invocation_stats()
-        ]
-
     async def execute_postprocessors(
         self,
         loop_response: LanguageModelStreamResponse,

{unique_toolkit-2026.32.0 → unique_toolkit-2026.32.0.dev1}/unique_toolkit/agentic/tools/a2a/tool/service.py

@@ -4,15 +4,12 @@ import json
 import logging
 import re
 from datetime import datetime
-from typing import Any, override
+from typing import override
 
 import unique_sdk
 from pydantic import Field, TypeAdapter, create_model
 from unique_sdk.api_resources._space import Space
-from unique_sdk.utils.chat_in_space import (
-    get_message_invocations,
-    send_message_and_wait_for_completion,
-)
+from unique_sdk.utils.chat_in_space import send_message_and_wait_for_completion
 
 from unique_toolkit._common.execution import SafeTaskExecutor
 from unique_toolkit._common.referencing import (
@@ -58,7 +55,6 @@ from unique_toolkit.language_model import (
     LanguageModelService,
     LanguageModelToolDescription,
 )
-from unique_toolkit.language_model.invocation_stats import LanguageModelInvocationStats
 
 logger = logging.getLogger(__name__)
 
@@ -300,13 +296,6 @@ class SubAgentTool(Tool[SubAgentToolConfig]):
                 if self.config.passthrough_config.enabled:
                     await self._display_sub_agent_response(response)
 
-                sub_agent_invocations = _prefix_sub_agent_invocation_sources(
-                    invocations=_parse_sub_agent_invocation_stats(
-                        get_message_invocations(response)
-                    ),
-                    tool_name=self.name,
-                    tool_call_id=tool_call.id,
-                )
                 return ToolCallResponse(
                     id=tool_call.id,
                     name=tool_call.name,
@@ -318,12 +307,9 @@ class SubAgentTool(Tool[SubAgentToolConfig]):
                     content_chunks=content_chunks,
                     debug_info={
                         "chat_id": response["chatId"],
-                        "user_message_id": response.get("triggeringUserMessageId"),
-                        "assistant_message_id": response.get("id"),
                         "assistant_id": self.config.assistant_id,
                         "display_name": self._display_name,
                     },
-                    invocation_stats=sub_agent_invocations,
                 )
         except TimeoutError as e:
             raise e
@@ -509,7 +495,6 @@ class SubAgentTool(Tool[SubAgentToolConfig]):
                     parentAssistantId=self.config.assistant_id,
                 ),
                 on_message_update=on_message_update,
-                wait_for_invocations=True,
             )
         except TimeoutError as e:
             await self._notify_progress(
@@ -528,42 +513,6 @@ class SubAgentTool(Tool[SubAgentToolConfig]):
             ) from e
 
 
-def _parse_sub_agent_invocation_stats(
-    raw_invocations: list[dict[str, Any]],
-) -> list[LanguageModelInvocationStats]:
-    """Deserialize sub-agent invocation stats, ignoring malformed entries.
-
-    A single unparseable entry (e.g. a stale model name) must not fail the
-    whole tool call and drop an otherwise-successful sub-agent reply -- see
-    `_load_invocation_stats_from_debug_info` in unique_orchestrator, which
-    applies the same per-entry tolerance for the same reason.
-    """
-    invocations: list[LanguageModelInvocationStats] = []
-    for raw_invocation in raw_invocations:
-        try:
-            invocations.append(
-                LanguageModelInvocationStats.model_validate(raw_invocation)
-            )
-        except Exception:
-            logger.warning(
-                "Ignoring malformed sub-agent LLM invocation stats",
-                exc_info=True,
-            )
-    return invocations
-
-
-def _prefix_sub_agent_invocation_sources(
-    invocations: list[LanguageModelInvocationStats],
-    tool_name: str,
-    tool_call_id: str,
-) -> list[LanguageModelInvocationStats]:
-    prefix = f"subagent.{tool_name}.{tool_call_id}"
-    return [
-        invocation.model_copy(update={"source": f"{prefix}.{invocation.source}"})
-        for invocation in invocations
-    ]
-
-
 def _format_response(tool_name: str, text: str, system_reminders: list[str]) -> str:
     if len(system_reminders) == 0:
         return text

{unique_toolkit-2026.32.0 → unique_toolkit-2026.32.0.dev1}/unique_toolkit/agentic/tools/a2a/tool/test/test_service_utils.py

@@ -17,7 +17,6 @@ from unique_toolkit.agentic.tools.a2a.tool.config import (
 from unique_toolkit.agentic.tools.a2a.tool.service import (
     _format_response,
     _get_sub_agent_system_reminders,
-    _parse_sub_agent_invocation_stats,
     _prepare_sub_agent_response_refs,
     _remove_extra_refs,
     _response_has_refs,
@@ -60,78 +59,6 @@ def refs_list() -> list[dict[str, Any]]:
     ]
 
 
-# Tests for _parse_sub_agent_invocation_stats
-
-
-@pytest.mark.ai
-def test_parse_sub_agent_invocation_stats__skips_malformed_entry__keeps_valid_ones() -> (
-    None
-):
-    """
-    Purpose: Verify one malformed invocation entry doesn't discard the rest.
-    Why this matters: A single bad entry must not fail the whole sub-agent tool
-        call and drop an otherwise-successful reply.
-    Setup summary: Mix a valid entry with a malformed one (missing required
-        fields), verify only the valid entry survives.
-    """
-    # Arrange
-    raw_invocations = [
-        {
-            "modelName": "gpt-4",
-            "tokenUsage": {"totalTokens": 10},
-            "source": "main_loop",
-        },
-        {"modelName": "gpt-4"},  # missing required tokenUsage/source
-    ]
-
-    # Act
-    result = _parse_sub_agent_invocation_stats(raw_invocations)
-
-    # Assert
-    assert len(result) == 1
-    assert result[0].source == "main_loop"
-
-
-@pytest.mark.ai
-def test_parse_sub_agent_invocation_stats__returns_empty__when_all_malformed() -> None:
-    """
-    Purpose: Verify an all-malformed list returns empty instead of raising.
-    Why this matters: The sub-agent tool call must still succeed and return the
-        answer even if every persisted stats entry is unparseable.
-    Setup summary: Only malformed entries, assert empty list with no exception.
-    """
-    # Arrange
-    raw_invocations = [{"modelName": "gpt-4"}, {"source": "main_loop"}]
-
-    # Act
-    result = _parse_sub_agent_invocation_stats(raw_invocations)
-
-    # Assert
-    assert result == []
-
-
-@pytest.mark.ai
-def test_parse_sub_agent_invocation_stats__parses_all__when_all_valid() -> None:
-    """
-    Purpose: Verify parsing is unaffected by the malformed-entry tolerance
-        when every entry is well-formed.
-    Why this matters: The fix must not silently drop good data too.
-    Setup summary: Two valid entries, assert both are returned.
-    """
-    # Arrange
-    raw_invocations = [
-        {"modelName": "gpt-4", "tokenUsage": {"totalTokens": 3}, "source": "a"},
-        {"modelName": "gpt-4", "tokenUsage": {"totalTokens": 5}, "source": "b"},
-    ]
-
-    # Act
-    result = _parse_sub_agent_invocation_stats(raw_invocations)
-
-    # Assert
-    assert len(result) == 2
-    assert [inv.source for inv in result] == ["a", "b"]
-
-
 # Tests for _format_response
 
 

{unique_toolkit-2026.32.0 → unique_toolkit-2026.32.0.dev1}/unique_toolkit/agentic_table/service.py

@@ -648,33 +648,6 @@ class AgenticTableService:
                 result.get("message") or "Failed to trigger artifact generation"
             )
 
-    async def rerun_row(self, row_order: int) -> None:
-        """Re-run the agent for a single row (`POST .../row/{rowOrder}/rerun`).
-
-        The only way to re-answer part of a sheet: ``import_questions_and_sources``
-        is delta-based and will not re-answer a row that already exists.
-
-        Asynchronous, like the whole-sheet run: this triggers it and returns.
-        Follow with ``wait_for_run`` to block until the sheet leaves PROCESSING.
-
-        Args:
-            row_order: Row position in the sheet's own numbering, where row 0 is
-                the header — so answerable rows start at 1, and row 0 is
-                rejected. Same numbering as ``get_cell``.
-
-        Raises:
-            Exception: If the API reports a non-success status, which includes a
-                locked or final row and a sheet that is already PROCESSING.
-        """
-        result = await AgenticTable.rerun_row(
-            user_id=self._user_id,
-            company_id=self._company_id,
-            tableId=self.table_id,
-            rowOrder=row_order,
-        )
-        if not result.get("status"):
-            raise Exception(result.get("message") or "Failed to trigger row rerun")
-
     async def list_artifacts(self) -> list[MagicTableArtifact]:
         """List export artifacts of the sheet (`GET .../artifacts`)."""
         artifacts = await AgenticTable.list_artifacts(

{unique_toolkit-2026.32.0 → unique_toolkit-2026.32.0.dev1}/unique_toolkit/chat/schemas.py

@@ -217,13 +217,7 @@ class MessageLogUncitedReferences(BaseModel):
 class MessageLogEvent(BaseModel):
     model_config = model_config
     type: Literal[
-        "WebSearch",
-        "InternalSearch",
-        "Elicitation",
-        "Thinking",
-        "ToolCall",
-        "Todo",
-        "UserMemory",
+        "WebSearch", "InternalSearch", "Elicitation", "Thinking", "ToolCall", "Todo"
     ]
     text: str
     step_type: str | None = None

{unique_toolkit-2026.32.0 → unique_toolkit-2026.32.0.dev1}/unique_toolkit/experimental/components/content_tree/functions.py

@@ -107,8 +107,9 @@ async def translate_scope_id_async(
 ) -> str | None:
     """Resolve a single ``scope_id`` to a folder name.
 
-    Returns ``None`` if the folder lookup fails (logged at debug; callers fall back
-    to the raw ``scope_id``), so batch resolution is not aborted by a single miss.
+    Returns ``None`` (and logs a warning) if the folder lookup fails, so callers
+    can batch-resolve ids without a single missing folder aborting the whole
+    operation.
     """
     try:
         folder_info = await get_folder_info_async(
@@ -118,7 +119,7 @@ async def translate_scope_id_async(
         )
         return folder_info.name
     except Exception as e:
-        _LOGGER.debug("Could not resolve folder for scope_id %s", scope_id, exc_info=e)
+        _LOGGER.warning(f"Could not resolve folder for scope_id {scope_id}", exc_info=e)
         return None
 
 

{unique_toolkit-2026.32.0 → unique_toolkit-2026.32.0.dev1}/unique_toolkit/language_model/infos.py

@@ -93,7 +93,6 @@ class LanguageModelName(StrEnum):
     ANTHROPIC_CLAUDE_OPUS_4_6 = "litellm:anthropic-claude-opus-4-6"
     ANTHROPIC_CLAUDE_OPUS_4_7 = "litellm:anthropic-claude-opus-4-7"
     ANTHROPIC_CLAUDE_OPUS_4_8 = "litellm:anthropic-claude-opus-4-8"
-    ANTHROPIC_CLAUDE_OPUS_5 = "litellm:anthropic-claude-opus-5"
     ANTHROPIC_CLAUDE_FABLE_5 = "litellm:anthropic-claude-fable-5"
     GEMINI_2_0_FLASH = "litellm:gemini-2-0-flash"
     GEMINI_2_5_FLASH = "litellm:gemini-2-5-flash"
@@ -138,7 +137,6 @@ class LanguageModelName(StrEnum):
     LITELLM_GLM_5_1 = "litellm:glm-5.1"
     LITELLM_GLM_5_2 = "litellm:glm-5.2"
     LITELLM_KIMI_K2_6 = "litellm:kimi-k2.6"
-    LITELLM_KIMI_K3 = "litellm:kimi-k3"
     LITELLM_QWEN_3 = "litellm:qwen-3-235B-A22B"
     LITELLM_QWEN_3_THINKING = "litellm:qwen-3-235B-A22B-thinking"
     VERTEX_CLAUDE_SONNET_4_6 = "litellm:vertex-claude-sonnet-4-6"
@@ -146,7 +144,6 @@ class LanguageModelName(StrEnum):
     VERTEX_CLAUDE_OPUS_4_6 = "litellm:vertex-claude-opus-4-6"
     VERTEX_CLAUDE_OPUS_4_7 = "litellm:vertex-claude-opus-4-7"
     VERTEX_CLAUDE_OPUS_4_8 = "litellm:vertex-claude-opus-4-8"
-    VERTEX_CLAUDE_OPUS_5 = "litellm:vertex-claude-opus-5"
     VERTEX_CLAUDE_FABLE_5 = "litellm:vertex-claude-fable-5"
 
 
@@ -1815,30 +1812,6 @@ class LanguageModelInfo(BaseModel):
                     published_at=date(2026, 5, 28),
                     supported_reasoning_efforts=[],
                 )
-            case (
-                LanguageModelName.ANTHROPIC_CLAUDE_OPUS_5
-                | LanguageModelName.VERTEX_CLAUDE_OPUS_5
-            ):
-                return cls(
-                    name=model_name,
-                    capabilities=[
-                        ModelCapabilities.FUNCTION_CALLING,
-                        ModelCapabilities.STREAMING,
-                        ModelCapabilities.VISION,
-                        ModelCapabilities.REASONING,
-                    ],
-                    provider=LanguageModelProvider.LITELLM,
-                    family=ModelFamily.ANTHROPIC,
-                    version="claude-opus-5",
-                    encoder_name=EncoderName.O200K_BASE,  # TODO: Update encoder with litellm
-                    token_limits=LanguageModelTokenLimits(
-                        token_limit_input=1_000_000,
-                        token_limit_output=128_000,
-                    ),
-                    info_cutoff_at=date(2026, 5, 1),
-                    published_at=date(2026, 7, 24),
-                    supported_reasoning_efforts=[],
-                )
             case (
                 LanguageModelName.ANTHROPIC_CLAUDE_FABLE_5
                 | LanguageModelName.VERTEX_CLAUDE_FABLE_5
@@ -2881,27 +2854,6 @@ class LanguageModelInfo(BaseModel):
                     published_at=date(2026, 1, 1),
                     supported_reasoning_efforts=[],
                 )
-            case LanguageModelName.LITELLM_KIMI_K3:
-                return cls(
-                    name=model_name,
-                    provider=LanguageModelProvider.LITELLM,
-                    family=ModelFamily.KIMI,
-                    version="kimi-k3",
-                    encoder_name=EncoderName.O200K_BASE,
-                    capabilities=[
-                        ModelCapabilities.FUNCTION_CALLING,
-                        ModelCapabilities.STRUCTURED_OUTPUT,
-                        ModelCapabilities.REASONING,
-                        ModelCapabilities.STREAMING,
-                        ModelCapabilities.VISION,
-                    ],
-                    token_limits=LanguageModelTokenLimits(
-                        token_limit_input=1_000_000,
-                        token_limit_output=128_000,
-                    ),
-                    published_at=date(2026, 7, 27),
-                    supported_reasoning_efforts=[],
-                )
             case LanguageModelName.LITELLM_QWEN_3:
                 return cls(
                     name=model_name,

{unique_toolkit-2026.32.0 → unique_toolkit-2026.32.0.dev1}/unique_toolkit/language_model/invocation_stats.py

@@ -11,7 +11,6 @@ from humps import camelize
 from pydantic import BaseModel, BeforeValidator, ConfigDict
 
 from unique_toolkit.language_model.infos import LanguageModelName
-from unique_toolkit.language_model.model_costs import calculate_invocation_cost_usd
 from unique_toolkit.language_model.schemas import LanguageModelTokenUsage
 
 # `protected_namespaces=()` allows the `model_name` field name.
@@ -60,7 +59,6 @@ class LanguageModelInvocationStats(BaseModel):
     model_name: ModelName
     token_usage: LanguageModelTokenUsage
     source: Source  # e.g. "main_loop", tool/evaluation/postprocessor name
-    cost_usd: float | None = None
 
     @classmethod
     def from_usage(
@@ -69,9 +67,4 @@ class LanguageModelInvocationStats(BaseModel):
         token_usage: LanguageModelTokenUsage,
         source: str,
     ) -> Self:
-        return cls(
-            model_name=model_name,
-            token_usage=token_usage,
-            source=source,
-            cost_usd=calculate_invocation_cost_usd(str(model_name), token_usage),
-        )
+        return cls(model_name=model_name, token_usage=token_usage, source=source)