move infer to alpha namespace

Author: [email protected]

README.md

@@ -74,7 +74,7 @@ print(f"Tx hash: {completion.transaction_hash}")
 #### Custom Model Inference
 Browse models on our [Model Hub](https://hub.opengradient.ai/) or upload your own:
 ```python
-result = client.inference.infer(
+result = client.alpha.infer(
     model_cid="your-model-cid",
     model_input={"input": [1.0, 2.0, 3.0]},
     inference_mode=og.InferenceMode.VANILLA,

docs/CLAUDE_SDK_USERS.md

@@ -88,7 +88,7 @@ result = client.llm.completion(
 ### ONNX Model Inference
 
 ```python
-result = client.inference.infer(
+result = client.alpha.infer(
     model_cid: str,                    # IPFS CID of model
     inference_mode: og.InferenceMode,  # VANILLA, TEE, or ZKML
     model_input: Dict[str, Any],       # Input tensors

examples/README.md

@@ -175,7 +175,7 @@ og_client = og.Client(
 Basic inference pattern:
 
 ```python
-result = og_client.inference.infer(
+result = og_client.alpha.infer(
     model_cid="your-model-cid",
     model_input={"input_key": "input_value"},
     inference_mode=og.InferenceMode.VANILLA

examples/alpha/run_embeddings_model.py

@@ -14,7 +14,7 @@
     "Since you're reading this, you are probably someone from a judo background or someone who is just wondering how judo techniques can be applied under wrestling rules. So without further ado, let's get to the question. Are Judo throws allowed in wrestling? Yes, judo throws are allowed in freestyle and folkstyle wrestling. You only need to be careful to follow the slam rules when executing judo throws. In wrestling, a slam is lifting and returning an opponent to the mat with unnecessary force.",
 ]
 
-model_embeddings = og_client.inference.infer(
+model_embeddings = og_client.alpha.infer(
     model_cid="intfloat/multilingual-e5-large-instruct",
     model_input={"queries": queries, "instruction": instruction, "passages": passages},
     inference_mode=og.InferenceMode.VANILLA,

examples/alpha/run_inference.py

@@ -4,7 +4,7 @@
 
 og_client = og.Client(private_key=os.environ.get("OG_PRIVATE_KEY"))
 
-inference_result = og_client.inference.infer(
+inference_result = og_client.alpha.infer(
     model_cid="hJD2Ja3akZFt1A2LT-D_1oxOCz_OtuGYw4V9eE1m39M",
     model_input={
         "open_high_low_close": [

integrationtest/agent/test_agent.py

@@ -87,12 +87,12 @@ def output_formatter(inference_result: InferenceResult):
             tool_name="One_hour_volatility_ETH_USDT",
             model_input_provider=model_input_provider,
             model_output_formatter=output_formatter,
-            inference=self.client.inference,
+            inference=self.client.alpha,
             tool_description="This tool measures the live 1 hour volatility for the trading pair ETH/USDT.",
             inference_mode=og.InferenceMode.VANILLA,
         )
 
-        expected_result = self.client.inference.infer(
+        expected_result = self.client.alpha.infer(
             inference_mode=og.InferenceMode.VANILLA, model_cid="QmRhcpDXfYCKsimTmJYrAVM4Bbvck59Zb2onj3MHv9Kw5N", model_input=model_input
         )
         formatted_expected_result = format(float(expected_result.model_output["Y"].item()), ".3%")
@@ -193,14 +193,14 @@ def output_formatter(inference_result: InferenceResult):
             tool_name="Return_volatility_tool",
             model_input_provider=model_input_provider,
             model_output_formatter=output_formatter,
-            inference=self.client.inference,
+            inference=self.client.alpha,
             tool_input_schema=InputSchema,
             tool_description="This tool takes a token and measures the return volatility (standard deviation of returns).",
             inference_mode=og.InferenceMode.VANILLA,
         )
 
         # Test option ETH
-        expected_result_eth = self.client.inference.infer(
+        expected_result_eth = self.client.alpha.infer(
             inference_mode=og.InferenceMode.VANILLA, model_cid="QmZdSfHWGJyzBiB2K98egzu3MypPcv4R1ASypUxwZ1MFUG", model_input=eth_model_input
         )
         formatted_expected_result_eth = format(float(expected_result_eth.model_output["std"].item()), ".3%")
@@ -215,7 +215,7 @@ def output_formatter(inference_result: InferenceResult):
         self.assertIn(formatted_expected_result_eth, list(events)[-1]["messages"][-1].content)
 
         # Test option BTC
-        expected_result_btc = self.client.inference.infer(
+        expected_result_btc = self.client.alpha.infer(
             inference_mode=og.InferenceMode.VANILLA, model_cid="QmZdSfHWGJyzBiB2K98egzu3MypPcv4R1ASypUxwZ1MFUG", model_input=btc_model_input
         )
         formatted_expected_result_btc = format(float(expected_result_btc.model_output["std"].item()), ".3%")

src/opengradient/__init__.py

@@ -38,7 +38,7 @@
         print(chunk.choices[0].delta.content, end="")
 
 # Run on-chain ONNX model inference
-result = client.inference.infer(
+result = client.alpha.infer(
     model_cid="your_model_cid",
     inference_mode=og.InferenceMode.VANILLA,
     model_input={"input": [1.0, 2.0, 3.0]},
@@ -51,7 +51,7 @@
 The `opengradient.client.Client` object exposes three namespaces:
 
 - **`opengradient.client.llm`** -- LLM chat and completion
-- **`opengradient.client.onchain_inference`** -- On-chain ONNX model inference
+- **`opengradient.client.alpha`** -- On-chain ONNX model inference, workflow deployment, and scheduled ML model execution
 - **`opengradient.client.model_hub`** -- Model repository management
 
 ## Model Hub (requires email auth)

src/opengradient/agents/og_langchain.py

@@ -155,11 +155,13 @@ def _generate(
                     ]
                 sdk_messages.append(msg)
             elif isinstance(message, ToolMessage):
-                sdk_messages.append({
-                    "role": "tool",
-                    "content": _extract_content(message.content),
-                    "tool_call_id": message.tool_call_id,
-                })
+                sdk_messages.append(
+                    {
+                        "role": "tool",
+                        "content": _extract_content(message.content),
+                        "tool_call_id": message.tool_call_id,
+                    }
+                )
             else:
                 raise ValueError(f"Unexpected message type: {message}")
 
@@ -181,9 +183,7 @@ def _generate(
         else:
             ai_message = AIMessage(content=_extract_content(chat_response.get("content", "")))
 
-        return ChatResult(
-            generations=[ChatGeneration(message=ai_message, generation_info={"finish_reason": finish_reason})]
-        )
+        return ChatResult(generations=[ChatGeneration(message=ai_message, generation_info={"finish_reason": finish_reason})])
 
     @property
     def _identifying_params(self) -> Dict[str, Any]:

src/opengradient/alphasense/run_model_tool.py

@@ -4,7 +4,7 @@
 from langchain_core.tools import BaseTool, StructuredTool
 from pydantic import BaseModel
 
-from ..client.onchain_inference import Inference
+from ..client.alpha import Alpha
 from ..types import InferenceMode, InferenceResult
 from .types import ToolType
 
@@ -15,7 +15,7 @@ def create_run_model_tool(
     tool_name: str,
     model_input_provider: Callable[..., Dict[str, Union[str, int, float, List, np.ndarray]]],
     model_output_formatter: Callable[[InferenceResult], str],
-    inference: Optional[Inference] = None,
+    inference: Optional[Alpha] = None,
     tool_input_schema: Optional[Type[BaseModel]] = None,
     tool_description: str = "Executes the given ML model",
     inference_mode: InferenceMode = InferenceMode.VANILLA,
@@ -49,8 +49,8 @@ def create_run_model_tool(
             InferenceResult has attributes:
                 * transaction_hash (str): Blockchain hash for the transaction
                 * model_output (Dict[str, np.ndarray]): Output of the ONNX model
-        inference (Inference, optional): The inference namespace from an initialized OpenGradient client
-            (client.inference). If not provided, falls back to the global client set via ``opengradient.init()``.
+        inference (Alpha, optional): The alpha namespace from an initialized OpenGradient client
+            (client.alpha). If not provided, falls back to the global client set via ``opengradient.init()``.
         tool_input_schema (Type[BaseModel], optional): A Pydantic BaseModel class defining the
             input schema.
 
@@ -104,7 +104,7 @@ def create_run_model_tool(
         ...     tool_name="Return_volatility_tool",
         ...     model_input_provider=model_input_provider,
         ...     model_output_formatter=output_formatter,
-        ...     inference=client.inference,
+        ...     inference=client.alpha,
         ...     tool_input_schema=InputSchema,
         ...     tool_description="This tool takes a token and measures the return volatility (standard deviation of returns).",
         ...     inference_mode=og.InferenceMode.VANILLA,
@@ -117,9 +117,9 @@ def create_run_model_tool(
         if og.global_client is None:
             raise ValueError(
                 "No inference instance provided and no global client initialized. "
-                "Either pass inference=client.inference or call opengradient.init() first."
+                "Either pass inference=client.alpha or call opengradient.init() first."
             )
-        inference = og.global_client.inference
+        inference = og.global_client.alpha
 
     def model_executor(**llm_input):
         # Pass LLM input arguments (formatted based on tool_input_schema) as parameters into model_input_provider

src/opengradient/cli.py

@@ -324,7 +324,7 @@ def infer(ctx, model_cid: str, inference_mode: str, input_data, input_file: Path
                 model_input = json.load(file)
 
         click.echo(f'Running {inference_mode} inference for model "{model_cid}"')
-        inference_result = client.inference.infer(
+        inference_result = client.alpha.infer(
             model_cid=model_cid, inference_mode=InferenceModes[inference_mode], model_input=model_input
         )