agentenv-framework-protocol 0.1.286__tar.gz → 0.1.288__tar.gz

{agentenv_framework_protocol-0.1.286 → agentenv_framework_protocol-0.1.288}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agentenv-framework-protocol
-Version: 0.1.286
+Version: 0.1.288
 Summary: Open data-plane protocol and server SDK for agent environments.
 Project-URL: Homepage, https://www.agentenvframework.com
 Project-URL: Documentation, https://www.agentenvframework.com/docs
@@ -177,6 +177,35 @@ extension's, and `client.invoke_extension(base_url, card, uri, params, method=..
 its HTTP verb. Without `method`, `invoke_extension` calls the first method listed; an extension
 with several methods, such as a gateway's `urn:agentenv:clock/v1`, should always be called by name.
 
+### Uploading an export through a grant
+
+An export too large to return from `data/get` can go straight to the caller's object store. A
+`@get_data` handler that takes a `write_namespace` parameter is advertised under
+`urn:agentenv:data-objects/v1` (`DATA_OBJECTS_EXTENSION_URI`), and a caller may then send a
+`transfers.WriteNamespaceGrant` with the call: `client.get_data(base_url,
+write_namespace=grant)`. The handler is called with the grant, or with None when the caller
+sent none. It uploads under the grant with `transfers.NamespaceUploader` and answers with
+`uploaded_file_part(path, name=..., mime_type=...)`, where `path` is relative to the grant's
+`root_path`; the caller reads it back with `uploaded_object_path(part)`, which refuses a path
+outside the root. A handler that cannot use the grant (its export outgrows the grant's limits,
+say) answers as it would without one.
+
+```python
+from agentenv_protocol import AgentEnvEnvironment, DataPart, environment_card, get_data, uploaded_file_part
+from agentenv_protocol.transfers import NamespaceUploader, WriteNamespaceGrant
+
+
+@environment_card(name="slack")
+class SlackEnv(AgentEnvEnvironment):
+    @get_data
+    async def _state(self, write_namespace: WriteNamespaceGrant | None = None):
+        bundle = self.write_bundle()  # a Path
+        if write_namespace is not None and bundle.stat().st_size <= write_namespace.max_object_bytes:
+            await NamespaceUploader(write_namespace).upload("slack.zip", bundle)
+            return [uploaded_file_part("slack.zip", name="slack.zip", mime_type="application/zip")]
+        return [DataPart(data=self.state())]
+```
+
 Dependencies are intentionally light (`pydantic`, `starlette`) so the package can be added to environment server images without pulling a heavier framework — `mcp` is imported lazily inside `create_fastmcp_app()` and is deliberately not a dependency.
 
 ## A2A agent framework

{agentenv_framework_protocol-0.1.286 → agentenv_framework_protocol-0.1.288}/README.md

@@ -133,6 +133,35 @@ extension's, and `client.invoke_extension(base_url, card, uri, params, method=..
 its HTTP verb. Without `method`, `invoke_extension` calls the first method listed; an extension
 with several methods, such as a gateway's `urn:agentenv:clock/v1`, should always be called by name.
 
+### Uploading an export through a grant
+
+An export too large to return from `data/get` can go straight to the caller's object store. A
+`@get_data` handler that takes a `write_namespace` parameter is advertised under
+`urn:agentenv:data-objects/v1` (`DATA_OBJECTS_EXTENSION_URI`), and a caller may then send a
+`transfers.WriteNamespaceGrant` with the call: `client.get_data(base_url,
+write_namespace=grant)`. The handler is called with the grant, or with None when the caller
+sent none. It uploads under the grant with `transfers.NamespaceUploader` and answers with
+`uploaded_file_part(path, name=..., mime_type=...)`, where `path` is relative to the grant's
+`root_path`; the caller reads it back with `uploaded_object_path(part)`, which refuses a path
+outside the root. A handler that cannot use the grant (its export outgrows the grant's limits,
+say) answers as it would without one.
+
+```python
+from agentenv_protocol import AgentEnvEnvironment, DataPart, environment_card, get_data, uploaded_file_part
+from agentenv_protocol.transfers import NamespaceUploader, WriteNamespaceGrant
+
+
+@environment_card(name="slack")
+class SlackEnv(AgentEnvEnvironment):
+    @get_data
+    async def _state(self, write_namespace: WriteNamespaceGrant | None = None):
+        bundle = self.write_bundle()  # a Path
+        if write_namespace is not None and bundle.stat().st_size <= write_namespace.max_object_bytes:
+            await NamespaceUploader(write_namespace).upload("slack.zip", bundle)
+            return [uploaded_file_part("slack.zip", name="slack.zip", mime_type="application/zip")]
+        return [DataPart(data=self.state())]
+```
+
 Dependencies are intentionally light (`pydantic`, `starlette`) so the package can be added to environment server images without pulling a heavier framework — `mcp` is imported lazily inside `create_fastmcp_app()` and is deliberately not a dependency.
 
 ## A2A agent framework

{agentenv_framework_protocol-0.1.286 → agentenv_framework_protocol-0.1.288}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agentenv-framework-protocol"
-version = "0.1.286"
+version = "0.1.288"
 description = "Open data-plane protocol and server SDK for agent environments."
 readme = "README.md"
 license = "Apache-2.0"

{agentenv_framework_protocol-0.1.286 → agentenv_framework_protocol-0.1.288}/src/agentenv_protocol/__init__.py

@@ -34,6 +34,7 @@ from .manifest import (
     manifest_compatible,
 )
 from .types import (
+    DATA_OBJECTS_EXTENSION_URI,
     INTAKE_EXTENSION_URI,
     MCP_PATH,
     MCP_TRANSPORT,
@@ -60,6 +61,8 @@ from .types import (
     TextPart,
     error_body,
     intake_extension,
+    uploaded_file_part,
+    uploaded_object_path,
 )
 
 __all__ = [
@@ -88,6 +91,9 @@ __all__ = [
     "intake_extension",
     "intake_fit_check",
     "INTAKE_EXTENSION_URI",
+    "DATA_OBJECTS_EXTENSION_URI",
+    "uploaded_file_part",
+    "uploaded_object_path",
     "MCP_PATH",
     "MCP_TRANSPORT",
     "MANIFEST_VERSION",

{agentenv_framework_protocol-0.1.286 → agentenv_framework_protocol-0.1.288}/src/agentenv_protocol/agent_env_environment.py

@@ -13,12 +13,14 @@ import uuid
 from abc import ABC, abstractmethod
 from typing import Annotated, Any, Callable, ClassVar, Literal, NamedTuple, Union, get_args, get_origin, get_type_hints
 
+from pydantic import ValidationError
 from pydantic.fields import FieldInfo
 from starlette.requests import Request
 from starlette.responses import Response
 from starlette.routing import Route
 
-from .types import MCP_TRANSPORT, METHOD_ADD, METHOD_GET, METHOD_RESET, RPC_PATH, WELL_KNOWN_PATH, AddDataRequest, AddDataResponse, EnvironmentCapabilities, EnvironmentCard, EnvironmentExtension, EnvironmentInterface, EnvironmentTool, GetDataResponse, ResetDataResponse, error_body
+from .transfers import WriteNamespaceGrant
+from .types import DATA_OBJECTS_EXTENSION_URI, MCP_TRANSPORT, METHOD_ADD, METHOD_GET, METHOD_RESET, RPC_PATH, WELL_KNOWN_PATH, AddDataRequest, AddDataResponse, EnvironmentCapabilities, EnvironmentCard, EnvironmentExtension, EnvironmentInterface, EnvironmentTool, GetDataResponse, ResetDataResponse, error_body
 
 logger = logging.getLogger(__name__)
 
@@ -50,6 +52,9 @@ def add_data(fn: Callable) -> Callable:
 
 
 def get_data(fn: Callable) -> Callable:
+    """Mark the ``data/get`` handler. One that takes a ``write_namespace`` parameter is advertised under
+    ``DATA_OBJECTS_EXTENSION_URI`` and called with the grant a caller sends, else None; it may upload its
+    export under the grant and return ``uploaded_file_part``."""
     setattr(fn, _OP_ATTR, OP_GET_DATA)
     return fn
 
@@ -157,6 +162,7 @@ class AgentEnvApplication(ABC):
         environment_card = _merge_tools(environment_card, tool_handlers)
         methods = _discover_methods(handler)
         environment_card = _merge_operations(environment_card, methods)
+        environment_card = _merge_data_objects(environment_card, methods)
         self.environment_card = environment_card
         self._dispatch = _jsonrpc_handler(methods)
         self._ext_routes = [(path, method, _extension_handler(fn, method)) for _descriptor, fn, path, method in ext_handlers]
@@ -426,6 +432,24 @@ def _merge_operations(card: EnvironmentCard, methods: dict) -> EnvironmentCard:
     return card.model_copy(update={"capabilities": caps.model_copy(update={"operations": list(methods)})})
 
 
+_DATA_OBJECTS_EXTENSION = EnvironmentExtension(
+    uri=DATA_OBJECTS_EXTENSION_URI,
+    description="data/get takes a write_namespace grant and may upload its export under it.",
+)
+
+
+def _takes_write_namespace(fn: Callable) -> bool:
+    return "write_namespace" in inspect.signature(fn).parameters
+
+
+def _merge_data_objects(card: EnvironmentCard, methods: dict) -> EnvironmentCard:
+    """Advertise the data-objects extension when the ``data/get`` handler takes a ``write_namespace``."""
+    entry = methods.get(METHOD_GET)
+    if entry is None or not _takes_write_namespace(entry[1]):
+        return card
+    return _merge_extensions(card, [(_DATA_OBJECTS_EXTENSION,)])
+
+
 def _merge_mcp_interface(card: EnvironmentCard, path: str) -> EnvironmentCard:
     """Declare the MCP endpoint at the path the app serves it on; a card-declared `MCP_TRANSPORT` interface wins.
 
@@ -471,8 +495,19 @@ async def _invoke_add(fn: Callable, params: dict) -> dict:
 
 
 async def _invoke_get(fn: Callable, params: dict) -> dict:
+    kwargs = {}
+    if _takes_write_namespace(fn):
+        if not isinstance(params, dict):
+            raise _InvalidParams("data/get takes its params by name")
+        raw = params.get("write_namespace")
+        try:
+            kwargs["write_namespace"] = None if raw is None else WriteNamespaceGrant.model_validate(raw)
+        except ValidationError as e:
+            # Name the fields only: the values carry the grant's signature.
+            fields = ", ".join(".".join(map(str, error["loc"])) or "write_namespace" for error in e.errors())
+            raise _InvalidParams(f"write_namespace is not a valid namespace grant ({fields})")
     try:
-        parts = await _maybe_await(fn())
+        parts = await _maybe_await(fn(**kwargs))
         return GetDataResponse(parts=parts).model_dump(exclude_none=True)
     except Exception as e:
         logger.exception("data/get failed")

{agentenv_framework_protocol-0.1.286 → agentenv_framework_protocol-0.1.288}/src/agentenv_protocol/client.py

@@ -6,6 +6,7 @@ import logging
 import httpx
 
 from .manifest import INTERFACE_MANIFEST_PATH
+from .transfers import WriteNamespaceGrant
 from .types import INTAKE_EXTENSION_URI, MCP_PATH, MCP_TRANSPORT, METHOD_ADD, METHOD_GET, METHOD_RESET, RPC_PATH, WELL_KNOWN_PATH, AddDataResponse, GetDataResponse, Part, ResetDataResponse
 
 logger = logging.getLogger(__name__)
@@ -32,8 +33,13 @@ async def add_data(base_url: str, parts: list[Part], timeout: int = 120, verify:
     return AddDataResponse.model_validate(await _rpc(base_url, METHOD_ADD, params, timeout, verify))
 
 
-async def get_data(base_url: str, timeout: int = 30, verify: bool = True) -> GetDataResponse:
-    return GetDataResponse.model_validate(await _rpc(base_url, METHOD_GET, {}, timeout, verify))
+async def get_data(
+    base_url: str, timeout: int = 30, verify: bool = True, *, write_namespace: WriteNamespaceGrant | None = None
+) -> GetDataResponse:
+    """`data/get`. A server advertising `DATA_OBJECTS_EXTENSION_URI` may be handed `write_namespace` to upload
+    its export under; `uploaded_object_path` reads from the answer where it did."""
+    params = {} if write_namespace is None else {"write_namespace": write_namespace.model_dump(mode="json", exclude_none=True)}
+    return GetDataResponse.model_validate(await _rpc(base_url, METHOD_GET, params, timeout, verify))
 
 
 async def get_card(base_url: str, timeout: int = 10, verify: bool = True) -> dict:

{agentenv_framework_protocol-0.1.286 → agentenv_framework_protocol-0.1.288}/src/agentenv_protocol/types.py

@@ -3,7 +3,9 @@ from __future__ import annotations
 
 from typing import Annotated, Literal, Optional, Union
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, TypeAdapter, ValidationError
+
+from .transfers import RelativePath
 
 
 def error_body(code: str, message: str) -> dict:
@@ -30,6 +32,13 @@ METHOD_GET = "data/get"
 # extension means "no claim" (skip fit-checks), matching the `supports_v1` 404->legacy precedent.
 INTAKE_EXTENSION_URI = "urn:agentenv:intake/v1"
 
+# A declaration-only extension: `data/get` takes a `write_namespace` param (a
+# `transfers.WriteNamespaceGrant`) and may upload its export under the grant instead of returning
+# it, answering with the part `uploaded_file_part` builds. A server that does not advertise it
+# is never sent one.
+DATA_OBJECTS_EXTENSION_URI = "urn:agentenv:data-objects/v1"
+_RELATIVE_PATH = TypeAdapter(RelativePath)
+
 
 class FileWithBytes(BaseModel):
     bytes: str
@@ -64,6 +73,29 @@ class DataPart(BaseModel):
 Part = Annotated[Union[TextPart, FilePart, DataPart], Field(discriminator="kind")]
 
 
+def uploaded_file_part(path: str, *, name: Optional[str] = None, mime_type: Optional[str] = None) -> FilePart:
+    """The `data/get` answer naming an export uploaded through its `write_namespace` grant, at
+    `path` relative to the grant's `root_path`."""
+    path = _RELATIVE_PATH.validate_python(path)
+    return FilePart(
+        file=FileWithUri(uri=path, name=name, mimeType=mime_type),
+        metadata={DATA_OBJECTS_EXTENSION_URI: {"path": path}},
+    )
+
+
+def uploaded_object_path(part: Part) -> Optional[str]:
+    """Where, relative to the `write_namespace` grant's `root_path`, `part` says the export was
+    uploaded; None when it names no upload. Raises ValueError for a path outside the root."""
+    marker = (part.metadata or {}).get(DATA_OBJECTS_EXTENSION_URI) if isinstance(part, FilePart) else None
+    if marker is None:
+        return None
+    path = marker.get("path") if isinstance(marker, dict) else None
+    try:
+        return _RELATIVE_PATH.validate_python(path)
+    except ValidationError:
+        raise ValueError(f"the uploaded export's path {path!r} is not a normalized relative path") from None
+
+
 class AddDataRequest(BaseModel):
     parts: list[Part] = Field(min_length=1)
 

agentenv_framework_protocol-0.1.288/tests/test_data_objects.py

@@ -0,0 +1,249 @@
+"""data/get through a write_namespace grant: the card advertisement, the handler binding, the client
+call, and the answer that names where the export was uploaded."""
+
+from __future__ import annotations
+
+import json
+from datetime import datetime, timedelta, timezone
+from types import SimpleNamespace
+
+import httpx
+import pytest
+from starlette.applications import Starlette
+from starlette.routing import Route
+
+from agentenv_protocol import (
+    DATA_OBJECTS_EXTENSION_URI,
+    AgentEnvFastMCPApplication,
+    DataPart,
+    EnvironmentCapabilities,
+    EnvironmentCard,
+    EnvironmentExtension,
+    FilePart,
+    GetDataResponse,
+    get_data,
+    uploaded_file_part,
+    uploaded_object_path,
+)
+from agentenv_protocol import client as protocol_v1
+from agentenv_protocol.transfers import HttpPostPolicyGrant, NamespaceUploader, WriteNamespaceGrant
+
+_SIGNATURE = "policy-signature-secret"
+
+
+def _grant(*, max_object_bytes: int = 1024) -> WriteNamespaceGrant:
+    return WriteNamespaceGrant(
+        root_path="snapshots/run-1",
+        expires_at=datetime.now(timezone.utc) + timedelta(minutes=5),
+        max_objects=1,
+        max_object_bytes=max_object_bytes,
+        max_total_bytes=max_object_bytes,
+        write=HttpPostPolicyGrant(
+            kind="http-post-policy",
+            url="https://objects.example.test/upload",
+            fields={"policy": _SIGNATURE},
+            path_field="key",
+            file_field="file",
+        ),
+    )
+
+
+class _FakeMCP:
+    def __init__(self) -> None:
+        self.routes: list[Route] = []
+        self.settings = SimpleNamespace(streamable_http_path="/mcp")
+
+    def custom_route(self, path: str, methods: list[str]):
+        def deco(fn):
+            self.routes.append(Route(path, fn, methods=methods))
+            return fn
+        return deco
+
+
+class _InlineHandler:
+    def __init__(self) -> None:
+        self.calls = 0
+
+    @get_data
+    async def _state(self) -> list:
+        self.calls += 1
+        return [DataPart(data={"rows": 1})]
+
+
+class _UploadingHandler:
+    def __init__(self) -> None:
+        self.grants: list[WriteNamespaceGrant | None] = []
+
+    @get_data
+    async def _state(self, write_namespace: WriteNamespaceGrant | None = None) -> list:
+        self.grants.append(write_namespace)
+        if write_namespace is None:
+            return [DataPart(data={"rows": 1})]
+        await NamespaceUploader(write_namespace).upload("slack.zip", b"PK\x03\x04bundle")
+        return [uploaded_file_part("slack.zip", name="slack.zip", mime_type="application/zip")]
+
+
+def _app(handler, card: EnvironmentCard | None = None) -> tuple[AgentEnvFastMCPApplication, Starlette]:
+    mcp = _FakeMCP()
+    application = AgentEnvFastMCPApplication(environment_card=card or EnvironmentCard(name="slack"), handler=handler)
+    application.add_routes_to_app(mcp)
+    return application, Starlette(routes=mcp.routes)
+
+
+def _rpc(params: dict | None = None) -> dict:
+    return {"jsonrpc": "2.0", "id": 1, "method": "data/get", "params": params or {}}
+
+
+async def _post(app: Starlette, body: dict) -> dict:
+    async with httpx.AsyncClient(transport=httpx.ASGITransport(app=app), base_url="http://t") as client:
+        return (await client.post("/agentenv", json=body)).json()
+
+
+def _uris(card: EnvironmentCard) -> list[str]:
+    return [e.uri for e in card.capabilities.extensions or []]
+
+
+def test_a_handler_that_takes_a_write_namespace_is_advertised():
+    application, _ = _app(_UploadingHandler())
+    (extension,) = application.environment_card.capabilities.extensions
+    assert extension.uri == DATA_OBJECTS_EXTENSION_URI
+    assert extension.params is None
+
+
+def test_a_handler_that_takes_none_is_not():
+    application, _ = _app(_InlineHandler())
+    assert _uris(application.environment_card) == []
+
+
+def test_a_card_declared_data_objects_extension_wins():
+    declared = EnvironmentExtension(uri=DATA_OBJECTS_EXTENSION_URI, description="declared")
+    card = EnvironmentCard(name="slack", capabilities=EnvironmentCapabilities(extensions=[declared]))
+    application, _ = _app(_UploadingHandler(), card)
+    assert application.environment_card.capabilities.extensions == [declared]
+
+
+@pytest.mark.asyncio
+async def test_the_handler_gets_the_grant_sent_or_none():
+    handler = _UploadingHandler()
+    _, app = _app(handler)
+    grant = _grant()
+
+    await _post(app, _rpc())
+    await _post(app, _rpc({"write_namespace": grant.model_dump(mode="json")}))
+
+    assert handler.grants == [None, grant]
+
+
+@pytest.mark.asyncio
+async def test_a_handler_that_takes_no_grant_ignores_one_sent():
+    handler = _InlineHandler()
+    _, app = _app(handler)
+
+    body = await _post(app, _rpc({"write_namespace": _grant().model_dump(mode="json")}))
+
+    assert body["result"]["parts"] == [{"kind": "data", "data": {"rows": 1}}]
+    assert handler.calls == 1
+
+
+@pytest.mark.asyncio
+async def test_an_invalid_grant_is_refused_without_echoing_it():
+    handler = _UploadingHandler()
+    _, app = _app(handler)
+    sent = _grant().model_dump(mode="json")
+    sent["root_path"] = "../elsewhere"
+
+    body = await _post(app, _rpc({"write_namespace": sent}))
+
+    assert body["error"]["code"] == -32602
+    assert "root_path" in body["error"]["data"]["detail"]
+    assert _SIGNATURE not in json.dumps(body)
+    assert handler.grants == []
+
+
+@pytest.mark.asyncio
+async def test_params_given_by_position_are_refused():
+    handler = _UploadingHandler()
+    _, app = _app(handler)
+
+    body = await _post(app, {"jsonrpc": "2.0", "id": 1, "method": "data/get", "params": [_grant().model_dump(mode="json")]})
+
+    assert body["error"]["code"] == -32602
+    assert _SIGNATURE not in json.dumps(body)
+    assert handler.grants == []
+
+
+@pytest.mark.asyncio
+async def test_get_data_sends_no_params_without_a_grant_and_the_grant_with_one(monkeypatch):
+    sent: list[dict] = []
+    real = httpx.AsyncClient
+
+    def handle(request: httpx.Request) -> httpx.Response:
+        sent.append(json.loads(request.content))
+        return httpx.Response(200, json={"jsonrpc": "2.0", "id": 1, "result": {"parts": []}})
+
+    monkeypatch.setattr(protocol_v1.httpx, "AsyncClient", lambda **kw: real(transport=httpx.MockTransport(handle)))
+
+    grant = _grant()
+    await protocol_v1.get_data("http://env")
+    await protocol_v1.get_data("http://env", write_namespace=grant)
+
+    assert sent[0]["params"] == {}
+    assert WriteNamespaceGrant.model_validate(sent[1]["params"]["write_namespace"]) == grant
+
+
+@pytest.mark.asyncio
+async def test_an_export_uploads_through_the_grant_and_the_answer_names_where(monkeypatch):
+    """The real handler, uploader, client and reader together: the bundle is POSTed under the grant's root, and
+    the answer names its path relative to it."""
+    handler = _UploadingHandler()
+    _, app = _app(handler)
+    uploads: list[httpx.Request] = []
+
+    def store(request: httpx.Request) -> httpx.Response:
+        uploads.append(request)
+        return httpx.Response(204)
+
+    real_sync, real_async = httpx.Client, httpx.AsyncClient
+    monkeypatch.setattr(httpx, "Client", lambda **kw: real_sync(**{**kw, "transport": httpx.MockTransport(store)}))
+    monkeypatch.setattr(httpx, "AsyncClient", lambda **kw: real_async(transport=httpx.ASGITransport(app=app)))
+
+    response = await protocol_v1.get_data("http://t", write_namespace=_grant())
+
+    (part,) = response.parts
+    assert uploaded_object_path(part) == "slack.zip"
+    assert (part.file.name, part.file.mimeType) == ("slack.zip", "application/zip")
+    (upload,) = uploads
+    assert str(upload.url) == "https://objects.example.test/upload"
+    assert b'name="key"\r\n\r\nsnapshots/run-1/slack.zip' in upload.content
+    assert b"PK\x03\x04bundle" in upload.content
+
+
+def test_the_uploaded_part_survives_the_wire():
+    wire = GetDataResponse(parts=[uploaded_file_part("dir/gdrive.zip", name="gdrive.zip")]).model_dump(mode="json", exclude_none=True)
+    (part,) = GetDataResponse.model_validate(json.loads(json.dumps(wire))).parts
+    assert uploaded_object_path(part) == "dir/gdrive.zip"
+
+
+@pytest.mark.parametrize("part", [
+    FilePart(file={"uri": "export-snapshot", "name": "gdrive.zip"}),
+    FilePart(file={"uri": "export-snapshot"}, metadata={"other": {"path": "x"}}),
+    DataPart(data={"path": "x"}, metadata={DATA_OBJECTS_EXTENSION_URI: {"path": "x"}}),
+], ids=["no-metadata", "other-metadata", "data-part"])
+def test_a_part_that_names_no_upload_reads_as_none(part):
+    assert uploaded_object_path(part) is None
+
+
+@pytest.mark.parametrize("path", ["../escape.zip", "/abs.zip", "a//b.zip", "a/./b.zip", "a/", "", "a\\b.zip", None, 3])
+def test_a_path_outside_the_root_is_refused(path):
+    part = FilePart(file={"uri": "x"}, metadata={DATA_OBJECTS_EXTENSION_URI: {"path": path}})
+    with pytest.raises(ValueError, match="not a normalized relative path"):
+        uploaded_object_path(part)
+    if isinstance(path, str):
+        with pytest.raises(ValueError):
+            uploaded_file_part(path)
+
+
+def test_a_marker_that_is_not_an_object_is_refused():
+    part = FilePart(file={"uri": "x"}, metadata={DATA_OBJECTS_EXTENSION_URI: "x.zip"})
+    with pytest.raises(ValueError, match="not a normalized relative path"):
+        uploaded_object_path(part)