opengradient 0.5.8__py3-none-any.whl → 0.5.10__py3-none-any.whl

opengradient/defaults.py

@@ -1,5 +1,5 @@
 # Default variables
-DEFAULT_RPC_URL = "https://eth-devnet.opengradient.ai"
+DEFAULT_RPC_URL = "https://ogevmdevnet.opengradient.ai"
 DEFAULT_API_URL = "https://sdk-devnet.opengradient.ai"
 DEFAULT_OG_FAUCET_URL = "https://faucet.opengradient.ai/?address="
 DEFAULT_HUB_SIGNUP_URL = "https://hub.opengradient.ai/signup"
@@ -9,4 +9,6 @@ DEFAULT_BLOCKCHAIN_EXPLORER = "https://explorer.opengradient.ai/tx/"
 DEFAULT_IMAGE_GEN_HOST = "18.217.25.69"
 DEFAULT_IMAGE_GEN_PORT = 5125
 DEFAULT_LLM_SERVER_URL = "http://35.225.197.84:8000"
-DEFAULT_OPENGRADIENT_LLM_SERVER_URL = "https://llm.opengradient.ai"
+DEFAULT_OPENGRADIENT_LLM_SERVER_URL = "https://llmogevm.opengradient.ai"
+DEFAULT_OPENGRADIENT_LLM_STREAMING_SERVER_URL = "https://llmogevm.opengradient.ai"
+DEFAULT_NETWORK_FILTER = "og-evm"

opengradient/types.py

@@ -1,7 +1,7 @@
 import time
 from dataclasses import dataclass
 from enum import Enum, IntEnum, StrEnum
-from typing import Dict, List, Optional, Tuple, Union, DefaultDict
+from typing import Dict, List, Optional, Tuple, Union, DefaultDict, Iterator, AsyncIterator
 import numpy as np
 
 
@@ -165,6 +165,196 @@ class InferenceResult:
     model_output: Dict[str, np.ndarray]
 
 
+@dataclass
+class StreamDelta:
+    """
+    Represents a delta (incremental change) in a streaming response.
+    
+    Attributes:
+        content: Incremental text content (if any)
+        role: Message role (appears in first chunk)
+        tool_calls: Tool call information (if function calling is used)
+    """
+    content: Optional[str] = None
+    role: Optional[str] = None
+    tool_calls: Optional[List[Dict]] = None
+
+
+@dataclass
+class StreamChoice:
+    """
+    Represents a choice in a streaming response.
+    
+    Attributes:
+        delta: The incremental changes in this chunk
+        index: Choice index (usually 0)
+        finish_reason: Reason for completion (appears in final chunk)
+    """
+    delta: StreamDelta
+    index: int = 0
+    finish_reason: Optional[str] = None
+
+
+@dataclass
+class StreamUsage:
+    """
+    Token usage information for a streaming response.
+    
+    Attributes:
+        prompt_tokens: Number of tokens in the prompt
+        completion_tokens: Number of tokens in the completion
+        total_tokens: Total tokens used
+    """
+    prompt_tokens: int
+    completion_tokens: int
+    total_tokens: int
+
+
+@dataclass
+class StreamChunk:
+    """
+    Represents a single chunk in a streaming LLM response.
+    
+    This follows the OpenAI streaming format but is provider-agnostic.
+    Each chunk contains incremental data, with the final chunk including
+    usage information.
+    
+    Attributes:
+        choices: List of streaming choices (usually contains one choice)
+        model: Model identifier
+        usage: Token usage information (only in final chunk)
+        is_final: Whether this is the final chunk (before [DONE])
+    """
+    choices: List[StreamChoice]
+    model: str
+    usage: Optional[StreamUsage] = None
+    is_final: bool = False
+    
+    @classmethod
+    def from_sse_data(cls, data: Dict) -> "StreamChunk":
+        """
+        Parse a StreamChunk from SSE data dictionary.
+        
+        Args:
+            data: Dictionary parsed from SSE data line
+            
+        Returns:
+            StreamChunk instance
+        """
+        choices = []
+        for choice_data in data.get("choices", []):
+            delta_data = choice_data.get("delta", {})
+            delta = StreamDelta(
+                content=delta_data.get("content"),
+                role=delta_data.get("role"),
+                tool_calls=delta_data.get("tool_calls")
+            )
+            choice = StreamChoice(
+                delta=delta,
+                index=choice_data.get("index", 0),
+                finish_reason=choice_data.get("finish_reason")
+            )
+            choices.append(choice)
+        
+        usage = None
+        if "usage" in data:
+            usage_data = data["usage"]
+            usage = StreamUsage(
+                prompt_tokens=usage_data.get("prompt_tokens", 0),
+                completion_tokens=usage_data.get("completion_tokens", 0),
+                total_tokens=usage_data.get("total_tokens", 0)
+            )
+        
+        is_final = any(c.finish_reason is not None for c in choices) or usage is not None
+        
+        return cls(
+            choices=choices,
+            model=data.get("model", "unknown"),
+            usage=usage,
+            is_final=is_final
+        )
+
+
+@dataclass
+class TextGenerationStream:
+    """
+    Iterator wrapper for streaming text generation responses.
+    
+    Provides a clean interface for iterating over stream chunks with
+    automatic parsing of SSE format.
+    
+    Usage:
+        stream = client.llm_chat(..., stream=True)
+        for chunk in stream:
+            if chunk.choices[0].delta.content:
+                print(chunk.choices[0].delta.content, end="")
+    """
+    _iterator: Union[Iterator[str], AsyncIterator[str]]
+    _is_async: bool = False
+    
+    def __iter__(self):
+        """Iterate over stream chunks."""
+        return self
+    
+    def __next__(self) -> StreamChunk:
+        """Get next stream chunk."""
+        import json
+        
+        while True:
+            try:
+                line = next(self._iterator)
+            except StopIteration:
+                raise
+            
+            if not line or not line.strip():
+                continue
+            
+            if not line.startswith("data: "):
+                continue
+            
+            data_str = line[6:]  # Remove "data: " prefix
+            
+            if data_str.strip() == "[DONE]":
+                raise StopIteration
+            
+            try:
+                data = json.loads(data_str)
+                return StreamChunk.from_sse_data(data)
+            except json.JSONDecodeError:
+                # Skip malformed chunks
+                continue
+    
+    async def __anext__(self) -> StreamChunk:
+        """Get next stream chunk (async version)."""
+        import json
+        
+        if not self._is_async:
+            raise TypeError("Use __next__ for sync iterators")
+        
+        while True:
+            try:
+                line = await self._iterator.__anext__()
+            except StopAsyncIteration:
+                raise
+            
+            if not line or not line.strip():
+                continue
+            
+            if not line.startswith("data: "):
+                continue
+            
+            data_str = line[6:]
+            
+            if data_str.strip() == "[DONE]":
+                raise StopAsyncIteration
+            
+            try:
+                data = json.loads(data_str)
+                return StreamChunk.from_sse_data(data)
+            except json.JSONDecodeError:
+                continue
+
+
 @dataclass
 class TextGenerationOutput:
     """

opengradient/workflow_models/utils.py

@@ -26,7 +26,7 @@ def read_workflow_wrapper(contract_address: str, format_function: Callable[...,
         format_function (Callable): Function for formatting the result returned by read_workflow
     """
     try:
-        result = og.read_workflow_result(contract_address)
+        result = og.alpha.read_workflow_result(contract_address)
 
         formatted_result = format_function(result)
         block_explorer_link = create_block_explorer_link_smart_contract(contract_address)

opengradient/x402_auth.py

@@ -0,0 +1,102 @@
+"""
+X402 Authentication handler for httpx streaming requests.
+
+This module provides an httpx Auth class that handles x402 payment protocol
+authentication for streaming responses.
+"""
+
+from typing import Generator, Optional
+
+import httpx
+from eth_account.account import LocalAccount
+from x402.clients.base import x402Client
+from x402.types import x402PaymentRequiredResponse
+
+
+class X402Auth(httpx.Auth):
+    """
+    httpx Auth handler for x402 payment protocol.
+
+    This class implements the httpx Auth interface to handle 402 Payment Required
+    responses by automatically creating and attaching payment headers.
+
+    Example:
+        async with httpx.AsyncClient(auth=X402Auth(account=wallet_account)) as client:
+            response = await client.get("https://api.example.com/paid-resource")
+    """
+
+    requires_response_body = True
+
+    def __init__(
+        self,
+        account: LocalAccount,
+        max_value: Optional[int] = None,
+        network_filter: Optional[str] = None,
+        scheme_filter: Optional[str] = None,
+    ):
+        """
+        Initialize X402Auth with an Ethereum account for signing payments.
+
+        Args:
+            account: eth_account LocalAccount instance for signing payments
+            max_value: Optional maximum allowed payment amount in base units
+            network_filter: Optional network filter for selecting payment requirements
+            scheme_filter: Optional scheme filter for selecting payment requirements
+        """
+        self._account = account
+        self._max_value = max_value
+        self._network_filter = network_filter
+        self._scheme_filter = scheme_filter
+        self._x402_client = x402Client(
+            account,
+            max_value=max_value,
+            network_filter=network_filter,
+            scheme_filter=scheme_filter,
+        )
+
+    def auth_flow(
+        self, request: httpx.Request
+    ) -> Generator[httpx.Request, httpx.Response, None]:
+        """
+        Implement the auth flow for x402 payment handling.
+
+        This method yields the initial request, and if a 402 response is received,
+        it creates a payment header and retries the request.
+
+        Args:
+            request: The initial httpx Request
+
+        Yields:
+            httpx.Request objects (initial and retry with payment header)
+        """
+        # Send the initial request
+        response = yield request
+
+        # If not a 402, we're done
+        if response.status_code != 402:
+            return
+
+        # Handle 402 Payment Required
+        try:
+            data = response.json()
+            payment_response = x402PaymentRequiredResponse(**data)
+
+            # Select payment requirements
+            selected_requirements = self._x402_client.select_payment_requirements(
+                payment_response.accepts
+            )
+
+            # Create payment header
+            payment_header = self._x402_client.create_payment_header(
+                selected_requirements, payment_response.x402_version
+            )
+
+            # Add payment header and retry
+            request.headers["X-Payment"] = payment_header
+            request.headers["Access-Control-Expose-Headers"] = "X-Payment-Response"
+
+            yield request
+
+        except Exception:
+            # If payment handling fails, just return the original 402 response
+            return

{opengradient-0.5.8.dist-info → opengradient-0.5.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opengradient
-Version: 0.5.8
+Version: 0.5.10
 Summary: Python SDK for OpenGradient decentralized model management & inference services
 Author-email: OpenGradient <kyle@vannalabs.ai>
 License-Expression: MIT
@@ -23,7 +23,7 @@ Requires-Dist: requests>=2.32.3
 Requires-Dist: langchain>=0.3.7
 Requires-Dist: openai>=1.58.1
 Requires-Dist: pydantic>=2.9.2
-Requires-Dist: og-test-x402==0.0.1
+Requires-Dist: og-test-x402==0.0.9
 Dynamic: license-file
 
 # OpenGradient Python SDK
@@ -35,6 +35,7 @@ A Python SDK for decentralized model management and inference services on the Op
 - Model management and versioning
 - Decentralized model inference
 - Support for LLM inference with various models
+- **Trusted Execution Environment (TEE) inference** with cryptographic attestation
 - End-to-end verified AI execution
 - Command-line interface (CLI) for direct access
 
@@ -46,7 +47,6 @@ Browse and discover AI models on our [Model Hub](https://hub.opengradient.ai/).
 - Direct integration with the SDK
 
 ## Installation
-
 ```bash
 pip install opengradient
 ```
@@ -62,7 +62,6 @@ You'll need two accounts to use the SDK:
 - **OpenGradient account**: Use an existing Ethereum-compatible wallet or create a new one via SDK
 
 The easiest way to set up your accounts is through our configuration wizard:
-
 ```bash
 opengradient config init
 ```
@@ -73,7 +72,6 @@ This wizard will:
 - Direct you to our Test Faucet for devnet tokens
 
 ### 2. Initialize the SDK
-
 ```python
 import opengradient as og
 og.init(private_key="<private_key>", email="<email>", password="<password>")
@@ -82,8 +80,6 @@ og.init(private_key="<private_key>", email="<email>", password="<password>")
 ### 3. Basic Usage
 
 Browse available models on our [Model Hub](https://hub.opengradient.ai/) or create and upload your own:
-
-
 ```python
 # Create and upload a model
 og.create_model(
@@ -101,20 +97,41 @@ result = og.infer(
 )
 ```
 
-### 4. Examples
+### 4. TEE (Trusted Execution Environment) Inference
+
+OpenGradient supports secure, verifiable inference through TEE for leading LLM providers. Access models from OpenAI, Anthropic, Google, and xAI with cryptographic attestation:
+```python
+from opengradient import TEE_LLM
+
+# Use TEE-enabled models for verifiable AI execution
+result = og.infer(
+    model_cid=TEE_LLM.CLAUDE_3_7_SONNET,  # or any other TEE_LLM model
+    model_inputs={"prompt": "Your prompt here"},
+    inference_mode=og.InferenceMode.TEE
+)
+```
+
+**Available TEE Models:**
+The SDK includes models from multiple providers accessible via the `TEE_LLM` enum:
+- **OpenAI**: GPT-4.1, GPT-4o, o4-mini
+- **Anthropic**: Claude 3.7 Sonnet, Claude 3.5 Haiku, Claude 4.0 Sonnet
+- **Google**: Gemini 2.5 Flash, Gemini 2.5 Pro, and more
+- **xAI**: Grok 3 Beta, Grok 4.1 Fast, and other Grok variants
+
+For the complete list of available models, check the `TEE_LLM` enum in your IDE autocomplete or see the [API documentation](https://docs.opengradient.ai/).
+
+### 5. Examples
 
 See code examples under [examples](./examples).
 
 ## CLI Usage
 
 The SDK includes a command-line interface for quick operations. First, verify your configuration:
-
 ```bash
 opengradient config show
 ```
 
 Run a test inference:
-
 ```bash
 opengradient infer -m QmbUqS93oc4JTLMHwpVxsE39mhNxy6hpf6Py3r9oANr8aZ \
     --input '{"num_input1":[1.0, 2.0, 3.0], "num_input2":10}'
@@ -124,7 +141,9 @@ opengradient infer -m QmbUqS93oc4JTLMHwpVxsE39mhNxy6hpf6Py3r9oANr8aZ \
 
 1. **Off-chain Applications**: Use OpenGradient as a decentralized alternative to centralized AI providers like HuggingFace and OpenAI.
 
-2. **Model Development**: Manage models on the Model Hub and integrate directly into your development workflow.
+2. **Verifiable AI Execution**: Leverage TEE inference for cryptographically attested AI outputs, enabling trustless AI applications.
+
+3. **Model Development**: Manage models on the Model Hub and integrate directly into your development workflow.
 
 ## Documentation
 
@@ -140,4 +159,4 @@ If you use [Claude Code](https://claude.ai/code), copy [docs/CLAUDE_SDK_USERS.md
 
 - Run `opengradient --help` for CLI command reference
 - Visit our [documentation](https://docs.opengradient.ai/) for detailed guides
-- Join our [community](https://.opengradient.ai/) for support
+- Join our [community](https://opengradient.ai/) for support

{opengradient-0.5.8.dist-info → opengradient-0.5.10.dist-info}/RECORD

@@ -1,17 +1,19 @@
-opengradient/__init__.py,sha256=7UkGoQRDtSb0lh3vobxmyJct_uFfm1Re_oz5s0s9dOs,13263
+opengradient/__init__.py,sha256=hRGex2VGwAQ-lqBNphW93D4R3wPHQpQrTkwgGLe2MoA,10255
 opengradient/account.py,sha256=5wrYpws_1lozjOFjLCTHtxgoxK-LmObDAaVy9eDcJY4,1145
-opengradient/cli.py,sha256=4IUKxecZV9la-_nEVxObOIjm6qQ9aEHhq5-m5clzzHc,29901
-opengradient/client.py,sha256=nozp80z8KSYQewKQmSVXZQIdVtsSjv53reS3TBRwlXc,63071
-opengradient/defaults.py,sha256=yiZnpIOLyHEmZhCEQXgWpT2eJin10UVsivJY6r61xmo,674
+opengradient/alpha.py,sha256=WAtL1GGbEpoeLO89rOMd8-YAgAFJYM1UJlICm6YGsPs,15195
+opengradient/cli.py,sha256=pfgyLfD1MIDifKmGLFsJqBlgvqIcnsIh3zzg7PaIeH4,33670
+opengradient/client.py,sha256=B13xv_iL2ZynCsiojfsXuERzIdbt62UoOLd_s_moCnA,65250
+opengradient/defaults.py,sha256=8faLPwvp_BQdErY_SEjBzvmGVuOBdZ2zKcoryD8SCXk,797
 opengradient/exceptions.py,sha256=88tfegboGtlehQcwhxsl6ZzhLJWZWlkf_bkHTiCtXpo,3391
-opengradient/types.py,sha256=DSkJAcD4fRQ78bG3Ny5-_OqcfptFSIpliS4qKKYE2jU,9026
+opengradient/types.py,sha256=bADakUM6WwdMORGC5HvQvWCezNwIlVc7l0zodPapbhQ,14622
 opengradient/utils.py,sha256=ZUq4OBIml2vsC0tRqus4Zwb_e3g4woo00apByrafuVw,8058
+opengradient/x402_auth.py,sha256=utfusvfKxPtsq4MtRX03yQ969G7VeatxAQwHLAW77JU,3350
 opengradient/abi/InferencePrecompile.abi,sha256=reepTHg6Q01UrFP0Gexc-JayplsvOLPfG7jrEZ-cV28,10197
 opengradient/abi/PriceHistoryInference.abi,sha256=ZB3fZdx1kaFlp2wt1vTbTZZG1k8HPvmNtkG5Q8Bnajw,5098
 opengradient/abi/WorkflowScheduler.abi,sha256=yEGs76qO4S1z980KL5hBdfyXiJ6k-kERcB1O_o73AEU,416
 opengradient/abi/inference.abi,sha256=MR5u9npZ-Yx2EqRW17_M-UnGgFF3mMEMepOwaZ-Bkgc,7040
 opengradient/alphasense/__init__.py,sha256=Ah6IpoPTb6UkY7ImOWLJs3tjlxDJx6vZVR7p5IwP_Ks,292
-opengradient/alphasense/read_workflow_tool.py,sha256=ojCf-eMO6e0ib77nqjgEJtXxTxdLZmc_-MvyRemYFY0,3216
+opengradient/alphasense/read_workflow_tool.py,sha256=Y_MKRpBR1dNvCu9gNxcSnT3E_IqxZUAkE-_XziJ0BVY,3222
 opengradient/alphasense/run_model_tool.py,sha256=wlDqXVHa1xpqQy_hmht_wWegxtqdYgYBXNbRP3qbfwM,6945
 opengradient/alphasense/types.py,sha256=uxk4JQKbaS2cM3ZiKpdHQb234OJ5ylprNR5vi01QFzA,220
 opengradient/bin/PriceHistoryInference.bin,sha256=nU2FZpGHIKBZ7NSK9Sr-p9lr-nXja_40ISPN9yckDq8,41276
@@ -25,11 +27,11 @@ opengradient/proto/infer_pb2_grpc.py,sha256=q42_eZ7OZCMTXdWocYA4Ka3B0c3B74dOhfqd
 opengradient/workflow_models/__init__.py,sha256=pAGRaMZOXmuPnqG5gAQB1FeFLYxQ4F4bmYdrqXIez7c,826
 opengradient/workflow_models/constants.py,sha256=viIkb_LGcfVprqQNaA80gBTj6cfYam0r6b6MHW9XGFA,740
 opengradient/workflow_models/types.py,sha256=Z22hF6c8Y4D2GlzVEIBODGwsqSjSrQvUcpZ7R-mIJdI,409
-opengradient/workflow_models/utils.py,sha256=ySfpuiOBqLTlfto6ZxZf2vc7K6RGIja0l4eaVm5AOzY,1503
+opengradient/workflow_models/utils.py,sha256=aL2-Hp5J5qlJft6-wx4GnZNOXZ1vjYaTF1uEgYavWdI,1509
 opengradient/workflow_models/workflow_models.py,sha256=d4C_gs39DAfy4cdY9Ee6GMXpPfzwvKFpmxzK1A7LNgU,3900
-opengradient-0.5.8.dist-info/licenses/LICENSE,sha256=xEcvQ3AxZOtDkrqkys2Mm6Y9diEnaSeQRKvxi-JGnNA,1069
-opengradient-0.5.8.dist-info/METADATA,sha256=DyqayJvXV39OUn5H9jUqVsKqX9ilHMAaQ2-u4GnqIwM,4215
-opengradient-0.5.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-opengradient-0.5.8.dist-info/entry_points.txt,sha256=yUKTaJx8RXnybkob0J62wVBiCp_1agVbgw9uzsmaeJc,54
-opengradient-0.5.8.dist-info/top_level.txt,sha256=oC1zimVLa2Yi1LQz8c7x-0IQm92milb5ax8gHBHwDqU,13
-opengradient-0.5.8.dist-info/RECORD,,
+opengradient-0.5.10.dist-info/licenses/LICENSE,sha256=xEcvQ3AxZOtDkrqkys2Mm6Y9diEnaSeQRKvxi-JGnNA,1069
+opengradient-0.5.10.dist-info/METADATA,sha256=Pfj4IQ8soL-1AO5X5PbqcunZF4K0UK3AixX3Lfsh_Bw,5437
+opengradient-0.5.10.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+opengradient-0.5.10.dist-info/entry_points.txt,sha256=yUKTaJx8RXnybkob0J62wVBiCp_1agVbgw9uzsmaeJc,54
+opengradient-0.5.10.dist-info/top_level.txt,sha256=oC1zimVLa2Yi1LQz8c7x-0IQm92milb5ax8gHBHwDqU,13
+opengradient-0.5.10.dist-info/RECORD,,

{opengradient-0.5.8.dist-info → opengradient-0.5.10.dist-info}/WHEEL

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