osmosis-ai 0.2.0__py3-none-any.whl → 0.2.2__py3-none-any.whl

osmosis_ai/utils.py

@@ -1,7 +1,8 @@
 
 import functools
 import inspect
-from typing import Callable
+import types
+from typing import Any, Callable, Mapping, Union, get_args, get_origin, get_type_hints
 
 
 def osmosis_reward(func: Callable) -> Callable:
@@ -54,6 +55,397 @@ def osmosis_reward(func: Callable) -> Callable:
 
     @functools.wraps(func)
     def wrapper(*args, **kwargs):
+        kwargs.pop("data_source", None)
+        result = func(*args, **kwargs)
+        if not isinstance(result, float):
+            raise TypeError(f"Function {func.__name__} must return a float, got {type(result).__name__}")
+        return result
+
+    return wrapper
+
+
+ALLOWED_ROLES = {"user", "system", "assistant", "developer", "tool", "function"}
+
+_UNION_TYPES = {Union}
+_types_union_type = getattr(types, "UnionType", None)
+if _types_union_type is not None:
+    _UNION_TYPES.add(_types_union_type)
+
+
+def _is_str_annotation(annotation: Any) -> bool:
+    if annotation is inspect.Parameter.empty:
+        return False
+    if annotation is str:
+        return True
+    if isinstance(annotation, str):
+        return annotation in {"str", "builtins.str"}
+    if isinstance(annotation, type):
+        try:
+            return issubclass(annotation, str)
+        except TypeError:
+            return False
+    forward_arg = getattr(annotation, "__forward_arg__", None)
+    if isinstance(forward_arg, str):
+        return forward_arg in {"str", "builtins.str"}
+    return False
+
+
+def _is_optional_str(annotation: Any) -> bool:
+    if _is_str_annotation(annotation):
+        return True
+    if isinstance(annotation, str):
+        normalized = annotation.replace(" ", "")
+        if normalized in {
+            "Optional[str]",
+            "typing.Optional[str]",
+            "Str|None",
+            "str|None",
+            "builtins.str|None",
+            "None|str",
+            "None|builtins.str",
+        }:
+            return True
+    origin = get_origin(annotation)
+    if origin in _UNION_TYPES:
+        args = tuple(arg for arg in get_args(annotation) if arg is not type(None))  # noqa: E721
+        return len(args) == 1 and _is_str_annotation(args[0])
+    return False
+
+
+def _is_list_annotation(annotation: Any) -> bool:
+    if annotation is list:
+        return True
+    if isinstance(annotation, str):
+        normalized = annotation.replace(" ", "")
+        return (
+            normalized in {"list", "builtins.list", "typing.List", "List"}
+            or normalized.startswith("list[")
+            or normalized.startswith("builtins.list[")
+            or normalized.startswith("typing.List[")
+            or normalized.startswith("List[")
+        )
+    origin = get_origin(annotation)
+    return origin is list
+
+
+def _is_float_annotation(annotation: Any) -> bool:
+    if annotation in {inspect.Parameter.empty, float}:
+        return True
+    if isinstance(annotation, str):
+        return annotation in {"float", "builtins.float"}
+    origin = get_origin(annotation)
+    return origin is float
+
+
+def _is_numeric(value: Any) -> bool:
+    return isinstance(value, (int, float)) and not isinstance(value, bool)
+
+
+def _is_dict_annotation(annotation: Any) -> bool:
+    if annotation in {dict, Mapping}:
+        return True
+    origin = get_origin(annotation)
+    if origin in {dict, Mapping}:
+        return True
+    if isinstance(annotation, type):
+        try:
+            return issubclass(annotation, dict)
+        except TypeError:
+            return False
+    if isinstance(annotation, str):
+        normalized = annotation.replace(" ", "")
+        return (
+            normalized in {"dict", "builtins.dict", "typing.Mapping", "collections.abc.Mapping", "Mapping"}
+            or normalized.startswith("dict[")
+            or normalized.startswith("builtins.dict[")
+            or normalized.startswith("typing.Dict[")
+            or normalized.startswith("Dict[")
+            or normalized.startswith("typing.Mapping[")
+            or normalized.startswith("Mapping[")
+        )
+    return False
+
+
+def osmosis_rubric(func: Callable) -> Callable:
+    """
+    Decorator for rubric functions that enforces the signature:
+    (model_info: dict, rubric: str, messages: list, ground_truth: Optional[str] = None,
+     system_message: Optional[str] = None, extra_info: dict = None,
+     score_min: float = 0.0, score_max: float = 1.0) -> float
+
+    The `model_info` mapping must provide non-empty string entries for both `provider` and `model`.
+
+    Args:
+        func: The rubric function to be wrapped
+
+    Returns:
+        The wrapped function
+
+    Raises:
+        TypeError: If the function doesn't have the required signature or doesn't return a float
+
+    Example:
+        @osmosis_rubric
+        def evaluate_response(
+            model_info: dict,
+            rubric: str,
+            messages: list,
+            ground_truth: str | None = None,
+            system_message: str | None = None,
+            extra_info: dict = None,
+            score_min: float = 0.0,
+            score_max: float = 1.0,
+        ) -> float:
+            return some_evaluation(model_info, messages, ground_truth)
+    """
+    # Validate function signature
+    sig = inspect.signature(func)
+    params = list(sig.parameters.values())
+    try:
+        resolved_annotations = get_type_hints(
+            func,
+            globalns=getattr(func, "__globals__", {}),
+            include_extras=True,
+        )
+    except Exception:  # pragma: no cover - best effort for forward refs
+        resolved_annotations = {}
+
+    # Check parameter count
+    if len(params) < 3 or len(params) > 8:
+        raise TypeError(f"Function {func.__name__} must have between 3 and 8 parameters, got {len(params)}")
+
+    # Check first parameter: model_info: dict
+    model_info_param = params[0]
+    if model_info_param.name != "model_info":
+        raise TypeError(f"First parameter must be named 'model_info', got '{model_info_param.name}'")
+    model_info_annotation = resolved_annotations.get(model_info_param.name, model_info_param.annotation)
+    if not _is_dict_annotation(model_info_annotation):
+        raise TypeError(
+            f"First parameter 'model_info' must be annotated as a dict or mapping, got {model_info_annotation}"
+        )
+    if model_info_param.default is not inspect.Parameter.empty:
+        raise TypeError("First parameter 'model_info' cannot have a default value")
+
+    # Check second parameter: rubric: str
+    rubric_param = params[1]
+    if rubric_param.name != "rubric":
+        raise TypeError(f"Second parameter must be named 'rubric', got '{rubric_param.name}'")
+    rubric_annotation = resolved_annotations.get(rubric_param.name, rubric_param.annotation)
+    if not _is_str_annotation(rubric_annotation):
+        raise TypeError(f"Second parameter 'rubric' must be annotated as str, got {rubric_annotation}")
+    if rubric_param.default is not inspect.Parameter.empty:
+        raise TypeError("Second parameter 'rubric' cannot have a default value")
+
+    # Check third parameter: messages: list
+    messages_param = params[2]
+    if messages_param.name != "messages":
+        raise TypeError(f"Third parameter must be named 'messages', got '{messages_param.name}'")
+    messages_annotation = resolved_annotations.get(messages_param.name, messages_param.annotation)
+    if messages_annotation is inspect.Parameter.empty:
+        raise TypeError("Third parameter 'messages' must be annotated as list")
+    if not _is_list_annotation(messages_annotation):
+        raise TypeError(f"Third parameter 'messages' must be annotated as list, got {messages_annotation}")
+    if messages_param.default is not inspect.Parameter.empty:
+        raise TypeError("Third parameter 'messages' cannot have a default value")
+
+    optional_params = params[3:]
+
+    if optional_params:
+        ground_truth_param = optional_params[0]
+        # Check fourth parameter: ground_truth: Optional[str]
+        if ground_truth_param.name != "ground_truth":
+            raise TypeError(f"Fourth parameter must be named 'ground_truth', got '{ground_truth_param.name}'")
+        ground_truth_annotation = resolved_annotations.get(
+            ground_truth_param.name,
+            ground_truth_param.annotation,
+        )
+        if ground_truth_annotation is inspect.Parameter.empty or not _is_optional_str(ground_truth_annotation):
+            raise TypeError(
+                "Fourth parameter 'ground_truth' must be annotated as Optional[str] or str"
+            )
+        if ground_truth_param.default is inspect.Parameter.empty:
+            raise TypeError("Fourth parameter 'ground_truth' must have a default value of None")
+        if ground_truth_param.default is not None:
+            raise TypeError("Fourth parameter 'ground_truth' must default to None")
+        optional_params = optional_params[1:]
+
+    if optional_params:
+        system_message_param = optional_params[0]
+        # Check fifth parameter: system_message: Optional[str]
+        if system_message_param.name != "system_message":
+            raise TypeError(f"Fifth parameter must be named 'system_message', got '{system_message_param.name}'")
+        system_message_annotation = resolved_annotations.get(
+            system_message_param.name,
+            system_message_param.annotation,
+        )
+        if system_message_annotation is inspect.Parameter.empty or not _is_optional_str(system_message_annotation):
+            raise TypeError(
+                "Fifth parameter 'system_message' must be annotated as Optional[str] or str"
+            )
+        if system_message_param.default is inspect.Parameter.empty:
+            raise TypeError("Fifth parameter 'system_message' must have a default value of None")
+        if system_message_param.default is not None:
+            raise TypeError("Fifth parameter 'system_message' must default to None")
+        optional_params = optional_params[1:]
+
+    if optional_params:
+        extra_info_param = optional_params[0]
+        # Check sixth parameter: extra_info: dict = None
+        if extra_info_param.name != "extra_info":
+            raise TypeError(f"Sixth parameter must be named 'extra_info', got '{extra_info_param.name}'")
+        extra_info_annotation = resolved_annotations.get(
+            extra_info_param.name,
+            extra_info_param.annotation,
+        )
+        if extra_info_annotation is inspect.Parameter.empty or not _is_dict_annotation(extra_info_annotation):
+            raise TypeError(
+                f"Sixth parameter 'extra_info' must be annotated as dict, got {extra_info_annotation}"
+            )
+        if extra_info_param.default is inspect.Parameter.empty:
+            raise TypeError("Sixth parameter 'extra_info' must have a default value of None")
+        if extra_info_param.default is not None:
+            raise TypeError("Sixth parameter 'extra_info' must default to None")
+        optional_params = optional_params[1:]
+
+    if optional_params:
+        score_min_param = optional_params[0]
+        # Check seventh parameter: score_min: float = 0.0
+        if score_min_param.name != "score_min":
+            raise TypeError(f"Seventh parameter must be named 'score_min', got '{score_min_param.name}'")
+        score_min_annotation = resolved_annotations.get(
+            score_min_param.name,
+            score_min_param.annotation,
+        )
+        if not _is_float_annotation(score_min_annotation):
+            raise TypeError(
+                f"Seventh parameter 'score_min' must be annotated as float, got {score_min_annotation}"
+            )
+        if score_min_param.default is inspect.Parameter.empty:
+            raise TypeError("Seventh parameter 'score_min' must have a default value of 0.0")
+        if not _is_numeric(score_min_param.default):
+            raise TypeError("Seventh parameter 'score_min' must default to a numeric value")
+        if float(score_min_param.default) != 0.0:
+            raise TypeError("Seventh parameter 'score_min' must default to 0.0")
+        optional_params = optional_params[1:]
+
+    if optional_params:
+        score_max_param = optional_params[0]
+        # Check eighth parameter: score_max: float = 1.0
+        if score_max_param.name != "score_max":
+            raise TypeError(f"Eighth parameter must be named 'score_max', got '{score_max_param.name}'")
+        score_max_annotation = resolved_annotations.get(
+            score_max_param.name,
+            score_max_param.annotation,
+        )
+        if not _is_float_annotation(score_max_annotation):
+            raise TypeError(
+                f"Eighth parameter 'score_max' must be annotated as float, got {score_max_annotation}"
+            )
+        if score_max_param.default is inspect.Parameter.empty:
+            raise TypeError("Eighth parameter 'score_max' must have a default value of 1.0")
+        if not _is_numeric(score_max_param.default):
+            raise TypeError("Eighth parameter 'score_max' must default to a numeric value")
+        if float(score_max_param.default) != 1.0:
+            raise TypeError("Eighth parameter 'score_max' must default to 1.0")
+        optional_params = optional_params[1:]
+
+    if optional_params:
+        unexpected_param = optional_params[0]
+        raise TypeError(f"Function {func.__name__} has unexpected parameter '{unexpected_param.name}'")
+
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        # Remove unsupported kwargs
+        kwargs.pop("data_source", None)
+        bound = sig.bind_partial(*args, **kwargs)
+        bound.apply_defaults()
+
+        # Validate model_info argument
+        if "model_info" not in bound.arguments:
+            raise TypeError("'model_info' argument is required")
+        model_info_value = bound.arguments["model_info"]
+        if not isinstance(model_info_value, Mapping):
+            raise TypeError(f"'model_info' must be a mapping, got {type(model_info_value).__name__}")
+        required_model_fields = {"provider", "model"}
+        missing_model_fields = required_model_fields - set(model_info_value.keys())
+        if missing_model_fields:
+            raise ValueError(f"'model_info' is missing required fields: {sorted(missing_model_fields)}")
+        provider_value = model_info_value.get("provider")
+        if not isinstance(provider_value, str) or not provider_value.strip():
+            raise TypeError("'model_info[\"provider\"]' must be a non-empty string")
+        model_value = model_info_value.get("model")
+        if not isinstance(model_value, str) or not model_value.strip():
+            raise TypeError("'model_info[\"model\"]' must be a non-empty string")
+
+        # Validate rubric argument
+        if "rubric" not in bound.arguments:
+            raise TypeError("'rubric' argument is required")
+        rubric_value = bound.arguments["rubric"]
+        if not isinstance(rubric_value, str):
+            raise TypeError(f"'rubric' must be a string, got {type(rubric_value).__name__}")
+
+        # Validate messages argument
+        if "messages" not in bound.arguments:
+            raise TypeError("'messages' argument is required")
+        messages_value = bound.arguments["messages"]
+        if not isinstance(messages_value, list):
+            raise TypeError(f"'messages' must be a list, got {type(messages_value).__name__}")
+
+        # Validate optional ground_truth argument
+        ground_truth_value = bound.arguments.get("ground_truth")
+        if ground_truth_value is not None and not isinstance(ground_truth_value, str):
+            raise TypeError(
+                f"'ground_truth' must be a string or None, got {type(ground_truth_value).__name__}"
+            )
+
+        # Validate optional system_message argument
+        system_message_value = bound.arguments.get("system_message")
+        if system_message_value is not None and not isinstance(system_message_value, str):
+            raise TypeError(
+                f"'system_message' must be a string or None, got {type(system_message_value).__name__}"
+            )
+
+        # Validate messages structure
+        for index, message in enumerate(messages_value):
+            if not isinstance(message, dict):
+                raise TypeError(f"'messages[{index}]' must be a dict, got {type(message).__name__}")
+            missing_fields = {"type", "role", "content"} - message.keys()
+            if missing_fields:
+                raise ValueError(f"'messages[{index}]' is missing required fields: {missing_fields}")
+            if message["role"] not in ALLOWED_ROLES:
+                raise ValueError(
+                    f"'messages[{index}]['role']' must be one of {sorted(ALLOWED_ROLES)}, "
+                    f"got '{message['role']}'"
+                )
+            if not isinstance(message["content"], list):
+                raise TypeError(f"'messages[{index}]['content']' must be a list")
+
+        score_min_present = "score_min" in bound.arguments
+        score_max_present = "score_max" in bound.arguments
+
+        if score_min_present:
+            score_min_value = bound.arguments["score_min"]
+            if not _is_numeric(score_min_value):
+                raise TypeError(
+                    f"'score_min' must be a numeric type, got {type(score_min_value).__name__}"
+                )
+        else:
+            score_min_value = None
+
+        if score_max_present:
+            score_max_value = bound.arguments["score_max"]
+            if not _is_numeric(score_max_value):
+                raise TypeError(
+                    f"'score_max' must be a numeric type, got {type(score_max_value).__name__}"
+                )
+        else:
+            score_max_value = None
+
+        if score_min_present and score_max_present:
+            if float(score_max_value) <= float(score_min_value):
+                raise ValueError("'score_max' must be greater than 'score_min'")
+
+        # Validate return type
         result = func(*args, **kwargs)
         if not isinstance(result, float):
             raise TypeError(f"Function {func.__name__} must return a float, got {type(result).__name__}")

osmosis_ai-0.2.2.dist-info/METADATA

@@ -0,0 +1,241 @@
+Metadata-Version: 2.4
+Name: osmosis-ai
+Version: 0.2.2
+Summary: A Python library for reward function validation with strict type enforcement.
+Author-email: Osmosis AI <jake@osmosis.ai>
+License: MIT License
+        
+        Copyright (c) 2025 Gulp AI
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE. 
+Project-URL: Homepage, https://github.com/Osmosis-AI/osmosis-sdk-python
+Project-URL: Issues, https://github.com/Osmosis-AI/osmosis-sdk-python/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# osmosis-ai
+
+A Python library that provides reward and rubric validation helpers for LLM applications with strict type enforcement.
+
+## Installation
+
+```bash
+pip install osmosis-ai
+```
+
+For development:
+```bash
+git clone https://github.com/Osmosis-AI/osmosis-sdk-python
+cd osmosis-sdk-python
+pip install -e .
+```
+
+## Quick Start
+
+```python
+from osmosis_ai import osmosis_reward
+
+@osmosis_reward
+def simple_reward(solution_str: str, ground_truth: str, extra_info: dict = None) -> float:
+    """Basic exact match reward function."""
+    return 1.0 if solution_str.strip() == ground_truth.strip() else 0.0
+
+# Use the reward function
+score = simple_reward("hello world", "hello world")  # Returns 1.0
+```
+
+```python
+from osmosis_ai import evaluate_rubric
+
+messages = [
+    {
+        "type": "message",
+        "role": "user",
+        "content": [{"type": "input_text", "text": "What is the capital of France?"}],
+    },
+    {
+        "type": "message",
+        "role": "assistant",
+        "content": [{"type": "output_text", "text": "The capital of France is Paris."}],
+    },
+]
+
+# Export OPENAI_API_KEY in your shell before running this snippet.
+rubric_score = evaluate_rubric(
+    rubric="Assistant must mention the verified capital city.",
+    messages=messages,
+    model_info={
+        "provider": "openai",
+        "model": "gpt-5",
+        "api_key_env": "OPENAI_API_KEY",
+    },
+    ground_truth="Paris",
+)
+
+print(rubric_score)  # -> 1.0 (full payload available via return_details=True)
+```
+
+## Remote Rubric Evaluation
+
+`evaluate_rubric` talks to each provider through its official Python SDK while enforcing the same JSON schema everywhere:
+
+- **OpenAI / xAI** – Uses `OpenAI(...).responses.create` (or `chat.completions.create`) with `response_format={"type": "json_schema"}` and falls back to `json_object` when needed.
+- **Anthropic** – Forces a tool call with a JSON schema via `Anthropic(...).messages.create`, extracting the returned tool arguments.
+- **Google Gemini** – Invokes `google.genai.Client(...).models.generate_content` with `response_mime_type="application/json"` and `response_schema`.
+
+Every provider therefore returns a strict JSON object with `{"score": number, "explanation": string}`. The helper clamps the score into your configured range, validates the structure, and exposes the raw payload when `return_details=True`.
+
+Credentials are resolved from environment variables by default:
+
+- `OPENAI_API_KEY` for OpenAI
+- `ANTHROPIC_API_KEY` for Anthropic
+- `GOOGLE_API_KEY` for Google Gemini
+- `XAI_API_KEY` for xAI
+
+Override the environment variable name with `model_info={"api_key_env": "CUSTOM_ENV_NAME"}` when needed, or supply an inline secret with `model_info={"api_key": "sk-..."}` for ephemeral credentials. Missing API keys raise a `MissingAPIKeyError` that explains how to export the secret before trying again.
+
+`model_info` accepts additional rubric-specific knobs:
+
+- `score_min` / `score_max` – change the default `[0.0, 1.0]` scoring bounds.
+- `system_prompt` / `original_input` – override the helper’s transcript inference when those entries are absent.
+- `timeout` – customise the provider timeout in seconds.
+
+Pass `extra_info={...}` to `evaluate_rubric` when you need structured context quoted in the judge prompt, and set `return_details=True` to receive the full `RewardRubricRunResult` payload (including the provider’s raw response).
+
+Remote failures surface as `ProviderRequestError` instances, with `ModelNotFoundError` reserved for missing model identifiers so you can retry with a new snapshot.
+
+> Older SDK versions that lack schema parameters automatically fall back to instruction-only JSON; the helper still validates the response payload before returning.
+> Provider model snapshot names change frequently. Check each vendor's dashboard for the latest identifier if you encounter a “model not found” error.
+
+### Provider Architecture
+
+All remote integrations live in `osmosis_ai/providers/` and implement the `RubricProvider` interface. At import time the default registry registers OpenAI, xAI, Anthropic, and Google Gemini so `evaluate_rubric` can route requests without additional configuration. The request/response plumbing is encapsulated in each provider module, keeping `evaluate_rubric` focused on prompt construction, payload validation, and credential resolution.
+
+Add your own provider by subclassing `RubricProvider`, implementing `run()` with the vendor SDK, and calling `register_provider()` during start-up. A step-by-step guide is available in [`osmosis_ai/providers/README.md`](osmosis_ai/providers/README.md).
+
+## Required Function Signature
+
+All functions decorated with `@osmosis_reward` must have exactly this signature:
+
+```python
+@osmosis_reward
+def your_function(solution_str: str, ground_truth: str, extra_info: dict = None) -> float:
+    # Your reward logic here
+    return float_score
+```
+
+### Parameters
+
+- **`solution_str: str`** - The solution string to evaluate (required)
+- **`ground_truth: str`** - The correct/expected answer (required)
+- **`extra_info: dict = None`** - Optional dictionary for additional configuration
+
+### Return Value
+
+- **`-> float`** - Must return a float value representing the reward score
+
+The decorator will raise a `TypeError` if the function doesn't match this exact signature or doesn't return a float.
+
+## Rubric Function Signature
+
+Rubric functions decorated with `@osmosis_rubric` must accept the parameters:
+
+- `model_info: dict`
+- `rubric: str`
+- `messages: list`
+- `ground_truth: Optional[str] = None`
+- `system_message: Optional[str] = None`
+- `extra_info: dict = None`
+- `score_min: float = 0.0` *(optional lower bound; must default to 0.0 and stay below `score_max`)*
+- `score_max: float = 1.0` *(optional upper bound; must default to 1.0 and stay above `score_min`)*
+
+and must return a `float`. The decorator validates the signature and runtime payload (including message role validation and return type) before delegating to your custom logic.
+
+> Required fields: `model_info` must contain non-empty `provider` and `model` string entries.
+
+> Annotation quirk: `extra_info` must be annotated as a plain `dict` with a default of `None` to satisfy the validator.
+
+> Tip: You can call `evaluate_rubric` from inside a rubric function (or any other orchestrator) to outsource judging to a hosted model while still benefiting from the decorator’s validation.
+
+## Examples
+
+See the [`examples/`](examples/) directory for complete examples:
+
+```python
+@osmosis_reward
+def case_insensitive_match(solution_str: str, ground_truth: str, extra_info: dict = None) -> float:
+    """Case-insensitive string matching with partial credit."""
+    match = solution_str.lower().strip() == ground_truth.lower().strip()
+
+    if extra_info and 'partial_credit' in extra_info:
+        if not match and extra_info['partial_credit']:
+            len_diff = abs(len(solution_str) - len(ground_truth))
+            if len_diff <= 2:
+                return 0.5
+
+    return 1.0 if match else 0.0
+
+@osmosis_reward
+def numeric_tolerance(solution_str: str, ground_truth: str, extra_info: dict = None) -> float:
+    """Numeric comparison with configurable tolerance."""
+    try:
+        solution_num = float(solution_str.strip())
+        truth_num = float(ground_truth.strip())
+
+        tolerance = extra_info.get('tolerance', 0.01) if extra_info else 0.01
+        return 1.0 if abs(solution_num - truth_num) <= tolerance else 0.0
+    except ValueError:
+        return 0.0
+```
+
+- `examples/rubric_functions.py` demonstrates `evaluate_rubric` with OpenAI, Anthropic, Gemini, and xAI using the schema-enforced SDK integrations.
+- `examples/reward_functions.py` keeps local reward helpers that showcase the decorator contract without external calls.
+
+## Running Examples
+
+```bash
+PYTHONPATH=. python examples/reward_functions.py
+PYTHONPATH=. python examples/rubric_functions.py  # Uncomment the provider you need before running
+```
+
+## Testing
+
+Run `python -m pytest tests/test_rubric_eval.py` to exercise the guards that ensure rubric prompts ignore message metadata (for example `tests/test_rubric_eval.py::test_collect_text_skips_metadata_fields`) while still preserving nested tool output. Add additional tests under `tests/` as you extend the library.
+
+## License
+
+MIT License - see [LICENSE](LICENSE) file for details.
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes
+4. Run tests and examples
+5. Submit a pull request
+
+## Links
+
+- [Homepage](https://github.com/Osmosis-AI/osmosis-sdk-python)
+- [Issues](https://github.com/Osmosis-AI/osmosis-sdk-python/issues)

osmosis_ai-0.2.2.dist-info/RECORD

@@ -0,0 +1,16 @@
+osmosis_ai/__init__.py,sha256=2_qXxu18Yc7UicqxFZds8PjR4q0mTY1Xt17iR38OFbw,725
+osmosis_ai/consts.py,sha256=-NDo9FaqBTebkCnhiFDxne6BY0W7BL3oM8HnGQDDgSE,73
+osmosis_ai/rubric_eval.py,sha256=bFgxgnbQeD-7K2LkTJfnSk5aG9s4lefLfmvQt4GQSnM,18332
+osmosis_ai/rubric_types.py,sha256=kJvNAjLd3Y-1Q-_Re9HLTprLAUO3qtwR-IWOBeMkFI8,1279
+osmosis_ai/utils.py,sha256=yjC_oQt1wwTJsX7lCx0ZGMa5txHURByuBDuU37WPAO0,19927
+osmosis_ai/providers/__init__.py,sha256=yLSExLbJToZ8AUOVxt4LDplxtIuwv-etSJJyZOcOE2Q,927
+osmosis_ai/providers/anthropic_provider.py,sha256=zrWCVP8co4v8xhcJDFLASwvwEADKN-1p34cY_GH4q5M,3758
+osmosis_ai/providers/base.py,sha256=fN5cnWXYAHN53RR_x6ykbUkM4bictNPDj4U8yd4b2a0,1492
+osmosis_ai/providers/gemini_provider.py,sha256=xqklXRO5K1YZ4SKq5lfU3bDUaF8QN2MIBP4DHGKwLVo,10611
+osmosis_ai/providers/openai_family.py,sha256=DeQWPMcafEvG4xcI97m3AADTKP2pYw9KwcQTcQg-h_4,26078
+osmosis_ai/providers/shared.py,sha256=dmVe8JDgafPmo6HkP-Kl0aWfffhAT6u3ElV_wLlYD34,2957
+osmosis_ai-0.2.2.dist-info/licenses/LICENSE,sha256=FV2ZmyhdCYinoLLvU_ci-7pZ3DeNYY9XqZjVjOd3h94,1064
+osmosis_ai-0.2.2.dist-info/METADATA,sha256=MPovk4NSQ_viTMd-zx1lp7Uo2EGB3EotjftcNddy4HU,10448
+osmosis_ai-0.2.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+osmosis_ai-0.2.2.dist-info/top_level.txt,sha256=UPNRTKIBSrxsJVNxwXnLCqSoBS4bAiL_3jMtjvf5zEY,11
+osmosis_ai-0.2.2.dist-info/RECORD,,