opengradient 0.4.5__py3-none-any.whl → 0.4.7__py3-none-any.whl

opengradient/client.py

@@ -2,12 +2,10 @@ import json
 import logging
 import os
 import time
-import uuid
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any, Dict, List, Optional, Union
 
 import firebase
-import grpc
 import numpy as np
 import requests
 from eth_account.account import LocalAccount
@@ -18,8 +16,18 @@ from web3.logs import DISCARD
 from . import utils
 from .exceptions import OpenGradientError
 from .proto import infer_pb2, infer_pb2_grpc
-from .types import LLM, TEE_LLM, HistoricalInputQuery, InferenceMode, LlmInferenceMode, ModelOutput, SchedulerParams
-from .defaults import DEFAULT_IMAGE_GEN_HOST, DEFAULT_IMAGE_GEN_PORT
+from .types import (
+    LLM,
+    TEE_LLM,
+    HistoricalInputQuery,
+    InferenceMode,
+    LlmInferenceMode,
+    ModelOutput,
+    TextGenerationOutput,
+    SchedulerParams,
+    InferenceResult,
+)
+from .defaults import DEFAULT_IMAGE_GEN_HOST, DEFAULT_IMAGE_GEN_PORT, DEFAULT_SCHEDULER_ADDRESS
 
 _FIREBASE_CONFIG = {
     "apiKey": "AIzaSyDUVckVtfl-hiteBzPopy1pDD8Uvfncs7w",
@@ -48,7 +56,7 @@ class Client:
     _hub_user: Dict
     _inference_abi: Dict
 
-    def __init__(self, private_key: str, rpc_url: str, contract_address: str, email: str, password: str):
+    def __init__(self, private_key: str, rpc_url: str, contract_address: str, email: Optional[str], password: Optional[str]):
         """
         Initialize the Client with private key, RPC URL, and contract address.
 
@@ -137,7 +145,7 @@ class Client:
             logging.error(f"Unexpected error during model creation: {str(e)}")
             raise
 
-    def create_version(self, model_name: str, notes: str = None, is_major: bool = False) -> dict:
+    def create_version(self, model_name: str, notes: str = "", is_major: bool = False) -> dict:
         """
         Create a new version for the specified model.
 
@@ -273,9 +281,7 @@ class Client:
             if hasattr(e, "response") and e.response is not None:
                 logging.error(f"Response status code: {e.response.status_code}")
                 logging.error(f"Response content: {e.response.text[:1000]}...")  # Log first 1000 characters
-            raise OpenGradientError(
-                f"Upload failed due to request exception: {str(e)}", status_code=e.response.status_code if hasattr(e, "response") else None
-            )
+            raise OpenGradientError(f"Upload failed due to request exception: {str(e)}")
         except Exception as e:
             logging.error(f"Unexpected error during upload: {str(e)}", exc_info=True)
             raise OpenGradientError(f"Unexpected error during upload: {str(e)}")
@@ -286,7 +292,7 @@ class Client:
         inference_mode: InferenceMode,
         model_input: Dict[str, Union[str, int, float, List, np.ndarray]],
         max_retries: Optional[int] = None,
-    ) -> Tuple[str, Dict[str, np.ndarray]]:
+    ) -> InferenceResult:
         """
         Perform inference on a model.
 
@@ -297,7 +303,7 @@ class Client:
             max_retries (int, optional): Maximum number of retry attempts. Defaults to 5.
 
         Returns:
-            Tuple[str, Dict[str, np.ndarray]]: The transaction hash and the model output.
+            InferenceResult: The transaction hash and the model output.
 
         Raises:
             OpenGradientError: If the inference fails.
@@ -306,7 +312,7 @@ class Client:
         def execute_transaction():
             contract = self._blockchain.eth.contract(address=self._inference_hub_contract_address, abi=self._inference_abi)
 
-            inference_mode_uint8 = int(inference_mode)
+            inference_mode_uint8 = inference_mode.value
             converted_model_input = utils.convert_to_model_input(model_input)
 
             run_function = contract.functions.run(model_cid, inference_mode_uint8, converted_model_input)
@@ -337,20 +343,21 @@ class Client:
 
             # TODO: This should return a ModelOutput class object
             model_output = utils.convert_to_model_output(parsed_logs[0]["args"])
-            return tx_hash.hex(), model_output
+
+            return InferenceResult(tx_hash.hex(), model_output)
 
         return run_with_retry(execute_transaction, max_retries)
 
     def llm_completion(
         self,
         model_cid: LLM,
-        inference_mode: InferenceMode,
+        inference_mode: LlmInferenceMode,
         prompt: str,
         max_tokens: int = 100,
         stop_sequence: Optional[List[str]] = None,
         temperature: float = 0.0,
         max_retries: Optional[int] = None,
-    ) -> Tuple[str, str]:
+    ) -> TextGenerationOutput:
         """
         Perform inference on an LLM model using completions.
 
@@ -363,7 +370,9 @@ class Client:
             temperature (float): Temperature for LLM inference, between 0 and 1. Default is 0.0.
 
         Returns:
-            Tuple[str, str]: The transaction hash and the LLM completion output.
+            TextGenerationOutput: Generated text results including:
+                - Transaction hash
+                - String of completion output
 
         Raises:
             OpenGradientError: If the inference fails.
@@ -381,7 +390,7 @@ class Client:
 
             # Prepare LLM input
             llm_request = {
-                "mode": inference_mode,
+                "mode": inference_mode.value,
                 "modelCID": model_cid,
                 "prompt": prompt,
                 "max_tokens": max_tokens,
@@ -418,14 +427,15 @@ class Client:
                 raise OpenGradientError("LLM completion result event not found in transaction logs")
 
             llm_answer = parsed_logs[0]["args"]["response"]["answer"]
-            return tx_hash.hex(), llm_answer
+
+            return TextGenerationOutput(transaction_hash=tx_hash.hex(), completion_output=llm_answer)
 
         return run_with_retry(execute_transaction, max_retries)
 
     def llm_chat(
         self,
         model_cid: LLM,
-        inference_mode: InferenceMode,
+        inference_mode: LlmInferenceMode,
         messages: List[Dict],
         max_tokens: int = 100,
         stop_sequence: Optional[List[str]] = None,
@@ -433,7 +443,7 @@ class Client:
         tools: Optional[List[Dict]] = [],
         tool_choice: Optional[str] = None,
         max_retries: Optional[int] = None,
-    ) -> Tuple[str, str]:
+    ) -> TextGenerationOutput:
         """
         Perform inference on an LLM model using chat.
 
@@ -485,7 +495,10 @@ class Client:
             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.
+            TextGenerationOutput: Generated text results including:
+                - Transaction hash
+                - Finish reason (tool_call, stop, etc.)
+                - Dictionary of chat message output (role, content, tool_call, etc.)
 
         Raises:
             OpenGradientError: If the inference fails.
@@ -527,7 +540,7 @@ class Client:
 
             # Prepare LLM input
             llm_request = {
-                "mode": inference_mode,
+                "mode": inference_mode.value,
                 "modelCID": model_cid,
                 "messages": messages,
                 "max_tokens": max_tokens,
@@ -570,7 +583,11 @@ class Client:
             if (tool_calls := message.get("tool_calls")) is not None:
                 message["tool_calls"] = [dict(tool_call) for tool_call in tool_calls]
 
-            return tx_hash.hex(), llm_result["finish_reason"], message
+            return TextGenerationOutput(
+                transaction_hash=tx_hash.hex(),
+                finish_reason=llm_result["finish_reason"],
+                chat_output=message,
+            )
 
         return run_with_retry(execute_transaction, max_retries)
 
@@ -611,233 +628,265 @@ class Client:
             if hasattr(e, "response") and e.response is not None:
                 logging.error(f"Response status code: {e.response.status_code}")
                 logging.error(f"Response content: {e.response.text[:1000]}...")  # Log first 1000 characters
-            raise OpenGradientError(
-                f"File listing failed: {str(e)}", status_code=e.response.status_code if hasattr(e, "response") else None
-            )
+            raise OpenGradientError(f"File listing failed: {str(e)}")
         except Exception as e:
             logging.error(f"Unexpected error during file listing: {str(e)}", exc_info=True)
             raise OpenGradientError(f"Unexpected error during file listing: {str(e)}")
 
-    def generate_image(
-        self,
-        model_cid: str,
-        prompt: str,
-        host: str = DEFAULT_IMAGE_GEN_HOST,
-        port: int = DEFAULT_IMAGE_GEN_PORT,
-        width: int = 1024,
-        height: int = 1024,
-        timeout: int = 300,  # 5 minute timeout
-        max_retries: int = 3,
-    ) -> bytes:
+    # def generate_image(
+    #     self,
+    #     model_cid: str,
+    #     prompt: str,
+    #     host: str = DEFAULT_IMAGE_GEN_HOST,
+    #     port: int = DEFAULT_IMAGE_GEN_PORT,
+    #     width: int = 1024,
+    #     height: int = 1024,
+    #     timeout: int = 300,  # 5 minute timeout
+    #     max_retries: int = 3,
+    # ) -> bytes:
+    #     """
+    #     Generate an image using a diffusion model through gRPC.
+
+    #     Args:
+    #         model_cid (str): The model identifier (e.g. "stabilityai/stable-diffusion-xl-base-1.0")
+    #         prompt (str): The text prompt to generate the image from
+    #         host (str, optional): gRPC host address. Defaults to DEFAULT_IMAGE_GEN_HOST.
+    #         port (int, optional): gRPC port number. Defaults to DEFAULT_IMAGE_GEN_PORT.
+    #         width (int, optional): Output image width. Defaults to 1024.
+    #         height (int, optional): Output image height. Defaults to 1024.
+    #         timeout (int, optional): Maximum time to wait for generation in seconds. Defaults to 300.
+    #         max_retries (int, optional): Maximum number of retry attempts. Defaults to 3.
+
+    #     Returns:
+    #         bytes: The raw image data bytes
+
+    #     Raises:
+    #         OpenGradientError: If the image generation fails
+    #         TimeoutError: If the generation exceeds the timeout period
+    #     """
+
+    #     def exponential_backoff(attempt: int, max_delay: float = 30.0) -> None:
+    #         """Calculate and sleep for exponential backoff duration"""
+    #         delay = min(0.1 * (2**attempt), max_delay)
+    #         time.sleep(delay)
+
+    #     channel = None
+    #     start_time = time.time()
+    #     retry_count = 0
+
+    #     try:
+    #         while retry_count < max_retries:
+    #             try:
+    #                 # Initialize gRPC channel and stub
+    #                 channel = grpc.insecure_channel(f"{host}:{port}")
+    #                 stub = infer_pb2_grpc.InferenceServiceStub(channel)
+
+    #                 # Create image generation request
+    #                 image_request = infer_pb2.ImageGenerationRequest(model=model_cid, prompt=prompt, height=height, width=width)
+
+    #                 # Create inference request with random transaction ID
+    #                 tx_id = str(uuid.uuid4())
+    #                 request = infer_pb2.InferenceRequest(tx=tx_id, image_generation=image_request)
+
+    #                 # Send request with timeout
+    #                 response_id = stub.RunInferenceAsync(
+    #                     request,
+    #                     timeout=min(30, timeout),  # Initial request timeout
+    #                 )
+
+    #                 # Poll for completion
+    #                 attempt = 0
+    #                 while True:
+    #                     # Check timeout
+    #                     if time.time() - start_time > timeout:
+    #                         raise TimeoutError(f"Image generation timed out after {timeout} seconds")
+
+    #                     status_request = infer_pb2.InferenceTxId(id=response_id.id)
+    #                     try:
+    #                         status = stub.GetInferenceStatus(
+    #                             status_request,
+    #                             timeout=min(5, timeout),  # Status check timeout
+    #                         ).status
+    #                     except grpc.RpcError as e:
+    #                         logging.warning(f"Status check failed (attempt {attempt}): {str(e)}")
+    #                         exponential_backoff(attempt)
+    #                         attempt += 1
+    #                         continue
+
+    #                     if status == infer_pb2.InferenceStatus.STATUS_COMPLETED:
+    #                         break
+    #                     elif status == infer_pb2.InferenceStatus.STATUS_ERROR:
+    #                         raise OpenGradientError("Image generation failed on server")
+    #                     elif status != infer_pb2.InferenceStatus.STATUS_IN_PROGRESS:
+    #                         raise OpenGradientError(f"Unexpected status: {status}")
+
+    #                     exponential_backoff(attempt)
+    #                     attempt += 1
+
+    #                 # Get result
+    #                 result = stub.GetInferenceResult(
+    #                     response_id,
+    #                     timeout=min(30, timeout),  # Result fetch timeout
+    #                 )
+    #                 return result.image_generation_result.image_data
+
+    #             except (grpc.RpcError, TimeoutError) as e:
+    #                 retry_count += 1
+    #                 if retry_count >= max_retries:
+    #                     raise OpenGradientError(f"Image generation failed after {max_retries} retries: {str(e)}")
+
+    #                 logging.warning(f"Attempt {retry_count} failed: {str(e)}. Retrying...")
+    #                 exponential_backoff(retry_count)
+
+    #     except grpc.RpcError as e:
+    #         logging.error(f"gRPC error: {str(e)}")
+    #         raise OpenGradientError(f"Image generation failed: {str(e)}")
+    #     except TimeoutError as e:
+    #         logging.error(f"Timeout error: {str(e)}")
+    #         raise
+    #     except Exception as e:
+    #         logging.error(f"Error in generate image method: {str(e)}", exc_info=True)
+    #         raise OpenGradientError(f"Image generation failed: {str(e)}")
+    #     finally:
+    #         if channel:
+    #             channel.close()
+
+    def _get_abi(self, abi_name) -> List[Dict]:
         """
-        Generate an image using a diffusion model through gRPC.
-
-        Args:
-            model_cid (str): The model identifier (e.g. "stabilityai/stable-diffusion-xl-base-1.0")
-            prompt (str): The text prompt to generate the image from
-            host (str, optional): gRPC host address. Defaults to DEFAULT_IMAGE_GEN_HOST.
-            port (int, optional): gRPC port number. Defaults to DEFAULT_IMAGE_GEN_PORT.
-            width (int, optional): Output image width. Defaults to 1024.
-            height (int, optional): Output image height. Defaults to 1024.
-            timeout (int, optional): Maximum time to wait for generation in seconds. Defaults to 300.
-            max_retries (int, optional): Maximum number of retry attempts. Defaults to 3.
-
-        Returns:
-            bytes: The raw image data bytes
-
-        Raises:
-            OpenGradientError: If the image generation fails
-            TimeoutError: If the generation exceeds the timeout period
+        Returns the ABI for the requested contract.
         """
+        abi_path = Path(__file__).parent / "abi" / abi_name
+        with open(abi_path, "r") as f:
+            return json.load(f)
 
-        def exponential_backoff(attempt: int, max_delay: float = 30.0) -> None:
-            """Calculate and sleep for exponential backoff duration"""
-            delay = min(0.1 * (2**attempt), max_delay)
-            time.sleep(delay)
-
-        channel = None
-        start_time = time.time()
-        retry_count = 0
-
-        try:
-            while retry_count < max_retries:
-                try:
-                    # Initialize gRPC channel and stub
-                    channel = grpc.insecure_channel(f"{host}:{port}")
-                    stub = infer_pb2_grpc.InferenceServiceStub(channel)
-
-                    # Create image generation request
-                    image_request = infer_pb2.ImageGenerationRequest(model=model_cid, prompt=prompt, height=height, width=width)
-
-                    # Create inference request with random transaction ID
-                    tx_id = str(uuid.uuid4())
-                    request = infer_pb2.InferenceRequest(tx=tx_id, image_generation=image_request)
-
-                    # Send request with timeout
-                    response_id = stub.RunInferenceAsync(
-                        request,
-                        timeout=min(30, timeout),  # Initial request timeout
-                    )
-
-                    # Poll for completion
-                    attempt = 0
-                    while True:
-                        # Check timeout
-                        if time.time() - start_time > timeout:
-                            raise TimeoutError(f"Image generation timed out after {timeout} seconds")
-
-                        status_request = infer_pb2.InferenceTxId(id=response_id.id)
-                        try:
-                            status = stub.GetInferenceStatus(
-                                status_request,
-                                timeout=min(5, timeout),  # Status check timeout
-                            ).status
-                        except grpc.RpcError as e:
-                            logging.warning(f"Status check failed (attempt {attempt}): {str(e)}")
-                            exponential_backoff(attempt)
-                            attempt += 1
-                            continue
-
-                        if status == infer_pb2.InferenceStatus.STATUS_COMPLETED:
-                            break
-                        elif status == infer_pb2.InferenceStatus.STATUS_ERROR:
-                            raise OpenGradientError("Image generation failed on server")
-                        elif status != infer_pb2.InferenceStatus.STATUS_IN_PROGRESS:
-                            raise OpenGradientError(f"Unexpected status: {status}")
-
-                        exponential_backoff(attempt)
-                        attempt += 1
-
-                    # Get result
-                    result = stub.GetInferenceResult(
-                        response_id,
-                        timeout=min(30, timeout),  # Result fetch timeout
-                    )
-                    return result.image_generation_result.image_data
-
-                except (grpc.RpcError, TimeoutError) as e:
-                    retry_count += 1
-                    if retry_count >= max_retries:
-                        raise OpenGradientError(f"Image generation failed after {max_retries} retries: {str(e)}")
-
-                    logging.warning(f"Attempt {retry_count} failed: {str(e)}. Retrying...")
-                    exponential_backoff(retry_count)
-
-        except grpc.RpcError as e:
-            logging.error(f"gRPC error: {str(e)}")
-            raise OpenGradientError(f"Image generation failed: {str(e)}")
-        except TimeoutError as e:
-            logging.error(f"Timeout error: {str(e)}")
-            raise
-        except Exception as e:
-            logging.error(f"Error in generate image method: {str(e)}", exc_info=True)
-            raise OpenGradientError(f"Image generation failed: {str(e)}")
-        finally:
-            if channel:
-                channel.close()
-
-    def _get_model_executor_abi(self) -> List[Dict]:
+    def _get_bin(self, bin_name) -> List[Dict]:
         """
-        Returns the ABI for the ModelExecutorHistorical contract.
+        Returns the bin for the requested contract.
         """
-        abi_path = Path(__file__).parent / "abi" / "ModelExecutorHistorical.abi"
-        with open(abi_path, "r") as f:
-            return json.load(f)
+        bin_path = Path(__file__).parent / "bin" / bin_name
+        # Read bytecode with explicit encoding
+        with open(bin_path, "r", encoding="utf-8") as f:
+            bytecode = f.read().strip()
+            if not bytecode.startswith("0x"):
+                bytecode = "0x" + bytecode
+            return bytecode
 
     def new_workflow(
         self,
         model_cid: str,
-        input_query: Union[Dict[str, Any], HistoricalInputQuery],
+        input_query: HistoricalInputQuery,
         input_tensor_name: str,
         scheduler_params: Optional[SchedulerParams] = None,
     ) -> str:
         """
         Deploy a new workflow contract with the specified parameters.
-        """
-        if isinstance(input_query, dict):
-            input_query = HistoricalInputQuery.from_dict(input_query)
 
+        This function deploys a new workflow contract and optionally registers it with
+        the scheduler for automated execution. If scheduler_params is not provided,
+        the workflow will be deployed without automated execution scheduling.
+
+        Args:
+            model_cid (str): IPFS CID of the model to be executed
+            input_query (HistoricalInputQuery): Query parameters for data input
+            input_tensor_name (str): Name of the input tensor expected by the model
+            scheduler_params (Optional[SchedulerParams]): Scheduler configuration for automated execution:
+                - frequency: Execution frequency in seconds
+                - duration_hours: How long to run in hours
+
+        Returns:
+            str: Deployed contract address. If scheduler_params was provided, the workflow
+                 will be automatically executed according to the specified schedule.
+
+        Raises:
+            Exception: If transaction fails or gas estimation fails
+        """
         # Get contract ABI and bytecode
-        abi = self._get_model_executor_abi()
-        bin_path = Path(__file__).parent / "bin" / "ModelExecutorHistorical.bin"
+        abi = self._get_abi("PriceHistoryInference.abi")
+        bytecode = self._get_bin("PriceHistoryInference.bin")
 
-        with open(bin_path, "r") as f:
-            bytecode = f.read().strip()
+        def deploy_transaction():
+            contract = self._blockchain.eth.contract(abi=abi, bytecode=bytecode)
+            query_tuple = input_query.to_abi_format()
+            constructor_args = [model_cid, input_tensor_name, query_tuple]
 
-        print("📦 Deploying workflow contract...")
+            try:
+                # Estimate gas needed
+                estimated_gas = contract.constructor(*constructor_args).estimate_gas({"from": self._wallet_account.address})
+                gas_limit = int(estimated_gas * 1.2)
+            except Exception as e:
+                print(f"⚠️ Gas estimation failed: {str(e)}")
+                gas_limit = 5000000  # Conservative fallback
+                print(f"📊 Using fallback gas limit: {gas_limit}")
 
-        # Create contract instance
-        contract = self._blockchain.eth.contract(abi=abi, bytecode=bytecode)
+            transaction = contract.constructor(*constructor_args).build_transaction(
+                {
+                    "from": self._wallet_account.address,
+                    "nonce": self._blockchain.eth.get_transaction_count(self._wallet_account.address, "pending"),
+                    "gas": gas_limit,
+                    "gasPrice": self._blockchain.eth.gas_price,
+                    "chainId": self._blockchain.eth.chain_id,
+                }
+            )
 
-        # Deploy contract with constructor arguments
-        transaction = contract.constructor().build_transaction(
-            {
-                "from": self._wallet_account.address,
-                "nonce": self._blockchain.eth.get_transaction_count(self._wallet_account.address, "pending"),
-                "gas": 15000000,
-                "gasPrice": self._blockchain.eth.gas_price,
-                "chainId": self._blockchain.eth.chain_id,
-            }
-        )
+            signed_txn = self._wallet_account.sign_transaction(transaction)
+            tx_hash = self._blockchain.eth.send_raw_transaction(signed_txn.raw_transaction)
 
-        signed_txn = self._wallet_account.sign_transaction(transaction)
-        tx_hash = self._blockchain.eth.send_raw_transaction(signed_txn.raw_transaction)
-        tx_receipt = self._blockchain.eth.wait_for_transaction_receipt(tx_hash, timeout=REGULAR_TX_TIMEOUT)
-        contract_address = tx_receipt.contractAddress
+            tx_receipt = self._blockchain.eth.wait_for_transaction_receipt(tx_hash, timeout=60)
+
+            if tx_receipt["status"] == 0:
+                raise Exception(f"❌ Contract deployment failed, transaction hash: {tx_hash.hex()}")
 
-        print(f"✅ Workflow contract deployed at: {contract_address}")
+            return tx_receipt.contractAddress
+
+        contract_address = run_with_retry(deploy_transaction)
 
-        # Register with scheduler if params provided
         if scheduler_params:
-            print("\n⏰ Setting up automated execution schedule...")
-            print(f"   • Frequency: Every {scheduler_params.frequency} seconds")
-            print(f"   • Duration: {scheduler_params.duration_hours} hours")
-            print(f"   • End Time: {time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(scheduler_params.end_time))}")
+            self._register_with_scheduler(contract_address, scheduler_params)
 
-            scheduler_abi = [
-                {
-                    "inputs": [
-                        {"internalType": "address", "name": "contractAddress", "type": "address"},
-                        {"internalType": "uint256", "name": "endTime", "type": "uint256"},
-                        {"internalType": "uint256", "name": "frequency", "type": "uint256"},
-                    ],
-                    "name": "registerTask",
-                    "outputs": [],
-                    "stateMutability": "nonpayable",
-                    "type": "function",
-                }
-            ]
+        return contract_address
 
-            scheduler_address = "0x6F937b9f4Fa7723932827cd73063B70Be2b56748"
-            scheduler_contract = self._blockchain.eth.contract(address=scheduler_address, abi=scheduler_abi)
+    def _register_with_scheduler(self, contract_address: str, scheduler_params: SchedulerParams) -> None:
+        """
+        Register the deployed workflow contract with the scheduler for automated execution.
 
-            try:
-                # Register the workflow with the scheduler
-                scheduler_tx = scheduler_contract.functions.registerTask(
-                    contract_address, scheduler_params.end_time, scheduler_params.frequency
-                ).build_transaction(
-                    {
-                        "from": self._wallet_account.address,
-                        "gas": 300000,
-                        "gasPrice": self._blockchain.eth.gas_price,
-                        "nonce": self._blockchain.eth.get_transaction_count(self._wallet_account.address, "pending"),
-                        "chainId": self._blockchain.eth.chain_id,
-                    }
-                )
+        Args:
+            contract_address (str): Address of the deployed workflow contract
+            scheduler_params (SchedulerParams): Scheduler configuration containing:
+                - frequency: Execution frequency in seconds
+                - duration_hours: How long to run in hours
+                - end_time: Unix timestamp when scheduling should end
 
-                signed_scheduler_tx = self._wallet_account.sign_transaction(scheduler_tx)
-                scheduler_tx_hash = self._blockchain.eth.send_raw_transaction(signed_scheduler_tx.raw_transaction)
-                self._blockchain.eth.wait_for_transaction_receipt(scheduler_tx_hash, timeout=REGULAR_TX_TIMEOUT)
+        Raises:
+            Exception: If registration with scheduler fails. The workflow contract will
+                      still be deployed and can be executed manually.
+        """
 
-                print("✅ Automated execution schedule set successfully!")
-                print(f"   Transaction hash: {scheduler_tx_hash.hex()}")
+        scheduler_abi = self._get_abi("WorkflowScheduler.abi")
 
-            except Exception as e:
-                print("❌ Failed to set up automated execution schedule")
-                print(f"   Error: {str(e)}")
-                print("   The workflow contract is still deployed and can be executed manually.")
+        # Scheduler contract address
+        scheduler_address = DEFAULT_SCHEDULER_ADDRESS
+        scheduler_contract = self._blockchain.eth.contract(address=scheduler_address, abi=scheduler_abi)
 
-        return contract_address
+        try:
+            # Register the workflow with the scheduler
+            scheduler_tx = scheduler_contract.functions.registerTask(
+                contract_address, scheduler_params.end_time, scheduler_params.frequency
+            ).build_transaction(
+                {
+                    "from": self._wallet_account.address,
+                    "gas": 300000,
+                    "gasPrice": self._blockchain.eth.gas_price,
+                    "nonce": self._blockchain.eth.get_transaction_count(self._wallet_account.address, "pending"),
+                    "chainId": self._blockchain.eth.chain_id,
+                }
+            )
+
+            signed_scheduler_tx = self._wallet_account.sign_transaction(scheduler_tx)
+            scheduler_tx_hash = self._blockchain.eth.send_raw_transaction(signed_scheduler_tx.raw_transaction)
+            self._blockchain.eth.wait_for_transaction_receipt(scheduler_tx_hash, timeout=REGULAR_TX_TIMEOUT)
+        except Exception as e:
+            print(f"❌ Error registering contract with scheduler: {str(e)}")
+            print("  The workflow contract is still deployed and can be executed manually.")
 
     def read_workflow_result(self, contract_address: str) -> ModelOutput:
         """
@@ -854,7 +903,9 @@ class Client:
             Web3Error: If there are issues with the web3 connection or contract interaction
         """
         # Get the contract interface
-        contract = self._blockchain.eth.contract(address=Web3.to_checksum_address(contract_address), abi=self._get_model_executor_abi())
+        contract = self._blockchain.eth.contract(
+            address=Web3.to_checksum_address(contract_address), abi=self._get_abi("PriceHistoryInference.abi")
+        )
 
         # Get the result
         result = contract.functions.getInferenceResult().call()
@@ -876,7 +927,9 @@ class Client:
             Web3Error: If there are issues with the web3 connection or contract interaction
         """
         # Get the contract interface
-        contract = self._blockchain.eth.contract(address=Web3.to_checksum_address(contract_address), abi=self._get_model_executor_abi())
+        contract = self._blockchain.eth.contract(
+            address=Web3.to_checksum_address(contract_address), abi=self._get_abi("PriceHistoryInference.abi")
+        )
 
         # Call run() function
         nonce = self._blockchain.eth.get_transaction_count(self._wallet_account.address, "pending")
@@ -904,6 +957,31 @@ class Client:
 
         return utils.convert_array_to_model_output(result)
 
+    def read_workflow_history(self, contract_address: str, num_results: int) -> List[Dict]:
+        """
+        Gets historical inference results from a workflow contract.
+
+        Retrieves the specified number of most recent inference results from the contract's
+        storage, with the most recent result first.
+
+        Args:
+            contract_address (str): Address of the deployed workflow contract
+            num_results (int): Number of historical results to retrieve
+
+        Returns:
+            List[Dict]: List of historical inference results, each containing:
+                - prediction values
+                - timestamps
+                - any additional metadata stored with the result
+
+        """
+        contract = self._blockchain.eth.contract(
+            address=Web3.to_checksum_address(contract_address), abi=self._get_abi("PriceHistoryInference.abi")
+        )
+
+        results = contract.functions.getLastInferenceResults(num_results).call()
+        return [utils.convert_array_to_model_output(result) for result in results]
+
 
 def run_with_retry(txn_function, max_retries=DEFAULT_MAX_RETRY, retry_delay=DEFAULT_RETRY_DELAY_SEC):
     """