fix: 5 critical bugs — TEE randomization, HTTP 402 hint, int dtype, inference None crash, gas estimation

.github/workflows/release.yml

@@ -44,6 +44,11 @@ jobs:
       - name: Run tests
         run: make test
 
+      - name: Run LLM integration tests
+        env:
+          PRIVATE_KEY: ${{ secrets.PRIVATE_KEY }}
+        run: make llm_integrationtest
+
   release:
     needs: [check, test]
     runs-on: ubuntu-latest

README.md

@@ -24,7 +24,7 @@ OpenGradient enables developers to build AI applications with verifiable executi
 pip install opengradient
 ```
 
-**Note**: Windows users should temporarily enable WSL during installation (fix in progress).
+**Note**: > **Windows users:** See the [Windows Installation Guide](./WINDOWS_INSTALL.md) for step-by-step setup instructions.
 
 ## Network Architecture
 

WINDOWS_INSTALL.md

@@ -0,0 +1,36 @@
+# Windows Installation Guide
+
+The `opengradient` package requires a C compiler
+to build its native dependencies. Windows does not
+have one by default.
+
+## Step 1 — Enable WSL
+
+Open PowerShell as Administrator and run:
+
+    wsl --install
+
+Restart your PC when prompted.
+
+## Step 2 — Install Python and uv inside WSL
+
+Open the Ubuntu app and run:
+
+    sudo apt update && sudo apt install -y python3 curl
+    curl -LsSf https://astral.sh/uv/install.sh | sh
+    source $HOME/.local/bin/env
+
+## Step 3 — Install SDK
+
+    uv add opengradient
+
+## Step 4 — Verify
+
+    uv run python3 -c "import opengradient; print('Ready!')"
+
+## Common Errors
+
+- Visual C++ 14.0 required → Use WSL instead
+- wsl: command not found → Update Windows 10 to Build 19041+
+- WSL stuck → Enable Virtualization in BIOS
+- uv: command not found → Run: source $HOME/.local/bin/env

docs/opengradient/client/llm.md

@@ -200,8 +200,8 @@ a transaction. Otherwise, sends an ERC-20 approve transaction.
 
 **Arguments**
 
-* **`opg_amount`**: Minimum number of OPG tokens required (e.g. ``0.05``
-        for 0.05 OPG). Must be at least 0.05 OPG.
+* **`opg_amount`**: Minimum number of OPG tokens required (e.g. ``0.1``
+        for 0.1 OPG). Must be at least 0.1 OPG.
 
 **Returns**
 
@@ -211,5 +211,5 @@ Permit2ApprovalResult: Contains ``allowance_before``,
 
 **Raises**
 
-* **`ValueError`**: If the OPG amount is less than 0.05.
+* **`ValueError`**: If the OPG amount is less than 0.1.
 * **`RuntimeError`**: If the approval transaction fails.

docs/opengradient/index.md

@@ -6,7 +6,7 @@ opengradient
 
 # Package opengradient
 
-**Version: 0.9.0**
+**Version: 0.9.2**
 
 OpenGradient Python SDK for decentralized AI inference with end-to-end verification.
 

integrationtest/llm/test_llm_chat.py

@@ -23,7 +23,7 @@
 ]
 
 # Amount of OPG tokens to fund the test account with
-OPG_FUND_AMOUNT = 0.05
+OPG_FUND_AMOUNT = 0.1
 # Amount of ETH to fund the test account with (for gas)
 ETH_FUND_AMOUNT = 0.0001
 

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "opengradient"
-version = "0.9.1"
+version = "0.9.3"
 description = "Python SDK for OpenGradient decentralized model management & inference services"
 authors = [{name = "OpenGradient", email = "adam@vannalabs.ai"}]
 readme = "README.md"
@@ -27,7 +27,7 @@ dependencies = [
     "langchain>=0.3.7",
     "openai>=1.58.1",
     "pydantic>=2.9.2",
-    "og-x402==0.0.1.dev2"
+    "og-x402==0.0.1.dev4"
 ]
 
 [project.optional-dependencies]

src/opengradient/client/_conversions.py

@@ -36,11 +36,32 @@ def convert_to_fixed_point(number: float) -> Tuple[int, int]:
     return value, decimals
 
 
+def convert_fixed_point_to_python(value: int, decimals: int) -> np.float32:
+    """
+    Converts a fixed-point representation back to a NumPy float32.
+
+    This function is intentionally type-stable and always returns np.float32,
+    regardless of the value of `decimals`. Callers that require integer
+    semantics should perform an explicit cast (e.g., int(...)) based on
+    their own dtype metadata or application logic.
+
+    Args:
+        value:    The integer significand stored on-chain.
+        decimals: The scale factor exponent (value / 10**decimals).
+
+    Returns:
+        np.float32 corresponding to `value / 10**decimals`.
+    """
+    return np.float32(Decimal(value) / (10 ** Decimal(decimals)))
+
+
 def convert_to_float32(value: int, decimals: int) -> np.float32:
     """
-    Converts fixed point back into floating point
+    Deprecated: use convert_fixed_point_to_python() instead.
 
-    Returns an np.float32 type
+    Kept for backwards compatibility. New callers should use
+    convert_fixed_point_to_python which is type-stable and always
+    returns np.float32.
     """
     return np.float32(Decimal(value) / (10 ** Decimal(decimals)))
 
@@ -131,10 +152,11 @@ def convert_to_model_output(event_data: AttributeDict) -> Dict[str, np.ndarray]:
                 name = tensor.get("name")
                 shape = tensor.get("shape")
                 values = []
-                # Convert from fixed point back into np.float32
+                # Use convert_fixed_point_to_python so integer tensors (decimals==0)
+                # come back as int instead of np.float32 (fixes issue #103).
                 for v in tensor.get("values", []):
                     if isinstance(v, (AttributeDict, dict)):
-                        values.append(convert_to_float32(value=int(v.get("value")), decimals=int(v.get("decimals"))))
+                        values.append(convert_fixed_point_to_python(value=int(v.get("value")), decimals=int(v.get("decimals"))))
                     else:
                         logging.warning(f"Unexpected number type: {type(v)}")
                 output_dict[name] = np.array(values).reshape(shape)
@@ -183,10 +205,11 @@ def convert_array_to_model_output(array_data: List) -> ModelOutput:
         values = tensor[1]
         shape = tensor[2]
 
-        # Convert from fixed point into np.float32
+        # Use convert_fixed_point_to_python so integer tensors (decimals==0)
+        # come back as int instead of np.float32 (fixes issue #103).
         converted_values = []
         for value in values:
-            converted_values.append(convert_to_float32(value=value[0], decimals=value[1]))
+            converted_values.append(convert_fixed_point_to_python(value=value[0], decimals=value[1]))
 
         number_data[name] = np.array(converted_values).reshape(shape)
 

src/opengradient/client/_utils.py

@@ -49,6 +49,9 @@ def run_with_retry(
     """
     effective_retries = max_retries if max_retries is not None else DEFAULT_MAX_RETRY
 
+    if effective_retries < 1:
+        raise ValueError(f"max_retries must be at least 1, got {effective_retries}")
+
     for attempt in range(effective_retries):
         try:
             return txn_function()
@@ -62,3 +65,5 @@ def run_with_retry(
                 continue
 
             raise
+
+    raise RuntimeError(f"run_with_retry exhausted {effective_retries} attempts without returning or raising")

src/opengradient/client/alpha.py

@@ -119,9 +119,19 @@ def execute_transaction():
             model_output = convert_to_model_output(parsed_logs[0]["args"])
             if len(model_output) == 0:
                 # check inference directly from node
-                parsed_logs = precompile_contract.events.ModelInferenceEvent().process_receipt(tx_receipt, errors=DISCARD)
-                inference_id = parsed_logs[0]["args"]["inferenceID"]
+                precompile_logs = precompile_contract.events.ModelInferenceEvent().process_receipt(tx_receipt, errors=DISCARD)
+                if not precompile_logs:
+                    raise RuntimeError(
+                        "ModelInferenceEvent not found in transaction logs. "
+                        "Cannot fall back to node-side inference result."
+                    )
+                inference_id = precompile_logs[0]["args"]["inferenceID"]
                 inference_result = self._get_inference_result_from_node(inference_id, inference_mode)
+                if inference_result is None:
+                    raise RuntimeError(
+                        f"Inference node returned no result for inference ID {inference_id!r}. "
+                        "The result may not be available yet — retry after a short delay."
+                    )
                 model_output = convert_to_model_output(inference_result)
 
             return InferenceResult(tx_hash.hex(), model_output)
@@ -315,7 +325,7 @@ def deploy_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=60)
+            tx_receipt = self._blockchain.eth.wait_for_transaction_receipt(tx_hash, timeout=INFERENCE_TX_TIMEOUT)
 
             if tx_receipt["status"] == 0:
                 raise Exception(f"Contract deployment failed, transaction hash: {tx_hash.hex()}")
@@ -419,11 +429,30 @@ def run_workflow(self, contract_address: str) -> ModelOutput:
         nonce = self._blockchain.eth.get_transaction_count(self._wallet_account.address, "pending")
 
         run_function = contract.functions.run()
+
+        # Estimate gas instead of using a hardcoded 30M limit, which is wasteful
+        # and may exceed the block gas limit on some networks.
+        try:
+            estimated_gas = run_function.estimate_gas({"from": self._wallet_account.address})
+            gas_limit = int(estimated_gas * 3)
+        except ContractLogicError as exc:
+            # Estimation failed due to a contract revert — simulate the call to
+            # surface the revert reason and avoid sending a transaction that will fail.
+            try:
+                run_function.call({"from": self._wallet_account.address})
+            except ContractLogicError as call_exc:
+                # Re-raise the detailed revert reason from the simulated call.
+                raise call_exc
+            # If the simulated call somehow doesn't raise, re-raise the original error.
+            raise exc
+        except Exception:
+            gas_limit = 30000000  # Conservative fallback for transient/RPC estimation errors
+
         transaction = run_function.build_transaction(
             {
                 "from": self._wallet_account.address,
                 "nonce": nonce,
-                "gas": 30000000,
+                "gas": gas_limit,
                 "gasPrice": self._blockchain.eth.gas_price,
                 "chainId": self._blockchain.eth.chain_id,
             }