lumera 0.41.2.dev20260909__tar.gz → 0.41.3.dev2026091001__tar.gz

{lumera-0.41.2.dev20260909 → lumera-0.41.3.dev2026091001}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lumera
-Version: 0.41.2.dev20260909
+Version: 0.41.3.dev2026091001
 Summary: SDK for building on Lumera platform
 Requires-Python: >=3.11
 Requires-Dist: requests>=2.33.0

{lumera-0.41.2.dev20260909 → lumera-0.41.3.dev2026091001}/lumera/function_resources.py

@@ -9,6 +9,8 @@ from urllib.parse import quote
 
 from ._utils import _api_request
 
+_FUNCTION_INVOCATION_TIMEOUT_SECONDS = 295
+
 
 def deploy_release(
     project: str,
@@ -104,6 +106,7 @@ def invoke_function(
         "POST",
         f"projects/{quote(project_ref, safe='')}/functions/{quote(function_ref, safe='')}/invoke",
         json_body=body,
+        timeout=_FUNCTION_INVOCATION_TIMEOUT_SECONDS,
     )
     return _mapping(payload, "Function invocation")
 
@@ -117,8 +120,6 @@ def list_function_executions(
 def get_function_execution(
     project: str,
     execution: str,
-    *,
-    wait_seconds: int | None = None,
 ) -> dict[str, Any]:
     project_ref = _required_ref(project, "project")
     execution_ref = _required_ref(execution, "execution")
@@ -126,31 +127,10 @@ def get_function_execution(
         f"projects/{quote(project_ref, safe='')}/function-executions/"
         f"{quote(execution_ref, safe='')}"
     )
-    options: dict[str, Any] = {}
-    if wait_seconds is not None:
-        if isinstance(wait_seconds, bool) or not 1 <= wait_seconds <= 30:
-            raise ValueError("wait_seconds must be between 1 and 30")
-        options["request_headers"] = {"Prefer": f"wait={wait_seconds}"}
-        options["timeout"] = wait_seconds + 5
-    payload = _api_request("GET", path, **options)
+    payload = _api_request("GET", path)
     return _mapping(payload, "Function execution")
 
 
-def cancel_function_execution(project: str, execution: str) -> dict[str, Any]:
-    project_ref = _required_ref(project, "project")
-    execution_ref = _required_ref(execution, "execution")
-    path = (
-        f"projects/{quote(project_ref, safe='')}/function-executions/"
-        f"{quote(execution_ref, safe='')}/cancel"
-    )
-    payload = _api_request(
-        "POST",
-        path,
-        json_body={},
-    )
-    return _mapping(payload, "Function execution cancellation")
-
-
 def _list(kind: str, project: str, *, cursor: str | None, limit: int) -> dict[str, Any]:
     project_ref = _required_ref(project, "project")
     payload = _api_request(
@@ -184,7 +164,6 @@ def _mapping(payload: object | None, kind: str) -> dict[str, Any]:
 
 
 __all__ = [
-    "cancel_function_execution",
     "deploy_release",
     "deploy_runtime",
     "get_function",

{lumera-0.41.2.dev20260909 → lumera-0.41.3.dev2026091001}/lumera/functions/__init__.py

@@ -29,8 +29,6 @@ from ._contract import (
 from ._errors import (
     DuplicateFunctionError,
     DuplicateHttpProjectionError,
-    DurableTransportUnavailableError,
-    DurableWaitNotAllowedError,
     FunctionCallModeError,
     FunctionCancelledError,
     FunctionCycleError,
@@ -44,18 +42,19 @@ from ._errors import (
     FunctionOutputSerializationError,
     FunctionRuntimeClosedError,
     FunctionsError,
+    FunctionTransportUnavailableError,
     FunctionValidationError,
-    InvalidDurableWaitError,
+    InvalidFunctionWaitError,
     UnexpectedFunctionError,
 )
 from ._execution import (
-    DurableFunctionTransport,
     ExecutionHandle,
     ExecutionStatus,
+    FunctionTransport,
     StartedExecution,
 )
 from ._registry import FunctionRegistry, discover_modules
-from ._remote import RemoteFunctionTransport, invoke_remote
+from ._remote import RemoteFunctionTransport, call_remote, invoke_remote
 from ._runtime import LocalFunctionRuntime, invoke_local
 
 del _dependencies
@@ -68,9 +67,6 @@ __all__ = [
     "CancellationToken",
     "DuplicateFunctionError",
     "DuplicateHttpProjectionError",
-    "DurableFunctionTransport",
-    "DurableTransportUnavailableError",
-    "DurableWaitNotAllowedError",
     "ExecutionHandle",
     "ExecutionStatus",
     "FUNCTION_MANIFEST_SCHEMA_VERSION",
@@ -94,12 +90,15 @@ __all__ = [
     "FunctionOutputSerializationError",
     "FunctionRegistry",
     "FunctionRuntimeClosedError",
+    "FunctionTransport",
+    "FunctionTransportUnavailableError",
     "FunctionsError",
     "FunctionValidationError",
     "HttpProjection",
-    "InvalidDurableWaitError",
+    "InvalidFunctionWaitError",
     "LocalFunctionRuntime",
     "RemoteFunctionTransport",
+    "call_remote",
     "ScopedLumeraClient",
     "StartedExecution",
     "StructuredLogger",

{lumera-0.41.2.dev20260909 → lumera-0.41.3.dev2026091001}/lumera/functions/_artifacts.py

@@ -10,7 +10,7 @@ from pydantic import BaseModel, ConfigDict, Field
 class ArtifactReference(BaseModel):
     """An opaque, non-authoritative reference to a Lumera-managed artifact.
 
-    Function payloads carry this JSON-safe envelope across local, API, durable,
+    Function payloads carry this JSON-safe envelope across local, API, remote,
     and sharing boundaries. Runtime adapters are responsible for authorizing
     and materializing the referenced artifact. Local paths, object-store keys,
     URLs, and credentials are deliberately absent from the contract.

{lumera-0.41.2.dev20260909 → lumera-0.41.3.dev2026091001}/lumera/functions/_context.py

@@ -25,7 +25,7 @@ if TYPE_CHECKING:
     from ._execution import ExecutionHandle
 
 ResultT = TypeVar("ResultT")
-RuntimeMode = Literal["local", "api", "worker", "external"]
+RuntimeMode = Literal["local", "api", "external"]
 
 
 @dataclass(frozen=True)
@@ -159,7 +159,7 @@ class LocalScopedLumeraClient:
 
 @runtime_checkable
 class FunctionCaller(Protocol):
-    """Validated same-release and durable Function composition interface."""
+    """Validated same-release and remote Function composition interface."""
 
     @overload
     async def call(
@@ -388,7 +388,7 @@ def create_test_context(
 ) -> TestFunctionContext:
     """Build a deterministic-shape context without platform credentials."""
 
-    if runtime_mode not in {"local", "api", "worker", "external"}:
+    if runtime_mode not in {"local", "api", "external"}:
         raise ValueError(f"unsupported Function runtime mode: {runtime_mode!r}")
     resolved_deadline = deadline or (datetime.now(UTC) + timedelta(minutes=5))
     if resolved_deadline.tzinfo is None:

{lumera-0.41.2.dev20260909 → lumera-0.41.3.dev2026091001}/lumera/functions/_errors.py

@@ -158,13 +158,9 @@ class FunctionCallModeError(FunctionInvocationError):
     """The caller used a sync composition API from an unsafe thread."""
 
 
-class DurableTransportUnavailableError(FunctionsError):
-    """No durable Function transport is configured in this phase/context."""
+class FunctionTransportUnavailableError(FunctionsError):
+    """No remote Function transport is configured in this context."""
 
 
-class DurableWaitNotAllowedError(FunctionsError):
-    """A Function worker attempted to wait for durable child work."""
-
-
-class InvalidDurableWaitError(FunctionsError):
-    """A durable result wait was not positive and bounded."""
+class InvalidFunctionWaitError(FunctionsError):
+    """A Function result wait was not positive and bounded."""

{lumera-0.41.2.dev20260909 → lumera-0.41.3.dev2026091001}/lumera/functions/_execution.py

@@ -1,4 +1,4 @@
-"""Durable-execution interfaces reserved for later transport adapters."""
+"""Function RPC execution handles and transport interfaces."""
 
 from __future__ import annotations
 
@@ -8,14 +8,14 @@ from dataclasses import dataclass
 from typing import Any, Generic, Protocol, TypeVar
 
 from ._context import FunctionContext
-from ._errors import DurableWaitNotAllowedError, InvalidDurableWaitError
+from ._errors import InvalidFunctionWaitError
 
 ResultT = TypeVar("ResultT")
 
 
 @dataclass(frozen=True)
 class ExecutionStatus:
-    """Transport-neutral durable execution status snapshot."""
+    """Transport-neutral Function execution status snapshot."""
 
     execution_id: str
     status: str
@@ -25,14 +25,16 @@ class ExecutionStatus:
 
 @dataclass(frozen=True)
 class StartedExecution:
-    """Identity returned when a durable transport accepts an invocation."""
+    """Execution snapshot returned by a Function transport."""
 
     execution_id: str
-    status: str = "queued"
+    status: str = "running"
+    result: Any | None = None
+    error: Mapping[str, Any] | None = None
 
 
-class DurableFunctionTransport(Protocol):
-    """Backend adapter seam; Phase 1 intentionally ships no real transport."""
+class FunctionTransport(Protocol):
+    """Backend adapter used for synchronous remote Function calls."""
 
     async def start(
         self,
@@ -56,9 +58,8 @@ class DurableFunctionTransport(Protocol):
 class ExecutionHandle(Generic[ResultT]):
     """Handle returned by ``ctx.functions.start``.
 
-    Waiting is deliberately bounded. Handles created inside Function-worker
-    contexts reject ``result`` so a saturated worker pool cannot deadlock while
-    waiting for queued child work.
+    The RPC has normally finished before this handle is returned. ``result``
+    remains bounded for compatibility with handles created by custom transports.
     """
 
     def __init__(
@@ -67,39 +68,43 @@ class ExecutionHandle(Generic[ResultT]):
         execution_id: str,
         function_ref: str,
         initial_status: str,
-        transport: DurableFunctionTransport,
-        wait_allowed: bool,
+        transport: FunctionTransport,
+        initial_result: object | None = None,
+        initial_error: Mapping[str, Any] | None = None,
         result_validator: Callable[[object], ResultT] | None = None,
     ) -> None:
         self.execution_id = execution_id
         self.function_ref = function_ref
         self.initial_status = initial_status
         self._transport = transport
-        self._wait_allowed = wait_allowed
+        self._initial_result = initial_result
+        self._initial_error = initial_error
         self._result_validator = result_validator
 
     async def status(self) -> ExecutionStatus:
-        """Read the latest durable status without waiting for completion."""
+        """Read the latest Function execution status."""
 
         return await self._transport.get_status(self.execution_id)
 
     async def result(self, *, timeout: float) -> ResultT:
         """Wait for at most ``timeout`` seconds and return the transport result."""
 
-        if not self._wait_allowed:
-            raise DurableWaitNotAllowedError(
-                "Function workers may start durable child work but cannot wait for it; "
-                "use same-release inline call/call_sync for an immediate result, or "
-                "move fan-out and waiting to a Workflow"
-            )
         if not math.isfinite(timeout) or timeout <= 0:
-            raise InvalidDurableWaitError(
+            raise InvalidFunctionWaitError(
                 "ExecutionHandle.result requires a positive, finite timeout"
             )
-        result = await self._transport.get_result(
-            self.execution_id,
-            timeout=timeout,
-        )
+        if self.initial_status in {"failed", "indeterminate", "timed_out"}:
+            raise RuntimeError(
+                f"Function execution {self.execution_id} ended as "
+                f"{self.initial_status}: {self._initial_error}"
+            )
+        if self.initial_status == "succeeded":
+            result = self._initial_result
+        else:
+            result = await self._transport.get_result(
+                self.execution_id,
+                timeout=timeout,
+            )
         if self._result_validator is not None:
             return self._result_validator(result)
         # Unknown/imported references are validated by the future authoritative

{lumera-0.41.2.dev20260909 → lumera-0.41.3.dev2026091001}/lumera/functions/_remote.py

@@ -1,4 +1,4 @@
-"""Durable backend transport and remote execution handles."""
+"""Synchronous backend Function transport and execution handles."""
 
 from __future__ import annotations
 
@@ -8,13 +8,12 @@ from collections.abc import Mapping
 from typing import Any
 
 from ._context import FunctionContext
-from ._execution import DurableFunctionTransport, ExecutionHandle, ExecutionStatus, StartedExecution
+from ._execution import ExecutionHandle, ExecutionStatus, FunctionTransport, StartedExecution
 
-_TERMINAL = {"succeeded", "failed", "indeterminate", "timed_out", "cancelled"}
-_MAX_LONG_POLL_SECONDS = 20
+_TERMINAL = {"succeeded", "failed", "indeterminate", "timed_out"}
 
 
-class RemoteFunctionTransport(DurableFunctionTransport):
+class RemoteFunctionTransport(FunctionTransport):
     def __init__(self, project: str) -> None:
         self.project = project
 
@@ -37,35 +36,27 @@ class RemoteFunctionTransport(DurableFunctionTransport):
             parent_execution_id=context.execution_id,
         )
         execution = _execution(response)
-        return StartedExecution(execution_id=str(execution["id"]), status=str(execution["status"]))
+        status = _status(execution)
+        return StartedExecution(
+            execution_id=status.execution_id,
+            status=status.status,
+            result=status.result,
+            error=status.error,
+        )
 
     async def get_status(self, execution_id: str) -> ExecutionStatus:
         return await self._get_status(execution_id)
 
-    async def _get_status(
-        self, execution_id: str, *, wait_seconds: int | None = None
-    ) -> ExecutionStatus:
+    async def _get_status(self, execution_id: str) -> ExecutionStatus:
         from lumera import function_resources
 
         response = await asyncio.to_thread(
             function_resources.get_function_execution,
             self.project,
             execution_id,
-            wait_seconds=wait_seconds,
         )
         execution = _execution(response)
-        error = None
-        if execution.get("error_code"):
-            error = {
-                "code": execution["error_code"],
-                "message": execution.get("error_message", ""),
-            }
-        return ExecutionStatus(
-            execution_id=str(execution["id"]),
-            status=str(execution["status"]),
-            result=execution.get("result"),
-            error=error,
-        )
+        return _status(execution)
 
     async def get_result(self, execution_id: str, *, timeout: float) -> object:
         deadline = time.monotonic() + timeout
@@ -73,12 +64,8 @@ class RemoteFunctionTransport(DurableFunctionTransport):
             remaining = deadline - time.monotonic()
             if remaining <= 0:
                 raise TimeoutError(f"Function execution {execution_id} did not finish in time")
-            wait_seconds = min(_MAX_LONG_POLL_SECONDS, int(remaining))
             request_started = time.monotonic()
-            status = await self._get_status(
-                execution_id,
-                wait_seconds=wait_seconds if wait_seconds >= 1 else None,
-            )
+            status = await self._get_status(execution_id)
             if status.status in _TERMINAL:
                 if status.status != "succeeded":
                     raise RuntimeError(
@@ -89,9 +76,8 @@ class RemoteFunctionTransport(DurableFunctionTransport):
             remaining = deadline - time.monotonic()
             if remaining <= 0:
                 raise TimeoutError(f"Function execution {execution_id} did not finish in time")
-            # An older backend may ignore Prefer and return immediately. Preserve
-            # coarse one-second polling in that case instead of hammering its status
-            # endpoint; completion-aware backends normally hold this request.
+            # A concurrent idempotent caller can observe the first RPC in flight.
+            # Poll coarsely rather than hammering the status endpoint.
             request_elapsed = time.monotonic() - request_started
             await asyncio.sleep(min(max(0.0, 1.0 - request_elapsed), remaining))
 
@@ -114,8 +100,31 @@ def invoke_remote(
         function_ref=function_ref,
         initial_status=str(execution["status"]),
         transport=RemoteFunctionTransport(project),
-        wait_allowed=True,
+        initial_result=execution.get("result"),
+        initial_error=_execution_error(execution),
+    )
+
+
+def call_remote(
+    project: str,
+    function_ref: str,
+    input: Mapping[str, Any] | None = None,
+    *,
+    idempotency_key: str | None = None,
+) -> object:
+    """Call a deployed Function synchronously and return its result."""
+    from lumera import function_resources
+
+    response = function_resources.invoke_function(
+        project, function_ref, input, idempotency_key=idempotency_key
     )
+    execution = _execution(response)
+    status = _status(execution)
+    if status.status != "succeeded":
+        raise RuntimeError(
+            f"Function execution {status.execution_id} ended as {status.status}: {status.error}"
+        )
+    return status.result
 
 
 def _execution(response: Mapping[str, Any]) -> Mapping[str, Any]:
@@ -125,4 +134,22 @@ def _execution(response: Mapping[str, Any]) -> Mapping[str, Any]:
     return execution
 
 
-__all__ = ["RemoteFunctionTransport", "invoke_remote"]
+def _execution_error(execution: Mapping[str, Any]) -> Mapping[str, Any] | None:
+    if not execution.get("error_code"):
+        return None
+    return {
+        "code": execution["error_code"],
+        "message": execution.get("error_message", ""),
+    }
+
+
+def _status(execution: Mapping[str, Any]) -> ExecutionStatus:
+    return ExecutionStatus(
+        execution_id=str(execution["id"]),
+        status=str(execution["status"]),
+        result=execution.get("result"),
+        error=_execution_error(execution),
+    )
+
+
+__all__ = ["RemoteFunctionTransport", "call_remote", "invoke_remote"]

{lumera-0.41.2.dev20260909 → lumera-0.41.3.dev2026091001}/lumera/functions/_runner.py

@@ -9,7 +9,7 @@ import json
 import os
 import sys
 import uuid
-from collections.abc import Iterator, Sequence
+from collections.abc import Iterator, Mapping, Sequence
 from contextlib import contextmanager, redirect_stdout
 from pathlib import Path
 from typing import Any, Callable, Never, cast
@@ -174,6 +174,24 @@ def _run_command(
                 raw_input,
                 idempotency_key=args.idempotency_key,
             )
+            execution = response.get("execution")
+            if not isinstance(execution, Mapping):
+                return _failure(
+                    "function_protocol_error",
+                    message="Lumera returned an invalid Function execution",
+                    retryable=False,
+                )
+            status = str(execution.get("status", ""))
+            if status != "succeeded":
+                return _failure(
+                    str(execution.get("error_code") or "function_not_succeeded"),
+                    message=str(
+                        execution.get("error_message")
+                        or f"Function execution ended as {status or 'unknown'}"
+                    ),
+                    retryable=False,
+                    execution=dict(execution),
+                )
             return _success("invoke", function_id=args.function_id, **response)
         definition = registry.get(args.function_id)
         with LocalFunctionRuntime(registry) as runtime:

{lumera-0.41.2.dev20260909 → lumera-0.41.3.dev2026091001}/lumera/functions/_runtime.py

@@ -29,7 +29,6 @@ from ._context import (
 )
 from ._contract import FunctionDefinition
 from ._errors import (
-    DurableTransportUnavailableError,
     FunctionCallModeError,
     FunctionCancelledError,
     FunctionCycleError,
@@ -40,9 +39,10 @@ from ._errors import (
     FunctionNotFoundError,
     FunctionRuntimeClosedError,
     FunctionsError,
+    FunctionTransportUnavailableError,
     UnexpectedFunctionError,
 )
-from ._execution import DurableFunctionTransport, ExecutionHandle
+from ._execution import ExecutionHandle, FunctionTransport
 from ._registry import FunctionRegistry
 
 ResultT = TypeVar("ResultT")
@@ -80,15 +80,14 @@ class _InvocationSyncLane:
     executor can therefore fill every worker with parents that are waiting for
     children queued behind them. Each root invocation instead owns this lane,
     which starts a daemon thread for every active sync call. The call-stack
-    depth guard still bounds recursive nesting; Phase 1 is local-only and does
-    not use this thread-per-call mechanism as a production admission-control or
-    workload-isolation boundary.
+    depth guard still bounds recursive nesting. The resident Function RPC child
+    process provides the production hard-termination boundary.
 
     Python cannot safely terminate a running thread. A deadline or task
     cancellation stops waiting for sync code but the thread may continue
-    cooperatively until the callable returns. Production adapters must execute
-    project code behind the separately specified process boundary when hard
-    termination is required.
+    cooperatively until the callable returns. The RPC host kills the child
+    process group at the execution deadline so timed-out sync code cannot keep
+    producing side effects in the App Lambda environment.
     """
 
     def __init__(self) -> None:
@@ -159,7 +158,7 @@ class LocalFunctionRuntime:
         self,
         registry: FunctionRegistry,
         *,
-        transport: DurableFunctionTransport | None = None,
+        transport: FunctionTransport | None = None,
         capability_resolver: CapabilityResolver | None = None,
         max_depth: int = 16,
     ) -> None:
@@ -557,7 +556,7 @@ class LocalFunctionRuntime:
             raise FunctionInvocationError(
                 "FunctionContext must declare its trusted runtime_mode"
             ) from exc
-        if mode not in {"local", "api", "worker", "external"}:
+        if mode not in {"local", "api", "external"}:
             raise FunctionInvocationError(f"unsupported FunctionContext runtime_mode: {mode!r}")
         return cast(RuntimeMode, mode)
 
@@ -662,13 +661,12 @@ class _BoundFunctionCaller:
     ) -> ExecutionHandle[Any]:
         transport = self._runtime.transport
         if transport is None:
-            raise DurableTransportUnavailableError(
-                "durable Function execution is not available in Phase 1; "
-                "configure a test transport only for contract tests"
+            raise FunctionTransportUnavailableError(
+                "remote Function execution is unavailable in this context"
             )
         normalized_ref = function_ref.strip()
         if not normalized_ref:
-            raise ValueError("durable Function reference cannot be empty")
+            raise ValueError("Function reference cannot be empty")
         normalized_key = idempotency_key.strip() if idempotency_key is not None else None
         if idempotency_key is not None and not normalized_key:
             raise ValueError("idempotency_key cannot be empty")
@@ -684,7 +682,8 @@ class _BoundFunctionCaller:
             function_ref=normalized_ref,
             initial_status=started.status,
             transport=transport,
-            wait_allowed=self._context.runtime_mode != "worker",
+            initial_result=started.result,
+            initial_error=started.error,
             result_validator=result_validator,
         )
 
@@ -708,7 +707,7 @@ class _BoundFunctionCaller:
             )
             decoded = json.loads(encoded)
             if not isinstance(decoded, dict):
-                raise ValueError("durable Function input must be a JSON object") from None
+                raise ValueError("Function input must be a JSON object") from None
             return decoded, None
         return definition.serialize_input(input), definition.validate_serialized_output
 

{lumera-0.41.2.dev20260909 → lumera-0.41.3.dev2026091001}/lumera/functions/testing.py

@@ -1,4 +1,4 @@
-"""Test helpers for Function contexts and future durable-transport contracts."""
+"""Test helpers for Function contexts and remote-transport contracts."""
 
 from __future__ import annotations
 
@@ -25,7 +25,7 @@ __all__ = [
     "ActorIdentity",
     "ActorTag",
     "AgentIdentity",
-    "FakeDurableTransport",
+    "FakeFunctionTransport",
     "FakeStart",
     "LocalCancellationToken",
     "LocalScopedLumeraClient",
@@ -38,7 +38,7 @@ __all__ = [
 
 @dataclass(frozen=True)
 class FakeStart:
-    """Recorded invocation accepted by FakeDurableTransport."""
+    """Recorded invocation accepted by FakeFunctionTransport."""
 
     execution_id: str
     function_ref: str
@@ -48,7 +48,7 @@ class FakeStart:
     caller_project_id: str
 
 
-class FakeDurableTransport:
+class FakeFunctionTransport:
     """In-memory transport for testing start/handle behavior only."""
 
     def __init__(self) -> None:
@@ -77,7 +77,7 @@ class FakeDurableTransport:
         )
         self._statuses[execution_id] = ExecutionStatus(
             execution_id=execution_id,
-            status="queued",
+            status="running",
         )
         self._events[execution_id] = asyncio.Event()
         return StartedExecution(execution_id=execution_id)

{lumera-0.41.2.dev20260909 → lumera-0.41.3.dev2026091001}/lumera/releases/__init__.py

@@ -44,9 +44,8 @@ _LAZY_MODULES = {
     "_archive": "._archive",
     "_builder": "._builder",
     "_contracts": "._contracts",
-    "_function_child": "._function_child",
+    "_rpc_event": "._rpc_event",
     "_runtime": "._runtime",
-    "_worker_child": "._worker_child",
 }
 
 _LAZY_ATTRIBUTES = {

{lumera-0.41.2.dev20260909 → lumera-0.41.3.dev2026091001}/lumera/releases/__main__.py

@@ -60,7 +60,7 @@ def _parser() -> argparse.ArgumentParser:
 
     contract = commands.add_parser("contract-test")
     contract.add_argument("archive")
-    contract.add_argument("--mode", choices=("api", "worker", "all"), default="all")
+    contract.add_argument("--mode", choices=("api", "function", "all"), default="all")
     contract.add_argument("--expected-digest")
 
     deploy = commands.add_parser("deploy")
@@ -173,7 +173,7 @@ def _declared_contract_modes(manifest: dict[str, object]) -> tuple[RuntimeMode,
         modes.append("api")
     function_modules = entrypoints.get("function_modules")
     if isinstance(function_modules, list) and function_modules:
-        modes.append("worker")
+        modes.append("function")
     if not modes:
         raise ValueError("release has no contract-testable entrypoints")
     return tuple(modes)