mplang-nightly 0.1.dev164__py3-none-any.whl → 0.1.dev166__py3-none-any.whl

mplang/protos/v1alpha1/mpir_pb2.pyi

@@ -38,6 +38,7 @@ class _DataType:
 class _DataTypeEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_DataType.ValueType], builtins.type):
     DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor
     UNDEFINED: _DataType.ValueType  # 0
+    """Undefined data type"""
     U8: _DataType.ValueType  # 1
     """uint8_t"""
     I8: _DataType.ValueType  # 2
@@ -83,6 +84,7 @@ class DataType(_DataType, metaclass=_DataTypeEnumTypeWrapper):
     """Data type enumeration"""
 
 UNDEFINED: DataType.ValueType  # 0
+"""Undefined data type"""
 U8: DataType.ValueType  # 1
 """uint8_t"""
 I8: DataType.ValueType  # 2
@@ -138,14 +140,23 @@ class AttrProto(google.protobuf.message.Message):
     class _AttrTypeEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[AttrProto._AttrType.ValueType], builtins.type):
         DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor
         UNDEFINED: AttrProto._AttrType.ValueType  # 0
+        """Undefined attribute type"""
         FLOAT: AttrProto._AttrType.ValueType  # 1
+        """Single float value"""
         INT: AttrProto._AttrType.ValueType  # 2
+        """Single integer value"""
         STRING: AttrProto._AttrType.ValueType  # 3
+        """Single string value"""
         BOOL: AttrProto._AttrType.ValueType  # 4
+        """Single boolean value"""
         BYTES: AttrProto._AttrType.ValueType  # 5
+        """Binary data"""
         FLOATS: AttrProto._AttrType.ValueType  # 6
+        """Array of float values"""
         INTS: AttrProto._AttrType.ValueType  # 7
+        """Array of integer values"""
         STRINGS: AttrProto._AttrType.ValueType  # 8
+        """Array of string values"""
         FUNCTION: AttrProto._AttrType.ValueType  # 10
         """Textual function reference"""
         GRAPH: AttrProto._AttrType.ValueType  # 11
@@ -155,14 +166,23 @@ class AttrProto(google.protobuf.message.Message):
         """Define possible attribute types"""
 
     UNDEFINED: AttrProto.AttrType.ValueType  # 0
+    """Undefined attribute type"""
     FLOAT: AttrProto.AttrType.ValueType  # 1
+    """Single float value"""
     INT: AttrProto.AttrType.ValueType  # 2
+    """Single integer value"""
     STRING: AttrProto.AttrType.ValueType  # 3
+    """Single string value"""
     BOOL: AttrProto.AttrType.ValueType  # 4
+    """Single boolean value"""
     BYTES: AttrProto.AttrType.ValueType  # 5
+    """Binary data"""
     FLOATS: AttrProto.AttrType.ValueType  # 6
+    """Array of float values"""
     INTS: AttrProto.AttrType.ValueType  # 7
+    """Array of integer values"""
     STRINGS: AttrProto.AttrType.ValueType  # 8
+    """Array of string values"""
     FUNCTION: AttrProto.AttrType.ValueType  # 10
     """Textual function reference"""
     GRAPH: AttrProto.AttrType.ValueType  # 11
@@ -182,24 +202,24 @@ class AttrProto(google.protobuf.message.Message):
     type: global___AttrProto.AttrType.ValueType
     """Type of the attribute"""
     f: builtins.float
-    """FLOAT"""
+    """FLOAT value"""
     i: builtins.int
-    """INT"""
+    """INT value"""
     s: builtins.str
-    """STRING"""
+    """STRING value"""
     b: builtins.bool
-    """BOOL"""
+    """BOOL value"""
     raw_bytes: builtins.bytes
     """BYTES - for raw binary data"""
     @property
     def floats(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.float]:
-        """FLOATS"""
+        """FLOATS - array of float values"""
     @property
     def ints(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.int]:
-        """INTS"""
+        """INTS - array of integer values"""
     @property
     def strs(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.str]:
-        """STRINGS"""
+        """STRINGS - array of string values"""
     @property
     def func(self) -> global___FuncProto:
         """FUNCTION - textual function reference"""
@@ -228,6 +248,8 @@ global___AttrProto = AttrProto
 
 @typing_extensions.final
 class FuncProto(google.protobuf.message.Message):
+    """Function prototype message"""
+
     DESCRIPTOR: google.protobuf.descriptor.Descriptor
 
     @typing_extensions.final
@@ -254,7 +276,7 @@ class FuncProto(google.protobuf.message.Message):
     DOC_STRING_FIELD_NUMBER: builtins.int
     ATTRS_FIELD_NUMBER: builtins.int
     type: builtins.str
-    """Function type."""
+    """Function type"""
     name: builtins.str
     """Function name"""
     body: builtins.str
@@ -279,13 +301,17 @@ global___FuncProto = FuncProto
 
 @typing_extensions.final
 class TensorTypeProto(google.protobuf.message.Message):
+    """Tensor type definition"""
+
     DESCRIPTOR: google.protobuf.descriptor.Descriptor
 
     DTYPE_FIELD_NUMBER: builtins.int
     SHAPE_DIMS_FIELD_NUMBER: builtins.int
     dtype: global___DataType.ValueType
+    """Data type of the tensor elements"""
     @property
-    def shape_dims(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.int]: ...
+    def shape_dims(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.int]:
+        """Shape dimensions of the tensor"""
     def __init__(
         self,
         *,
@@ -298,16 +324,22 @@ global___TensorTypeProto = TensorTypeProto
 
 @typing_extensions.final
 class TableTypeProto(google.protobuf.message.Message):
+    """Table type definition"""
+
     DESCRIPTOR: google.protobuf.descriptor.Descriptor
 
     @typing_extensions.final
     class Column(google.protobuf.message.Message):
+        """Column definition within a table"""
+
         DESCRIPTOR: google.protobuf.descriptor.Descriptor
 
         NAME_FIELD_NUMBER: builtins.int
         DTYPE_FIELD_NUMBER: builtins.int
         name: builtins.str
+        """Name of the column"""
         dtype: global___DataType.ValueType
+        """Data type of the column"""
         def __init__(
             self,
             *,
@@ -318,7 +350,8 @@ class TableTypeProto(google.protobuf.message.Message):
 
     COLUMNS_FIELD_NUMBER: builtins.int
     @property
-    def columns(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___TableTypeProto.Column]: ...
+    def columns(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___TableTypeProto.Column]:
+        """List of columns in the table"""
     def __init__(
         self,
         *,
@@ -330,6 +363,8 @@ global___TableTypeProto = TableTypeProto
 
 @typing_extensions.final
 class MPTypeProto(google.protobuf.message.Message):
+    """Multi-party type definition"""
+
     DESCRIPTOR: google.protobuf.descriptor.Descriptor
 
     @typing_extensions.final
@@ -355,14 +390,16 @@ class MPTypeProto(google.protobuf.message.Message):
     PMASK_FIELD_NUMBER: builtins.int
     ATTRS_FIELD_NUMBER: builtins.int
     @property
-    def tensor_type(self) -> global___TensorTypeProto: ...
+    def tensor_type(self) -> global___TensorTypeProto:
+        """Tensor type specification"""
     @property
-    def table_type(self) -> global___TableTypeProto: ...
+    def table_type(self) -> global___TableTypeProto:
+        """Table type specification"""
     pmask: builtins.int
-    """party mask (-1 for dynamic mask, >=0 for static mask)"""
+    """Party mask (-1 for dynamic mask, >=0 for static mask)"""
     @property
     def attrs(self) -> google.protobuf.internal.containers.MessageMap[builtins.str, global___AttrProto]:
-        """attributes"""
+        """Additional attributes"""
     def __init__(
         self,
         *,
@@ -379,6 +416,8 @@ global___MPTypeProto = MPTypeProto
 
 @typing_extensions.final
 class NodeProto(google.protobuf.message.Message):
+    """Node prototype definition"""
+
     DESCRIPTOR: google.protobuf.descriptor.Descriptor
 
     @typing_extensions.final
@@ -406,16 +445,20 @@ class NodeProto(google.protobuf.message.Message):
     ATTRS_FIELD_NUMBER: builtins.int
     DOC_STRING_FIELD_NUMBER: builtins.int
     op_type: builtins.str
+    """Operation type of the node"""
     name: builtins.str
+    """Name of the node"""
     @property
     def inputs(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.str]:
-        """{name:index}"""
+        """Input specifications in format {name:index}"""
     @property
     def outs_info(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___MPTypeProto]:
-        """"""
+        """Output type information"""
     @property
-    def attrs(self) -> google.protobuf.internal.containers.MessageMap[builtins.str, global___AttrProto]: ...
+    def attrs(self) -> google.protobuf.internal.containers.MessageMap[builtins.str, global___AttrProto]:
+        """Node attributes"""
     doc_string: builtins.str
+    """Documentation string"""
     def __init__(
         self,
         *,
@@ -432,6 +475,8 @@ global___NodeProto = NodeProto
 
 @typing_extensions.final
 class VersionInfo(google.protobuf.message.Message):
+    """Version information definition"""
+
     DESCRIPTOR: google.protobuf.descriptor.Descriptor
 
     MAJOR_FIELD_NUMBER: builtins.int
@@ -460,6 +505,8 @@ global___VersionInfo = VersionInfo
 
 @typing_extensions.final
 class GraphProto(google.protobuf.message.Message):
+    """Graph prototype definition"""
+
     DESCRIPTOR: google.protobuf.descriptor.Descriptor
 
     @typing_extensions.final
@@ -485,14 +532,17 @@ class GraphProto(google.protobuf.message.Message):
     OUTPUTS_FIELD_NUMBER: builtins.int
     ATTRS_FIELD_NUMBER: builtins.int
     @property
-    def version(self) -> global___VersionInfo: ...
+    def version(self) -> global___VersionInfo:
+        """Version information"""
     @property
-    def nodes(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___NodeProto]: ...
+    def nodes(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___NodeProto]:
+        """List of nodes in the graph"""
     @property
     def outputs(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.str]:
-        """{name:index}"""
+        """Output specifications in format {name:index}"""
     @property
-    def attrs(self) -> google.protobuf.internal.containers.MessageMap[builtins.str, global___AttrProto]: ...
+    def attrs(self) -> google.protobuf.internal.containers.MessageMap[builtins.str, global___AttrProto]:
+        """Graph attributes"""
     def __init__(
         self,
         *,

mplang/protos/v1alpha1/value_pb2.py

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: mplang/protos/v1alpha1/value.proto
+# Protobuf Python Version: 5.26.1
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\"mplang/protos/v1alpha1/value.proto\x12\x16mplang.protos.v1alpha1\"\xe8\x02\n\x0eValueAttrProto\x12\x43\n\x04type\x18\x01 \x01(\x0e\x32/.mplang.protos.v1alpha1.ValueAttrProto.AttrTypeR\x04type\x12\x0c\n\x01\x66\x18\x02 \x01(\x02R\x01\x66\x12\x0c\n\x01i\x18\x03 \x01(\x03R\x01i\x12\x0c\n\x01s\x18\x04 \x01(\tR\x01s\x12\x0c\n\x01\x62\x18\x05 \x01(\x08R\x01\x62\x12\x1b\n\traw_bytes\x18\x06 \x01(\x0cR\x08rawBytes\x12\x16\n\x06\x66loats\x18\x07 \x03(\x02R\x06\x66loats\x12\x12\n\x04ints\x18\x08 \x03(\x03R\x04ints\x12\x12\n\x04strs\x18\t \x03(\tR\x04strs\"|\n\x08\x41ttrType\x12\r\n\tUNDEFINED\x10\x00\x12\t\n\x05\x46LOAT\x10\x01\x12\x07\n\x03INT\x10\x02\x12\n\n\x06STRING\x10\x03\x12\x08\n\x04\x42OOL\x10\x04\x12\t\n\x05\x42YTES\x10\x05\x12\n\n\x06\x46LOATS\x10\x06\x12\x08\n\x04INTS\x10\x07\x12\x0b\n\x07STRINGS\x10\x08\x12\t\n\x05\x45MPTY\x10\t\"\xa3\x02\n\nValueProto\x12\x12\n\x04kind\x18\x01 \x01(\tR\x04kind\x12#\n\rvalue_version\x18\x02 \x01(\rR\x0cvalueVersion\x12\x18\n\x07payload\x18\x03 \x01(\x0cR\x07payload\x12Y\n\rruntime_attrs\x18\x04 \x03(\x0b\x32\x34.mplang.protos.v1alpha1.ValueProto.RuntimeAttrsEntryR\x0cruntimeAttrs\x1ag\n\x11RuntimeAttrsEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12<\n\x05value\x18\x02 \x01(\x0b\x32&.mplang.protos.v1alpha1.ValueAttrProtoR\x05value:\x02\x38\x01\x62\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'mplang.protos.v1alpha1.value_pb2', _globals)
+if not _descriptor._USE_C_DESCRIPTORS:
+  DESCRIPTOR._loaded_options = None
+  _globals['_VALUEPROTO_RUNTIMEATTRSENTRY']._loaded_options = None
+  _globals['_VALUEPROTO_RUNTIMEATTRSENTRY']._serialized_options = b'8\001'
+  _globals['_VALUEATTRPROTO']._serialized_start=63
+  _globals['_VALUEATTRPROTO']._serialized_end=423
+  _globals['_VALUEATTRPROTO_ATTRTYPE']._serialized_start=299
+  _globals['_VALUEATTRPROTO_ATTRTYPE']._serialized_end=423
+  _globals['_VALUEPROTO']._serialized_start=426
+  _globals['_VALUEPROTO']._serialized_end=717
+  _globals['_VALUEPROTO_RUNTIMEATTRSENTRY']._serialized_start=614
+  _globals['_VALUEPROTO_RUNTIMEATTRSENTRY']._serialized_end=717
+# @@protoc_insertion_point(module_scope)

mplang/protos/v1alpha1/value_pb2.pyi

@@ -0,0 +1,169 @@
+"""
+@generated by mypy-protobuf.  Do not edit manually!
+isort:skip_file
+Copyright 2025 Ant Group Co., Ltd.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+import builtins
+import collections.abc
+import google.protobuf.descriptor
+import google.protobuf.internal.containers
+import google.protobuf.internal.enum_type_wrapper
+import google.protobuf.message
+import sys
+import typing
+
+if sys.version_info >= (3, 10):
+    import typing as typing_extensions
+else:
+    import typing_extensions
+
+DESCRIPTOR: google.protobuf.descriptor.FileDescriptor
+
+@typing_extensions.final
+class ValueAttrProto(google.protobuf.message.Message):
+    """Lightweight attribute proto used solely for ValueProto runtime metadata."""
+
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    class _AttrType:
+        ValueType = typing.NewType("ValueType", builtins.int)
+        V: typing_extensions.TypeAlias = ValueType
+
+    class _AttrTypeEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[ValueAttrProto._AttrType.ValueType], builtins.type):
+        DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor
+        UNDEFINED: ValueAttrProto._AttrType.ValueType  # 0
+        FLOAT: ValueAttrProto._AttrType.ValueType  # 1
+        INT: ValueAttrProto._AttrType.ValueType  # 2
+        STRING: ValueAttrProto._AttrType.ValueType  # 3
+        BOOL: ValueAttrProto._AttrType.ValueType  # 4
+        BYTES: ValueAttrProto._AttrType.ValueType  # 5
+        FLOATS: ValueAttrProto._AttrType.ValueType  # 6
+        INTS: ValueAttrProto._AttrType.ValueType  # 7
+        STRINGS: ValueAttrProto._AttrType.ValueType  # 8
+        EMPTY: ValueAttrProto._AttrType.ValueType  # 9
+        """Represents an explicitly empty attribute value (e.g., empty list)"""
+
+    class AttrType(_AttrType, metaclass=_AttrTypeEnumTypeWrapper): ...
+    UNDEFINED: ValueAttrProto.AttrType.ValueType  # 0
+    FLOAT: ValueAttrProto.AttrType.ValueType  # 1
+    INT: ValueAttrProto.AttrType.ValueType  # 2
+    STRING: ValueAttrProto.AttrType.ValueType  # 3
+    BOOL: ValueAttrProto.AttrType.ValueType  # 4
+    BYTES: ValueAttrProto.AttrType.ValueType  # 5
+    FLOATS: ValueAttrProto.AttrType.ValueType  # 6
+    INTS: ValueAttrProto.AttrType.ValueType  # 7
+    STRINGS: ValueAttrProto.AttrType.ValueType  # 8
+    EMPTY: ValueAttrProto.AttrType.ValueType  # 9
+    """Represents an explicitly empty attribute value (e.g., empty list)"""
+
+    TYPE_FIELD_NUMBER: builtins.int
+    F_FIELD_NUMBER: builtins.int
+    I_FIELD_NUMBER: builtins.int
+    S_FIELD_NUMBER: builtins.int
+    B_FIELD_NUMBER: builtins.int
+    RAW_BYTES_FIELD_NUMBER: builtins.int
+    FLOATS_FIELD_NUMBER: builtins.int
+    INTS_FIELD_NUMBER: builtins.int
+    STRS_FIELD_NUMBER: builtins.int
+    type: global___ValueAttrProto.AttrType.ValueType
+    f: builtins.float
+    i: builtins.int
+    s: builtins.str
+    b: builtins.bool
+    raw_bytes: builtins.bytes
+    @property
+    def floats(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.float]: ...
+    @property
+    def ints(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.int]: ...
+    @property
+    def strs(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.str]: ...
+    def __init__(
+        self,
+        *,
+        type: global___ValueAttrProto.AttrType.ValueType = ...,
+        f: builtins.float = ...,
+        i: builtins.int = ...,
+        s: builtins.str = ...,
+        b: builtins.bool = ...,
+        raw_bytes: builtins.bytes = ...,
+        floats: collections.abc.Iterable[builtins.float] | None = ...,
+        ints: collections.abc.Iterable[builtins.int] | None = ...,
+        strs: collections.abc.Iterable[builtins.str] | None = ...,
+    ) -> None: ...
+    def ClearField(self, field_name: typing_extensions.Literal["b", b"b", "f", b"f", "floats", b"floats", "i", b"i", "ints", b"ints", "raw_bytes", b"raw_bytes", "s", b"s", "strs", b"strs", "type", b"type"]) -> None: ...
+
+global___ValueAttrProto = ValueAttrProto
+
+@typing_extensions.final
+class ValueProto(google.protobuf.message.Message):
+    """Generic envelope for kernel-level transferable values.
+
+    DESIGN PRINCIPLES
+    * Small, stable schema: only descriptors needed for dynamic dispatch.
+    * Payload is opaque to the envelope; per-kind versioning lives in
+    value_version.
+    * Backward-compatible evolution: only append new optional fields.
+
+    Versioning Guidelines:
+    - value_version: per-kind semantic payload version (maintained by KernelValue
+    subclass).
+    - Adding fields: assign new unique field numbers; never reuse old numbers.
+    - Removing fields: reserve the field number & (optionally) name.
+    """
+
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    @typing_extensions.final
+    class RuntimeAttrsEntry(google.protobuf.message.Message):
+        DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+        KEY_FIELD_NUMBER: builtins.int
+        VALUE_FIELD_NUMBER: builtins.int
+        key: builtins.str
+        @property
+        def value(self) -> global___ValueAttrProto: ...
+        def __init__(
+            self,
+            *,
+            key: builtins.str = ...,
+            value: global___ValueAttrProto | None = ...,
+        ) -> None: ...
+        def HasField(self, field_name: typing_extensions.Literal["value", b"value"]) -> builtins.bool: ...
+        def ClearField(self, field_name: typing_extensions.Literal["key", b"key", "value", b"value"]) -> None: ...
+
+    KIND_FIELD_NUMBER: builtins.int
+    VALUE_VERSION_FIELD_NUMBER: builtins.int
+    PAYLOAD_FIELD_NUMBER: builtins.int
+    RUNTIME_ATTRS_FIELD_NUMBER: builtins.int
+    kind: builtins.str
+    """Globally unique identifier for Value subclass, e.g. "mplang.ndarray"."""
+    value_version: builtins.int
+    """Per-kind payload schema version (>=1)."""
+    payload: builtins.bytes
+    """Primary data payload bytes (layout defined by each Value subclass)."""
+    @property
+    def runtime_attrs(self) -> google.protobuf.internal.containers.MessageMap[builtins.str, global___ValueAttrProto]:
+        """Additional runtime metadata required to recreate the Value instance."""
+    def __init__(
+        self,
+        *,
+        kind: builtins.str = ...,
+        value_version: builtins.int = ...,
+        payload: builtins.bytes = ...,
+        runtime_attrs: collections.abc.Mapping[builtins.str, global___ValueAttrProto] | None = ...,
+    ) -> None: ...
+    def ClearField(self, field_name: typing_extensions.Literal["kind", b"kind", "payload", b"payload", "runtime_attrs", b"runtime_attrs", "value_version", b"value_version"]) -> None: ...
+
+global___ValueProto = ValueProto

mplang/runtime/client.py

@@ -25,9 +25,10 @@ from __future__ import annotations
 import base64
 from typing import Any
 
-import cloudpickle as pickle
 import httpx
 
+from mplang.kernels.value import Value, decode_value, encode_value
+
 
 class ExecutionStatus:
     """Status of a computation execution."""
@@ -253,8 +254,10 @@ class HttpExecutorClient:
         """
         url = f"/sessions/{session_name}/symbols/{symbol_name}"
 
-        # Serialize data
-        data_bytes = pickle.dumps(data)
+        # Serialize data using Value envelope
+        if not isinstance(data, Value):
+            raise TypeError(f"Data must be a Value instance, got {type(data)}")
+        data_bytes = encode_value(data)
         data_b64 = base64.b64encode(data_bytes).decode("utf-8")
 
         payload = {"data": data_b64, "mptype": mptype or {}}
@@ -286,11 +289,15 @@ class HttpExecutorClient:
             response.raise_for_status()
             symbol_data = response.json()
 
-            # Deserialize data
+            # Deserialize data using Value envelope
             data_bytes = base64.b64decode(symbol_data["data"])
-            return pickle.loads(data_bytes)
+            return decode_value(data_bytes)
 
-        except (httpx.HTTPStatusError, httpx.RequestError) as e:
+        except httpx.HTTPStatusError as e:
+            if e.response is not None and e.response.status_code == 404:
+                return None
+            raise self._raise_http_error(f"get symbol {symbol_name}", e) from e
+        except httpx.RequestError as e:
             raise self._raise_http_error(f"get symbol {symbol_name}", e) from e
 
     async def delete_symbol(self, session_name: str, symbol_name: str) -> None:
@@ -403,8 +410,12 @@ class HttpExecutorClient:
         """
         url = f"/api/v1/symbols/{symbol_name}"
         try:
+            # Serialize using Value envelope
+            if not isinstance(data, Value):
+                raise TypeError(f"Data must be a Value instance, got {type(data)}")
+            data_bytes = encode_value(data)
             payload = {
-                "data": base64.b64encode(pickle.dumps(data)).decode("utf-8"),
+                "data": base64.b64encode(data_bytes).decode("utf-8"),
                 "mptype": mptype or {},
             }
             resp = await self._client.put(url, json=payload)
@@ -421,7 +432,7 @@ class HttpExecutorClient:
             resp.raise_for_status()
             payload = resp.json()
             data_bytes = base64.b64decode(payload["data"])
-            return pickle.loads(data_bytes)
+            return decode_value(data_bytes)
         except (httpx.HTTPStatusError, httpx.RequestError) as e:
             raise self._raise_http_error(f"get global symbol {symbol_name}", e) from e
 

mplang/runtime/communicator.py

@@ -21,10 +21,10 @@ import base64
 import logging
 from typing import Any
 
-import cloudpickle as pickle
 import httpx
 
 from mplang.core.comm import CommunicatorBase
+from mplang.kernels.value import Value, decode_value, encode_value
 
 
 class HttpCommunicator(CommunicatorBase):
@@ -52,8 +52,14 @@ class HttpCommunicator(CommunicatorBase):
         )
 
         try:
-            # Use cloudpickle for robust serialization of complex Python objects
-            data_bytes = pickle.dumps(data)
+            # Serialize data using Value envelope.
+            if not isinstance(data, Value):
+                raise TypeError(
+                    f"Communicator requires Value instance, got {type(data).__name__}. "
+                    "Wrap data in TensorValue or custom Value subclass."
+                )
+            data_bytes = encode_value(data)
+
             data_b64 = base64.b64encode(data_bytes).decode("utf-8")
 
             request_data = {
@@ -79,7 +85,8 @@ class HttpCommunicator(CommunicatorBase):
         data_b64 = super().recv(frm, key)
 
         data_bytes = base64.b64decode(data_b64)
-        result = pickle.loads(data_bytes)
+        # Deserialize using Value envelope
+        result = decode_value(data_bytes)
 
         logging.debug(
             f"Received data: from_rank={frm}, to_rank={self._rank}, key={key}"

mplang/runtime/driver.py

@@ -27,6 +27,8 @@ import uuid
 from collections.abc import Sequence
 from typing import Any
 
+import numpy as np
+
 from mplang.core.cluster import ClusterSpec
 from mplang.core.expr.ast import Expr
 from mplang.core.interp import InterpContext, InterpVar
@@ -34,6 +36,7 @@ from mplang.core.mask import Mask
 from mplang.core.mpir import Writer
 from mplang.core.mpobject import MPObject
 from mplang.core.mptype import MPType
+from mplang.kernels.value import TableValue, TensorValue
 from mplang.runtime.client import HttpExecutorClient
 
 
@@ -257,7 +260,19 @@ class Driver(InterpContext):
             try:
                 # The results will be in the same order as the clients (ranks)
                 results = await asyncio.gather(*tasks)
-                return list(results)
+                converted: list[Any] = []
+                for value in results:
+                    if isinstance(value, TensorValue):
+                        arr = value.to_numpy()
+                        if isinstance(arr, np.ndarray) and arr.size == 1:
+                            converted.append(arr.item())
+                        else:
+                            converted.append(arr)
+                    elif isinstance(value, TableValue):
+                        converted.append(value.to_pandas())
+                    else:
+                        converted.append(value)
+                return converted
             except RuntimeError as e:
                 raise RuntimeError(
                     f"Failed to fetch symbol from one or more parties: {e}"