remember 0.2.0__tar.gz → 0.3.0__tar.gz

{remember-0.2.0 → remember-0.3.0}/.gitignore

@@ -32,6 +32,9 @@ fe/*.tsbuildinfo
 fe/.pages-deploy.digest
 fe/.agent-browser-shots/
 fe/.pen-exports/
+fe/playwright-report/
+fe/test-results/
+.e2e-runtime/
 
 # Observability host — secret-bearing / generated deploy artifacts (never commit)
 infra/obs/.env
@@ -47,6 +50,8 @@ infra/obs/certs/
 *.env
 !*.env.example
 !infra/obs/.env.example
+# Reviewed non-secret image/address inventory; credentials are separate files.
+!infra/storage-cell/runtime.env
 *.rendered.yaml
 Caddyfile.rendered
 **/umcobs0.conf
@@ -66,3 +71,8 @@ fe_admin/storybook-static/
 # Built client distributions (published via the release workflow, never committed).
 client/dist/
 client/.venv/
+
+# RememberFS local native build products (source and lockfiles remain tracked).
+rememberfs/target/
+experiments/rememberfs/rust-spike/target/
+experiments/rememberfs/go-spike/rememberfs-go-spike

remember-0.3.0/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.5
+Name: remember
+Version: 0.3.0
+Summary: Official Python client for the remember.dev managed memory service.
+Project-URL: Homepage, https://remember.dev
+Project-URL: Documentation, https://remember.dev/docs
+Project-URL: Source, https://github.com/writeitai/ultimate-memory-cloud
+Author-email: "WriteIt.ai s.r.o." <info@writeit.ai>
+License: Apache-2.0
+Keywords: agents,memory,remember.dev,rememberstack
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: httpx>=0.27
+Requires-Dist: rememberstack>=0.8.1
+Description-Content-Type: text/markdown
+
+# remember
+
+Official Python SDK for the [remember.dev](https://remember.dev) managed memory service.
+
+This distribution provides:
+- **`remember.Client`** (D65): The primary ergonomic client for memory operations. Connects directly to your dedicated tenant deployment ingress with a single deployment API token (`umc_dp_…`).
+- **`remember.CloudClient`** (D53): The control-plane client for checking deployment readiness, credit balances, and spend gates using a control-plane token (`umc_cp_…`).
+- **`remember-status`**: CLI tool for quick control-plane status checks.
+
+## Install
+
+```console
+pip install remember
+```
+
+This automatically installs `rememberstack` (which provides the `remember` CLI tool on `PATH`).
+
+## Quickstart: Memory Operations (`Client`)
+
+Mint an **API Token** (`umc_dp_…`) from your dashboard at **Settings → API Tokens**, then initialize `Client`:
+
+```python
+import remember
+
+# Client accepts a bare secret (umc_dp_...) or a full Bearer string,
+# and converts string file paths automatically:
+with remember.Client(
+    api_key="umc_dp_…",
+    base_url="https://<deployment-id>.dp.remember.dev",
+) as memory:
+    landed = memory.ingest("notes/project.md")
+    print("Ingested version:", landed.version_id)
+
+    # Search claims or chunks
+    claims = memory.search_claims(query="architecture decisions")
+```
+
+### Environment Variables
+
+For zero-config agent setups, set `REMEMBER_API_KEY` and `REMEMBER_API_URL`:
+
+```console
+export REMEMBER_API_URL="https://<deployment-id>.dp.remember.dev"
+export REMEMBER_API_KEY="umc_dp_…"
+```
+
+```python
+import remember
+
+with remember.Client.from_env() as memory:
+    landed = memory.ingest("notes/project.md")
+```
+
+`Client` also automatically falls back to `REMEMBERSTACK_API_AUTHORIZATION` and `REMEMBERSTACK_API_URL` for seamless compatibility.
+
+## Quickstart: Status & Balances (`CloudClient`)
+
+To check billing balance and deployment readiness in CI or monitoring bots, use `CloudClient` with an organisation-scoped control-plane token (`umc_cp_…`).
+
+Control tokens are read-only, expiring status credentials (D53/D65). Because they are an API-only operational surface, mint one via the control-plane endpoint while authenticated with an owner session:
+- **Endpoint**: `POST /app/api/v1/orgs/{org_id}/control-tokens` (or `POST /v1/orgs/{org_id}/control-tokens` against the direct control-plane URL).
+- **Body**: `{"label": "ci-monitor", "expires_in_days": 90}` (accepts `label` and optional `expires_in_days` up to 90).
+
+```console
+export REMEMBER_CLOUD_TOKEN='umc_cp_…'
+export REMEMBER_CLOUD_ORG='your-organisation-id'
+```
+
+```python
+from remember import CloudClient
+
+with CloudClient.from_env() as cloud:
+    if cloud.is_ready():
+        print("Balance:", cloud.billing_status().balance)
+```
+
+You can also run the status CLI:
+
+```console
+$ remember-status
+deployment  active     bb81063d-6b7b-41d0-a1df-dc57d4f1fe87
+endpoint    live       bb81063d-6b7b-41d0-a1df-dc57d4f1fe87.dp.remember.dev
+billing     active     balance 42.10
+spend       allow
+```

remember-0.3.0/README.md

@@ -0,0 +1,85 @@
+# remember
+
+Official Python SDK for the [remember.dev](https://remember.dev) managed memory service.
+
+This distribution provides:
+- **`remember.Client`** (D65): The primary ergonomic client for memory operations. Connects directly to your dedicated tenant deployment ingress with a single deployment API token (`umc_dp_…`).
+- **`remember.CloudClient`** (D53): The control-plane client for checking deployment readiness, credit balances, and spend gates using a control-plane token (`umc_cp_…`).
+- **`remember-status`**: CLI tool for quick control-plane status checks.
+
+## Install
+
+```console
+pip install remember
+```
+
+This automatically installs `rememberstack` (which provides the `remember` CLI tool on `PATH`).
+
+## Quickstart: Memory Operations (`Client`)
+
+Mint an **API Token** (`umc_dp_…`) from your dashboard at **Settings → API Tokens**, then initialize `Client`:
+
+```python
+import remember
+
+# Client accepts a bare secret (umc_dp_...) or a full Bearer string,
+# and converts string file paths automatically:
+with remember.Client(
+    api_key="umc_dp_…",
+    base_url="https://<deployment-id>.dp.remember.dev",
+) as memory:
+    landed = memory.ingest("notes/project.md")
+    print("Ingested version:", landed.version_id)
+
+    # Search claims or chunks
+    claims = memory.search_claims(query="architecture decisions")
+```
+
+### Environment Variables
+
+For zero-config agent setups, set `REMEMBER_API_KEY` and `REMEMBER_API_URL`:
+
+```console
+export REMEMBER_API_URL="https://<deployment-id>.dp.remember.dev"
+export REMEMBER_API_KEY="umc_dp_…"
+```
+
+```python
+import remember
+
+with remember.Client.from_env() as memory:
+    landed = memory.ingest("notes/project.md")
+```
+
+`Client` also automatically falls back to `REMEMBERSTACK_API_AUTHORIZATION` and `REMEMBERSTACK_API_URL` for seamless compatibility.
+
+## Quickstart: Status & Balances (`CloudClient`)
+
+To check billing balance and deployment readiness in CI or monitoring bots, use `CloudClient` with an organisation-scoped control-plane token (`umc_cp_…`).
+
+Control tokens are read-only, expiring status credentials (D53/D65). Because they are an API-only operational surface, mint one via the control-plane endpoint while authenticated with an owner session:
+- **Endpoint**: `POST /app/api/v1/orgs/{org_id}/control-tokens` (or `POST /v1/orgs/{org_id}/control-tokens` against the direct control-plane URL).
+- **Body**: `{"label": "ci-monitor", "expires_in_days": 90}` (accepts `label` and optional `expires_in_days` up to 90).
+
+```console
+export REMEMBER_CLOUD_TOKEN='umc_cp_…'
+export REMEMBER_CLOUD_ORG='your-organisation-id'
+```
+
+```python
+from remember import CloudClient
+
+with CloudClient.from_env() as cloud:
+    if cloud.is_ready():
+        print("Balance:", cloud.billing_status().balance)
+```
+
+You can also run the status CLI:
+
+```console
+$ remember-status
+deployment  active     bb81063d-6b7b-41d0-a1df-dc57d4f1fe87
+endpoint    live       bb81063d-6b7b-41d0-a1df-dc57d4f1fe87.dp.remember.dev
+billing     active     balance 42.10
+spend       allow
+```

{remember-0.2.0 → remember-0.3.0}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "hatchling.build"
 
 [project]
 name = "remember"
-version = "0.2.0"
-description = "Control-plane client for the remember.dev managed memory service."
+version = "0.3.0"
+description = "Official Python client for the remember.dev managed memory service."
 readme = "README.md"
 requires-python = ">=3.12"
 license = { text = "Apache-2.0" }
@@ -20,9 +20,9 @@ classifiers = [
     "Typing :: Typed",
 ]
 
-# D43 rule 1: the cloud distribution may depend on the memory client; never the
-# reverse. The memory verbs stay in rememberstack — this package adds only the
-# control-plane questions that engine has no business answering.
+# D43 rule 1 & D65: the cloud distribution depends on rememberstack for the core
+# memory client and engine wire models. This package exposes the ergonomic Client
+# facade for data-plane memory operations and CloudClient for control-plane queries.
 dependencies = [
     "httpx>=0.27",
     "rememberstack>=0.8.1",

remember-0.3.0/src/remember/__init__.py

@@ -0,0 +1,77 @@
+"""Python client library for the remember.dev managed memory service (D65).
+
+PyPI project **`remember`**, import name **`remember`**.
+
+What this package provides
+--------------------------
+
+1. **`Client`** (D65):
+   The primary developer memory client. Accepts a single deployment API token
+   (``umc_dp_…``) or bare secret, connects directly to tenant deployment ingress,
+   and provides ergonomic access to all memory operations (ingest, search,
+   pipeline readiness, and assured operations).
+
+       import remember
+
+       with remember.Client(
+           api_key="umc_dp_…",
+           base_url="https://<deployment-id>.dp.remember.dev",
+       ) as memory:
+           landed = memory.ingest("guide.pdf")
+
+   Or zero-config from environment variables (``REMEMBER_API_KEY`` and ``REMEMBER_API_URL``):
+
+       memory = remember.Client.from_env()
+
+2. **`CloudClient`** (D53):
+   The control-plane client. Uses an organisation-scoped control-plane token
+   (``umc_cp_…``) to inspect deployment readiness, credit balance, and spend gates.
+
+       from remember import CloudClient
+
+       with CloudClient.from_env() as cloud:
+           status = cloud.billing_status()
+           print(status.state, status.balance)
+
+3. **Core Re-exports**:
+   Typed models and errors (:class:`Envelope`, :class:`ContextBundleV1`,
+   :class:`IngestedVersion`, :class:`ReadinessRequirements`, :class:`MemoryApiError`)
+   are re-exported directly from ``remember`` for convenient typing.
+"""
+
+from rememberstack.client import MemoryApiError
+from rememberstack.client import ReadinessRequirements
+from rememberstack.model import ContextBundleV1
+from rememberstack.model import Envelope
+from rememberstack.model import IngestedVersion
+
+from remember.client import Client
+from remember.client import CloudClient
+from remember.errors import CloudError
+from remember.errors import NotPermitted
+from remember.errors import RateLimited
+from remember.errors import Unauthenticated
+from remember.models import BillingStatus
+from remember.models import Deployment
+from remember.models import LedgerEntry
+from remember.models import SpendGate
+
+__all__ = [
+    "BillingStatus",
+    "Client",
+    "CloudClient",
+    "CloudError",
+    "ContextBundleV1",
+    "Deployment",
+    "Envelope",
+    "IngestedVersion",
+    "LedgerEntry",
+    "MemoryApiError",
+    "NotPermitted",
+    "RateLimited",
+    "ReadinessRequirements",
+    "SpendGate",
+    "Unauthenticated",
+]
+
+__version__ = "0.3.0"

{remember-0.2.0 → remember-0.3.0}/src/remember/client.py

@@ -1,8 +1,9 @@
-"""The control-plane client.
+"""The remember.dev clients.
 
-One class, a handful of read methods, and no memory verbs. Everything it can do
-is what D53's ``status:read`` profile permits — which is deliberate: a credential
-that could do more would be a credential worth stealing.
+- :class:`Client`: Ergonomic memory client connecting directly to tenant deployment
+  ingress for memory storage and retrieval (D65).
+- :class:`CloudClient`: Control-plane client for organisation status, deployment
+  inspection, and billing balances (D53).
 """
 
 from __future__ import annotations
@@ -10,11 +11,18 @@ from __future__ import annotations
 from collections.abc import Iterator
 from collections.abc import Mapping
 from contextlib import contextmanager
+from datetime import datetime
 import os
+from pathlib import Path
 from types import TracebackType
 from typing import Any
+from typing import Literal
+from typing import Self
 
 import httpx
+from rememberstack.client import ClientSettings
+from rememberstack.client import MemoryClient
+from rememberstack.model.documents import IngestedVersion
 
 from remember.errors import CloudError
 from remember.errors import NotPermitted
@@ -34,6 +42,156 @@ TOKEN_ENV = "REMEMBER_CLOUD_TOKEN"
 ORG_ENV = "REMEMBER_CLOUD_ORG"
 BASE_URL_ENV = "REMEMBER_CLOUD_URL"
 
+#: Environment variables for the unified data-plane client (D65).
+API_KEY_ENV = "REMEMBER_API_KEY"
+API_URL_ENV = "REMEMBER_API_URL"
+REMEMBERSTACK_AUTH_ENV = "REMEMBERSTACK_API_AUTHORIZATION"
+REMEMBERSTACK_URL_ENV = "REMEMBERSTACK_API_URL"
+
+
+def _format_bearer(token: str) -> str:
+    """Ensure a token string has the standard Bearer header prefix."""
+    if not token or not token.strip():
+        raise ValueError("API key or authorization token cannot be empty")
+    if "\r" in token or "\n" in token:
+        raise ValueError("Authorization token must not contain newline characters")
+    cleaned = token.strip()
+    if cleaned.lower() == "bearer":
+        raise ValueError("Bearer token value cannot be empty")
+    if cleaned.lower().startswith("bearer "):
+        rest = cleaned[7:].strip()
+        if not rest:
+            raise ValueError("Bearer token value cannot be empty")
+        return f"Bearer {rest}"
+    return f"Bearer {cleaned}"
+
+
+class Client(MemoryClient):
+    """Ergonomic data-plane memory client for remember.dev (D65).
+
+    Subclasses :class:`rememberstack.client.MemoryClient`, providing:
+    - ``api_key`` parameter accepting bare secrets (``umc_dp_...``) or full
+      ``Bearer`` headers.
+    - Path string support in :meth:`ingest` (accepts ``str``, ``Path``, or ``bytes``).
+    - Environment configuration from ``REMEMBER_API_KEY`` and ``REMEMBER_API_URL``
+      with fallbacks to ``REMEMBERSTACK_API_AUTHORIZATION`` and ``REMEMBERSTACK_API_URL``.
+    - Direct connection to deployment ingress (queries are never proxied through
+      the control plane).
+    """
+
+    def __init__(
+        self,
+        *,
+        api_key: str | None = None,
+        base_url: str | None = None,
+        authorization: str | None = None,
+        client: httpx.Client | None = None,
+        timeout: float | None = None,
+        settings: ClientSettings | None = None,
+    ) -> None:
+        if client is not None and any(
+            value is not None
+            for value in (api_key, base_url, authorization, timeout, settings)
+        ):
+            raise ValueError(
+                "an injected client cannot be combined with client settings"
+            )
+        if client is not None:
+            super().__init__(client=client)
+            return
+
+        resolved_authorization: str | None = None
+        if api_key is not None:
+            resolved_authorization = _format_bearer(api_key)
+        elif authorization is not None:
+            resolved_authorization = authorization
+        elif settings is not None and settings.api_authorization is not None:
+            resolved_authorization = settings.api_authorization.get_secret_value()
+        elif os.getenv(API_KEY_ENV):
+            resolved_authorization = _format_bearer(os.environ[API_KEY_ENV])
+        elif os.getenv(REMEMBERSTACK_AUTH_ENV):
+            resolved_authorization = os.environ[REMEMBERSTACK_AUTH_ENV]
+
+        resolved_base_url: str | None = None
+        if base_url is not None:
+            resolved_base_url = base_url
+        elif settings is not None and settings.api_url:
+            resolved_base_url = settings.api_url
+        elif os.getenv(API_URL_ENV):
+            resolved_base_url = os.environ[API_URL_ENV]
+        elif os.getenv(REMEMBERSTACK_URL_ENV):
+            resolved_base_url = os.environ[REMEMBERSTACK_URL_ENV]
+
+        super().__init__(
+            base_url=resolved_base_url,
+            authorization=resolved_authorization,
+            timeout=timeout,
+            settings=settings,
+        )
+
+    @classmethod
+    def from_env(cls, **overrides: Any) -> Self:
+        """Build from environment variables with keyword argument overrides."""
+        return cls(**overrides)
+
+    def ingest(
+        self,
+        source: str | Path | bytes,
+        *,
+        filename: str | None = None,
+        mime: str | None = None,
+        title: str | None = None,
+        source_kind: str | None = None,
+        source_ref: str | None = None,
+        source_modified_at: datetime | None = None,
+        versioning_mode: Literal["snapshot", "living"] = "snapshot",
+        source_version_ref: str | None = None,
+    ) -> IngestedVersion:
+        """Ingest a document from a file path, string path, or raw bytes."""
+        resolved_source = Path(source) if isinstance(source, str) else source
+        return super().ingest(
+            resolved_source,
+            filename=filename,
+            mime=mime,
+            title=title,
+            source_kind=source_kind,
+            source_ref=source_ref,
+            source_modified_at=source_modified_at,
+            versioning_mode=versioning_mode,
+            source_version_ref=source_version_ref,
+        )
+
+    def ingest_file(
+        self,
+        file_path: str | Path,
+        *,
+        filename: str | None = None,
+        mime: str | None = None,
+        title: str | None = None,
+        source_kind: str | None = None,
+        source_ref: str | None = None,
+        source_modified_at: datetime | None = None,
+        versioning_mode: Literal["snapshot", "living"] = "snapshot",
+        source_version_ref: str | None = None,
+    ) -> IngestedVersion:
+        """Alias for :meth:`ingest` accepting a string file path or :class:`pathlib.Path`."""
+        return self.ingest(
+            file_path,
+            filename=filename,
+            mime=mime,
+            title=title,
+            source_kind=source_kind,
+            source_ref=source_ref,
+            source_modified_at=source_modified_at,
+            versioning_mode=versioning_mode,
+            source_version_ref=source_version_ref,
+        )
+
+    def __enter__(self) -> Self:
+        """Support ``with Client(...) as memory:`` returning Self."""
+        super().__enter__()
+        return self
+
 
 class CloudClient:
     """Ask the control plane what it knows about one organisation.
@@ -67,7 +225,7 @@ class CloudClient:
         )
 
     @classmethod
-    def from_env(cls, **overrides: Any) -> "CloudClient":
+    def from_env(cls, **overrides: Any) -> Self:
         """Build from ``REMEMBER_CLOUD_TOKEN`` / ``_ORG`` / ``_URL``.
 
         The usual shape for an agent: credentials in the environment, nothing in
@@ -168,7 +326,7 @@ class CloudClient:
         """Release the underlying connection pool."""
         self._http.close()
 
-    def __enter__(self) -> "CloudClient":
+    def __enter__(self) -> Self:
         """Support ``with CloudClient(...) as cloud:``."""
         return self
 

remember-0.3.0/tests/test_client_facade.py

@@ -0,0 +1,195 @@
+"""Tests for remember.Client facade (D65)."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import httpx
+from pydantic import SecretStr
+import pytest
+import remember
+from remember import Client
+from remember.client import _format_bearer
+from rememberstack.client import ClientSettings
+
+
+def test_format_bearer() -> None:
+    assert _format_bearer("umc_dp_secret") == "Bearer umc_dp_secret"
+    assert _format_bearer("Bearer umc_dp_secret") == "Bearer umc_dp_secret"
+    assert _format_bearer("bearer umc_dp_secret") == "Bearer umc_dp_secret"
+    assert _format_bearer("  Bearer  umc_dp_secret  ") == "Bearer umc_dp_secret"
+
+
+def test_format_bearer_validation() -> None:
+    with pytest.raises(ValueError, match="cannot be empty"):
+        _format_bearer("")
+    with pytest.raises(ValueError, match="cannot be empty"):
+        _format_bearer("   ")
+    with pytest.raises(ValueError, match="cannot be empty"):
+        _format_bearer("Bearer")
+    with pytest.raises(ValueError, match="cannot be empty"):
+        _format_bearer("Bearer   ")
+    with pytest.raises(ValueError, match="newline"):
+        _format_bearer("umc_dp_key\r\n")
+    with pytest.raises(ValueError, match="newline"):
+        _format_bearer("Bearer secret\n")
+
+
+def test_client_bare_api_key_formats_bearer() -> None:
+    client = Client(api_key="umc_dp_12345", base_url="https://dp.test")
+    auth_header = client._client.headers.get("Authorization")
+    assert auth_header == "Bearer umc_dp_12345"
+    assert str(client._client.base_url) == "https://dp.test"
+
+
+def test_client_api_key_with_bearer_prefix() -> None:
+    client = Client(api_key="Bearer umc_dp_12345", base_url="https://dp.test")
+    auth_header = client._client.headers.get("Authorization")
+    assert auth_header == "Bearer umc_dp_12345"
+
+
+def test_client_api_key_takes_precedence_over_authorization() -> None:
+    client = Client(
+        api_key="umc_dp_primary",
+        authorization="Bearer umc_dp_fallback",
+        base_url="https://dp.test",
+    )
+    assert client._client.headers.get("Authorization") == "Bearer umc_dp_primary"
+
+
+def test_client_env_var_resolution(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv("REMEMBER_API_KEY", "umc_dp_from_env")
+    monkeypatch.setenv("REMEMBER_API_URL", "https://env.dp.remember.dev")
+    # Fallbacks that must be overridden
+    monkeypatch.setenv("REMEMBERSTACK_API_AUTHORIZATION", "Bearer rs_auth")
+    monkeypatch.setenv("REMEMBERSTACK_API_URL", "https://rs.dp.remember.dev")
+
+    client = Client.from_env()
+    assert client._client.headers.get("Authorization") == "Bearer umc_dp_from_env"
+    assert str(client._client.base_url) == "https://env.dp.remember.dev"
+
+
+def test_client_falls_back_to_rememberstack_env(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.delenv("REMEMBER_API_KEY", raising=False)
+    monkeypatch.delenv("REMEMBER_API_URL", raising=False)
+    monkeypatch.setenv("REMEMBERSTACK_API_AUTHORIZATION", "Bearer rs_auth")
+    monkeypatch.setenv("REMEMBERSTACK_API_URL", "https://rs.dp.remember.dev")
+
+    client = Client.from_env()
+    assert client._client.headers.get("Authorization") == "Bearer rs_auth"
+    assert str(client._client.base_url) == "https://rs.dp.remember.dev"
+
+
+def test_client_explicit_settings_overrides_env(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setenv("REMEMBER_API_KEY", "umc_dp_ambient")
+    monkeypatch.setenv("REMEMBER_API_URL", "https://ambient.dp.remember.dev")
+
+    settings = ClientSettings(
+        api_url="https://settings.dp.remember.dev",
+        api_authorization=SecretStr("Bearer rs_settings_auth"),
+    )
+    client = Client(settings=settings)
+    assert client._client.headers.get("Authorization") == "Bearer rs_settings_auth"
+    assert str(client._client.base_url) == "https://settings.dp.remember.dev"
+
+
+def test_client_ignores_cloud_token_and_org(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.delenv("REMEMBER_API_KEY", raising=False)
+    monkeypatch.delenv("REMEMBER_API_URL", raising=False)
+    monkeypatch.delenv("REMEMBERSTACK_API_AUTHORIZATION", raising=False)
+    monkeypatch.delenv("REMEMBERSTACK_API_URL", raising=False)
+    monkeypatch.setenv("REMEMBER_CLOUD_TOKEN", "umc_cp_secret")
+    monkeypatch.setenv("REMEMBER_CLOUD_ORG", "some-org-id")
+
+    # Client must NOT pick up control-plane tokens
+    client = Client.from_env()
+    assert client._client.headers.get("Authorization") is None
+
+
+def test_client_injected_client_refuses_settings() -> None:
+    mock_http = httpx.Client()
+    with pytest.raises(ValueError, match="injected client cannot be combined"):
+        Client(client=mock_http, api_key="umc_dp_test")
+
+
+def test_client_ingest_string_path(tmp_path: Path) -> None:
+    test_file = tmp_path / "sample.txt"
+    test_file.write_text("hello memory")
+
+    seen_request: dict[str, str] = {}
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        seen_request["path"] = request.url.path
+        seen_request["filename"] = request.url.params.get("filename", "")
+        seen_request["mime"] = request.url.params.get("mime", "")
+        seen_request["content"] = request.content.decode()
+        return httpx.Response(
+            200,
+            json={
+                "deployment_id": "00000000-0000-0000-0000-000000000000",
+                "doc_id": "11111111-1111-1111-1111-111111111111",
+                "version_id": "22222222-2222-2222-2222-222222222222",
+                "content_hash": "sha256:abcd",
+                "created": True,
+            },
+        )
+
+    mock_client = httpx.Client(
+        base_url="https://dp.test", transport=httpx.MockTransport(handler)
+    )
+    with Client(client=mock_client) as memory:
+        landed = memory.ingest(str(test_file))
+
+    assert seen_request["path"] == "/ingest"
+    assert seen_request["filename"] == "sample.txt"
+    assert seen_request["mime"] == "text/plain"
+    assert seen_request["content"] == "hello memory"
+    assert str(landed.version_id) == "22222222-2222-2222-2222-222222222222"
+    assert landed.created is True
+
+
+def test_client_ingest_file_alias(tmp_path: Path) -> None:
+    test_file = tmp_path / "doc.md"
+    test_file.write_text("# Doc\n\nContent here.")
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        return httpx.Response(
+            200,
+            json={
+                "deployment_id": "00000000-0000-0000-0000-000000000000",
+                "doc_id": "11111111-1111-1111-1111-111111111111",
+                "version_id": "22222222-2222-2222-2222-222222222222",
+                "content_hash": "sha256:abcd",
+                "created": True,
+            },
+        )
+
+    mock_client = httpx.Client(
+        base_url="https://dp.test", transport=httpx.MockTransport(handler)
+    )
+    with Client(client=mock_client) as memory:
+        # String path
+        landed_str = memory.ingest_file(str(test_file))
+        assert landed_str.created is True
+
+        # Path object
+        landed_path = memory.ingest_file(test_file)
+        assert landed_path.created is True
+
+
+def test_top_level_exports() -> None:
+    assert hasattr(remember, "Client")
+    assert hasattr(remember, "CloudClient")
+    assert hasattr(remember, "Envelope")
+    assert hasattr(remember, "ContextBundleV1")
+    assert hasattr(remember, "IngestedVersion")
+    assert hasattr(remember, "MemoryApiError")
+    assert hasattr(remember, "ReadinessRequirements")
+    assert hasattr(remember, "BillingStatus")
+    assert hasattr(remember, "Deployment")
+    assert hasattr(remember, "LedgerEntry")
+    assert hasattr(remember, "SpendGate")

{remember-0.2.0 → remember-0.3.0}/uv.lock

@@ -496,7 +496,7 @@ wheels = [
 
 [[package]]
 name = "remember"
-version = "0.2.0"
+version = "0.3.0"
 source = { editable = "." }
 dependencies = [
     { name = "httpx" },

remember-0.2.0/PKG-INFO

@@ -1,78 +0,0 @@
-Metadata-Version: 2.5
-Name: remember
-Version: 0.2.0
-Summary: Control-plane client for the remember.dev managed memory service.
-Project-URL: Homepage, https://remember.dev
-Project-URL: Documentation, https://remember.dev/docs
-Project-URL: Source, https://github.com/writeitai/ultimate-memory-cloud
-Author-email: "WriteIt.ai s.r.o." <info@writeit.ai>
-License: Apache-2.0
-Keywords: agents,memory,remember.dev,rememberstack
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Developers
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Typing :: Typed
-Requires-Python: >=3.12
-Requires-Dist: httpx>=0.27
-Requires-Dist: rememberstack>=0.8.1
-Description-Content-Type: text/markdown
-
-# remember
-
-Control-plane client for the [remember.dev](https://remember.dev) managed memory service.
-
-`rememberstack` answers *memory* questions — ingest a document, search claims, run an assured
-operation. This package answers the questions an operator of that memory also has:
-
-- is my deployment ready?
-- what is my balance, and what did that ingest cost?
-- has spend safety parked my work?
-
-```python
-from remember import CloudClient
-
-with CloudClient.from_env() as cloud:
-    if cloud.is_ready():
-        print(cloud.billing_status().balance)
-```
-
-```console
-$ remember-status
-deployment  active     bb81063d-6b7b-41d0-a1df-dc57d4f1fe87
-endpoint    live       bb81063d-6b7b-41d0-a1df-dc57d4f1fe87.dp.remember.dev
-billing     active     balance 42.10
-spend       allow
-```
-
-## Install
-
-```console
-pip install remember
-```
-
-This installs `rememberstack` too. The `remember` **command** comes from that package and is
-unaffected by this one; this distribution adds only `remember-status`.
-
-## Credentials
-
-This client authenticates with a **control-plane token** (`umc_cp_…`) — the D53 credential kind.
-It is not the same thing as a deployment API token (`umc_dp_…`): that one authenticates *memory*
-calls at the deployment's ingress and will be rejected here.
-
-Mint one with `POST /v1/orgs/<org>/control-tokens` while signed in to the app. There is no button
-for this yet — the API landed before the interface did — so today it is a call, not a click:
-
-```console
-export REMEMBER_CLOUD_TOKEN='umc_cp_…'
-export REMEMBER_CLOUD_ORG='your-organisation-id'
-```
-
-The secret is shown once. The credential is organisation-scoped, **read-only**, expires (90 days by
-default), and can be surrendered by its holder at any time.
-
-## What it will not do
-
-No memory verbs, no second ingest or search contract. To *use* the memory, use `rememberstack`
-pointed at your deployment; this package tells you what that memory costs and whether it is ready.

remember-0.2.0/README.md

@@ -1,57 +0,0 @@
-# remember
-
-Control-plane client for the [remember.dev](https://remember.dev) managed memory service.
-
-`rememberstack` answers *memory* questions — ingest a document, search claims, run an assured
-operation. This package answers the questions an operator of that memory also has:
-
-- is my deployment ready?
-- what is my balance, and what did that ingest cost?
-- has spend safety parked my work?
-
-```python
-from remember import CloudClient
-
-with CloudClient.from_env() as cloud:
-    if cloud.is_ready():
-        print(cloud.billing_status().balance)
-```
-
-```console
-$ remember-status
-deployment  active     bb81063d-6b7b-41d0-a1df-dc57d4f1fe87
-endpoint    live       bb81063d-6b7b-41d0-a1df-dc57d4f1fe87.dp.remember.dev
-billing     active     balance 42.10
-spend       allow
-```
-
-## Install
-
-```console
-pip install remember
-```
-
-This installs `rememberstack` too. The `remember` **command** comes from that package and is
-unaffected by this one; this distribution adds only `remember-status`.
-
-## Credentials
-
-This client authenticates with a **control-plane token** (`umc_cp_…`) — the D53 credential kind.
-It is not the same thing as a deployment API token (`umc_dp_…`): that one authenticates *memory*
-calls at the deployment's ingress and will be rejected here.
-
-Mint one with `POST /v1/orgs/<org>/control-tokens` while signed in to the app. There is no button
-for this yet — the API landed before the interface did — so today it is a call, not a click:
-
-```console
-export REMEMBER_CLOUD_TOKEN='umc_cp_…'
-export REMEMBER_CLOUD_ORG='your-organisation-id'
-```
-
-The secret is shown once. The credential is organisation-scoped, **read-only**, expires (90 days by
-default), and can be surrendered by its holder at any time.
-
-## What it will not do
-
-No memory verbs, no second ingest or search contract. To *use* the memory, use `rememberstack`
-pointed at your deployment; this package tells you what that memory costs and whether it is ready.

remember-0.2.0/src/remember/__init__.py

@@ -1,74 +0,0 @@
-"""Control-plane client for the remember.dev managed service.
-
-PyPI project **`remember`**, import name **`remember`** (D43 left the import name
-open and required the first publish to document it; this is that record). The
-distribution installs **no** ``remember`` console script — that entry point
-belongs to ``rememberstack`` alone, and two distributions competing for one name
-on ``PATH`` is the collision D43 rule 3 forbids.
-
-What this package is for
-------------------------
-
-``rememberstack`` answers *memory* questions: ingest a document, search claims,
-run an assured operation. It cannot answer the questions an operator of that
-memory also has —
-
-* is my deployment ready?
-* what is my balance, and what did that ingest cost?
-* has spend safety parked my work?
-
-Those live on the control plane, which until D53 accepted only a browser session
-cookie. This client speaks to it with a **control-plane token** (``umc_cp_…``):
-organisation-scoped, read-only, bounded lifetime, revocable by its bearer.
-
-    from remember import CloudClient
-
-    with CloudClient.from_env() as cloud:
-        status = cloud.billing_status()
-        print(status.state, status.balance)
-
-Getting a credential
---------------------
-
-A control-plane token is not a deployment API token: `umc_dp_…` authenticates
-*memory* calls at a deployment's ingress and is rejected here. Mint one with
-`POST /v1/orgs/<org>/control-tokens` while signed in to the app — there is no
-button for it yet, the API landed before the interface did. Then:
-
-    export REMEMBER_CLOUD_TOKEN='umc_cp_…'
-    export REMEMBER_CLOUD_ORG='your-organisation-id'
-
-The secret is shown once. `remember login` does not yet mint this kind — that
-needs an amendment to the device grant (D40), tracked in D53 §6.
-
-What it deliberately does not do
---------------------------------
-
-No memory verbs. No second ingest, search, or envelope contract (D35). If you
-want to *use* the memory, use ``rememberstack``; this package tells you what the
-memory costs and whether it is ready.
-"""
-
-from remember.client import CloudClient
-from remember.errors import CloudError
-from remember.errors import NotPermitted
-from remember.errors import RateLimited
-from remember.errors import Unauthenticated
-from remember.models import BillingStatus
-from remember.models import Deployment
-from remember.models import LedgerEntry
-from remember.models import SpendGate
-
-__all__ = [
-    "BillingStatus",
-    "CloudClient",
-    "CloudError",
-    "Deployment",
-    "LedgerEntry",
-    "NotPermitted",
-    "RateLimited",
-    "SpendGate",
-    "Unauthenticated",
-]
-
-__version__ = "0.2.0"