opengradient 0.3.5__py3-none-any.whl → 0.3.6__py3-none-any.whl

opengradient/__init__.py

@@ -1,11 +1,10 @@
+from typing import Dict, List, Optional, Tuple
+
 from .client import Client
-from .defaults import *
-from .types import InferenceMode
-from typing import List, Dict, Optional, Tuple
-import os
+from .defaults import DEFAULT_INFERENCE_CONTRACT_ADDRESS, DEFAULT_RPC_URL
+from .types import InferenceMode, LLM
 
-__version__ = "0.3.5"
-__all__ = ['init', 'upload', 'create_model', 'create_version', 'infer', 'infer_llm', 'login', 'list_files', 'InferenceMode']
+__version__ = "0.3.7"
 
 _client = None
 
@@ -45,31 +44,32 @@ def infer(model_cid, inference_mode, model_input):
         raise RuntimeError("OpenGradient client not initialized. Call og.init() first.")
     return _client.infer(model_cid, inference_mode, model_input)
 
-def infer_llm(model_cid: str, 
-              prompt: str, 
-              max_tokens: int = 100, 
-              stop_sequence: Optional[List[str]] = None, 
-              temperature: float = 0.0) -> Tuple[str, str]:
+def llm_completion(model_cid: LLM, 
+                         prompt: str, 
+                         max_tokens: int = 100, 
+                         stop_sequence: Optional[List[str]] = None, 
+                         temperature: float = 0.0) -> Tuple[str, str]:
     if _client is None:
         raise RuntimeError("OpenGradient client not initialized. Call og.init() first.")
-    return _client.infer_llm(model_cid, prompt, max_tokens, stop_sequence, temperature)
+    return _client.llm_completion(model_cid, prompt, max_tokens, stop_sequence, temperature)
 
-def login(email: str, password: str):
+def llm_chat(model_cid: LLM,
+                   messages: List[Dict],
+                   max_tokens: int = 100,
+                   stop_sequence: Optional[List[str]] = None,
+                   temperature: float = 0.0,
+                   tools: Optional[List[Dict]] = None,
+                   tool_choice: Optional[str] = None):
     if _client is None:
         raise RuntimeError("OpenGradient client not initialized. Call og.init() first.")
-    return _client.login(email, password)
+    return _client.llm_chat(model_cid, messages, max_tokens, stop_sequence, temperature, tools, tool_choice)
 
-def list_files(model_name: str, version: str) -> List[Dict]:
+def login(email: str, password: str):
     if _client is None:
         raise RuntimeError("OpenGradient client not initialized. Call og.init() first.")
-    return _client.list_files(model_name, version)
+    return _client.login(email, password)
 
-def create_model_from_huggingface(repo_id: str, model_name: str, model_desc: str):
+def list_files(model_name: str, version: str) -> List[Dict]:
     if _client is None:
         raise RuntimeError("OpenGradient client not initialized. Call og.init() first.")
-
-    with tempfile.TemporaryDirectory() as temp_dir:
-        snapshot_download(repo_id, local_dir=temp_dir)
-        result = create_model(model_name, model_desc, temp_dir)
-    
-    return result
+    return _client.list_files(model_name, version)

opengradient/abi/inference.abi

@@ -1 +1 @@
-[{"anonymous":false,"inputs":[{"components":[{"components":[{"internalType":"string","name":"name","type":"string"},{"components":[{"internalType":"int128","name":"value","type":"int128"},{"internalType":"int128","name":"decimals","type":"int128"}],"internalType":"struct TensorLib.Number[]","name":"values","type":"tuple[]"},{"internalType":"uint32[]","name":"shape","type":"uint32[]"}],"internalType":"struct TensorLib.MultiDimensionalNumberTensor[]","name":"numbers","type":"tuple[]"},{"components":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string[]","name":"values","type":"string[]"}],"internalType":"struct TensorLib.StringTensor[]","name":"strings","type":"tuple[]"},{"internalType":"bool","name":"is_simulation_result","type":"bool"}],"indexed":false,"internalType":"struct ModelOutput","name":"output","type":"tuple"}],"name":"InferenceResult","type":"event"},{"inputs":[{"internalType":"string","name":"modelId","type":"string"},{"internalType":"enum ModelInferenceMode","name":"inferenceMode","type":"uint8"},{"components":[{"components":[{"internalType":"string","name":"name","type":"string"},{"components":[{"internalType":"int128","name":"value","type":"int128"},{"internalType":"int128","name":"decimals","type":"int128"}],"internalType":"struct TensorLib.Number[]","name":"values","type":"tuple[]"},{"internalType":"uint32[]","name":"shape","type":"uint32[]"}],"internalType":"struct TensorLib.MultiDimensionalNumberTensor[]","name":"numbers","type":"tuple[]"},{"components":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string[]","name":"values","type":"string[]"}],"internalType":"struct TensorLib.StringTensor[]","name":"strings","type":"tuple[]"}],"internalType":"struct ModelInput","name":"modelInput","type":"tuple"}],"name":"run","outputs":[{"components":[{"components":[{"internalType":"string","name":"name","type":"string"},{"components":[{"internalType":"int128","name":"value","type":"int128"},{"internalType":"int128","name":"decimals","type":"int128"}],"internalType":"struct TensorLib.Number[]","name":"values","type":"tuple[]"},{"internalType":"uint32[]","name":"shape","type":"uint32[]"}],"internalType":"struct TensorLib.MultiDimensionalNumberTensor[]","name":"numbers","type":"tuple[]"},{"components":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string[]","name":"values","type":"string[]"}],"internalType":"struct TensorLib.StringTensor[]","name":"strings","type":"tuple[]"},{"internalType":"bool","name":"is_simulation_result","type":"bool"}],"internalType":"struct ModelOutput","name":"","type":"tuple"}],"stateMutability":"nonpayable","type":"function"}]
+[{"anonymous":false,"inputs":[{"components":[{"components":[{"internalType":"string","name":"name","type":"string"},{"components":[{"internalType":"int128","name":"value","type":"int128"},{"internalType":"int128","name":"decimals","type":"int128"}],"internalType":"struct TensorLib.Number[]","name":"values","type":"tuple[]"},{"internalType":"uint32[]","name":"shape","type":"uint32[]"}],"internalType":"struct TensorLib.MultiDimensionalNumberTensor[]","name":"numbers","type":"tuple[]"},{"components":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string[]","name":"values","type":"string[]"}],"internalType":"struct TensorLib.StringTensor[]","name":"strings","type":"tuple[]"},{"internalType":"bool","name":"is_simulation_result","type":"bool"}],"indexed":false,"internalType":"struct ModelOutput","name":"output","type":"tuple"}],"name":"InferenceResult","type":"event"},{"anonymous":false,"inputs":[{"components":[{"internalType":"string","name":"finish_reason","type":"string"},{"components":[{"internalType":"string","name":"role","type":"string"},{"internalType":"string","name":"content","type":"string"},{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"tool_call_id","type":"string"},{"components":[{"internalType":"string","name":"id","type":"string"},{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"arguments","type":"string"}],"internalType":"struct ToolCall[]","name":"tool_calls","type":"tuple[]"}],"internalType":"struct ChatMessage","name":"message","type":"tuple"}],"indexed":false,"internalType":"struct LLMChatResponse","name":"response","type":"tuple"}],"name":"LLMChatResult","type":"event"},{"anonymous":false,"inputs":[{"components":[{"internalType":"string","name":"answer","type":"string"}],"indexed":false,"internalType":"struct LLMCompletionResponse","name":"response","type":"tuple"}],"name":"LLMCompletionResult","type":"event"},{"inputs":[{"internalType":"string","name":"modelId","type":"string"},{"internalType":"enum ModelInferenceMode","name":"inferenceMode","type":"uint8"},{"components":[{"components":[{"internalType":"string","name":"name","type":"string"},{"components":[{"internalType":"int128","name":"value","type":"int128"},{"internalType":"int128","name":"decimals","type":"int128"}],"internalType":"struct TensorLib.Number[]","name":"values","type":"tuple[]"},{"internalType":"uint32[]","name":"shape","type":"uint32[]"}],"internalType":"struct TensorLib.MultiDimensionalNumberTensor[]","name":"numbers","type":"tuple[]"},{"components":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string[]","name":"values","type":"string[]"}],"internalType":"struct TensorLib.StringTensor[]","name":"strings","type":"tuple[]"}],"internalType":"struct ModelInput","name":"modelInput","type":"tuple"}],"name":"run","outputs":[{"components":[{"components":[{"internalType":"string","name":"name","type":"string"},{"components":[{"internalType":"int128","name":"value","type":"int128"},{"internalType":"int128","name":"decimals","type":"int128"}],"internalType":"struct TensorLib.Number[]","name":"values","type":"tuple[]"},{"internalType":"uint32[]","name":"shape","type":"uint32[]"}],"internalType":"struct TensorLib.MultiDimensionalNumberTensor[]","name":"numbers","type":"tuple[]"},{"components":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string[]","name":"values","type":"string[]"}],"internalType":"struct TensorLib.StringTensor[]","name":"strings","type":"tuple[]"},{"internalType":"bool","name":"is_simulation_result","type":"bool"}],"internalType":"struct ModelOutput","name":"","type":"tuple"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"enum LLMInferenceMode","name":"mode","type":"uint8"},{"internalType":"string","name":"modelCID","type":"string"},{"components":[{"internalType":"string","name":"role","type":"string"},{"internalType":"string","name":"content","type":"string"},{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"tool_call_id","type":"string"},{"components":[{"internalType":"string","name":"id","type":"string"},{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"arguments","type":"string"}],"internalType":"struct ToolCall[]","name":"tool_calls","type":"tuple[]"}],"internalType":"struct ChatMessage[]","name":"messages","type":"tuple[]"},{"components":[{"internalType":"string","name":"description","type":"string"},{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"parameters","type":"string"}],"internalType":"struct ToolDefinition[]","name":"tools","type":"tuple[]"},{"internalType":"string","name":"tool_choice","type":"string"},{"internalType":"uint32","name":"max_tokens","type":"uint32"},{"internalType":"string[]","name":"stop_sequence","type":"string[]"},{"internalType":"uint32","name":"temperature","type":"uint32"}],"internalType":"struct LLMChatRequest","name":"request","type":"tuple"}],"name":"runLLMChat","outputs":[{"components":[{"internalType":"string","name":"finish_reason","type":"string"},{"components":[{"internalType":"string","name":"role","type":"string"},{"internalType":"string","name":"content","type":"string"},{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"tool_call_id","type":"string"},{"components":[{"internalType":"string","name":"id","type":"string"},{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"arguments","type":"string"}],"internalType":"struct ToolCall[]","name":"tool_calls","type":"tuple[]"}],"internalType":"struct ChatMessage","name":"message","type":"tuple"}],"internalType":"struct LLMChatResponse","name":"","type":"tuple"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"enum LLMInferenceMode","name":"mode","type":"uint8"},{"internalType":"string","name":"modelCID","type":"string"},{"internalType":"string","name":"prompt","type":"string"},{"internalType":"uint32","name":"max_tokens","type":"uint32"},{"internalType":"string[]","name":"stop_sequence","type":"string[]"},{"internalType":"uint32","name":"temperature","type":"uint32"}],"internalType":"struct LLMCompletionRequest","name":"request","type":"tuple"}],"name":"runLLMCompletion","outputs":[{"components":[{"internalType":"string","name":"answer","type":"string"}],"internalType":"struct LLMCompletionResponse","name":"","type":"tuple"}],"stateMutability":"nonpayable","type":"function"}]

opengradient/account.py

@@ -1,8 +1,9 @@
-from eth_account import Account
+import hashlib
+import os
 import secrets
 from collections import namedtuple
-import os
-import hashlib
+
+from eth_account import Account
 
 EthAccount = namedtuple('EthAccount', ['address', 'private_key'])
 

opengradient/cli.py

@@ -1,18 +1,26 @@
-import click
-import opengradient
-import json
 import ast
-from pathlib import Path
+import json
 import logging
-from pprint import pformat
-from typing import List
 import webbrowser
-import sys
+from pathlib import Path
+from typing import List, Dict, Optional
+from enum import Enum
+from . import types
 
+import click
+
+import opengradient
+
+from .account import EthAccount, generate_eth_account
 from .client import Client
-from .defaults import *
+from .defaults import (
+    DEFAULT_BLOCKCHAIN_EXPLORER,
+    DEFAULT_HUB_SIGNUP_URL,
+    DEFAULT_INFERENCE_CONTRACT_ADDRESS,
+    DEFAULT_OG_FAUCET_URL,
+    DEFAULT_RPC_URL,
+)
 from .types import InferenceMode
-from .account import EthAccount, generate_eth_account
 
 OG_CONFIG_FILE = Path.home() / '.opengradient_config.json'
 
@@ -50,13 +58,19 @@ class DictParamType(click.ParamType):
 
 Dict = DictParamType()
 
-# Support inference modes
+# Supported inference modes
 InferenceModes = {
     "VANILLA": InferenceMode.VANILLA,
     "ZKML": InferenceMode.ZKML,
     "TEE": InferenceMode.TEE,
 }
 
+# Supported LLMs
+LlmModels = {
+    "meta-llama/Meta-Llama-3-8B-Instruct",
+    "meta-llama/Llama-3.2-3B-Instruct",
+    "mistralai/Mistral-7B-Instruct-v0.3"
+}
 
 def initialize_config(ctx):
     """Interactively initialize OpenGradient config"""
@@ -307,11 +321,11 @@ def infer(ctx, model_cid: str, inference_mode: str, input_data, input_file: Path
         click.echo()  # Add a newline for better spacing
         click.secho("✅ Transaction successful", fg="green", bold=True)
         click.echo("──────────────────────────────────────")
-        click.echo(f"Transaction hash: ", nl=False)
+        click.echo("Transaction hash: ", nl=False)
         click.secho(tx_hash, fg="cyan", bold=True)
 
         block_explorer_link = f"{DEFAULT_BLOCKCHAIN_EXPLORER}0x{tx_hash}"
-        click.echo(f"Block explorer link: ", nl=False)
+        click.echo("Block explorer link: ", nl=False)
         click.secho(block_explorer_link, fg="blue", underline=True)
         click.echo()
 
@@ -325,28 +339,28 @@ def infer(ctx, model_cid: str, inference_mode: str, input_data, input_file: Path
         click.echo(f"Error running inference: {str(e)}")
 
 @cli.command()
-@click.option('--model', '-m', 'model_cid', required=True, help='CID of the LLM model to run inference on')
-@click.option('--prompt', '-p', required=True, help='Input prompt for the LLM')
-@click.option('--max-tokens', type=int, default=100, help='Maximum number of tokens for LLM output')
+@click.option('--model', '-m', 'model_cid', type=click.Choice(LlmModels), required=True, help='CID of the LLM model to run inference on')
+@click.option('--prompt', '-p', required=True, help='Input prompt for the LLM completion')
+@click.option('--max-tokens', type=int, default=100, help='Maximum number of tokens for LLM completion output')
 @click.option('--stop-sequence', multiple=True, help='Stop sequences for LLM')
 @click.option('--temperature', type=float, default=0.0, help='Temperature for LLM inference (0.0 to 1.0)')
 @click.pass_context
-def llm(ctx, model_cid: str, prompt: str, max_tokens: int, stop_sequence: List[str], temperature: float):
+def completion(ctx, model_cid: str, prompt: str, max_tokens: int, stop_sequence: List[str], temperature: float):
     """
-    Run inference on an LLM model.
+    Run completion inference on an LLM model.
 
-    This command runs inference on the specified LLM model using the provided prompt and parameters.
+    This command runs a completion inference on the specified LLM model using the provided prompt and parameters.
 
     Example usage:
 
     \b
-    opengradient llm --model Qm... --prompt "Hello, how are you?" --max-tokens 50 --temperature 0.7
-    opengradient llm -m Qm... -p "Translate to French: Hello world" --stop-sequence "." --stop-sequence "\n"
+    opengradient completion --model meta-llama/Meta-Llama-3-8B-Instruct --prompt "Hello, how are you?" --max-tokens 50 --temperature 0.7
+    opengradient completion -m meta-llama/Meta-Llama-3-8B-Instruct -p "Translate to French: Hello world" --stop-sequence "." --stop-sequence "\n"
     """
     client: Client = ctx.obj['client']
     try:
-        click.echo(f"Running LLM inference for model \"{model_cid}\"\n")
-        tx_hash, llm_output = client.infer_llm(
+        click.echo(f"Running LLM completion inference for model \"{model_cid}\"\n")
+        tx_hash, llm_output = client.llm_completion(
             model_cid=model_cid,
             prompt=prompt,
             max_tokens=max_tokens,
@@ -354,19 +368,19 @@ def llm(ctx, model_cid: str, prompt: str, max_tokens: int, stop_sequence: List[s
             temperature=temperature
         )
 
-        print_llm_inference_result(model_cid, tx_hash, llm_output)
+        print_llm_completion_result(model_cid, tx_hash, llm_output)
     except Exception as e:
-        click.echo(f"Error running LLM inference: {str(e)}")
+        click.echo(f"Error running LLM completion: {str(e)}")
 
-def print_llm_inference_result(model_cid, tx_hash, llm_output):
-    click.secho(f"✅ LLM Inference Successful", fg="green", bold=True)
+def print_llm_completion_result(model_cid, tx_hash, llm_output):
+    click.secho("✅ LLM completion Successful", fg="green", bold=True)
     click.echo("──────────────────────────────────────")
-    click.echo(f"Model CID: ", nl=False)
+    click.echo("Model CID: ", nl=False)
     click.secho(model_cid, fg="cyan", bold=True)
-    click.echo(f"Transaction hash: ", nl=False)
+    click.echo("Transaction hash: ", nl=False)
     click.secho(tx_hash, fg="cyan", bold=True)
     block_explorer_link = f"{DEFAULT_BLOCKCHAIN_EXPLORER}0x{tx_hash}"
-    click.echo(f"Block explorer link: ", nl=False)
+    click.echo("Block explorer link: ", nl=False)
     click.secho(block_explorer_link, fg="blue", underline=True)
     click.echo("──────────────────────────────────────")
     click.secho("LLM Output:", fg="yellow", bold=True)
@@ -374,6 +388,146 @@ def print_llm_inference_result(model_cid, tx_hash, llm_output):
     click.echo(llm_output)
     click.echo()
 
+
+@cli.command()
+@click.option('--model', '-m', 'model_cid', 
+              type=click.Choice([e.value for e in types.LLM]), 
+              required=True, 
+              help='CID of the LLM model to run inference on')
+@click.option('--messages', 
+              type=str,
+              required=False, 
+              help='Input messages for the chat inference in JSON format')
+@click.option('--messages-file', 
+              type=click.Path(exists=True, path_type=Path),
+              required=False, 
+              help='Path to JSON file containing input messages for the chat inference')
+@click.option('--max-tokens', 
+              type=int,
+              default=100, 
+              help='Maximum number of tokens for LLM output')
+@click.option('--stop-sequence',
+              type=str,
+              default=None,
+              multiple=True,
+              help='Stop sequences for LLM')
+@click.option('--temperature', 
+              type=float,
+              default=0.0,
+              help='Temperature for LLM inference (0.0 to 1.0)')
+@click.option('--tools',
+              type=str,
+              default="[]",
+              help='Tool configurations in JSON format')
+@click.option('--tools-file',
+              type=click.Path(exists=True, path_type=Path),
+              required=False,
+              help='Path to JSON file containing tool configurations')
+@click.option('--tool-choice',
+              type=str,
+              default='',
+              help='Specific tool choice for the LLM')
+@click.pass_context
+def chat(
+    ctx,
+    model_cid: str,
+    messages: Optional[str],
+    messages_file: Optional[Path],
+    max_tokens: int,
+    stop_sequence: List[str],
+    temperature: float,
+    tools: Optional[str],
+    tools_file: Optional[Path],
+    tool_choice: Optional[str]): 
+    """
+    Run chat inference on an LLM model.
+
+    This command runs a chat inference on the specified LLM model using the provided messages and parameters.
+
+    Example usage:
+
+    \b
+    opengradient chat --model meta-llama/Meta-Llama-3-8B-Instruct --messages '[{"role":"user","content":"hello"}]' --max-tokens 50 --temperature 0.7
+    opengradient chat -m mistralai/Mistral-7B-Instruct-v0.3 --messages-file messages.json --stop-sequence "." --stop-sequence "\n"
+    """
+    # TODO (Kyle): ^^^^^^^ Edit description with more examples using tools
+    client: Client = ctx.obj['client']
+    try:
+        click.echo(f"Running LLM chat inference for model \"{model_cid}\"\n")
+        if not messages and not messages_file:
+            click.echo("Must specify either messages or messages-file")
+            ctx.exit(1)
+            return
+        if messages and messages_file:
+            click.echo("Cannot have both messages and messages_file")
+            ctx.exit(1)
+            return
+
+        if messages:
+            try:
+                messages = json.loads(messages)
+            except Exception as e:
+                click.echo(f"Failed to parse messages: {e}")
+                ctx.exit(1)
+        else:
+            with messages_file.open('r') as file:
+                messages = json.load(file)
+
+        # Parse tools if provided
+        if (tools or tools != "[]") and tools_file:
+            click.echo("Cannot have both tools and tools_file")
+            click.exit(1)
+            return
+        
+        parsed_tools=[]
+        if tools:
+            try:
+                parsed_tools = json.loads(tools)
+                if not isinstance(parsed_tools, list):
+                    click.echo("Tools must be a JSON array")
+                    ctx.exit(1)
+                    return
+            except json.JSONDecodeError as e:
+                click.echo(f"Failed to parse tools JSON: {e}")
+                ctx.exit(1)
+                return
+
+        if tools_file:
+            try:
+                with tools_file.open('r') as file:
+                    parsed_tools = json.load(file)
+                if not isinstance(parsed_tools, list):
+                    click.echo("Tools must be a JSON array")
+                    ctx.exit(1)
+                    return
+            except Exception as e:
+                click.echo("Failed to load JSON from tools_file: %s" % e)
+                ctx.exit(1)
+                return
+            
+        if not tools and not tools_file:
+            parsed_tools = None
+
+        tx_hash, finish_reason, llm_chat_output = client.llm_chat(
+            model_cid=model_cid,
+            messages=messages,
+            max_tokens=max_tokens,
+            stop_sequence=list(stop_sequence),
+            temperature=temperature,
+            tools=parsed_tools,
+            tool_choice=tool_choice,
+        )
+
+        # TODO (Kyle): Make this prettier
+        print("TX Hash: ", tx_hash)
+        print("Finish reason: ", finish_reason)
+        print("Chat output: ", llm_chat_output)
+    except Exception as e:
+        click.echo(f"Error running LLM chat inference: {str(e)}")
+
+def print_llm_chat_result():
+    pass
+
 @cli.command()
 def create_account():
     """Create a new test account for OpenGradient inference and model management"""
@@ -389,7 +543,7 @@ def create_account_impl() -> EthAccount:
     click.echo("Step 1: Create Account on OpenGradient Hub")
     click.echo("-" * 50)
 
-    click.echo(f"Please create an account on the OpenGradient Hub")
+    click.echo("Please create an account on the OpenGradient Hub")
     webbrowser.open(DEFAULT_HUB_SIGNUP_URL, new=2)
     click.confirm("Have you successfully created your account on the OpenGradient Hub?", abort=True)
 
@@ -402,7 +556,7 @@ def create_account_impl() -> EthAccount:
     click.echo("\n" + "-" * 50)
     click.echo("Step 3: Fund Your Account")
     click.echo("-" * 50)
-    click.echo(f"Please fund your account clicking 'Request' on the Faucet website")
+    click.echo("Please fund your account clicking 'Request' on the Faucet website")
     webbrowser.open(DEFAULT_OG_FAUCET_URL + eth_account.address, new=2)
     click.confirm("Have you successfully funded your account using the Faucet?", abort=True)
 

opengradient/client.py

@@ -1,15 +1,19 @@
-import requests
-import os
 import json
-from web3 import Web3
-from opengradient.exceptions import OpenGradientError
-from opengradient.types import InferenceMode
-from opengradient import utils
-import numpy as np
 import logging
-from typing import Dict, Optional, Tuple, Union, List
-from web3.exceptions import ContractLogicError
+import os
+from typing import Dict, List, Optional, Tuple, Union
+
 import firebase
+import numpy as np
+import requests
+from web3 import Web3
+from web3.exceptions import ContractLogicError
+from web3.logs import DISCARD
+
+from opengradient import utils
+from opengradient.exceptions import OpenGradientError
+from opengradient.types import InferenceMode, LLM
+
 
 class Client:
     FIREBASE_CONFIG = {
@@ -100,7 +104,7 @@ class Client:
         if not self.user:
             raise ValueError("User not authenticated")
 
-        url = f"https://api.opengradient.ai/api/v0/models/"
+        url = "https://api.opengradient.ai/api/v0/models/"
         headers = {
             'Authorization': f'Bearer {self.user["idToken"]}',
             'Content-Type': 'application/json'
@@ -186,15 +190,15 @@ class Client:
             logging.debug(f"Full server response: {json_response}")
 
             if isinstance(json_response, list) and not json_response:
-                logging.info(f"Server returned an empty list. Assuming version was created successfully.")
+                logging.info("Server returned an empty list. Assuming version was created successfully.")
                 return {"versionString": "Unknown", "note": "Created based on empty response"}
             elif isinstance(json_response, dict):
-                versionString = json_response.get('versionString')
-                if not versionString:
+                version_string = json_response.get('versionString')
+                if not version_string:
                     logging.warning(f"'versionString' not found in response. Response: {json_response}")
                     return {"versionString": "Unknown", "note": "Version ID not provided in response"}
-                logging.info(f"Version creation successful. Version ID: {versionString}")
-                return {"versionString": versionString}
+                logging.info(f"Version creation successful. Version ID: {version_string}")
+                return {"versionString": version_string}
             else:
                 logging.error(f"Unexpected response type: {type(json_response)}. Content: {json_response}")
                 raise Exception(f"Unexpected response type: {type(json_response)}")
@@ -295,7 +299,12 @@ class Client:
             logging.error(f"Unexpected error during upload: {str(e)}", exc_info=True)
             raise OpenGradientError(f"Unexpected error during upload: {str(e)}")
     
-    def infer(self, model_cid: str, inference_mode: InferenceMode, model_input: Dict[str, Union[str, int, float, List, np.ndarray]]) -> Tuple[str, Dict[str, np.ndarray]]:
+    def infer(
+            self, 
+            model_cid: str, 
+            inference_mode: InferenceMode, 
+            model_input: Dict[str, Union[str, int, float, List, np.ndarray]]
+            ) -> Tuple[str, Dict[str, np.ndarray]]:
         """
         Perform inference on a model.
 
@@ -376,19 +385,11 @@ class Client:
                 raise ContractLogicError(f"Transaction failed. Receipt: {tx_receipt}")
 
             # Process the InferenceResult event
-            inference_result = None
-            for log in tx_receipt['logs']:
-                try:
-                    decoded_log = contract.events.InferenceResult().process_log(log)
-                    inference_result = decoded_log
-                    break
-                except:
-                    continue
-
-            if inference_result is None:
-                logging.error("InferenceResult event not found in transaction logs")
-                logging.debug(f"Transaction receipt logs: {tx_receipt['logs']}")
+            parsed_logs = contract.events.InferenceResult().process_receipt(tx_receipt, errors=DISCARD)
+
+            if len(parsed_logs) < 1:
                 raise OpenGradientError("InferenceResult event not found in transaction logs")
+            inference_result = parsed_logs[0]
 
             # Extract the ModelOutput from the event
             event_data = inference_result['args']
@@ -410,24 +411,24 @@ class Client:
             logging.error(f"Error in infer method: {str(e)}", exc_info=True)
             raise OpenGradientError(f"Inference failed: {str(e)}")
         
-    def infer_llm(self, 
-                  model_cid: str, 
-                  prompt: str, 
-                  max_tokens: int = 100, 
-                  stop_sequence: Optional[List[str]] = None, 
-                  temperature: float = 0.0) -> Tuple[str, str]:
+    def llm_completion(self, 
+                       model_cid: LLM, 
+                       prompt: str, 
+                       max_tokens: int = 100, 
+                       stop_sequence: Optional[List[str]] = None, 
+                       temperature: float = 0.0) -> Tuple[str, str]:
         """
         Perform inference on an LLM model using completions.
 
         Args:
-            model_cid (str): The unique content identifier for the model.
+            model_cid (LLM): The unique content identifier for the model.
             prompt (str): The input prompt for the LLM.
             max_tokens (int): Maximum number of tokens for LLM output. Default is 100.
             stop_sequence (List[str], optional): List of stop sequences for LLM. Default is None.
             temperature (float): Temperature for LLM inference, between 0 and 1. Default is 0.0.
 
         Returns:
-            Tuple[str, str]: The transaction hash and the LLM output.
+            Tuple[str, str]: The transaction hash and the LLM completion output.
 
         Raises:
             OpenGradientError: If the inference fails.
@@ -435,7 +436,7 @@ class Client:
         try:
             self._initialize_web3()
             
-            abi_path = os.path.join(os.path.dirname(__file__), 'abi', 'llm.abi')
+            abi_path = os.path.join(os.path.dirname(__file__), 'abi', 'inference.abi')
             with open(abi_path, 'r') as abi_file:
                 llm_abi = json.load(abi_file)
             contract = self._w3.eth.contract(address=self.contract_address, abi=llm_abi)
@@ -452,7 +453,166 @@ class Client:
             logging.debug(f"Prepared LLM request: {llm_request}")
 
             # Prepare run function
-            run_function = contract.functions.runLLM(llm_request)
+            run_function = contract.functions.runLLMCompletion(llm_request)
+
+            # Build transaction
+            nonce = self._w3.eth.get_transaction_count(self.wallet_address)
+            estimated_gas = run_function.estimate_gas({'from': self.wallet_address})
+            gas_limit = int(estimated_gas * 1.2)
+
+            transaction = run_function.build_transaction({
+                'from': self.wallet_address,
+                'nonce': nonce,
+                'gas': gas_limit,
+                'gasPrice': self._w3.eth.gas_price,
+            })
+
+            # Sign and send transaction
+            signed_tx = self._w3.eth.account.sign_transaction(transaction, self.private_key)
+            tx_hash = self._w3.eth.send_raw_transaction(signed_tx.raw_transaction)
+            logging.debug(f"Transaction sent. Hash: {tx_hash.hex()}")
+
+            # Wait for transaction receipt
+            tx_receipt = self._w3.eth.wait_for_transaction_receipt(tx_hash)
+
+            if tx_receipt['status'] == 0:
+                raise ContractLogicError(f"Transaction failed. Receipt: {tx_receipt}")
+
+            # Process the LLMResult event
+            parsed_logs = contract.events.LLMCompletionResult().process_receipt(tx_receipt, errors=DISCARD)
+
+            if len(parsed_logs) < 1:
+                raise OpenGradientError("LLM completion result event not found in transaction logs")
+            llm_result = parsed_logs[0]
+
+            llm_answer = llm_result['args']['response']['answer']
+            return tx_hash.hex(), llm_answer
+
+        except ContractLogicError as e:
+            logging.error(f"Contract logic error: {str(e)}", exc_info=True)
+            raise OpenGradientError(f"LLM inference failed due to contract logic error: {str(e)}")
+        except Exception as e:
+            logging.error(f"Error in infer completion method: {str(e)}", exc_info=True)
+            raise OpenGradientError(f"LLM inference failed: {str(e)}")
+        
+    def llm_chat(self,
+                 model_cid: str,
+                 messages: List[Dict],
+                 max_tokens: int = 100,
+                 stop_sequence: Optional[List[str]] = None,
+                 temperature: float = 0.0,
+                 tools: Optional[List[Dict]] = [],
+                 tool_choice: Optional[str] = None) -> Tuple[str, str]:
+        """
+        Perform inference on an LLM model using chat.
+
+        Args:
+            model_cid (LLM): The unique content identifier for the model.
+            messages (dict): The messages that will be passed into the chat. 
+                This should be in OpenAI API format (https://platform.openai.com/docs/api-reference/chat/create)
+                Example:
+                [
+                    {
+                        "role": "system",
+                        "content": "You are a helpful assistant."
+                    },
+                    {
+                        "role": "user",
+                        "content": "Hello!"
+                    }
+                ]
+            max_tokens (int): Maximum number of tokens for LLM output. Default is 100.
+            stop_sequence (List[str], optional): List of stop sequences for LLM. Default is None.
+            temperature (float): Temperature for LLM inference, between 0 and 1. Default is 0.0.
+            tools (List[dict], optional): Set of tools
+                This should be in OpenAI API format (https://platform.openai.com/docs/api-reference/chat/create#chat-create-tools)
+                Example:
+                [
+                    {
+                        "type": "function",
+                        "function": {
+                            "name": "get_current_weather",
+                            "description": "Get the current weather in a given location",
+                            "parameters": {
+                                "type": "object",
+                                "properties": {
+                                    "location": {
+                                        "type": "string",
+                                        "description": "The city and state, e.g. San Francisco, CA"
+                                    },
+                                    "unit": {
+                                        "type": "string",
+                                        "enum": ["celsius", "fahrenheit"]
+                                    }
+                                },
+                                "required": ["location"]
+                            }
+                        }
+                    }
+                ]
+            tool_choice (str, optional): Sets a specific tool to choose. Default value is "auto". 
+
+        Returns:
+            Tuple[str, str, dict]: The transaction hash, finish reason, and a dictionary struct of LLM chat messages.
+
+        Raises:
+            OpenGradientError: If the inference fails.
+        """
+        try:
+            self._initialize_web3()
+            
+            abi_path = os.path.join(os.path.dirname(__file__), 'abi', 'inference.abi')
+            with open(abi_path, 'r') as abi_file:
+                llm_abi = json.load(abi_file)
+            contract = self._w3.eth.contract(address=self.contract_address, abi=llm_abi)
+
+            # For incoming chat messages, tool_calls can be empty. Add an empty array so that it will fit the ABI.
+            for message in messages:
+                if 'tool_calls' not in message:
+                    message['tool_calls'] = []
+                if 'tool_call_id' not in message:
+                    message['tool_call_id'] = ""
+                if 'name' not in message:
+                    message['name'] = ""
+
+            # Create simplified tool structure for smart contract
+            #
+            #   struct ToolDefinition {
+            #       string description;
+            #       string name;
+            #       string parameters; // This must be a JSON 
+            #   }
+            converted_tools = []
+            if tools is not None:
+                for tool in tools:
+                    function = tool['function']
+
+                    converted_tool = {}
+                    converted_tool['name'] = function['name']
+                    converted_tool['description'] = function['description']
+                    if (parameters := function.get('parameters')) is not None:
+                        try:
+                            converted_tool['parameters'] = json.dumps(parameters)
+                        except Exception as e:
+                            raise OpenGradientError("Chat LLM failed to convert parameters into JSON: %s", e)
+                    
+                    converted_tools.append(converted_tool)
+
+            # Prepare LLM input
+            llm_request = {
+                "mode": InferenceMode.VANILLA,
+                "modelCID": model_cid,
+                "messages": messages,
+                "max_tokens": max_tokens,
+                "stop_sequence": stop_sequence or [],
+                "temperature": int(temperature * 100),  # Scale to 0-100 range
+                "tools": converted_tools or [],
+                "tool_choice": tool_choice if tool_choice else ("" if tools is None else "auto")
+            }
+            logging.debug(f"Prepared LLM request: {llm_request}")
+
+            # Prepare run function
+            run_function = contract.functions.runLLMChat(llm_request)
 
             # Build transaction
             nonce = self._w3.eth.get_transaction_count(self.wallet_address)
@@ -478,27 +638,27 @@ class Client:
                 raise ContractLogicError(f"Transaction failed. Receipt: {tx_receipt}")
 
             # Process the LLMResult event
-            llm_result = None
-            for log in tx_receipt['logs']:
-                try:
-                    decoded_log = contract.events.LLMResult().process_log(log)
-                    llm_result = decoded_log['args']['response']['answer']
-                    break
-                except:
-                    continue
+            parsed_logs = contract.events.LLMChatResult().process_receipt(tx_receipt, errors=DISCARD)
 
-            if llm_result is None:
-                raise OpenGradientError("LLMResult event not found in transaction logs")
+            if len(parsed_logs) < 1:
+                raise OpenGradientError("LLM chat result event not found in transaction logs")
+            llm_result = parsed_logs[0]['args']['response']
 
-            logging.debug(f"LLM output: {llm_result}")
+            # Turn tool calls into normal dicts
+            message = dict(llm_result['message'])
+            if (tool_calls := message.get('tool_calls')) != None:
+                new_tool_calls = []
+                for tool_call in tool_calls:
+                    new_tool_calls.append(dict(tool_call))
+                message['tool_calls'] = new_tool_calls
 
-            return tx_hash.hex(), llm_result
+            return (tx_hash.hex(), llm_result['finish_reason'], message)
 
         except ContractLogicError as e:
             logging.error(f"Contract logic error: {str(e)}", exc_info=True)
             raise OpenGradientError(f"LLM inference failed due to contract logic error: {str(e)}")
         except Exception as e:
-            logging.error(f"Error in infer_llm method: {str(e)}", exc_info=True)
+            logging.error(f"Error in infer chat method: {str(e)}", exc_info=True)
             raise OpenGradientError(f"LLM inference failed: {str(e)}")
 
 

opengradient/defaults.py

@@ -3,5 +3,5 @@
 DEFAULT_RPC_URL="http://18.218.115.248:8545"
 DEFAULT_OG_FAUCET_URL="http://18.218.115.248:8080/?address="
 DEFAULT_HUB_SIGNUP_URL="https://hub.opengradient.ai/signup"
-DEFAULT_INFERENCE_CONTRACT_ADDRESS="0x24Ec56879245C707220Af7234d2fF3F22cA9Aa63"
+DEFAULT_INFERENCE_CONTRACT_ADDRESS="0xF78F7d5a7e9f484f0924Cc21347029715bD3B8f4"
 DEFAULT_BLOCKCHAIN_EXPLORER="http://3.145.62.2/tx/"

opengradient/types.py

@@ -1,5 +1,6 @@
-from typing import List, Tuple, Union
 from dataclasses import dataclass
+from typing import List, Tuple, Union
+from enum import Enum
 
 @dataclass
 class Number:
@@ -9,7 +10,7 @@ class Number:
 @dataclass
 class NumberTensor:
     name: str
-    values: List[Tuple[int, int]]  # (int128, int128)[]
+    values: List[Tuple[int, int]]
 
 @dataclass
 class StringTensor:
@@ -37,7 +38,7 @@ class AbiFunction:
     name: str
     inputs: List[Union[str, 'AbiFunction']]
     outputs: List[Union[str, 'AbiFunction']]
-    stateMutability: str
+    state_mutability: str
 
 @dataclass
 class Abi:
@@ -54,7 +55,7 @@ class Abi:
                     name=item['name'],
                     inputs=inputs,
                     outputs=outputs,
-                    stateMutability=item['stateMutability']
+                    state_mutability=item['stateMutability']
                 ))
         return cls(functions=functions)
 
@@ -67,8 +68,13 @@ class Abi:
                     name=item['name'],
                     inputs=Abi._parse_inputs_outputs(item['components']),
                     outputs=[],
-                    stateMutability=''
+                    state_mutability=''
                 ))
             else:
                 result.append(f"{item['name']}:{item['type']}")
-        return result
+        return result
+    
+class LLM(str, Enum):
+    META_LLAMA3_8B_INSTRUCT = "meta-llama/Meta-Llama-3-8B-Instruct"
+    LLAMA_3_2_3B_INSTRUCT = "meta-llama/Llama-3.2-3B-Instruct"
+    MISTRAL_7B_INSTRUCT_V3 = "mistralai/Mistral-7B-Instruct-v0.3"

opengradient/utils.py

@@ -1,9 +1,11 @@
-import numpy as np
 import logging
 from decimal import Decimal
 from typing import Dict, List, Tuple
+
+import numpy as np
 from web3.datastructures import AttributeDict
 
+
 def convert_to_fixed_point(number: float) -> Tuple[int, int]:
     """
     Converts input number to the Number tensor used by the sequencer.
@@ -36,14 +38,16 @@ def convert_to_float32(value: int, decimals: int) -> np.float32:
     """
     return np.float32(Decimal(value) / (10 ** Decimal(decimals)))
 
-def convert_to_model_input(inputs: Dict[str, np.ndarray]) -> Tuple[List[Tuple[str, List[Tuple[int, int]]]], List[Tuple[str, List[str]]]]:
+def convert_to_model_input(
+        inputs: Dict[str, np.ndarray]
+    ) -> Tuple[List[Tuple[str, List[Tuple[int, int]]]], List[Tuple[str, List[str]]]]:
     """
     Expect SDK input to be a dict with the format
         key: tensor name
         value: np.array / list
 
-    Return a tuple of (number tensors, string tensors) depending on the input type. Each number and string tensor converted
-    to a numpy array and flattened and the shape saved.
+    Return a tuple of (number tensors, string tensors) depending on the input type.
+    Each number and string tensor converted to a numpy array and flattened and the shape saved.
     """
     logging.debug("Converting the following input dictionary to ModelInput: %s", inputs)
     number_tensors = []
@@ -60,7 +64,9 @@ def convert_to_model_input(inputs: Dict[str, np.ndarray]) -> Tuple[List[Tuple[st
 
         # Check if type is np array
         if not isinstance(tensor_data, np.ndarray):
-            raise TypeError("Inference input must be list, numpy array, or type (str, int, float): %s" % type(tensor_data))
+            raise TypeError(
+                "Inference input must be list, numpy array, or type (str, int, float): %s" 
+                % type(tensor_data))
 
         # Flatten list and retain shape
         shape = tensor_data.shape

{opengradient-0.3.5.dist-info → opengradient-0.3.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: opengradient
-Version: 0.3.5
+Version: 0.3.6
 Summary: Python SDK for OpenGradient decentralized model management & inference services
 Author-email: OpenGradient <oliver@opengradient.ai>
 License: MIT License
@@ -29,14 +29,10 @@ Project-URL: Homepage, https://opengradient.ai
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Python: >=3.7
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiohappyeyeballs==2.4.3

opengradient-0.3.6.dist-info/RECORD

@@ -0,0 +1,15 @@
+opengradient/__init__.py,sha256=_n-w4S35NVarz8_d1l2dQ3750zWQ42woGm02XZoxwK8,3110
+opengradient/account.py,sha256=2B7rtCXQDX-yF4U69h8B9-OUreJU4IqoGXG_1Hn9nWs,1150
+opengradient/cli.py,sha256=Mv7iAyeBFUxaXL1hDIgHgn5x-GCMdi2BQgY6zrOkg_4,23003
+opengradient/client.py,sha256=yaexPTr-CSPQXR5AOrhHDmygKCq37Q_FIVy8Mtq6THk,31253
+opengradient/defaults.py,sha256=jweJ6QyzNY0oO22OUA8B-uJPA90cyedhMT9J38MmGjw,319
+opengradient/exceptions.py,sha256=v4VmUGTvvtjhCZAhR24Ga42z3q-DzR1Y5zSqP_yn2Xk,3366
+opengradient/types.py,sha256=Hkp0cXveMtNKxMpcwIHl1n4OGgYxx0HQM70qA05SZV8,2076
+opengradient/utils.py,sha256=_dEIhepJXjJFfHLGTUwXloZJXnlQbvwqHSPu08548jI,6532
+opengradient/abi/inference.abi,sha256=VMxv4pli9ESYL2hCpbU41Z_WweCBy_3EcTYkCWCb-rU,6623
+opengradient-0.3.6.dist-info/LICENSE,sha256=xEcvQ3AxZOtDkrqkys2Mm6Y9diEnaSeQRKvxi-JGnNA,1069
+opengradient-0.3.6.dist-info/METADATA,sha256=FWD86cWEvUXfyH6-gu3-oSAc5lOezUKFN7jejuPs3Ug,7608
+opengradient-0.3.6.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+opengradient-0.3.6.dist-info/entry_points.txt,sha256=yUKTaJx8RXnybkob0J62wVBiCp_1agVbgw9uzsmaeJc,54
+opengradient-0.3.6.dist-info/top_level.txt,sha256=oC1zimVLa2Yi1LQz8c7x-0IQm92milb5ax8gHBHwDqU,13
+opengradient-0.3.6.dist-info/RECORD,,

{opengradient-0.3.5.dist-info → opengradient-0.3.6.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.2.0)
+Generator: setuptools (75.3.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

opengradient/abi/llm.abi

@@ -1 +0,0 @@
-[{"anonymous":false,"inputs":[{"components":[{"components":[{"internalType":"string","name":"name","type":"string"},{"components":[{"internalType":"int128","name":"value","type":"int128"},{"internalType":"int128","name":"decimals","type":"int128"}],"internalType":"struct TensorLib.Number[]","name":"values","type":"tuple[]"},{"internalType":"uint32[]","name":"shape","type":"uint32[]"}],"internalType":"struct TensorLib.MultiDimensionalNumberTensor[]","name":"numbers","type":"tuple[]"},{"components":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string[]","name":"values","type":"string[]"}],"internalType":"struct TensorLib.StringTensor[]","name":"strings","type":"tuple[]"},{"internalType":"bool","name":"is_simulation_result","type":"bool"}],"indexed":false,"internalType":"struct ModelOutput","name":"output","type":"tuple"}],"name":"InferenceResult","type":"event"},{"anonymous":false,"inputs":[{"components":[{"internalType":"string","name":"answer","type":"string"}],"indexed":false,"internalType":"struct LlmResponse","name":"response","type":"tuple"}],"name":"LLMResult","type":"event"},{"inputs":[{"internalType":"string","name":"modelId","type":"string"},{"internalType":"enum ModelInferenceMode","name":"inferenceMode","type":"uint8"},{"components":[{"components":[{"internalType":"string","name":"name","type":"string"},{"components":[{"internalType":"int128","name":"value","type":"int128"},{"internalType":"int128","name":"decimals","type":"int128"}],"internalType":"struct TensorLib.Number[]","name":"values","type":"tuple[]"},{"internalType":"uint32[]","name":"shape","type":"uint32[]"}],"internalType":"struct TensorLib.MultiDimensionalNumberTensor[]","name":"numbers","type":"tuple[]"},{"components":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string[]","name":"values","type":"string[]"}],"internalType":"struct TensorLib.StringTensor[]","name":"strings","type":"tuple[]"}],"internalType":"struct ModelInput","name":"modelInput","type":"tuple"}],"name":"run","outputs":[{"components":[{"components":[{"internalType":"string","name":"name","type":"string"},{"components":[{"internalType":"int128","name":"value","type":"int128"},{"internalType":"int128","name":"decimals","type":"int128"}],"internalType":"struct TensorLib.Number[]","name":"values","type":"tuple[]"},{"internalType":"uint32[]","name":"shape","type":"uint32[]"}],"internalType":"struct TensorLib.MultiDimensionalNumberTensor[]","name":"numbers","type":"tuple[]"},{"components":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string[]","name":"values","type":"string[]"}],"internalType":"struct TensorLib.StringTensor[]","name":"strings","type":"tuple[]"},{"internalType":"bool","name":"is_simulation_result","type":"bool"}],"internalType":"struct ModelOutput","name":"","type":"tuple"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"enum LlmInferenceMode","name":"mode","type":"uint8"},{"internalType":"string","name":"modelCID","type":"string"},{"internalType":"string","name":"prompt","type":"string"},{"internalType":"uint32","name":"max_tokens","type":"uint32"},{"internalType":"string[]","name":"stop_sequence","type":"string[]"},{"internalType":"uint32","name":"temperature","type":"uint32"}],"internalType":"struct LlmInferenceRequest","name":"request","type":"tuple"}],"name":"runLLM","outputs":[{"components":[{"internalType":"string","name":"answer","type":"string"}],"internalType":"struct LlmResponse","name":"","type":"tuple"}],"stateMutability":"nonpayable","type":"function"}]

opengradient-0.3.5.dist-info/RECORD

@@ -1,16 +0,0 @@
-opengradient/__init__.py,sha256=sRZyD9zh_QZFC8H9P8T8pOL5l_ebe3I7hn_gTbTzr6I,2976
-opengradient/account.py,sha256=s1C4hAtc8vcHObWjwxwlYJA041S6DTbr7-rK6qiWPsQ,1149
-opengradient/cli.py,sha256=gbYJcfLWSZRQ8-xZ2OM0PbicutVGclMiCvCFIQxkvD0,17548
-opengradient/client.py,sha256=DCDp2EWPF62ZQnx2_cM0wPghRxgn213VnR65R8yZBVY,23964
-opengradient/defaults.py,sha256=YI84_wWTvWxPMQIuKiSair2wffATnhitE3Ll2P1jHMU,319
-opengradient/exceptions.py,sha256=v4VmUGTvvtjhCZAhR24Ga42z3q-DzR1Y5zSqP_yn2Xk,3366
-opengradient/types.py,sha256=EoJN-DkQrJ2WTUv8OenlrlWJWFY2jPGTl-T8C_OVjp8,1849
-opengradient/utils.py,sha256=F1Nj-GMNFQFxCtbGgWQq1RP4TSurbpQxJV3yKeEo1b0,6482
-opengradient/abi/inference.abi,sha256=u8FsW0s1YeRjUb9eLS1k_qh_5f_cwOdr0bii-tAdxh0,2683
-opengradient/abi/llm.abi,sha256=zhiPFyBT09EI3QU5DVoKHo7e8T9PFcfIQ3RHDYetm4M,3609
-opengradient-0.3.5.dist-info/LICENSE,sha256=xEcvQ3AxZOtDkrqkys2Mm6Y9diEnaSeQRKvxi-JGnNA,1069
-opengradient-0.3.5.dist-info/METADATA,sha256=jqfpyRml-74KsXuOK-b0nA9RyU9jOS4vUbizBTbr38k,7805
-opengradient-0.3.5.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
-opengradient-0.3.5.dist-info/entry_points.txt,sha256=yUKTaJx8RXnybkob0J62wVBiCp_1agVbgw9uzsmaeJc,54
-opengradient-0.3.5.dist-info/top_level.txt,sha256=oC1zimVLa2Yi1LQz8c7x-0IQm92milb5ax8gHBHwDqU,13
-opengradient-0.3.5.dist-info/RECORD,,