Rename serverless to on-demand-sandbox APIs

Rename the Serverless activity RPC surface and messages to OnDemandSandbox equivalents across the proto, generated pb2/pb2_grpc stubs, and client usage. Add CPU and memory normalization/validation helpers to client (kubernetes-style quantities parsed using Decimal) and wire those into activity declaration construction. Remove DefaultAzureCredential usage in the worker (token credential set to None). Update examples, tests, and markdown tooling (enable front-matter in .pymarkdown.json), and add a new .github agent doc. Generated protobuf/grpc files and version/warning text were updated to reflect the renamed package and expected grpc tool/runtime versions.

Author: YunchuWang

.github/agents/elementary-pr-teacher.agent.md

@@ -1,4 +1,9 @@
 {
+    "extensions": {
+        "front-matter": {
+            "enabled": true
+        }
+    },
     "plugins": {
         "md013": {
             "line_length": 100

.pymarkdown.json

@@ -2,6 +2,7 @@
 # Licensed under the MIT License.
 
 from dataclasses import dataclass, field
+from decimal import Decimal, InvalidOperation
 from typing import Callable, Iterable, Optional, Sequence
 
 import grpc
@@ -134,7 +135,7 @@ def build_serverless_activity_declaration(
         environment_variables: Optional[dict[str, str]] = None,
         max_concurrent_activities: int = DEFAULT_MAX_CONCURRENT_ACTIVITIES,
         entrypoint: Optional[Iterable[str]] = None,
-        cmd: Optional[Iterable[str]] = None) -> pb.ServerlessActivityDeclaration:
+        cmd: Optional[Iterable[str]] = None) -> pb.OnDemandSandboxActivityDeclaration:
     resolved_activity_names = resolve_activity_names(activity_names)
     if not resolved_activity_names:
         raise ValueError("Serverless activity declaration requires at least one activity name.")
@@ -154,19 +155,16 @@ def build_serverless_activity_declaration(
     if not image_ref:
         raise ValueError("Serverless activity image metadata requires a container image reference.")
 
-    if not cpu or not cpu.strip():
-        raise ValueError("Serverless activity declaration requires CPU resources.")
+    resolved_cpu = _normalize_cpu(cpu)
+    resolved_memory = _normalize_memory(memory)
 
-    if not memory or not memory.strip():
-        raise ValueError("Serverless activity declaration requires memory resources.")
-
-    declaration = pb.ServerlessActivityDeclaration(
+    declaration = pb.OnDemandSandboxActivityDeclaration(
         worker_profile_id=worker_profile_id.strip(),
-        image=pb.ServerlessActivityImage(
+        image=pb.OnDemandSandboxActivityImage(
             image_ref=image_ref),
-        resources=pb.ServerlessActivityResources(
-            cpu=cpu.strip(),
-            memory=memory.strip()),
+        resources=pb.OnDemandSandboxActivityResources(
+            cpu=resolved_cpu,
+            memory=resolved_memory),
         max_concurrent_activities=max_concurrent_activities)
     declaration.activity_names.extend(resolved_activity_names)
     declaration.environment_variables.update(environment_variables or {})
@@ -175,9 +173,9 @@ def build_serverless_activity_declaration(
     return declaration
 
 
-def build_profile_serverless_activity_declarations() -> list[pb.ServerlessActivityDeclaration]:
+def build_profile_serverless_activity_declarations() -> list[pb.OnDemandSandboxActivityDeclaration]:
     """Build serverless declarations from worker profile configuration."""
-    declarations: list[pb.ServerlessActivityDeclaration] = []
+    declarations: list[pb.OnDemandSandboxActivityDeclaration] = []
     activity_owners: dict[str, str] = {}
     for profile in _worker_profiles.values():
         activity_names = resolve_activity_names(profile.activity_names)
@@ -217,7 +215,7 @@ def build_serverless_worker_start(
         max_activities_count: int,
         activity_names: Iterable[str],
         substrate: Optional[str] = None,
-        dts_sandbox_identifier: Optional[str] = None) -> pb.ServerlessActivityWorkerMessage:
+        dts_sandbox_identifier: Optional[str] = None) -> pb.OnDemandSandboxActivityWorkerMessage:
     if not taskhub or not taskhub.strip():
         raise ValueError("Serverless activity worker registration requires a task hub name.")
 
@@ -231,8 +229,8 @@ def build_serverless_worker_start(
     if not resolved_activity_names:
         raise ValueError("Serverless activity worker registration requires at least one registered activity.")
 
-    message = pb.ServerlessActivityWorkerMessage(
-        start=pb.ServerlessActivityWorkerStart(
+    message = pb.OnDemandSandboxActivityWorkerMessage(
+        start=pb.OnDemandSandboxActivityWorkerStart(
             task_hub=taskhub.strip(),
             worker_profile_id=worker_profile_id.strip(),
             max_activities_count=max_activities_count,
@@ -242,12 +240,12 @@ def build_serverless_worker_start(
     return message
 
 
-def build_serverless_worker_heartbeat(active_activities_count: int) -> pb.ServerlessActivityWorkerMessage:
+def build_serverless_worker_heartbeat(active_activities_count: int) -> pb.OnDemandSandboxActivityWorkerMessage:
     if active_activities_count < 0:
         raise ValueError("Serverless activity worker active activity count cannot be negative.")
 
-    return pb.ServerlessActivityWorkerMessage(
-        heartbeat=pb.ServerlessActivityWorkerHeartbeat(
+    return pb.OnDemandSandboxActivityWorkerMessage(
+        heartbeat=pb.OnDemandSandboxActivityWorkerHeartbeat(
             active_activities_count=active_activities_count))
 
 
@@ -278,7 +276,7 @@ def __init__(
                 interceptors=resolved_interceptors,
                 channel_options=channel_options)
         self._channel = channel
-        self._stub = stubs.ServerlessActivitiesStub(channel)
+        self._stub = stubs.OnDemandSandboxActivitiesStub(channel)
 
     def close(self) -> None:
         if self._owns_channel:
@@ -291,17 +289,18 @@ def enable_serverless_activities(self) -> None:
             raise ValueError("No configured serverless activities were found.")
 
         for declaration in declarations:
-            self._stub.DeclareServerlessActivities(declaration)
+            self._stub.DeclareOnDemandSandboxActivities(declaration)
 
     def remove_serverless_activity_declaration(self, worker_profile_id: str) -> None:
         worker_profile_id = _normalize_required(worker_profile_id, "Worker profile ID is required.")
-        self._stub.RemoveServerlessActivityDeclaration(
-            pb.RemoveServerlessActivityDeclarationRequest(worker_profile_id=worker_profile_id))
+        self._stub.RemoveOnDemandSandboxActivityDeclaration(
+            pb.RemoveOnDemandSandboxActivityDeclarationRequest(worker_profile_id=worker_profile_id))
 
     def connect_serverless_activity_worker(
             self,
-            messages: Iterable[pb.ServerlessActivityWorkerMessage]) -> pb.ServerlessActivityWorkerSessionResult:
-        return self._stub.ConnectServerlessActivityWorker(messages)
+            messages: Iterable[pb.OnDemandSandboxActivityWorkerMessage]
+    ) -> pb.OnDemandSandboxActivityWorkerSessionResult:
+        return self._stub.ConnectOnDemandSandboxActivityWorker(messages)
 
 
 def _normalize_optional_strings(values: Iterable[str]) -> list[str]:
@@ -314,6 +313,46 @@ def _normalize_required(value: str, message: str) -> str:
     return value.strip()
 
 
+def _normalize_cpu(value: str) -> str:
+    normalized = _normalize_required(value, "Serverless activity declaration requires CPU resources.")
+    milli_cpu = _try_parse_cpu_millicores(normalized)
+    if milli_cpu is None or milli_cpu <= 0:
+        raise ValueError(
+            "Serverless activity CPU resources must be a positive Kubernetes-style CPU quantity. "
+            "Use formats like '500m', '2', or '0.5'.")
+    return normalized
+
+
+def _normalize_memory(value: str) -> str:
+    normalized = _normalize_required(value, "Serverless activity declaration requires memory resources.")
+    memory_mib = _try_parse_memory_mib(normalized)
+    if memory_mib is None or memory_mib <= 0:
+        raise ValueError(
+            "Serverless activity memory resources must be a positive Kubernetes-style memory quantity. "
+            "Use formats like '256Mi', '1Gi', or '2048'.")
+    return normalized
+
+
+def _try_parse_cpu_millicores(value: str) -> Optional[int]:
+    try:
+        if value[-1:].lower() == "m":
+            return int(Decimal(value[:-1]))
+        return int(Decimal(value) * 1000)
+    except (InvalidOperation, ValueError):
+        return None
+
+
+def _try_parse_memory_mib(value: str) -> Optional[int]:
+    try:
+        if value[-2:].lower() == "gi":
+            return int(Decimal(value[:-2]) * 1024)
+        if value[-2:].lower() == "mi":
+            return int(Decimal(value[:-2]))
+        return int(Decimal(value))
+    except (InvalidOperation, ValueError):
+        return None
+
+
 def _parse_substrate(substrate: Optional[str]) -> "pb.SubstrateKind":
     if not substrate:
         return pb.SUBSTRATE_KIND_UNSPECIFIED

durabletask-azuremanaged/durabletask/azuremanaged/extensions/serverless/client.py

@@ -7,8 +7,6 @@
 
 from typing import Iterator, Optional
 
-from azure.identity import DefaultAzureCredential
-
 from durabletask.azuremanaged.extensions.serverless.client import (
     DEFAULT_MAX_CONCURRENT_ACTIVITIES,
     DEFAULT_WORKER_PROFILE_ID,
@@ -36,10 +34,7 @@ def __init__(self):
         resolved_host_address = _resolve_host_address()
         resolved_taskhub = _resolve_taskhub()
         resolved_secure_channel = _resolve_secure_channel(resolved_host_address)
-        resolved_token_credential = (
-            DefaultAzureCredential()
-            if resolved_secure_channel
-            else None)
+        resolved_token_credential = None
         resolved_max_concurrent_activities = _resolve_max_concurrent_activities()
         concurrency_options = ConcurrencyOptions(
             maximum_concurrent_activity_work_items=resolved_max_concurrent_activities)

durabletask-azuremanaged/durabletask/azuremanaged/extensions/serverless/worker.py

@@ -3,34 +3,36 @@
 
 syntax = "proto3";
 
-package microsoft.durabletask.serverless;
+package microsoft.durabletask.ondemandsandbox;
 
-option csharp_namespace = "Microsoft.DurableTask.Protobuf.Serverless";
+option csharp_namespace = "Microsoft.DurableTask.Protobuf.OnDemandSandbox";
 
-service ServerlessActivities {
-  // Opens a live serverless activity worker session. The first message must be a
-  // start message with static worker metadata. Heartbeats carry dynamic state
-  // only. Closing the stream deregisters the worker.
-  rpc ConnectServerlessActivityWorker(stream ServerlessActivityWorkerMessage) returns (ServerlessActivityWorkerSessionResult);
+service OnDemandSandboxActivities {
+  // Opens a live on-demand sandbox activity worker session. The first message
+  // must be a start message with static worker metadata. Heartbeats carry
+  // dynamic state only. Closing the stream deregisters the worker.
+  rpc ConnectOnDemandSandboxActivityWorker(stream OnDemandSandboxActivityWorkerMessage) returns (OnDemandSandboxActivityWorkerSessionResult);
 
-  // Declares serverless activities before any live worker stream exists. This is a
-  // configuration contract and does not advertise active worker capacity.
-  rpc DeclareServerlessActivities(ServerlessActivityDeclaration) returns (ServerlessActivityDeclarationResult);
+  // Declares on-demand sandbox activities before any live worker stream exists.
+  // This is a configuration contract and does not advertise active worker
+  // capacity.
+  rpc DeclareOnDemandSandboxActivities(OnDemandSandboxActivityDeclaration) returns (OnDemandSandboxActivityDeclarationResult);
 
-  // Removes a serverless activity declaration so the backend stops waking new workers
-  // for the specified worker profile. Existing workers are not terminated by this RPC.
-  rpc RemoveServerlessActivityDeclaration(RemoveServerlessActivityDeclarationRequest) returns (RemoveServerlessActivityDeclarationResult);
+  // Removes an on-demand sandbox activity declaration so the backend stops
+  // waking new sandbox workers for the specified worker profile. Existing
+  // workers are not terminated by this RPC.
+  rpc RemoveOnDemandSandboxActivityDeclaration(RemoveOnDemandSandboxActivityDeclarationRequest) returns (RemoveOnDemandSandboxActivityDeclarationResult);
 
 }
 
-message ServerlessActivityWorkerMessage {
+message OnDemandSandboxActivityWorkerMessage {
   oneof message {
-    ServerlessActivityWorkerStart start = 1;
-    ServerlessActivityWorkerHeartbeat heartbeat = 2;
+    OnDemandSandboxActivityWorkerStart start = 1;
+    OnDemandSandboxActivityWorkerHeartbeat heartbeat = 2;
   }
 }
 
-message ServerlessActivityWorkerStart {
+message OnDemandSandboxActivityWorkerStart {
   reserved 2;
   reserved "worker_instance_id";
 
@@ -47,43 +49,43 @@ message ServerlessActivityWorkerStart {
   repeated string activity_names = 7;
 }
 
-message ServerlessActivityWorkerHeartbeat {
+message OnDemandSandboxActivityWorkerHeartbeat {
   int32 active_activities_count = 1;
 }
 
-message ServerlessActivityWorkerSessionResult {
+message OnDemandSandboxActivityWorkerSessionResult {
   bool accepted = 1;
   string message = 2;
 }
 
-message ServerlessActivityDeclaration {
+message OnDemandSandboxActivityDeclaration {
   string worker_profile_id = 2;
   repeated string activity_names = 3;
-  ServerlessActivityImage image = 4;
+  OnDemandSandboxActivityImage image = 4;
   map<string, string> environment_variables = 5;
   int32 max_concurrent_activities = 6;
-  ServerlessActivityResources resources = 7;
+  OnDemandSandboxActivityResources resources = 7;
   repeated string entrypoint = 8;
   repeated string cmd = 9;
 }
 
-message ServerlessActivityImage {
+message OnDemandSandboxActivityImage {
   string image_ref = 1;
 }
 
-message ServerlessActivityResources {
+message OnDemandSandboxActivityResources {
   string cpu = 1;
   string memory = 2;
 }
 
-message ServerlessActivityDeclarationResult {
+message OnDemandSandboxActivityDeclarationResult {
 }
 
-message RemoveServerlessActivityDeclarationRequest {
+message RemoveOnDemandSandboxActivityDeclarationRequest {
   string worker_profile_id = 1;
 }
 
-message RemoveServerlessActivityDeclarationResult {
+message RemoveOnDemandSandboxActivityDeclarationResult {
 }
 
 // Compute substrate executing the activity worker.