model-library 0.1.4__tar.gz → 0.1.5__tar.gz

{model_library-0.1.4 → model_library-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model-library
-Version: 0.1.4
+Version: 0.1.5
 Summary: Model Library for vals.ai 
 Author-email: "Vals AI, Inc." <contact@vals.ai>
 License: MIT

{model_library-0.1.4 → model_library-0.1.5}/model_library/base/output.py

@@ -9,9 +9,7 @@ from pydantic import BaseModel, Field, computed_field, field_validator
 from typing_extensions import override
 
 from model_library.base.input import InputItem, ToolCall
-from model_library.base.utils import (
-    sum_optional,
-)
+from model_library.base.utils import add_optional
 from model_library.utils import truncate_str
 
 
@@ -42,10 +40,14 @@ class QueryResultCost(BaseModel):
     reasoning: float | None = None
     cache_read: float | None = None
     cache_write: float | None = None
+    total_override: float | None = None
 
     @computed_field
     @property
     def total(self) -> float:
+        if self.total_override is not None:
+            return self.total_override
+
         return sum(
             filter(
                 None,
@@ -86,6 +88,16 @@ class QueryResultCost(BaseModel):
             )
         )
 
+    def __add__(self, other: "QueryResultCost") -> "QueryResultCost":
+        return QueryResultCost(
+            input=self.input + other.input,
+            output=self.output + other.output,
+            reasoning=add_optional(self.reasoning, other.reasoning),
+            cache_read=add_optional(self.cache_read, other.cache_read),
+            cache_write=add_optional(self.cache_write, other.cache_write),
+            total_override=add_optional(self.total_override, other.total_override),
+        )
+
     @override
     def __repr__(self):
         use_cents = self.total < 1
@@ -150,18 +162,20 @@ class QueryResultMetadata(BaseModel):
         return QueryResultMetadata(
             in_tokens=self.in_tokens + other.in_tokens,
             out_tokens=self.out_tokens + other.out_tokens,
-            reasoning_tokens=sum_optional(
-                self.reasoning_tokens, other.reasoning_tokens
+            reasoning_tokens=cast(
+                int | None, add_optional(self.reasoning_tokens, other.reasoning_tokens)
             ),
-            cache_read_tokens=sum_optional(
-                self.cache_read_tokens, other.cache_read_tokens
+            cache_read_tokens=cast(
+                int | None,
+                add_optional(self.cache_read_tokens, other.cache_read_tokens),
             ),
-            cache_write_tokens=sum_optional(
-                self.cache_write_tokens, other.cache_write_tokens
+            cache_write_tokens=cast(
+                int | None,
+                add_optional(self.cache_write_tokens, other.cache_write_tokens),
             ),
             duration_seconds=self.default_duration_seconds
             + other.default_duration_seconds,
-            cost=self.cost,
+            cost=cast(QueryResultCost | None, add_optional(self.cost, other.cost)),
         )
 
     @override

{model_library-0.1.4 → model_library-0.1.5}/model_library/base/utils.py

@@ -1,4 +1,4 @@
-from typing import Sequence, cast
+from typing import Sequence, TypeVar, cast
 
 from model_library.base.input import (
     FileBase,
@@ -8,17 +8,39 @@ from model_library.base.input import (
     ToolResult,
 )
 from model_library.utils import truncate_str
+from pydantic import BaseModel
 
+T = TypeVar("T", bound=BaseModel)
 
-def sum_optional(a: int | None, b: int | None) -> int | None:
-    """Sum two optional integers, returning None if both are None.
+
+def add_optional(
+    a: int | float | T | None, b: int | float | T | None
+) -> int | float | T | None:
+    """Add two optional objects, returning None if both are None.
 
     Preserves None to indicate "unknown/not provided" when both inputs are None,
-    otherwise treats None as 0 for summation.
+    otherwise returns the non-None value or their sum.
     """
     if a is None and b is None:
         return None
-    return (a or 0) + (b or 0)
+
+    if a is None or b is None:
+        return a or b
+
+    if isinstance(a, (int, float)) and isinstance(b, (int, float)):
+        return a + b
+
+    # NOTE: Ensure that the subtypes are the same so we can use the __add__ method just from one
+    if type(a) is type(b):
+        add_method = getattr(a, "__add__", None)
+        if add_method is not None:
+            return add_method(b)
+    else:
+        raise ValueError(
+            f"Cannot add {type(a)} and {type(b)} because they are not the same subclass"
+        )
+
+    return None
 
 
 def get_pretty_input_types(input: Sequence["InputItem"], verbose: bool = False) -> str:

{model_library-0.1.4 → model_library-0.1.5}/model_library/config/all_models.json

@@ -1,4 +1,54 @@
 {
+    "google/gemini-3-flash-preview": {
+        "company": "Google",
+        "label": "Gemini 3 Flash (12/25)",
+        "description": "Google's newest budget workhorse model",
+        "release_date": "2025-12-17",
+        "open_source": false,
+        "documentation_url": "https://ai.google.dev/gemini-api/docs/models",
+        "properties": {
+            "context_window": 1048576,
+            "max_tokens": 65536,
+            "training_cutoff": null,
+            "reasoning_model": true
+        },
+        "supports": {
+            "images": true,
+            "videos": true,
+            "files": true,
+            "batch": true,
+            "temperature": true,
+            "tools": true
+        },
+        "metadata": {
+            "deprecated": false,
+            "available_for_everyone": true,
+            "available_as_evaluator": false,
+            "ignored_for_cost": false
+        },
+        "provider_properties": {},
+        "costs_per_million_token": {
+            "input": 0.5,
+            "output": 3.0,
+            "cache": {
+                "read_discount": 0.1,
+                "write_markup": 1.0
+            },
+            "batch": {
+                "input_discount": 0.5,
+                "output_discount": 0.5
+            }
+        },
+        "alternative_keys": [],
+        "default_parameters": {
+            "temperature": 1.0,
+            "reasoning_effort": "high"
+        },
+        "provider_endpoint": "gemini-3-flash-preview",
+        "provider_name": "google",
+        "full_key": "google/gemini-3-flash-preview",
+        "slug": "google_gemini-3-flash-preview"
+    },
     "openai/gpt-5.2-pro-2025-12-11": {
         "company": "OpenAI",
         "label": "GPT 5.2 Pro",
@@ -15428,7 +15478,7 @@
             "tools": false
         },
         "metadata": {
-            "deprecated": false,
+            "deprecated": true,
             "available_for_everyone": true,
             "available_as_evaluator": false,
             "ignored_for_cost": false

{model_library-0.1.4 → model_library-0.1.5}/model_library/config/google_models.yaml

@@ -54,6 +54,21 @@ gemini-3-models:
       temperature: 1
       reasoning_effort: "high"
 
+  google/gemini-3-flash-preview:
+    label: Gemini 3 Flash (12/25)
+    description: Google's newest budget workhorse model
+    release_date: 2025-12-17
+    properties:
+      context_window: 1048576
+      max_tokens: 65536
+      reasoning_model: true
+    costs_per_million_token:
+      input: 0.50
+      output: 3.00
+    default_parameters:
+      temperature: 1
+      reasoning_effort: "high"
+
   google/gemini-3-pro-preview:
     label: Gemini 3 Pro (11/25)
     description: Gemini 3 Pro, Google's most powerful model.

{model_library-0.1.4 → model_library-0.1.5}/model_library/config/perplexity_models.yaml

@@ -46,6 +46,8 @@ perplexity-models:
     label: Sonar Reasoning
     description: Reasoning-focused search model that exposes intermediate thinking for step-by-step answers.
     documentation_url: https://docs.perplexity.ai/models/models/sonar-reasoning
+    metadata:
+      deprecated: true
     properties:
       context_window: 128000
       reasoning_model: true

{model_library-0.1.4 → model_library-0.1.5}/model_library/exceptions.py

@@ -183,8 +183,8 @@ RETRIABLE_EXCEPTION_CODES = [
     "server_error",
     "overloaded",
     "throttling",  # AWS throttling errors
-    "throttlingexception",  # AWS throttling errors
     "internal server error",
+    "InternalServerError",
 ]
 
 

{model_library-0.1.4 → model_library-0.1.5}/model_library/registry_utils.py

@@ -1,9 +1,11 @@
 from functools import cache
 from pathlib import Path
+from typing import TypedDict
 
 import tiktoken
 
 from model_library.base import LLM, LLMConfig, ProviderConfig
+from model_library.base.output import QueryResultCost, QueryResultMetadata
 from model_library.register_models import (
     CostProperties,
     ModelConfig,
@@ -129,6 +131,64 @@ def get_model_cost(model_str: str) -> CostProperties | None:
     return model_config.costs_per_million_token
 
 
+class TokenDict(TypedDict, total=False):
+    """Token counts for cost calculation."""
+
+    in_tokens: int
+    out_tokens: int
+    reasoning_tokens: int | None
+    cache_read_tokens: int | None
+    cache_write_tokens: int | None
+
+
+async def recompute_cost(
+    model_str: str,
+    tokens: TokenDict,
+) -> QueryResultCost:
+    """
+    Recompute the cost for a model based on token information.
+
+    Uses the model provider's existing _calculate_cost method to ensure
+    provider-specific cost calculations are applied.
+
+    Args:
+        model_str: The model identifier (e.g., "openai/gpt-4o")
+        tokens: Dictionary containing token counts with keys:
+            - in_tokens (required): Number of input tokens
+            - out_tokens (required): Number of output tokens
+            - reasoning_tokens (optional): Number of reasoning tokens
+            - cache_read_tokens (optional): Number of cache read tokens
+            - cache_write_tokens (optional): Number of cache write tokens
+
+    Returns:
+        QueryResultCost with computed costs
+
+    Raises:
+        ValueError: If required token parameters are missing
+        Exception: If model not found in registry or costs not configured
+    """
+    if "in_tokens" not in tokens:
+        raise ValueError("Token dict must contain 'in_tokens'")
+    if "out_tokens" not in tokens:
+        raise ValueError("Token dict must contain 'out_tokens'")
+
+    model = get_registry_model(model_str)
+
+    metadata = QueryResultMetadata(
+        in_tokens=tokens["in_tokens"],
+        out_tokens=tokens["out_tokens"],
+        reasoning_tokens=tokens.get("reasoning_tokens"),
+        cache_read_tokens=tokens.get("cache_read_tokens"),
+        cache_write_tokens=tokens.get("cache_write_tokens"),
+    )
+
+    cost = await model._calculate_cost(metadata)  # type: ignore[arg-type]
+    if cost is None:
+        raise Exception(f"No cost information available for model {model_str}")
+
+    return cost
+
+
 @cache
 def get_provider_names() -> list[str]:
     """Return all provider names in the registry"""

{model_library-0.1.4 → model_library-0.1.5}/model_library.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model-library
-Version: 0.1.4
+Version: 0.1.5
 Summary: Model Library for vals.ai 
 Author-email: "Vals AI, Inc." <contact@vals.ai>
 License: MIT

{model_library-0.1.4 → model_library-0.1.5}/model_library.egg-info/SOURCES.txt

@@ -115,6 +115,7 @@ tests/unit/test_deep_research.py
 tests/unit/test_perplexity_provider.py
 tests/unit/test_prompt_caching.py
 tests/unit/test_registry.py
+tests/unit/test_result_metadata.py
 tests/unit/test_retry.py
 tests/unit/test_streaming.py
 tests/unit/test_tools.py

model_library-0.1.5/tests/unit/test_result_metadata.py

@@ -0,0 +1,206 @@
+import pytest
+
+from model_library.base.output import QueryResultCost, QueryResultMetadata
+
+
+@pytest.mark.unit
+class TestQueryResultCostAddition:
+    def test_add_full_costs(self):
+        cost1 = QueryResultCost(
+            input=0.01,
+            output=0.02,
+            reasoning=0.005,
+            cache_read=0.001,
+            cache_write=0.002,
+        )
+        cost2 = QueryResultCost(
+            input=0.02,
+            output=0.03,
+            reasoning=0.01,
+            cache_read=0.002,
+            cache_write=0.003,
+        )
+
+        result = cost1 + cost2
+
+        assert result.input == 0.03
+        assert result.output == 0.05
+        assert result.reasoning == 0.015
+        assert result.cache_read == 0.003
+        assert result.cache_write == 0.005
+
+    def test_add_costs_with_none_fields(self):
+        cost1 = QueryResultCost(input=0.01, output=0.02, reasoning=0.005)
+        cost2 = QueryResultCost(input=0.02, output=0.03, cache_read=0.002)
+
+        result = cost1 + cost2
+
+        assert result.input == 0.03
+        assert result.output == 0.05
+        assert result.reasoning == 0.005
+        assert result.cache_read == 0.002
+        assert result.cache_write is None
+
+    def test_add_costs_both_none_fields(self):
+        cost1 = QueryResultCost(input=0.01, output=0.02)
+        cost2 = QueryResultCost(input=0.02, output=0.03)
+
+        result = cost1 + cost2
+
+        assert result.input == 0.03
+        assert result.output == 0.05
+        assert result.reasoning is None
+        assert result.cache_read is None
+        assert result.cache_write is None
+
+    def test_cost_total_computed(self):
+        cost1 = QueryResultCost(input=0.01, output=0.02, reasoning=0.005)
+        cost2 = QueryResultCost(input=0.02, output=0.03, cache_read=0.001)
+
+        result = cost1 + cost2
+
+        expected_total = 0.03 + 0.05 + 0.005 + 0.001
+        assert abs(result.total - expected_total) < 1e-10
+
+
+@pytest.mark.unit
+class TestQueryResultMetadataAddition:
+    def test_add_full_metadata(self):
+        meta1 = QueryResultMetadata(
+            in_tokens=100,
+            out_tokens=50,
+            reasoning_tokens=20,
+            cache_read_tokens=10,
+            cache_write_tokens=5,
+            duration_seconds=1.5,
+            cost=QueryResultCost(input=0.01, output=0.02),
+        )
+        meta2 = QueryResultMetadata(
+            in_tokens=200,
+            out_tokens=100,
+            reasoning_tokens=30,
+            cache_read_tokens=15,
+            cache_write_tokens=10,
+            duration_seconds=2.0,
+            cost=QueryResultCost(input=0.02, output=0.03),
+        )
+
+        result = meta1 + meta2
+
+        assert result.in_tokens == 300
+        assert result.out_tokens == 150
+        assert result.reasoning_tokens == 50
+        assert result.cache_read_tokens == 25
+        assert result.cache_write_tokens == 15
+        assert result.duration_seconds == 3.5
+        assert result.cost is not None
+        assert result.cost.input == 0.03
+        assert result.cost.output == 0.05
+
+    def test_add_metadata_missing_optional_tokens(self):
+        meta1 = QueryResultMetadata(
+            in_tokens=100,
+            out_tokens=50,
+            reasoning_tokens=20,
+            duration_seconds=1.0,
+        )
+        meta2 = QueryResultMetadata(
+            in_tokens=200,
+            out_tokens=100,
+            cache_read_tokens=15,
+            duration_seconds=2.0,
+        )
+
+        result = meta1 + meta2
+
+        assert result.in_tokens == 300
+        assert result.out_tokens == 150
+        assert result.reasoning_tokens == 20
+        assert result.cache_read_tokens == 15
+        assert result.cache_write_tokens is None
+
+    def test_add_metadata_both_missing_optional_tokens(self):
+        meta1 = QueryResultMetadata(in_tokens=100, out_tokens=50)
+        meta2 = QueryResultMetadata(in_tokens=200, out_tokens=100)
+
+        result = meta1 + meta2
+
+        assert result.in_tokens == 300
+        assert result.out_tokens == 150
+        assert result.reasoning_tokens is None
+        assert result.cache_read_tokens is None
+        assert result.cache_write_tokens is None
+
+    def test_add_metadata_one_has_cost(self):
+        meta1 = QueryResultMetadata(
+            in_tokens=100,
+            out_tokens=50,
+            cost=QueryResultCost(input=0.01, output=0.02),
+        )
+        meta2 = QueryResultMetadata(in_tokens=200, out_tokens=100, cost=None)
+
+        result = meta1 + meta2
+
+        assert result.cost is not None
+        assert result.cost.input == 0.01
+        assert result.cost.output == 0.02
+
+    def test_add_metadata_other_has_cost(self):
+        meta1 = QueryResultMetadata(in_tokens=100, out_tokens=50, cost=None)
+        meta2 = QueryResultMetadata(
+            in_tokens=200,
+            out_tokens=100,
+            cost=QueryResultCost(input=0.02, output=0.03),
+        )
+
+        result = meta1 + meta2
+
+        assert result.cost is not None
+        assert result.cost.input == 0.02
+        assert result.cost.output == 0.03
+
+    def test_add_metadata_neither_has_cost(self):
+        meta1 = QueryResultMetadata(in_tokens=100, out_tokens=50)
+        meta2 = QueryResultMetadata(in_tokens=200, out_tokens=100)
+
+        result = meta1 + meta2
+
+        assert result.cost is None
+
+    def test_add_metadata_default_duration(self):
+        meta1 = QueryResultMetadata(in_tokens=100, out_tokens=50, duration_seconds=None)
+        meta2 = QueryResultMetadata(in_tokens=200, out_tokens=100, duration_seconds=2.0)
+
+        result = meta1 + meta2
+
+        assert result.duration_seconds == 2.0
+
+    def test_add_metadata_both_none_duration(self):
+        meta1 = QueryResultMetadata(in_tokens=100, out_tokens=50, duration_seconds=None)
+        meta2 = QueryResultMetadata(
+            in_tokens=200, out_tokens=100, duration_seconds=None
+        )
+
+        result = meta1 + meta2
+
+        assert result.duration_seconds == 0.0
+
+    def test_computed_total_tokens(self):
+        meta1 = QueryResultMetadata(
+            in_tokens=100,
+            out_tokens=50,
+            reasoning_tokens=20,
+            cache_read_tokens=10,
+            cache_write_tokens=5,
+        )
+        meta2 = QueryResultMetadata(
+            in_tokens=200,
+            out_tokens=100,
+            reasoning_tokens=30,
+            cache_read_tokens=15,
+        )
+
+        result = meta1 + meta2
+
+        assert result.total_input_tokens == 300 + 25 + 5
+        assert result.total_output_tokens == 150 + 50