openai-agents-memorysync 1.0.0__tar.gz

openai_agents_memorysync-1.0.0/.gitignore

@@ -0,0 +1,6 @@
+__pycache__/
+*.egg-info/
+dist/
+build/
+.venv/
+.pytest_cache/

openai_agents_memorysync-1.0.0/PKG-INFO

@@ -0,0 +1,129 @@
+Metadata-Version: 2.5
+Name: openai-agents-memorysync
+Version: 1.0.0
+Summary: MemorySync memory for the OpenAI Agents SDK: a drop-in Session implementation with durable server-side history, long-term memory instructions, and agent memory tools.
+Project-URL: Homepage, https://memorysync.io
+Project-URL: Documentation, https://docs.memorysync.io/guides/openai-agents
+Project-URL: API Reference, https://docs.memorysync.io/api/overview
+Project-URL: Changelog, https://docs.memorysync.io/release-notes
+Project-URL: Support, https://docs.memorysync.io/debugging/support
+Project-URL: Status, https://status.memorysync.io
+Author: MemorySync
+License: MIT
+Keywords: agent-memory,agents-sdk,ai,ai-agents,llm,long-term-memory,memory,memorysync,openai,openai-agents,session
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: httpx<1.0,>=0.25
+Requires-Dist: memorysync>=1.9
+Description-Content-Type: text/markdown
+
+# openai-agents-memorysync
+
+Long-term memory for the [OpenAI Agents SDK](https://github.com/openai/openai-agents-python), backed by [MemorySync](https://memorysync.io) — including the first drop-in implementation of the SDK's Session protocol from any memory vendor.
+
+- **`MemorySyncSession`** — durable server-side conversation history for `Runner.run(..., session=...)`: survives restarts and deploys, follows multi-agent handoffs, extracts long-term memory automatically.
+- **`memory_instructions`** — dynamic instructions that inject recalled memory context per run.
+- **Five agent tools** — add, search, list, update, delete; they never raise.
+- **Async helpers** — `get_memory_context`, `search_memories`, `save_turn`.
+
+```bash
+pip install openai-agents-memorysync openai-agents
+```
+
+Set `MEMORYSYNC_API_KEY` in the environment (create a key at [app.memorysync.io](https://app.memorysync.io)), or pass `api_key` explicitly. Python 3.10+. The package never imports the Agents SDK at runtime — the Session contract is a structural protocol — so it never constrains which SDK version you run.
+
+## The drop-in session
+
+```python
+from agents import Agent, Runner
+from openai_agents_memorysync import MemorySyncSession
+
+agent = Agent(name="Assistant", instructions="You are a helpful assistant.")
+
+session = MemorySyncSession(
+    "thread-42",          # the conversation
+    user_id="customer-7", # the end user it belongs to — required
+)
+
+# First conversation
+await Runner.run(agent, "I'm vegetarian and I fly aisle.", session=session)
+
+# Any later run — same session id, any process, any deploy
+result = await Runner.run(agent, "Book my trip.", session=session)
+# The model saw the full prior history — no manual .to_input_list() plumbing.
+```
+
+Items are stored and returned **byte-for-byte** — assistant messages, function calls, tool outputs, reasoning items — verified in the test suite against OpenAI's own `SQLiteSession`, item for item. Each session lives in its own server-side namespace: `clear_session()` can only ever reach that one conversation, and function-call JSON never pollutes the user's long-term memories.
+
+**Multi-agent handoffs:** the SDK shares one session across every agent in a run, so with a correct Session implementation, cross-handoff memory needs no extra code.
+
+**Failure discipline:** the transcript IS the conversation state, so session-plane errors raise (a silently empty history would corrupt every following turn); the auxiliary long-term plane degrades through `on_error`. `pop_item`/`clear_session` refuse loudly when the key cannot delete. Transcript writes converge under retries — total and partial batch failures alike — via position + content-hash seeds.
+
+## Long-term memory in instructions
+
+```python
+from openai_agents_memorysync import memory_instructions
+
+agent = Agent(
+    name="Assistant",
+    instructions=memory_instructions(
+        "You are a helpful assistant.",
+        user_id="customer-7",                      # or a per-run resolver:
+        # user_id=lambda ctx: ctx.context.user_id,
+    ),
+)
+```
+
+Every run starts with what MemorySync knows about the user. Recall failure degrades to the base instructions — reported through `on_error`, never thrown. Modes: `"profile"` (default), `"query"`, `"full"`.
+
+## Agent tools
+
+```python
+from openai_agents_memorysync import create_memory_tools
+
+agent = Agent(
+    name="Assistant",
+    instructions="Use the memory tools to remember durable facts.",
+    tools=create_memory_tools(user_id="customer-7"),
+)
+
+# Untrusted agents: search + list only.
+create_memory_tools(user_id="customer-7", read_only=True)
+```
+
+`add_memory`, `search_memory`, `list_memories`, `update_memory`, `delete_memory` — the same five operations, same response strings as the MemorySync LangChain, AI SDK, CrewAI and Mastra tool sets. All async; failures return short readable strings, never exceptions.
+
+## Helpers
+
+```python
+from openai_agents_memorysync import get_memory_context, save_turn, search_memories
+
+context = await get_memory_context("what should I cook?", user_id="customer-7")
+hits = await search_memories("dietary preferences", user_id="customer-7")
+await save_turn(user_id="customer-7", user="I'm vegetarian", assistant="Noted!")
+```
+
+All surfaces share the same idempotency seeds, so mixing styles cannot double-store a turn. `save_turn` raises on failure — an explicit persist call is owed the truth.
+
+## Version support
+
+| Package | Requires | Runtime |
+| --- | --- | --- |
+| `openai-agents-memorysync` 1.0.0 | `openai-agents` installed alongside (any current 0.x) | Python 3.10+ |
+
+CI drives a real `Runner` — SQLite parity oracle, handoffs, retry convergence — against the latest `openai-agents` release on every push.
+
+## Documentation
+
+- [OpenAI Agents SDK Memory guide](https://docs.memorysync.io/guides/openai-agents)
+- [MemorySync docs](https://docs.memorysync.io)
+- [Get an API key](https://app.memorysync.io)

openai_agents_memorysync-1.0.0/README.md

@@ -0,0 +1,101 @@
+# openai-agents-memorysync
+
+Long-term memory for the [OpenAI Agents SDK](https://github.com/openai/openai-agents-python), backed by [MemorySync](https://memorysync.io) — including the first drop-in implementation of the SDK's Session protocol from any memory vendor.
+
+- **`MemorySyncSession`** — durable server-side conversation history for `Runner.run(..., session=...)`: survives restarts and deploys, follows multi-agent handoffs, extracts long-term memory automatically.
+- **`memory_instructions`** — dynamic instructions that inject recalled memory context per run.
+- **Five agent tools** — add, search, list, update, delete; they never raise.
+- **Async helpers** — `get_memory_context`, `search_memories`, `save_turn`.
+
+```bash
+pip install openai-agents-memorysync openai-agents
+```
+
+Set `MEMORYSYNC_API_KEY` in the environment (create a key at [app.memorysync.io](https://app.memorysync.io)), or pass `api_key` explicitly. Python 3.10+. The package never imports the Agents SDK at runtime — the Session contract is a structural protocol — so it never constrains which SDK version you run.
+
+## The drop-in session
+
+```python
+from agents import Agent, Runner
+from openai_agents_memorysync import MemorySyncSession
+
+agent = Agent(name="Assistant", instructions="You are a helpful assistant.")
+
+session = MemorySyncSession(
+    "thread-42",          # the conversation
+    user_id="customer-7", # the end user it belongs to — required
+)
+
+# First conversation
+await Runner.run(agent, "I'm vegetarian and I fly aisle.", session=session)
+
+# Any later run — same session id, any process, any deploy
+result = await Runner.run(agent, "Book my trip.", session=session)
+# The model saw the full prior history — no manual .to_input_list() plumbing.
+```
+
+Items are stored and returned **byte-for-byte** — assistant messages, function calls, tool outputs, reasoning items — verified in the test suite against OpenAI's own `SQLiteSession`, item for item. Each session lives in its own server-side namespace: `clear_session()` can only ever reach that one conversation, and function-call JSON never pollutes the user's long-term memories.
+
+**Multi-agent handoffs:** the SDK shares one session across every agent in a run, so with a correct Session implementation, cross-handoff memory needs no extra code.
+
+**Failure discipline:** the transcript IS the conversation state, so session-plane errors raise (a silently empty history would corrupt every following turn); the auxiliary long-term plane degrades through `on_error`. `pop_item`/`clear_session` refuse loudly when the key cannot delete. Transcript writes converge under retries — total and partial batch failures alike — via position + content-hash seeds.
+
+## Long-term memory in instructions
+
+```python
+from openai_agents_memorysync import memory_instructions
+
+agent = Agent(
+    name="Assistant",
+    instructions=memory_instructions(
+        "You are a helpful assistant.",
+        user_id="customer-7",                      # or a per-run resolver:
+        # user_id=lambda ctx: ctx.context.user_id,
+    ),
+)
+```
+
+Every run starts with what MemorySync knows about the user. Recall failure degrades to the base instructions — reported through `on_error`, never thrown. Modes: `"profile"` (default), `"query"`, `"full"`.
+
+## Agent tools
+
+```python
+from openai_agents_memorysync import create_memory_tools
+
+agent = Agent(
+    name="Assistant",
+    instructions="Use the memory tools to remember durable facts.",
+    tools=create_memory_tools(user_id="customer-7"),
+)
+
+# Untrusted agents: search + list only.
+create_memory_tools(user_id="customer-7", read_only=True)
+```
+
+`add_memory`, `search_memory`, `list_memories`, `update_memory`, `delete_memory` — the same five operations, same response strings as the MemorySync LangChain, AI SDK, CrewAI and Mastra tool sets. All async; failures return short readable strings, never exceptions.
+
+## Helpers
+
+```python
+from openai_agents_memorysync import get_memory_context, save_turn, search_memories
+
+context = await get_memory_context("what should I cook?", user_id="customer-7")
+hits = await search_memories("dietary preferences", user_id="customer-7")
+await save_turn(user_id="customer-7", user="I'm vegetarian", assistant="Noted!")
+```
+
+All surfaces share the same idempotency seeds, so mixing styles cannot double-store a turn. `save_turn` raises on failure — an explicit persist call is owed the truth.
+
+## Version support
+
+| Package | Requires | Runtime |
+| --- | --- | --- |
+| `openai-agents-memorysync` 1.0.0 | `openai-agents` installed alongside (any current 0.x) | Python 3.10+ |
+
+CI drives a real `Runner` — SQLite parity oracle, handoffs, retry convergence — against the latest `openai-agents` release on every push.
+
+## Documentation
+
+- [OpenAI Agents SDK Memory guide](https://docs.memorysync.io/guides/openai-agents)
+- [MemorySync docs](https://docs.memorysync.io)
+- [Get an API key](https://app.memorysync.io)

openai_agents_memorysync-1.0.0/pyproject.toml

@@ -0,0 +1,71 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "openai-agents-memorysync"
+dynamic = ["version"]
+description = "MemorySync memory for the OpenAI Agents SDK: a drop-in Session implementation with durable server-side history, long-term memory instructions, and agent memory tools."
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.10"
+authors = [{ name = "MemorySync" }]
+keywords = [
+  "memorysync",
+  "openai-agents",
+  "openai",
+  "agents-sdk",
+  "session",
+  "memory",
+  "agent-memory",
+  "long-term-memory",
+  "ai",
+  "llm",
+  "ai-agents",
+]
+classifiers = [
+  "Development Status :: 5 - Production/Stable",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Topic :: Software Development :: Libraries :: Python Modules",
+  "Typing :: Typed",
+]
+# Deliberately NO dependency on openai-agents: the Session contract is a
+# structural @runtime_checkable Protocol, so this package never needs to
+# import the SDK at runtime — and never constrains which SDK version a
+# user can run. The SDK iterates fast (0.x); a version pin here would rot.
+# `create_memory_tools` imports `agents.function_tool` lazily and raises a
+# clear error if the SDK is missing.
+dependencies = [
+  "memorysync>=1.9",
+  "httpx>=0.25,<1.0",
+]
+
+[project.urls]
+Homepage = "https://memorysync.io"
+Documentation = "https://docs.memorysync.io/guides/openai-agents"
+"API Reference" = "https://docs.memorysync.io/api/overview"
+Changelog = "https://docs.memorysync.io/release-notes"
+Support = "https://docs.memorysync.io/debugging/support"
+Status = "https://status.memorysync.io"
+
+[tool.hatch.version]
+path = "src/openai_agents_memorysync/_version.py"
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/openai_agents_memorysync"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+  "src/openai_agents_memorysync",
+  "README.md",
+  "pyproject.toml",
+]

openai_agents_memorysync-1.0.0/src/openai_agents_memorysync/__init__.py

@@ -0,0 +1,45 @@
+"""openai-agents-memorysync — MemorySync memory for the OpenAI Agents SDK.
+
+Three layers, all optional and composable:
+
+- ``MemorySyncSession`` — a drop-in implementation of the SDK's Session
+  protocol: durable server-side conversation history that survives
+  restarts and deploys, shared across multi-agent handoffs, with
+  automatic long-term memory extraction.
+- ``memory_instructions`` — dynamic instructions that inject recalled
+  memory context per run.
+- ``create_memory_tools`` — five agentic memory tools (add, search,
+  list, update, delete) that never raise.
+- Helpers — ``get_memory_context``, ``search_memories``, ``save_turn``
+  for hand-wired setups.
+"""
+
+from ._api import (
+    FALLBACK_TENANT,
+    MemorySyncAPIError,
+    fnv1a64,
+    resolve_api_key,
+    resolve_base_url,
+)
+from ._version import __version__
+from .helpers import get_memory_context, save_turn, search_memories
+from .instructions import DEFAULT_TEMPLATE, PROFILE_PROMPT, memory_instructions
+from .session import MemorySyncSession
+from .tools import create_memory_tools
+
+__all__ = [
+    "MemorySyncSession",
+    "memory_instructions",
+    "create_memory_tools",
+    "get_memory_context",
+    "search_memories",
+    "save_turn",
+    "MemorySyncAPIError",
+    "DEFAULT_TEMPLATE",
+    "PROFILE_PROMPT",
+    "FALLBACK_TENANT",
+    "fnv1a64",
+    "resolve_api_key",
+    "resolve_base_url",
+    "__version__",
+]

openai_agents_memorysync-1.0.0/src/openai_agents_memorysync/_api.py

@@ -0,0 +1,305 @@
+"""Async client for the MemorySync v1 data plane used by this integration.
+
+The session store persists items through the *episodic* ingestion path
+(``POST /v1/memory/add_turn``), which stores text verbatim — no fact
+extraction, no low-value-chatter gate, no rewriting. A conversation
+transcript that the Agents SDK will replay to the model must round-trip
+byte-for-byte; a plane that second-guessed it would corrupt the run.
+
+Everything here is async-native because the Agents SDK's ``Session``
+protocol is async and its runner drives every call from the event loop —
+a blocking HTTP client inside ``get_items`` would stall the whole run.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Any, Dict, List, Optional
+
+import httpx
+
+from ._version import __version__
+
+DEFAULT_BASE_URL = "https://api.memorysync.io"
+_USER_AGENT = f"openai-agents-memorysync/{__version__}"
+
+#: Namespace used when the key cannot list projects (see resolve_tenant_id).
+FALLBACK_TENANT = "default"
+
+
+class MemorySyncAPIError(Exception):
+    """A MemorySync call failed. Carries the status code and server detail."""
+
+    def __init__(self, message: str, *, status_code: Optional[int] = None) -> None:
+        super().__init__(message)
+        self.status_code = status_code
+
+
+def resolve_api_key(api_key: Optional[str]) -> str:
+    key = api_key or os.environ.get("MEMORYSYNC_API_KEY", "")
+    if not key or not key.strip():
+        raise ValueError(
+            "A MemorySync API key is required. Pass api_key=... or set the "
+            "MEMORYSYNC_API_KEY environment variable."
+        )
+    return key.strip()
+
+
+def resolve_base_url(base_url: Optional[str]) -> str:
+    url = base_url or os.environ.get("MEMORYSYNC_BASE_URL", "") or DEFAULT_BASE_URL
+    return url.rstrip("/")
+
+
+def fnv1a64(value: str) -> str:
+    """FNV-1a 64-bit over UTF-16 code units, as a fixed-width hex string.
+
+    Over UTF-16 code units — not code points, not UTF-8 bytes — so the
+    output matches the JavaScript adapters (`fnv1a64` in memorysync-ai-sdk
+    and memorysync-mastra hash over ``charCodeAt``) character for
+    character. Identical seeds across languages mean a turn persisted by a
+    Python surface and again by a JS surface converge on one stored row.
+    """
+    prime = 0x100000001B3
+    mask = 0xFFFFFFFFFFFFFFFF
+    h = 0xCBF29CE484222325
+    data = value.encode("utf-16-le")
+    for i in range(0, len(data), 2):
+        unit = data[i] | (data[i + 1] << 8)
+        h ^= unit
+        h = (h * prime) & mask
+    return format(h, "016x")
+
+
+class AsyncV1Api:
+    """Minimal asynchronous v1 client: add_turn, recall, query, list."""
+
+    def __init__(
+        self,
+        *,
+        api_key: str,
+        base_url: str,
+        project_id: Optional[str] = None,
+        timeout: float = 30.0,
+        transport: Optional[httpx.AsyncBaseTransport] = None,
+    ) -> None:
+        self._api_key = api_key
+        self._base_url = base_url.rstrip("/")
+        self._project_id = project_id
+        self._timeout = timeout
+        self._transport = transport
+        self._http = httpx.AsyncClient(timeout=timeout, transport=transport)
+        self._tenant_id: Optional[str] = None
+        self._tenant_is_fallback = False
+
+    async def aclose(self) -> None:
+        await self._http.aclose()
+
+    @property
+    def api_key(self) -> str:
+        return self._api_key
+
+    @property
+    def base_url(self) -> str:
+        return self._base_url
+
+    @property
+    def project_id(self) -> Optional[str]:
+        return self._project_id
+
+    @property
+    def timeout(self) -> float:
+        return self._timeout
+
+    @property
+    def transport(self) -> Optional[httpx.AsyncBaseTransport]:
+        return self._transport
+
+    # ── plumbing ─────────────────────────────────────────────────────
+
+    def _headers(self) -> Dict[str, str]:
+        h = {
+            "X-API-Key": self._api_key,
+            "Accept": "application/json",
+            "User-Agent": _USER_AGENT,
+        }
+        if self._project_id:
+            h["X-Project-ID"] = self._project_id
+        return h
+
+    async def _request(
+        self,
+        method: str,
+        path: str,
+        *,
+        json: Optional[Dict[str, Any]] = None,
+        params: Optional[Dict[str, Any]] = None,
+    ) -> Any:
+        url = f"{self._base_url}{path}"
+        try:
+            response = await self._http.request(
+                method, url, headers=self._headers(), json=json, params=params
+            )
+        except httpx.TimeoutException as e:
+            raise MemorySyncAPIError(f"Request timed out: {e}") from e
+        except httpx.HTTPError as e:
+            raise MemorySyncAPIError(f"Network error: {e}") from e
+
+        if response.status_code == 204:
+            return None
+        try:
+            body: Any = response.json()
+        except ValueError:
+            body = response.text or None
+        if response.status_code >= 400:
+            detail = body.get("detail") if isinstance(body, dict) else body
+            raise MemorySyncAPIError(
+                f"{method} {path} failed with HTTP {response.status_code}: {detail}",
+                status_code=response.status_code,
+            )
+        return body
+
+    # ── calls ────────────────────────────────────────────────────────
+
+    async def resolve_tenant_id(self) -> str:
+        """The tenant id, which the v1 routes need in path or body.
+
+        Derived from the project listing rather than asked for. Cached for
+        the lifetime of this client; one extra GET per process, not per
+        turn. Keys without the ``projects:read`` scope (evaluation keys)
+        fall back to the fixed namespace ``"default"`` — deterministic, so
+        every read and write through this client lands in one namespace.
+        Only a definite 401/403 triggers the fallback; a transient server
+        error re-raises rather than silently switching namespaces.
+        """
+        if self._tenant_id:
+            return self._tenant_id
+        try:
+            projects = await self._request("GET", "/org/projects")
+        except MemorySyncAPIError as exc:
+            if exc.status_code in (401, 403):
+                self._tenant_id = FALLBACK_TENANT
+                self._tenant_is_fallback = True
+                return self._tenant_id
+            raise
+        first = projects[0] if isinstance(projects, list) and projects else None
+        tenant = first.get("tenant_id") if isinstance(first, dict) else None
+        if not tenant:
+            raise MemorySyncAPIError(
+                "Could not determine the tenant for this API key. Pass "
+                "tenant_id=... explicitly, or verify the key with "
+                "`memorysync doctor`."
+            )
+        self._tenant_id = str(tenant)
+        return self._tenant_id
+
+    @property
+    def tenant_is_fallback(self) -> bool:
+        """True when the namespace came from the 401/403 fallback.
+
+        Callers that mix this v1 plane with the header-scoped legacy plane
+        (the agent tools do) check this: under the fallback the two planes
+        resolve *different* internal users, so a v1 read would silently
+        miss legacy-plane writes. Better to say so than to answer wrongly.
+        """
+        return self._tenant_is_fallback
+
+    def set_tenant_id(self, tenant_id: str) -> None:
+        self._tenant_id = tenant_id
+
+    async def add_turn(
+        self,
+        *,
+        tenant_id: str,
+        user_id: str,
+        text: str,
+        speaker: Optional[str] = None,
+        occurred_at: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        source: str = "openai-agents",
+        sync_embed: bool = False,
+    ) -> Dict[str, Any]:
+        """Store one item verbatim (episodic ingestion).
+
+        ``speaker`` + ``occurred_at`` participate in the server's
+        idempotency seed, so retrying an identical payload is recognised
+        (``already_exists: true``) instead of stored twice.
+        """
+        body: Dict[str, Any] = {
+            "tenant_id": tenant_id,
+            "user_id": user_id,
+            "source": source,
+            "text": text,
+            "sync_embed": sync_embed,
+        }
+        if speaker is not None:
+            body["speaker"] = speaker
+        if occurred_at is not None:
+            body["occurred_at"] = occurred_at
+        if metadata is not None:
+            body["metadata"] = metadata
+        return await self._request("POST", "/v1/memory/add_turn", json=body) or {}
+
+    async def recall(
+        self,
+        *,
+        tenant_id: str,
+        user_id: str,
+        prompt: str,
+        k: Optional[int] = None,
+        types: Optional[List[str]] = None,
+    ) -> Dict[str, Any]:
+        """Hierarchical recall: grouped, prompt-ready context block."""
+        body: Dict[str, Any] = {
+            "tenant_id": tenant_id,
+            "user_id": user_id,
+            "prompt": prompt,
+        }
+        if k is not None:
+            body["k"] = k
+        if types is not None:
+            body["types"] = types
+        return await self._request("POST", "/v1/memory/recall", json=body) or {}
+
+    async def query(
+        self,
+        *,
+        tenant_id: str,
+        user_id: str,
+        prompt: str,
+        k: Optional[int] = None,
+    ) -> Dict[str, Any]:
+        """Plain semantic search over the pair's memories (episodic included)."""
+        body: Dict[str, Any] = {
+            "tenant_id": tenant_id,
+            "user_id": user_id,
+            "prompt": prompt,
+        }
+        if k is not None:
+            body["k"] = k
+        return await self._request("POST", "/v1/memory/query", json=body) or {}
+
+    async def list_memories(
+        self,
+        *,
+        tenant_id: str,
+        user_id: str,
+        limit: int = 0,
+    ) -> List[Dict[str, Any]]:
+        """Every memory for the tenant/user pair, newest first.
+
+        ``limit=0`` means no limit — a transcript read must never be
+        silently truncated, so that is the default here.
+
+        Both path segments are percent-encoded so an id containing ``/``,
+        ``%`` or ``?`` addresses the right row set — the server decodes
+        path parameters, so sending the raw string would corrupt the path.
+        """
+        from urllib.parse import quote
+
+        raw = await self._request(
+            "GET",
+            f"/v1/memory/{quote(tenant_id, safe='')}/{quote(user_id, safe='')}/list",
+            params={"limit": limit},
+        )
+        memories = raw.get("memories") if isinstance(raw, dict) else None
+        return list(memories) if isinstance(memories, list) else []

openai_agents_memorysync-1.0.0/src/openai_agents_memorysync/_version.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"