opengradient 0.4.8__tar.gz → 0.4.9__tar.gz

{opengradient-0.4.8/src/opengradient.egg-info → opengradient-0.4.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: opengradient
-Version: 0.4.8
+Version: 0.4.9
 Summary: Python SDK for OpenGradient decentralized model management & inference services
 Author-email: OpenGradient <oliver@opengradient.ai>
 License: MIT License

{opengradient-0.4.8 → opengradient-0.4.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "opengradient"
-version = "0.4.8"
+version = "0.4.9"
 description = "Python SDK for OpenGradient decentralized model management & inference services"
 authors = [{name = "OpenGradient", email = "oliver@opengradient.ai"}]
 license = {file = "LICENSE"}

{opengradient-0.4.8 → opengradient-0.4.9}/src/opengradient/__init__.py

@@ -14,6 +14,7 @@ from .types import (
     CandleType,
     CandleOrder,
     InferenceMode,
+    InferenceResult,
     LlmInferenceMode,
     TextGenerationOutput,
     ModelOutput,
@@ -128,7 +129,7 @@ def create_version(model_name, notes=None, is_major=False):
     return _client.create_version(model_name, notes, is_major)
 
 
-def infer(model_cid, inference_mode, model_input, max_retries: Optional[int] = None):
+def infer(model_cid, inference_mode, model_input, max_retries: Optional[int] = None) -> InferenceResult:
     """Run inference on a model.
 
     Args:
@@ -138,7 +139,9 @@ def infer(model_cid, inference_mode, model_input, max_retries: Optional[int] = N
         max_retries: Maximum number of retries for failed transactions
 
     Returns:
-        InferenceResult: Transaction hash and model output
+        InferenceResult (InferenceResult): A dataclass object containing the transaction hash and model output.
+            * transaction_hash (str): Blockchain hash for the transaction
+            * model_output (Dict[str, np.ndarray]): Output of the ONNX model
 
     Raises:
         RuntimeError: If SDK is not initialized

opengradient-0.4.9/src/opengradient/alphasense/run_model_tool.py

@@ -0,0 +1,152 @@
+from enum import Enum
+from typing import Any, Callable, List, Dict, Type, Optional, Union
+
+from langchain_core.tools import BaseTool, StructuredTool
+from pydantic import BaseModel
+
+import opengradient as og
+from .types import ToolType
+from opengradient import InferenceResult
+import numpy as np
+
+
+def create_run_model_tool(
+    tool_type: ToolType,
+    model_cid: str,
+    tool_name: str,
+    model_input_provider: Callable[..., Dict[str, Union[str, int, float, List, np.ndarray]]],
+    model_output_formatter: Callable[[InferenceResult], str],
+    tool_input_schema: Optional[Type[BaseModel]] = None,
+    tool_description: str = "Executes the given ML model",
+    inference_mode: og.InferenceMode = og.InferenceMode.VANILLA,
+) -> BaseTool | Callable:
+    """
+    Creates a tool that wraps an OpenGradient model for inference.
+
+    This function generates a tool that can be integrated into either a LangChain pipeline
+    or a Swarm system, allowing the model to be executed as part of a chain of operations.
+    The tool uses the provided input_getter function to obtain the necessary input data and
+    runs inference using the specified OpenGradient model.
+
+    Args:
+        tool_type (ToolType): Specifies the framework to create the tool for. Use
+            ToolType.LANGCHAIN for LangChain integration or ToolType.SWARM for Swarm
+            integration.
+        model_cid (str): The CID of the OpenGradient model to be executed.
+        tool_name (str): The name to assign to the created tool. This will be used to identify
+            and invoke the tool within the agent.
+        model_input_provider (Callable): A function that takes in the tool_input_schema with arguments
+            filled by the agent and returns input data required by the model.
+
+            The function should return data in a format compatible with the model's expectations.
+        model_output_formatter (Callable[..., str]): A function that takes the output of
+            the OpenGradient infer method (with type InferenceResult) and formats it into a string.
+
+            This is required to ensure the output is compatible with the tool framework.
+
+            Default returns the InferenceResult object.
+
+            InferenceResult has attributes:
+                * transaction_hash (str): Blockchain hash for the transaction
+                * model_output (Dict[str, np.ndarray]): Output of the ONNX model
+        tool_input_schema (Type[BaseModel], optional): A Pydantic BaseModel class defining the
+            input schema.
+
+            For LangChain tools the schema will be used directly. The defined schema will be used as
+            input keyword arguments for the `model_input_provider` function. If no arguments are required
+            for the `model_input_provider` function then this schema can be unspecified.
+
+            For Swarm tools the schema will be converted to appropriate annotations.
+
+            Default is None -- an empty schema will be provided for LangChain.
+        tool_description (str, optional): A description of what the tool does. Defaults to
+            "Executes the given ML model".
+        inference_mode (og.InferenceMode, optional): The inference mode to use when running
+            the model. Defaults to VANILLA.
+
+    Returns:
+        BaseTool: For ToolType.LANGCHAIN, returns a LangChain StructuredTool.
+        Callable: For ToolType.SWARM, returns a decorated function with appropriate metadata.
+
+    Raises:
+        ValueError: If an invalid tool_type is provided.
+
+    Examples:
+        >>> from pydantic import BaseModel, Field
+        >>> from enum import Enum
+        >>> from opengradient.alphasense import create_run_model_tool
+        >>> class Token(str, Enum):
+        ...     ETH = "ethereum"
+        ...     BTC = "bitcoin"
+        ...
+        >>> class InputSchema(BaseModel):
+        ...     token: Token = Field(default=Token.ETH, description="Token name specified by user.")
+        ...
+        >>> eth_model_input = {"price_series": [2010.1, 2012.3, 2020.1, 2019.2]}        # Example data
+        >>> btc_model_input = {"price_series": [100001.1, 100013.2, 100149.2, 99998.1]} # Example data
+        >>> def model_input_provider(**llm_input):
+        ...     token = llm_input.get("token")
+        ...     if token == Token.BTC:
+        ...             return btc_model_input
+        ...     elif token == Token.ETH:
+        ...             return eth_model_input
+        ...     else:
+        ...             raise ValueError("Unexpected token found")
+        ...
+        >>> def output_formatter(inference_result):
+        ...     return format(float(inference_result.model_output["std"].item()), ".3%")
+        ...
+        >>> run_model_tool = create_run_model_tool(
+        ...     tool_type=ToolType.LANGCHAIN,
+        ...     model_cid="QmZdSfHWGJyzBiB2K98egzu3MypPcv4R1ASypUxwZ1MFUG",
+        ...     tool_name="Return_volatility_tool",
+        ...     model_input_provider=model_input_provider,
+        ...     model_output_formatter=output_formatter,
+        ...     tool_input_schema=InputSchema,
+        ...     tool_description="This tool takes a token and measures the return volatility (standard deviation of returns).",
+        ...     inference_mode=og.InferenceMode.VANILLA,
+        ... )
+    """
+
+    def model_executor(**llm_input):
+        # Pass LLM input arguments (formatted based on tool_input_schema) as parameters into model_input_provider
+        model_input = model_input_provider(**llm_input)
+
+        inference_result = og.infer(model_cid=model_cid, inference_mode=inference_mode, model_input=model_input)
+
+        return model_output_formatter(inference_result)
+
+    if tool_type == ToolType.LANGCHAIN:
+        if not tool_input_schema:
+            tool_input_schema = type("EmptyInputSchema", (BaseModel,), {})
+
+        return StructuredTool.from_function(
+            func=model_executor, name=tool_name, description=tool_description, args_schema=tool_input_schema
+        )
+    elif tool_type == ToolType.SWARM:
+        model_executor.__name__ = tool_name
+        model_executor.__doc__ = tool_description
+        # Convert Pydantic model to Swarm annotations if provided
+        if tool_input_schema:
+            model_executor.__annotations__ = _convert_pydantic_to_annotations(tool_input_schema)
+        return model_executor
+    else:
+        raise ValueError(f"Invalid tooltype: {tool_type}")
+
+
+def _convert_pydantic_to_annotations(model: Type[BaseModel]) -> Dict[str, Any]:
+    """
+    Convert a Pydantic model to function annotations format used by Swarm.
+
+    Args:
+        model: A Pydantic BaseModel class
+
+    Returns:
+        Dict mapping field names to (type, description) tuples
+    """
+    annotations = {}
+    for field_name, field in model.model_fields.items():
+        field_type = field.annotation
+        description = field.description or ""
+        annotations[field_name] = (field_type, description)
+    return annotations

{opengradient-0.4.8 → opengradient-0.4.9}/src/opengradient/client.py

@@ -129,7 +129,6 @@ class Client:
 
         return ModelRepository(model_name, version_response["versionString"])
 
-
     def create_version(self, model_name: str, notes: str = "", is_major: bool = False) -> dict:
         """
         Create a new version for the specified model.
@@ -283,7 +282,9 @@ class Client:
             max_retries (int, optional): Maximum number of retry attempts. Defaults to 5.
 
         Returns:
-            InferenceResult: The transaction hash and the model output.
+            InferenceResult (InferenceResult): A dataclass object containing the transaction hash and model output.
+                transaction_hash (str): Blockchain hash for the transaction
+                model_output (Dict[str, np.ndarray]): Output of the ONNX model
 
         Raises:
             OpenGradientError: If the inference fails.

{opengradient-0.4.8 → opengradient-0.4.9}/src/opengradient/types.py

@@ -47,29 +47,63 @@ class Number:
 
 @dataclass
 class NumberTensor:
+    """
+    A container for numeric tensor data used as input for ONNX models.
+
+    Attributes:
+
+        name: Identifier for this tensor in the model.
+
+        values: List of integer tuples representing the tensor data.
+    """
+
     name: str
     values: List[Tuple[int, int]]
 
 
 @dataclass
 class StringTensor:
+    """
+    A container for string tensor data used as input for ONNX models.
+
+    Attributes:
+
+        name: Identifier for this tensor in the model.
+
+        values: List of strings representing the tensor data.
+    """
+
     name: str
     values: List[str]
 
 
 @dataclass
 class ModelInput:
+    """
+    A collection of tensor inputs required for ONNX model inference.
+
+    Attributes:
+
+        numbers: Collection of numeric tensors for the model.
+
+        strings: Collection of string tensors for the model.
+    """
+
     numbers: List[NumberTensor]
     strings: List[StringTensor]
 
 
 class InferenceMode(Enum):
+    """Enum for the different inference modes available for inference (VANILLA, ZKML, TEE)"""
+
     VANILLA = 0
     ZKML = 1
     TEE = 2
 
 
 class LlmInferenceMode(Enum):
+    """Enum for differetn inference modes available for LLM inferences (VANILLA, TEE)"""
+
     VANILLA = 0
     TEE = 1
 
@@ -89,14 +123,14 @@ class ModelOutput:
 @dataclass
 class InferenceResult:
     """
-    Output for ML inference requests
+    Output for ML inference requests.
+    This class has two fields
+        transaction_hash (str): Blockchain hash for the transaction
+        model_output (Dict[str, np.ndarray]): Output of the ONNX model
     """
 
     transaction_hash: str
-    """Blockchain hash for the transaction."""
-
     model_output: Dict[str, np.ndarray]
-    """Output of ONNX model"""
 
 
 @dataclass

opengradient-0.4.9/src/opengradient/workflow_models/__init__.py

@@ -0,0 +1,28 @@
+"""
+OpenGradient Hardcoded Models
+"""
+
+from .workflow_models import *
+from .types import WorkflowModelOutput
+
+__all__ = [
+    "read_eth_usdt_one_hour_volatility_forecast",
+    "read_btc_1_hour_price_forecast",
+    "read_eth_1_hour_price_forecast",
+    "read_sol_1_hour_price_forecast",
+    "read_sui_1_hour_price_forecast",
+    "read_sui_usdt_30_min_price_forecast",
+    "read_sui_usdt_6_hour_price_forecast",
+    "WorkflowModelOutput",
+]
+
+__pdoc__ = {
+    "read_eth_usdt_one_hour_volatility_forecast": False,
+    "read_btc_1_hour_price_forecast": False,
+    "read_eth_1_hour_price_forecast": False,
+    "read_sol_1_hour_price_forecast": False,
+    "read_sui_1_hour_price_forecast": False,
+    "read_sui_usdt_30_min_price_forecast": False,
+    "read_sui_usdt_6_hour_price_forecast": False,
+    "WorkflowModelOutput": False,
+}

opengradient-0.4.9/src/opengradient/workflow_models/constants.py

@@ -0,0 +1,13 @@
+"""Constants used by the models module"""
+
+# URL for OpenGradient block explorer
+BLOCK_EXPLORER_URL = "https://explorer.opengradient.ai/"
+
+# Workflow Contract Addresses
+ETH_USDT_1_HOUR_VOLATILITY_ADDRESS = "0xD5629A5b95dde11e4B5772B5Ad8a13B933e33845"
+BTC_1_HOUR_PRICE_FORECAST_ADDRESS = "0xb4146E095c2CD2a7aA497EdfB513F1cB868Dcc3D"
+ETH_1_HOUR_PRICE_FORECAST_ADDRESS = "0x58826c6dc9A608238d9d57a65bDd50EcaE27FE99"
+SOL_1_HOUR_PRICE_FORECAST_ADDRESS = "0xaE12EC7314e91A612CF4Fa4DC07dC02cfCc4dF95"
+SUI_1_HOUR_PRICE_FORECAST_ADDRESS = "0x90FE6434C46838c96E9ACb8d394C0fdfe38C6182"
+SUI_30_MINUTE_PRICE_FORECAST_ADDRESS = "0xD85BA71f5701dc4C5BDf9780189Db49C6F3708D2"
+SUI_6_HOUR_PRICE_FORECAST_ADDRESS = "0x3C2E4DbD653Bd30F1333d456480c1b7aB122e946"

opengradient-0.4.9/src/opengradient/workflow_models/types.py

@@ -0,0 +1,16 @@
+"""Type definitions for models module."""
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class WorkflowModelOutput:
+    """
+    Output definition for reading from a workflow model.
+    """
+
+    result: str
+    """Result of the workflow formatted as a string."""
+
+    block_explorer_link: str = field(default="")
+    """(Optional) Block explorer link for the smart contract address of the workflow."""

opengradient-0.4.9/src/opengradient/workflow_models/utils.py

@@ -0,0 +1,39 @@
+"""Utility functions for the models module."""
+
+from .constants import BLOCK_EXPLORER_URL
+from typing import Callable, Any
+from .types import WorkflowModelOutput
+import opengradient as og
+
+
+def create_block_explorer_link_smart_contract(transaction_hash: str) -> str:
+    """Create block explorer link for smart contract."""
+    block_explorer_url = BLOCK_EXPLORER_URL + "address/" + transaction_hash
+    return block_explorer_url
+
+
+def create_block_explorer_link_transaction(transaction_hash: str) -> str:
+    """Create block explorer link for transaction."""
+    block_explorer_url = BLOCK_EXPLORER_URL + "tx/" + transaction_hash
+    return block_explorer_url
+
+
+def read_workflow_wrapper(contract_address: str, format_function: Callable[..., str]) -> WorkflowModelOutput:
+    """
+    Wrapper function for reading from models through workflows.
+    Args:
+        contract_address (str): Smart contract address of the workflow
+        format_function (Callable): Function for formatting the result returned by read_workflow
+    """
+    try:
+        result = og.read_workflow_result(contract_address)
+
+        formatted_result = format_function(result)
+        block_explorer_link = create_block_explorer_link_smart_contract(contract_address)
+
+        return WorkflowModelOutput(
+            result=formatted_result,
+            block_explorer_link=block_explorer_link,
+        )
+    except Exception as e:
+        raise RuntimeError(f"Error reading from workflow with address {contract_address}: {e!s}")

opengradient-0.4.9/src/opengradient/workflow_models/workflow_models.py

@@ -0,0 +1,97 @@
+"""Repository of OpenGradient quantitative workflow models."""
+
+import opengradient as og
+from .constants import (
+    ETH_USDT_1_HOUR_VOLATILITY_ADDRESS,
+    BTC_1_HOUR_PRICE_FORECAST_ADDRESS,
+    ETH_1_HOUR_PRICE_FORECAST_ADDRESS,
+    SOL_1_HOUR_PRICE_FORECAST_ADDRESS,
+    SUI_1_HOUR_PRICE_FORECAST_ADDRESS,
+    SUI_30_MINUTE_PRICE_FORECAST_ADDRESS,
+    SUI_6_HOUR_PRICE_FORECAST_ADDRESS,
+)
+from .utils import read_workflow_wrapper
+from .types import WorkflowModelOutput
+
+
+def read_eth_usdt_one_hour_volatility_forecast() -> WorkflowModelOutput:
+    """
+    Read from the ETH/USDT one hour volatility forecast model workflow on the OpenGradient network.
+
+    More information on this model can be found at https://hub.opengradient.ai/models/OpenGradient/og-1hr-volatility-ethusdt.
+    """
+    return read_workflow_wrapper(
+        contract_address=ETH_USDT_1_HOUR_VOLATILITY_ADDRESS, format_function=lambda x: format(float(x.numbers["Y"].item()), ".10%")
+    )
+
+
+def read_btc_1_hour_price_forecast() -> WorkflowModelOutput:
+    """
+    Read from the BTC one hour return forecast workflow on the OpenGradient network.
+
+    More information on this model can be found at https://hub.opengradient.ai/models/OpenGradient/og-btc-1hr-forecast.
+    """
+    return read_workflow_wrapper(
+        contract_address=BTC_1_HOUR_PRICE_FORECAST_ADDRESS,
+        format_function=lambda x: format(float(x.numbers["regression_output"].item()), ".10%"),
+    )
+
+
+def read_eth_1_hour_price_forecast() -> WorkflowModelOutput:
+    """
+    Read from the ETH one hour return forecast workflow on the OpenGradient network.
+
+    More information on this model can be found at https://hub.opengradient.ai/models/OpenGradient/og-eth-1hr-forecast.
+    """
+    return read_workflow_wrapper(
+        contract_address=ETH_1_HOUR_PRICE_FORECAST_ADDRESS,
+        format_function=lambda x: format(float(x.numbers["regression_output"].item()), ".10%"),
+    )
+
+
+def read_sol_1_hour_price_forecast() -> WorkflowModelOutput:
+    """
+    Read from the SOL one hour return forecast workflow on the OpenGradient network.
+
+    More information on this model can be found at https://hub.opengradient.ai/models/OpenGradient/og-sol-1hr-forecast.
+    """
+    return read_workflow_wrapper(
+        contract_address=SOL_1_HOUR_PRICE_FORECAST_ADDRESS,
+        format_function=lambda x: format(float(x.numbers["regression_output"].item()), ".10%"),
+    )
+
+
+def read_sui_1_hour_price_forecast() -> WorkflowModelOutput:
+    """
+    Read from the SUI one hour return forecast workflow on the OpenGradient network.
+
+    More information on this model can be found at https://hub.opengradient.ai/models/OpenGradient/og-sui-1hr-forecast.
+    """
+    return read_workflow_wrapper(
+        contract_address=SUI_1_HOUR_PRICE_FORECAST_ADDRESS,
+        format_function=lambda x: format(float(x.numbers["regression_output"].item()), ".10%"),
+    )
+
+
+def read_sui_usdt_30_min_price_forecast() -> WorkflowModelOutput:
+    """
+    Read from the SUI/USDT pair 30 min return forecast workflow on the OpenGradient network.
+
+    More information on this model can be found at https://hub.opengradient.ai/models/OpenGradient/og-30min-return-suiusdt.
+    """
+    return read_workflow_wrapper(
+        contract_address=SUI_30_MINUTE_PRICE_FORECAST_ADDRESS,
+        format_function=lambda x: format(float(x.numbers["destandardized_prediction"].item()), ".10%"),
+    )
+
+
+def read_sui_usdt_6_hour_price_forecast() -> WorkflowModelOutput:
+    """
+    Read from the SUI/USDT pair 6 hour return forecast workflow on the OpenGradient network.
+
+    More information on this model can be found at https://hub.opengradient.ai/models/OpenGradient/og-6h-return-suiusdt.
+    """
+    return read_workflow_wrapper(
+        contract_address=SUI_6_HOUR_PRICE_FORECAST_ADDRESS,
+        format_function=lambda x: format(float(x.numbers["destandardized_prediction"].item()), ".10%"),
+    )

{opengradient-0.4.8 → opengradient-0.4.9/src/opengradient.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: opengradient
-Version: 0.4.8
+Version: 0.4.9
 Summary: Python SDK for OpenGradient decentralized model management & inference services
 Author-email: OpenGradient <oliver@opengradient.ai>
 License: MIT License

{opengradient-0.4.8 → opengradient-0.4.9}/src/opengradient.egg-info/SOURCES.txt

@@ -29,4 +29,9 @@ src/opengradient/llm/og_openai.py
 src/opengradient/proto/__init__.py
 src/opengradient/proto/infer.proto
 src/opengradient/proto/infer_pb2.py
-src/opengradient/proto/infer_pb2_grpc.py
+src/opengradient/proto/infer_pb2_grpc.py
+src/opengradient/workflow_models/__init__.py
+src/opengradient/workflow_models/constants.py
+src/opengradient/workflow_models/types.py
+src/opengradient/workflow_models/utils.py
+src/opengradient/workflow_models/workflow_models.py

opengradient-0.4.8/src/opengradient/alphasense/run_model_tool.py

@@ -1,114 +0,0 @@
-from enum import Enum
-from typing import Any, Callable, Dict, Type, Optional
-
-from langchain_core.tools import BaseTool, StructuredTool
-from pydantic import BaseModel
-
-import opengradient as og
-from .types import ToolType
-
-
-def create_run_model_tool(
-    tool_type: ToolType,
-    model_cid: str,
-    tool_name: str,
-    input_getter: Callable,
-    output_formatter: Callable[..., str] = lambda x: x,
-    input_schema: Optional[Type[BaseModel]] = None,
-    tool_description: str = "Executes the given ML model",
-    inference_mode: og.InferenceMode = og.InferenceMode.VANILLA,
-) -> BaseTool | Callable:
-    """
-    Creates a tool that wraps an OpenGradient model for inference.
-
-    This function generates a tool that can be integrated into either a LangChain pipeline
-    or a Swarm system, allowing the model to be executed as part of a chain of operations.
-    The tool uses the provided input_getter function to obtain the necessary input data and
-    runs inference using the specified OpenGradient model.
-
-    Args:
-        tool_type (ToolType): Specifies the framework to create the tool for. Use
-            ToolType.LANGCHAIN for LangChain integration or ToolType.SWARM for Swarm
-            integration.
-        model_cid (str): The CID of the OpenGradient model to be executed.
-        tool_name (str): The name to assign to the created tool. This will be used to identify
-            and invoke the tool within the agent.
-        input_getter (Callable): A function that returns the input data required by the model.
-            The function should return data in a format compatible with the model's expectations.
-        output_formatter (Callable[..., str], optional): A function that takes the model output and
-            formats it into a string. This is required to ensure the output is compatible
-            with the tool framework. Default returns string as is.
-        input_schema (Type[BaseModel], optional): A Pydantic BaseModel class defining the
-            input schema. This will be used directly for LangChain tools and converted
-            to appropriate annotations for Swarm tools. Default is None.
-        tool_description (str, optional): A description of what the tool does. Defaults to
-            "Executes the given ML model".
-        inference_mode (og.InferenceMode, optional): The inference mode to use when running
-            the model. Defaults to VANILLA.
-
-    Returns:
-        BaseTool: For ToolType.LANGCHAIN, returns a LangChain StructuredTool.
-        Callable: For ToolType.SWARM, returns a decorated function with appropriate metadata.
-
-    Raises:
-        ValueError: If an invalid tool_type is provided.
-
-    Examples:
-        >>> from pydantic import BaseModel, Field
-        >>> class ClassifierInput(BaseModel):
-        ...     query: str = Field(description="User query to analyze")
-        ...     parameters: dict = Field(description="Additional parameters")
-        >>> def get_input():
-        ...     return {"text": "Sample input text"}
-        >>> def format_output(output):
-        ...     return str(output.get("class", "Unknown"))
-        >>> # Create a LangChain tool
-        >>> langchain_tool = create_og_model_tool(
-        ...     tool_type=ToolType.LANGCHAIN,
-        ...     model_cid="Qm...",
-        ...     tool_name="text_classifier",
-        ...     input_getter=get_input,
-        ...     output_formatter=format_output,
-        ...     input_schema=ClassifierInput
-        ...     tool_description="Classifies text into categories"
-        ... )
-    """
-
-    # define runnable
-    def model_executor(**llm_input):
-        # Combine LLM input with input provided by code
-        combined_input = {**llm_input, **input_getter()}
-
-        _, output = og.infer(model_cid=model_cid, inference_mode=inference_mode, model_input=combined_input)
-
-        return output_formatter(output)
-
-    if tool_type == ToolType.LANGCHAIN:
-        return StructuredTool.from_function(func=model_executor, name=tool_name, description=tool_description, args_schema=input_schema)
-    elif tool_type == ToolType.SWARM:
-        model_executor.__name__ = tool_name
-        model_executor.__doc__ = tool_description
-        # Convert Pydantic model to Swarm annotations if provided
-        if input_schema:
-            model_executor.__annotations__ = _convert_pydantic_to_annotations(input_schema)
-        return model_executor
-    else:
-        raise ValueError(f"Invalid tooltype: {tool_type}")
-
-
-def _convert_pydantic_to_annotations(model: Type[BaseModel]) -> Dict[str, Any]:
-    """
-    Convert a Pydantic model to function annotations format used by Swarm.
-
-    Args:
-        model: A Pydantic BaseModel class
-
-    Returns:
-        Dict mapping field names to (type, description) tuples
-    """
-    annotations = {}
-    for field_name, field in model.model_fields.items():
-        field_type = field.annotation
-        description = field.description or ""
-        annotations[field_name] = (field_type, description)
-    return annotations