unique_toolkit 2026.30.0.dev24__tar.gz → 2026.32.0__tar.gz

{unique_toolkit-2026.30.0.dev24 → unique_toolkit-2026.32.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: unique-toolkit
-Version: 2026.30.0.dev24
+Version: 2026.32.0
 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.30.0.dev10,<2026.30.0rc0
+Requires-Dist: unique-sdk>=2026.32.0
 Requires-Dist: jambo>=0.1.2,<0.2
 Requires-Dist: jinja2>=3.1.6,<4
 Requires-Dist: docxtpl>=0.20.1,<0.21
@@ -33,8 +33,9 @@ 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: fastapi>=0.121.0,<0.122 ; extra == 'fastapi'
-Requires-Dist: starlette>=0.49.1 ; extra == 'fastapi'
+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: 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.30.0.dev24 → unique_toolkit-2026.32.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "unique_toolkit"
-version = "2026.30.0.dev24"
+version = "2026.32.0"
 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.30.0.dev10,<2026.30.0rc0",
+    "unique-sdk>=2026.32.0",
     "jambo>=0.1.2,<0.2",
     "jinja2>=3.1.6,<4",
     "docxtpl>=0.20.1,<0.21",
@@ -45,6 +45,7 @@ dependencies = [
     "pydantic-core>=2.41.5",
     "cachetools>=5.0,<6",
     "rapidfuzz>=3.0,<4",
+    "pyyaml>=6.0.3",
 ]
 
 [project.optional-dependencies]
@@ -55,8 +56,8 @@ langchain = [
     "langchain-core>=1.0.0,<2",
 ]
 fastapi = [
-    "fastapi>=0.121.0,<0.122",
-    "starlette>=0.49.1",
+    "fastapi>=0.133.0,<1.0.0",
+    "starlette>=1.3.1,<2.0.0",
     "uvicorn>=0.37.0,<0.38",
 ]
 monitoring = [
@@ -77,7 +78,6 @@ dev = [
 [tool.uv]
 exclude-newer = "2 weeks"
 constraint-dependencies = [
-    "starlette>=0.49.1",
     "lxml>=6.1.0",
 ]
 

{unique_toolkit-2026.30.0.dev24 → unique_toolkit-2026.32.0}/unique_toolkit/agentic/debug_info_manager/debug_info_manager.py

@@ -1,3 +1,4 @@
+from collections import defaultdict
 from typing import Any, Required, TypedDict
 
 from unique_toolkit.agentic.tools.openai_builtin import OpenAICodeInterpreterTool
@@ -7,8 +8,10 @@ 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,
 )
 
@@ -40,11 +43,29 @@ 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]
@@ -115,6 +136,7 @@ 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.
 
@@ -134,6 +156,7 @@ 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),
@@ -152,6 +175,8 @@ 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,
@@ -163,6 +188,71 @@ 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.30.0.dev24 → unique_toolkit-2026.32.0}/unique_toolkit/agentic/postprocessor/postprocessor_manager.py

@@ -41,6 +41,17 @@ 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):
@@ -74,6 +85,13 @@ 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:
     """
@@ -196,6 +214,19 @@ 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.30.0.dev24 → unique_toolkit-2026.32.0}/unique_toolkit/agentic/tools/a2a/tool/service.py

@@ -4,12 +4,15 @@ import json
 import logging
 import re
 from datetime import datetime
-from typing import override
+from typing import Any, 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 send_message_and_wait_for_completion
+from unique_sdk.utils.chat_in_space import (
+    get_message_invocations,
+    send_message_and_wait_for_completion,
+)
 
 from unique_toolkit._common.execution import SafeTaskExecutor
 from unique_toolkit._common.referencing import (
@@ -55,6 +58,7 @@ from unique_toolkit.language_model import (
     LanguageModelService,
     LanguageModelToolDescription,
 )
+from unique_toolkit.language_model.invocation_stats import LanguageModelInvocationStats
 
 logger = logging.getLogger(__name__)
 
@@ -296,6 +300,13 @@ 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,
@@ -307,9 +318,12 @@ 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
@@ -495,6 +509,7 @@ 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(
@@ -513,6 +528,42 @@ 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.30.0.dev24 → unique_toolkit-2026.32.0}/unique_toolkit/agentic/tools/a2a/tool/test/test_service_utils.py

@@ -17,6 +17,7 @@ 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,
@@ -59,6 +60,78 @@ 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.30.0.dev24 → unique_toolkit-2026.32.0}/unique_toolkit/agentic_table/service.py

@@ -648,6 +648,33 @@ 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.30.0.dev24 → unique_toolkit-2026.32.0}/unique_toolkit/chat/schemas.py

@@ -216,9 +216,21 @@ class MessageLogUncitedReferences(BaseModel):
 
 class MessageLogEvent(BaseModel):
     model_config = model_config
-    type: Literal["WebSearch", "InternalSearch", "Elicitation", "Thinking", "ToolCall"]
+    type: Literal[
+        "WebSearch",
+        "InternalSearch",
+        "Elicitation",
+        "Thinking",
+        "ToolCall",
+        "Todo",
+        "UserMemory",
+    ]
     text: str
     step_type: str | None = None
+    status: Literal["todo", "done"] | None = Field(
+        default=None,
+        description="Checklist item state for 'Todo' events; unused for other event types",
+    )
 
 
 class MessageLogDetails(BaseModel):

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

@@ -107,9 +107,8 @@ async def translate_scope_id_async(
 ) -> str | None:
     """Resolve a single ``scope_id`` to a folder name.
 
-    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.
+    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.
     """
     try:
         folder_info = await get_folder_info_async(
@@ -119,7 +118,7 @@ async def translate_scope_id_async(
         )
         return folder_info.name
     except Exception as e:
-        _LOGGER.warning(f"Could not resolve folder for scope_id {scope_id}", exc_info=e)
+        _LOGGER.debug("Could not resolve folder for scope_id %s", scope_id, exc_info=e)
         return None
 
 

{unique_toolkit-2026.30.0.dev24 → unique_toolkit-2026.32.0}/unique_toolkit/language_model/infos.py

@@ -93,6 +93,7 @@ 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"
@@ -137,6 +138,7 @@ 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"
@@ -144,6 +146,7 @@ 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"
 
 
@@ -1812,6 +1815,30 @@ 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
@@ -2854,6 +2881,27 @@ 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.30.0.dev24 → unique_toolkit-2026.32.0}/unique_toolkit/language_model/invocation_stats.py

@@ -11,6 +11,7 @@ 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.
@@ -59,6 +60,7 @@ 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(
@@ -67,4 +69,9 @@ class LanguageModelInvocationStats(BaseModel):
         token_usage: LanguageModelTokenUsage,
         source: str,
     ) -> Self:
-        return cls(model_name=model_name, token_usage=token_usage, source=source)
+        return cls(
+            model_name=model_name,
+            token_usage=token_usage,
+            source=source,
+            cost_usd=calculate_invocation_cost_usd(str(model_name), token_usage),
+        )