v 0.0.7b5

exosphere-runtimes/cloud-storage-runtime/main.py

@@ -1,14 +1,19 @@
 from dotenv import load_dotenv
 from exospherehost import Runtime
 from nodes.list_s3_files import ListS3FilesNode
+from nodes.download_s3_file import DownloadS3FileNode
 
 # Load environment variables from .env file
 # EXOSPHERE_STATE_MANAGER_URI is the URI of the state manager
 # EXOSPHERE_API_KEY is the key of the runtime
 load_dotenv()
 
+# Note on node ordering:
+# The order of node classes in the `nodes` list does not define execution sequence.
+# Nodes are registered with the state manager; orchestration and dependencies are handled externally.
+# `ListS3FilesNode` is listed before `DownloadS3FileNode` for readability only.
 Runtime(
  name="cloud-storage-runtime",
  namespace="exospherehost",
- nodes=[ListS3FilesNode]
+ nodes=[ListS3FilesNode, DownloadS3FileNode]
 ).start()

exosphere-runtimes/cloud-storage-runtime/nodes/download_s3_file.py

@@ -0,0 +1,33 @@
+import boto3
+from exospherehost import BaseNode
+from pydantic import BaseModel
+
+
+class DownloadS3FileNode(BaseNode):
+
+ class Inputs(BaseModel):
+ bucket_name: str
+ key: str
+
+ class Outputs(BaseModel):
+ file_path: str
+
+ class Secrets(BaseModel):
+ aws_access_key_id: str
+ aws_secret_access_key: str
+ aws_region: str
+
+ async def execute(self) -> Outputs:
+
+ s3_client = boto3.client(
+ 's3',
+ aws_access_key_id=self.secrets.aws_access_key_id,
+ aws_secret_access_key=self.secrets.aws_secret_access_key,
+ region_name=self.secrets.aws_region
+ )
+
+ file_name = self.inputs.key.split('/')[-1]
+
+ s3_client.download_file(self.inputs.bucket_name, self.inputs.key, file_name)
+
+ return self.Outputs(file_path=self.outputs.file_path)

python-sdk/README.md

@@ -23,6 +23,8 @@ pip install exospherehost
 
 ## Quick Start
 
+> Important: In v1, all fields in `Inputs`, `Outputs`, and `Secrets` must be strings. If you need to pass complex data (e.g., JSON), serialize the data to a string first, then parse that string within your node.
+
 ### Basic Node Creation
 
 Create a simple node that processes data:
@@ -34,24 +36,24 @@ from pydantic import BaseModel
 class SampleNode(BaseNode):
  class Inputs(BaseModel):
  name: str
- data: dict
+ data: str # v1: strings only
 
  class Outputs(BaseModel):
  message: str
- processed_data: dict
+ processed_data: str # v1: strings only
 
  async def execute(self) -> Outputs:
  print(f"Processing data for: {self.inputs.name}")
- # Your processing logic here
- processed_data = {"status": "completed", "input": self.inputs.data}
+ # Your processing logic here; serialize complex data to strings (e.g., JSON)
+ processed_data = f"completed:{self.inputs.data}"
  return self.Outputs(
- message="success",
+ message="success",
  processed_data=processed_data
  )
 
 # Initialize the runtime
 Runtime(
- namespace="MyProject",
+ namespace="MyProject",
  name="DataProcessor",
  nodes=[SampleNode]
 ).start()
@@ -71,6 +73,7 @@ export EXOSPHERE_API_KEY="your-api-key"
 - **Distributed Execution**: Run nodes across multiple compute resources
 - **State Management**: Automatic state persistence and recovery
 - **Type Safety**: Full Pydantic integration for input/output validation
+- **String-only data model (v1)**: All `Inputs`, `Outputs`, and `Secrets` fields are strings. Serialize non-string data (e.g., JSON) as needed.
 - **Async Support**: Native async/await support for high-performance operations
 - **Error Handling**: Built-in retry mechanisms and error recovery
 - **Scalability**: Designed for high-volume batch processing and workflows
@@ -103,15 +106,16 @@ Nodes are the building blocks of your workflows. Each node:
 class ConfigurableNode(BaseNode):
  class Inputs(BaseModel):
  text: str
- max_length: int = 100
+ max_length: str = "100" # v1: strings only
 
  class Outputs(BaseModel):
  result: str
- length: int
+ length: str # v1: strings only
 
  async def execute(self) -> Outputs:
- result = self.inputs.text[:self.inputs.max_length]
- return self.Outputs(result=result, length=len(result))
+ max_length = int(self.inputs.max_length)
+ result = self.inputs.text[:max_length]
+ return self.Outputs(result=result, length=str(len(result)))
 ```
 
 ### Error Handling
@@ -122,7 +126,7 @@ class RobustNode(BaseNode):
  data: str
 
  class Outputs(BaseModel):
- success: bool
+ success: str
  result: str
 
  async def execute(self) -> Outputs:
@@ -137,14 +141,15 @@ Secrets allow you to securely manage sensitive configuration data like API keys,
 ```python
 from exospherehost import Runtime, BaseNode
 from pydantic import BaseModel
+import json
 
 class APINode(BaseNode):
  class Inputs(BaseModel):
  user_id: str
  query: str
 
  class Outputs(BaseModel):
- response: dict
+ response: str # v1: strings only
  status: str
 
  class Secrets(BaseModel):
@@ -159,14 +164,24 @@ class APINode(BaseNode):
  # Use secrets for API calls
  import httpx
  async with httpx.AsyncClient() as client:
-response = await client.post(
+http_response = await client.post(
  f"{self.secrets.api_endpoint}/process",
  headers=headers,
  json={"user_id": self.inputs.user_id, "query": self.inputs.query}
  )
 
+ # Serialize body: prefer JSON if valid; fallback to text or empty string
+ response_text = http_response.text or ""
+ if response_text:
+ try:
+ response_str = json.dumps(http_response.json())
+ except Exception:
+ response_str = response_text
+ else:
+ response_str = ""
+
  return self.Outputs(
- response=response.json(),
+ response=response_str,
  status="success"
  )
 ```
@@ -175,6 +190,7 @@ class APINode(BaseNode):
 
 - **Security**: Secrets are stored securely by the ExosphereHost Runtime and are never exposed in logs or error messages
 - **Validation**: The `Secrets` class uses Pydantic for automatic validation of secret values
+- **String-only (v1)**: All `Secrets` fields must be strings.
 - **Access**: Secrets are available via `self.secrets` during node execution
 - **Types**: Common secret types include API keys, database credentials, encryption keys, and authentication tokens
 - **Injection**: Secrets are injected by the Runtime at execution time, so you don't need to handle them manually

python-sdk/exospherehost/_version.py

@@ -1 +1 @@
-version = "0.0.7b4"
+version = "0.0.7b5"

python-sdk/exospherehost/node/__init__.py

@@ -11,6 +11,5 @@
 """
 
 from .BaseNode import BaseNode
-from .status import Status
 
-__all__ = ["BaseNode", "Status"]
+__all__ = ["BaseNode"]

python-sdk/exospherehost/runtime.py

@@ -279,6 +279,15 @@ def _validate_nodes(self):
  errors.append(f"{node.__name__} does not have an Secrets class")
  if not issubclass(node.Secrets, BaseModel):
  errors.append(f"{node.__name__} does not have an Secrets class that inherits from pydantic.BaseModel")
+
+ # check all data objects are strings
+ for field_name, field_info in node.Inputs.model_fields.items():
+ if field_info.annotation is not str:
+ errors.append(f"{node.__name__}.Inputs field '{field_name}' must be of type str, got {field_info.annotation}")
+
+ for field_name, field_info in node.Outputs.model_fields.items():
+ if field_info.annotation is not str:
+ errors.append(f"{node.__name__}.Outputs field '{field_name}' must be of type str, got {field_info.annotation}")
 
  for field_name, field_info in node.Secrets.model_fields.items():
  if field_info.annotation is not str:

state-manager/app/models/node_template_model.py

@@ -7,5 +7,4 @@ class NodeTemplate(BaseModel):
  namespace: str = Field(..., description="Namespace of the node")
  identifier: str = Field(..., description="Identifier of the node")
  inputs: dict[str, Any] = Field(..., description="Inputs of the node")
- store: dict[str, Any] = Field(..., description="Upsert data to store object for the node")
  next_nodes: Optional[List[str]] = Field(None, description="Next nodes to execute")