blaxel 0.2.34__py3-none-any.whl → 0.2.35__py3-none-any.whl

blaxel/core/client/models/function.py

@@ -3,6 +3,7 @@ from typing import TYPE_CHECKING, Any, TypeVar, Union
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
 
+from ..models.status import Status
 from ..types import UNSET, Unset
 
 if TYPE_CHECKING:
@@ -16,22 +17,35 @@ T = TypeVar("T", bound="Function")
 
 @_attrs_define
 class Function:
-    """Function
-
-    Attributes:
-        events (Union[Unset, list['CoreEvent']]): Core events
-        metadata (Union[Unset, Metadata]): Metadata
-        spec (Union[Unset, FunctionSpec]): Function specification
-        status (Union[Unset, str]): Function status
+    """MCP server deployment that exposes tools for AI agents via the Model Context Protocol (MCP). Deployed as a
+    serverless auto-scaling endpoint using streamable HTTP transport.
+
+        Attributes:
+            metadata (Metadata): Common metadata fields shared by all Blaxel resources including name, labels, timestamps,
+                and ownership information
+            spec (FunctionSpec): Configuration for an MCP server function including runtime settings, transport protocol,
+                and connected integrations
+            events (Union[Unset, list['CoreEvent']]): Events happening on a resource deployed on Blaxel
+            status (Union[Unset, Status]): Deployment status of a resource deployed on Blaxel
     """
 
+    metadata: "Metadata"
+    spec: "FunctionSpec"
     events: Union[Unset, list["CoreEvent"]] = UNSET
-    metadata: Union[Unset, "Metadata"] = UNSET
-    spec: Union[Unset, "FunctionSpec"] = UNSET
-    status: Union[Unset, str] = UNSET
+    status: Union[Unset, Status] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
+        if type(self.metadata) is dict:
+            metadata = self.metadata
+        else:
+            metadata = self.metadata.to_dict()
+
+        if type(self.spec) is dict:
+            spec = self.spec
+        else:
+            spec = self.spec.to_dict()
+
         events: Union[Unset, list[dict[str, Any]]] = UNSET
         if not isinstance(self.events, Unset):
             events = []
@@ -44,33 +58,20 @@ class Function:
                     )
                 events.append(componentsschemas_core_events_item)
 
-        metadata: Union[Unset, dict[str, Any]] = UNSET
-        if (
-            self.metadata
-            and not isinstance(self.metadata, Unset)
-            and not isinstance(self.metadata, dict)
-        ):
-            metadata = self.metadata.to_dict()
-        elif self.metadata and isinstance(self.metadata, dict):
-            metadata = self.metadata
-
-        spec: Union[Unset, dict[str, Any]] = UNSET
-        if self.spec and not isinstance(self.spec, Unset) and not isinstance(self.spec, dict):
-            spec = self.spec.to_dict()
-        elif self.spec and isinstance(self.spec, dict):
-            spec = self.spec
-
-        status = self.status
+        status: Union[Unset, str] = UNSET
+        if not isinstance(self.status, Unset):
+            status = self.status.value
 
         field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
-        field_dict.update({})
+        field_dict.update(
+            {
+                "metadata": metadata,
+                "spec": spec,
+            }
+        )
         if events is not UNSET:
             field_dict["events"] = events
-        if metadata is not UNSET:
-            field_dict["metadata"] = metadata
-        if spec is not UNSET:
-            field_dict["spec"] = spec
         if status is not UNSET:
             field_dict["status"] = status
 
@@ -85,6 +86,10 @@ class Function:
         if not src_dict:
             return None
         d = src_dict.copy()
+        metadata = Metadata.from_dict(d.pop("metadata"))
+
+        spec = FunctionSpec.from_dict(d.pop("spec"))
+
         events = []
         _events = d.pop("events", UNSET)
         for componentsschemas_core_events_item_data in _events or []:
@@ -94,26 +99,17 @@ class Function:
 
             events.append(componentsschemas_core_events_item)
 
-        _metadata = d.pop("metadata", UNSET)
-        metadata: Union[Unset, Metadata]
-        if isinstance(_metadata, Unset):
-            metadata = UNSET
+        _status = d.pop("status", UNSET)
+        status: Union[Unset, Status]
+        if isinstance(_status, Unset):
+            status = UNSET
         else:
-            metadata = Metadata.from_dict(_metadata)
-
-        _spec = d.pop("spec", UNSET)
-        spec: Union[Unset, FunctionSpec]
-        if isinstance(_spec, Unset):
-            spec = UNSET
-        else:
-            spec = FunctionSpec.from_dict(_spec)
-
-        status = d.pop("status", UNSET)
+            status = Status(_status)
 
         function = cls(
-            events=events,
             metadata=metadata,
             spec=spec,
+            events=events,
             status=status,
         )
 

blaxel/core/client/models/function_runtime.py

@@ -0,0 +1,138 @@
+from typing import TYPE_CHECKING, Any, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.function_runtime_generation import FunctionRuntimeGeneration
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.env import Env
+
+
+T = TypeVar("T", bound="FunctionRuntime")
+
+
+@_attrs_define
+class FunctionRuntime:
+    """Runtime configuration defining how the MCP server function is deployed and scaled
+
+    Attributes:
+        envs (Union[Unset, list['Env']]): Environment variables injected into the function. Supports Kubernetes EnvVar
+            format with valueFrom references.
+        generation (Union[Unset, FunctionRuntimeGeneration]): Infrastructure generation: mk2 (containers, 2-10s cold
+            starts, 15+ global regions) or mk3 (microVMs, sub-25ms cold starts) Example: mk3.
+        image (Union[Unset, str]): Container image built by Blaxel when deploying with 'bl deploy'. This field is auto-
+            populated during deployment.
+        max_scale (Union[Unset, int]): Maximum number of concurrent function instances for auto-scaling Example: 10.
+        memory (Union[Unset, int]): Memory allocation in megabytes. Also determines CPU allocation (CPU cores = memory
+            in MB / 2048, e.g., 4096MB = 2 CPUs). Example: 2048.
+        min_scale (Union[Unset, int]): Minimum instances to keep warm. Set to 1+ to eliminate cold starts, 0 for scale-
+            to-zero.
+    """
+
+    envs: Union[Unset, list["Env"]] = UNSET
+    generation: Union[Unset, FunctionRuntimeGeneration] = UNSET
+    image: Union[Unset, str] = UNSET
+    max_scale: Union[Unset, int] = UNSET
+    memory: Union[Unset, int] = UNSET
+    min_scale: Union[Unset, int] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        envs: Union[Unset, list[dict[str, Any]]] = UNSET
+        if not isinstance(self.envs, Unset):
+            envs = []
+            for envs_item_data in self.envs:
+                if type(envs_item_data) is dict:
+                    envs_item = envs_item_data
+                else:
+                    envs_item = envs_item_data.to_dict()
+                envs.append(envs_item)
+
+        generation: Union[Unset, str] = UNSET
+        if not isinstance(self.generation, Unset):
+            generation = self.generation.value
+
+        image = self.image
+
+        max_scale = self.max_scale
+
+        memory = self.memory
+
+        min_scale = self.min_scale
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if envs is not UNSET:
+            field_dict["envs"] = envs
+        if generation is not UNSET:
+            field_dict["generation"] = generation
+        if image is not UNSET:
+            field_dict["image"] = image
+        if max_scale is not UNSET:
+            field_dict["maxScale"] = max_scale
+        if memory is not UNSET:
+            field_dict["memory"] = memory
+        if min_scale is not UNSET:
+            field_dict["minScale"] = min_scale
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T | None:
+        from ..models.env import Env
+
+        if not src_dict:
+            return None
+        d = src_dict.copy()
+        envs = []
+        _envs = d.pop("envs", UNSET)
+        for envs_item_data in _envs or []:
+            envs_item = Env.from_dict(envs_item_data)
+
+            envs.append(envs_item)
+
+        _generation = d.pop("generation", UNSET)
+        generation: Union[Unset, FunctionRuntimeGeneration]
+        if isinstance(_generation, Unset):
+            generation = UNSET
+        else:
+            generation = FunctionRuntimeGeneration(_generation)
+
+        image = d.pop("image", UNSET)
+
+        max_scale = d.pop("maxScale", d.pop("max_scale", UNSET))
+
+        memory = d.pop("memory", UNSET)
+
+        min_scale = d.pop("minScale", d.pop("min_scale", UNSET))
+
+        function_runtime = cls(
+            envs=envs,
+            generation=generation,
+            image=image,
+            max_scale=max_scale,
+            memory=memory,
+            min_scale=min_scale,
+        )
+
+        function_runtime.additional_properties = d
+        return function_runtime
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

blaxel/core/client/models/function_runtime_generation.py

@@ -0,0 +1,18 @@
+from enum import Enum
+
+
+class FunctionRuntimeGeneration(str, Enum):
+    MK2 = "mk2"
+    MK3 = "mk3"
+
+    def __str__(self) -> str:
+        return str(self.value)
+
+    @classmethod
+    def _missing_(cls, value: object) -> "FunctionRuntimeGeneration | None":
+        if isinstance(value, str):
+            upper_value = value.upper()
+            for member in cls:
+                if member.value.upper() == upper_value:
+                    return member
+        return None

blaxel/core/client/models/function_spec.py

@@ -3,13 +3,12 @@ from typing import TYPE_CHECKING, Any, TypeVar, Union, cast
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
 
+from ..models.function_spec_transport import FunctionSpecTransport
 from ..types import UNSET, Unset
 
 if TYPE_CHECKING:
-    from ..models.core_spec_configurations import CoreSpecConfigurations
-    from ..models.flavor import Flavor
+    from ..models.function_runtime import FunctionRuntime
     from ..models.revision_configuration import RevisionConfiguration
-    from ..models.runtime import Runtime
     from ..models.trigger import Trigger
 
 
@@ -18,56 +17,33 @@ T = TypeVar("T", bound="FunctionSpec")
 
 @_attrs_define
 class FunctionSpec:
-    """Function specification
+    """Configuration for an MCP server function including runtime settings, transport protocol, and connected integrations
 
     Attributes:
-        configurations (Union[Unset, CoreSpecConfigurations]): Optional configurations for the object
-        enabled (Union[Unset, bool]): Enable or disable the resource
-        flavors (Union[Unset, list['Flavor']]): Types of hardware available for deployments
+        enabled (Union[Unset, bool]): When false, the function is disabled and will not serve requests Default: True.
+            Example: True.
         integration_connections (Union[Unset, list[str]]):
         policies (Union[Unset, list[str]]):
         revision (Union[Unset, RevisionConfiguration]): Revision configuration
-        runtime (Union[Unset, Runtime]): Set of configurations for a deployment
-        sandbox (Union[Unset, bool]): Sandbox mode
-        description (Union[Unset, str]): Function description, very important for the agent function to work with an LLM
+        runtime (Union[Unset, FunctionRuntime]): Runtime configuration defining how the MCP server function is deployed
+            and scaled
+        transport (Union[Unset, FunctionSpecTransport]): Transport compatibility for the MCP, can be "websocket" or
+            "http-stream" Example: http-stream.
         triggers (Union[Unset, list['Trigger']]): Triggers to use your agent
     """
 
-    configurations: Union[Unset, "CoreSpecConfigurations"] = UNSET
-    enabled: Union[Unset, bool] = UNSET
-    flavors: Union[Unset, list["Flavor"]] = UNSET
+    enabled: Union[Unset, bool] = True
     integration_connections: Union[Unset, list[str]] = UNSET
     policies: Union[Unset, list[str]] = UNSET
     revision: Union[Unset, "RevisionConfiguration"] = UNSET
-    runtime: Union[Unset, "Runtime"] = UNSET
-    sandbox: Union[Unset, bool] = UNSET
-    description: Union[Unset, str] = UNSET
+    runtime: Union[Unset, "FunctionRuntime"] = UNSET
+    transport: Union[Unset, FunctionSpecTransport] = UNSET
     triggers: Union[Unset, list["Trigger"]] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
-        configurations: Union[Unset, dict[str, Any]] = UNSET
-        if (
-            self.configurations
-            and not isinstance(self.configurations, Unset)
-            and not isinstance(self.configurations, dict)
-        ):
-            configurations = self.configurations.to_dict()
-        elif self.configurations and isinstance(self.configurations, dict):
-            configurations = self.configurations
-
         enabled = self.enabled
 
-        flavors: Union[Unset, list[dict[str, Any]]] = UNSET
-        if not isinstance(self.flavors, Unset):
-            flavors = []
-            for componentsschemas_flavors_item_data in self.flavors:
-                if type(componentsschemas_flavors_item_data) is dict:
-                    componentsschemas_flavors_item = componentsschemas_flavors_item_data
-                else:
-                    componentsschemas_flavors_item = componentsschemas_flavors_item_data.to_dict()
-                flavors.append(componentsschemas_flavors_item)
-
         integration_connections: Union[Unset, list[str]] = UNSET
         if not isinstance(self.integration_connections, Unset):
             integration_connections = self.integration_connections
@@ -96,9 +72,9 @@ class FunctionSpec:
         elif self.runtime and isinstance(self.runtime, dict):
             runtime = self.runtime
 
-        sandbox = self.sandbox
-
-        description = self.description
+        transport: Union[Unset, str] = UNSET
+        if not isinstance(self.transport, Unset):
+            transport = self.transport.value
 
         triggers: Union[Unset, list[dict[str, Any]]] = UNSET
         if not isinstance(self.triggers, Unset):
@@ -113,12 +89,8 @@ class FunctionSpec:
         field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
         field_dict.update({})
-        if configurations is not UNSET:
-            field_dict["configurations"] = configurations
         if enabled is not UNSET:
             field_dict["enabled"] = enabled
-        if flavors is not UNSET:
-            field_dict["flavors"] = flavors
         if integration_connections is not UNSET:
             field_dict["integrationConnections"] = integration_connections
         if policies is not UNSET:
@@ -127,10 +99,8 @@ class FunctionSpec:
             field_dict["revision"] = revision
         if runtime is not UNSET:
             field_dict["runtime"] = runtime
-        if sandbox is not UNSET:
-            field_dict["sandbox"] = sandbox
-        if description is not UNSET:
-            field_dict["description"] = description
+        if transport is not UNSET:
+            field_dict["transport"] = transport
         if triggers is not UNSET:
             field_dict["triggers"] = triggers
 
@@ -138,31 +108,15 @@ class FunctionSpec:
 
     @classmethod
     def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T | None:
-        from ..models.core_spec_configurations import CoreSpecConfigurations
-        from ..models.flavor import Flavor
+        from ..models.function_runtime import FunctionRuntime
         from ..models.revision_configuration import RevisionConfiguration
-        from ..models.runtime import Runtime
         from ..models.trigger import Trigger
 
         if not src_dict:
             return None
         d = src_dict.copy()
-        _configurations = d.pop("configurations", UNSET)
-        configurations: Union[Unset, CoreSpecConfigurations]
-        if isinstance(_configurations, Unset):
-            configurations = UNSET
-        else:
-            configurations = CoreSpecConfigurations.from_dict(_configurations)
-
         enabled = d.pop("enabled", UNSET)
 
-        flavors = []
-        _flavors = d.pop("flavors", UNSET)
-        for componentsschemas_flavors_item_data in _flavors or []:
-            componentsschemas_flavors_item = Flavor.from_dict(componentsschemas_flavors_item_data)
-
-            flavors.append(componentsschemas_flavors_item)
-
         integration_connections = cast(
             list[str], d.pop("integrationConnections", d.pop("integration_connections", UNSET))
         )
@@ -177,15 +131,18 @@ class FunctionSpec:
             revision = RevisionConfiguration.from_dict(_revision)
 
         _runtime = d.pop("runtime", UNSET)
-        runtime: Union[Unset, Runtime]
+        runtime: Union[Unset, FunctionRuntime]
         if isinstance(_runtime, Unset):
             runtime = UNSET
         else:
-            runtime = Runtime.from_dict(_runtime)
-
-        sandbox = d.pop("sandbox", UNSET)
+            runtime = FunctionRuntime.from_dict(_runtime)
 
-        description = d.pop("description", UNSET)
+        _transport = d.pop("transport", UNSET)
+        transport: Union[Unset, FunctionSpecTransport]
+        if isinstance(_transport, Unset):
+            transport = UNSET
+        else:
+            transport = FunctionSpecTransport(_transport)
 
         triggers = []
         _triggers = d.pop("triggers", UNSET)
@@ -197,15 +154,12 @@ class FunctionSpec:
             triggers.append(componentsschemas_triggers_item)
 
         function_spec = cls(
-            configurations=configurations,
             enabled=enabled,
-            flavors=flavors,
             integration_connections=integration_connections,
             policies=policies,
             revision=revision,
             runtime=runtime,
-            sandbox=sandbox,
-            description=description,
+            transport=transport,
             triggers=triggers,
         )
 

blaxel/core/client/models/function_spec_transport.py

@@ -0,0 +1,18 @@
+from enum import Enum
+
+
+class FunctionSpecTransport(str, Enum):
+    HTTP_STREAM = "http-stream"
+    WEBSOCKET = "websocket"
+
+    def __str__(self) -> str:
+        return str(self.value)
+
+    @classmethod
+    def _missing_(cls, value: object) -> "FunctionSpecTransport | None":
+        if isinstance(value, str):
+            upper_value = value.upper()
+            for member in cls:
+                if member.value.upper() == upper_value:
+                    return member
+        return None

blaxel/core/client/models/image.py

@@ -1,10 +1,8 @@
-from typing import TYPE_CHECKING, Any, TypeVar, Union
+from typing import TYPE_CHECKING, Any, TypeVar
 
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
 
-from ..types import UNSET, Unset
-
 if TYPE_CHECKING:
     from ..models.image_metadata import ImageMetadata
     from ..models.image_spec import ImageSpec
@@ -17,38 +15,33 @@ T = TypeVar("T", bound="Image")
 class Image:
     """
     Attributes:
-        metadata (Union[Unset, ImageMetadata]):
-        spec (Union[Unset, ImageSpec]):
+        metadata (ImageMetadata):
+        spec (ImageSpec):
     """
 
-    metadata: Union[Unset, "ImageMetadata"] = UNSET
-    spec: Union[Unset, "ImageSpec"] = UNSET
+    metadata: "ImageMetadata"
+    spec: "ImageSpec"
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
-        metadata: Union[Unset, dict[str, Any]] = UNSET
-        if (
-            self.metadata
-            and not isinstance(self.metadata, Unset)
-            and not isinstance(self.metadata, dict)
-        ):
-            metadata = self.metadata.to_dict()
-        elif self.metadata and isinstance(self.metadata, dict):
+        if type(self.metadata) is dict:
             metadata = self.metadata
+        else:
+            metadata = self.metadata.to_dict()
 
-        spec: Union[Unset, dict[str, Any]] = UNSET
-        if self.spec and not isinstance(self.spec, Unset) and not isinstance(self.spec, dict):
-            spec = self.spec.to_dict()
-        elif self.spec and isinstance(self.spec, dict):
+        if type(self.spec) is dict:
             spec = self.spec
+        else:
+            spec = self.spec.to_dict()
 
         field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
-        field_dict.update({})
-        if metadata is not UNSET:
-            field_dict["metadata"] = metadata
-        if spec is not UNSET:
-            field_dict["spec"] = spec
+        field_dict.update(
+            {
+                "metadata": metadata,
+                "spec": spec,
+            }
+        )
 
         return field_dict
 
@@ -60,19 +53,9 @@ class Image:
         if not src_dict:
             return None
         d = src_dict.copy()
-        _metadata = d.pop("metadata", UNSET)
-        metadata: Union[Unset, ImageMetadata]
-        if isinstance(_metadata, Unset):
-            metadata = UNSET
-        else:
-            metadata = ImageMetadata.from_dict(_metadata)
+        metadata = ImageMetadata.from_dict(d.pop("metadata"))
 
-        _spec = d.pop("spec", UNSET)
-        spec: Union[Unset, ImageSpec]
-        if isinstance(_spec, Unset):
-            spec = UNSET
-        else:
-            spec = ImageSpec.from_dict(_spec)
+        spec = ImageSpec.from_dict(d.pop("spec"))
 
         image = cls(
             metadata=metadata,