langgraph_checkpoint_firestore 0.2.0__py3-none-any.whl

langgraph_checkpoint_firestore/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2018 The Python Packaging Authority
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

langgraph_checkpoint_firestore/__init__.py

@@ -0,0 +1,7 @@
+
+
+from langgraph_checkpoint_firestore.firestoreSaver import FirestoreSaver
+from .firestoreSerializer import FirestoreSerializer
+
+__all__ = ["FirestoreSaver", "FirestoreSerializer"]
+

langgraph_checkpoint_firestore/firestoreSaver.py

@@ -0,0 +1,362 @@
+# create firestore Saver (langgraph checkpointer) basis firestoredb implementation in included code include=src/langgraph_checkpoint_firestore/firestoredbSaver.py 
+#  Remember there is no partition key in firestore only unique ID.
+# create separate collection for checkpoints and writes. Next level collection will be thread_id and then checkpoint_id
+# we have to preserve the function signatures and return values (as in firestoredbsaver) as it is.
+# Do provide full and complete code, i.e all function along with Saver in the included file.
+# @!
+
+import copy
+from contextlib import contextmanager
+from typing import Any, Iterator, List, Optional, Tuple, AsyncIterator
+
+from langchain_core.runnables import RunnableConfig
+
+from langgraph.checkpoint.base import WRITES_IDX_MAP, BaseCheckpointSaver, ChannelVersions, Checkpoint, CheckpointMetadata, CheckpointTuple, PendingWrite, get_checkpoint_id
+
+from google.cloud import firestore
+from langgraph_checkpoint_firestore.firestoreSerializer import FirestoreSerializer
+import asyncio
+
+FIRESTORE_KEY_SEPARATOR = "/"
+
+def _make_firestore_checkpoint_key(thread_id: str, checkpoint_ns: str, checkpoint_id: str) -> str:
+    return FIRESTORE_KEY_SEPARATOR.join([
+        "checkpoint", thread_id, checkpoint_ns, checkpoint_id
+    ])
+
+
+def _make_firestore_checkpoint_writes_key(thread_id: str, checkpoint_ns: str, checkpoint_id: str, task_id: str, idx: Optional[int]) -> str:
+    if idx is None:
+        return FIRESTORE_KEY_SEPARATOR.join([
+            "writes", thread_id, checkpoint_ns, checkpoint_id, task_id
+        ])
+
+    return FIRESTORE_KEY_SEPARATOR.join([
+        "writes", thread_id, checkpoint_ns, checkpoint_id, task_id, str(idx)
+    ])
+
+
+def _parse_firestore_checkpoint_key(firestoredb_key: str) -> dict:
+    namespace, thread_id, checkpoint_ns, checkpoint_id = firestoredb_key.split(
+        FIRESTORE_KEY_SEPARATOR
+    )
+    if namespace != "checkpoint":
+        raise ValueError("Expected checkpoint key to start with 'checkpoint'")
+
+    return {
+        "thread_id": thread_id,
+        "checkpoint_ns": checkpoint_ns,
+        "checkpoint_id": checkpoint_id,
+    }
+
+
+def _parse_firestore_checkpoint_writes_key(firestoredb_key: str) -> dict:
+    namespace, thread_id, checkpoint_ns, checkpoint_id, task_id, idx = firestoredb_key.split(
+        FIRESTORE_KEY_SEPARATOR
+    )
+    if namespace != "writes":
+        raise ValueError("Expected checkpoint key to start with 'writes'")
+
+    return {
+        "thread_id": thread_id,
+        "checkpoint_ns": checkpoint_ns,
+        "checkpoint_id": checkpoint_id,
+        "task_id": task_id,
+        "idx": idx,
+    }
+
+
+def _filter_keys(keys: List[str], before: Optional[RunnableConfig], limit: Optional[int]) -> list:
+    if before:
+        keys = [
+            k
+            for k in keys
+            if _parse_firestore_checkpoint_key(k)["checkpoint_id"]
+            < before["configurable"]["checkpoint_id"]
+        ]
+
+    keys = sorted(
+        keys,
+        key=lambda k: _parse_firestore_checkpoint_key(k)["checkpoint_id"],
+        reverse=True,
+    )
+    if limit:
+        keys = keys[:limit]
+    return keys
+
+
+def _load_writes(serde: FirestoreSerializer, task_id_to_data: dict[tuple[str, str], dict]) -> list[PendingWrite]:
+    writes = [
+        (
+            task_id,
+            data["channel"],
+            serde.loads_typed((data["type"], data["value"])),
+        )
+        for (task_id, _), data in task_id_to_data.items()
+    ]
+    return writes
+
+
+def _parse_firestore_checkpoint_data(serde: FirestoreSerializer, key: str, data: dict, pending_writes: Optional[List[PendingWrite]] = None) -> Optional[CheckpointTuple]:
+    if not data:
+        return None
+
+    parsed_key = _parse_firestore_checkpoint_key(key)
+    thread_id = parsed_key["thread_id"]
+    checkpoint_ns = parsed_key["checkpoint_ns"]
+    checkpoint_id = parsed_key["checkpoint_id"]
+    config = {
+        "configurable": {
+            "thread_id": thread_id,
+            "checkpoint_ns": checkpoint_ns,
+            "checkpoint_id": checkpoint_id,
+        }
+    }
+
+    checkpoint = serde.loads_typed((data["type"], data["checkpoint"]))
+    
+    metadata = serde.loads_typed(data["metadata"])
+    parent_checkpoint_id = data.get("parent_checkpoint_id", "")
+    parent_config = (
+        {
+            "configurable": {
+                "thread_id": thread_id,
+                "checkpoint_ns": checkpoint_ns,
+                "checkpoint_id": parent_checkpoint_id,
+            }
+        }
+        if parent_checkpoint_id
+        else None
+    )
+    return CheckpointTuple(
+        config=config,
+        checkpoint=checkpoint,
+        metadata=metadata,
+        parent_config=parent_config,
+        pending_writes=pending_writes,
+    )
+
+class FirestoreSaver(BaseCheckpointSaver):
+    def __init__(self, project_id, checkpoints_collection='checkpoints', reducer=None, messages_key="messages"):
+        super().__init__()
+        self.client = firestore.Client(project=project_id)
+        self.firestore_serde = FirestoreSerializer(self.serde)
+        self.checkpoints_collection = self.client.collection(checkpoints_collection)
+        self.reducer = reducer
+        self.messages_key = messages_key
+
+    @classmethod
+    @contextmanager
+    def from_conn_info(cls, *, project_id: str, checkpoints_collection: str, reducer=None, messages_key="messages", **kwargs) -> Iterator['FirestoreSaver']:
+        saver = None
+        try:
+            saver = FirestoreSaver(project_id, checkpoints_collection, reducer=reducer, messages_key=messages_key)
+            yield saver
+        finally:
+            pass
+
+    def _apply_reducer(self, checkpoint: Checkpoint) -> Checkpoint:
+        if self.reducer is None:
+            return checkpoint
+        channel_values = checkpoint.get("channel_values", {})
+        messages = channel_values.get(self.messages_key)
+        if not messages:
+            return checkpoint
+        result = self.reducer.reduce(existing=messages, new=[])
+        new_channel_values = dict(channel_values)
+        new_channel_values[self.messages_key] = result.surviving
+        new_checkpoint = copy.copy(checkpoint)
+        new_checkpoint["channel_values"] = new_channel_values
+        return new_checkpoint
+
+    # Helper to get subcollection for a given partition
+    def _get_partition_collection(self, thread_id: str, checkpoint_ns: str):
+        """Return the Firestore collection reference representing one partition (thread+ns)."""
+        partition_doc = self.checkpoints_collection.document(f"{thread_id}_{checkpoint_ns}")
+        return partition_doc.collection("checkpoints")
+    
+    def put(self, config: RunnableConfig, checkpoint: Checkpoint, metadata: CheckpointMetadata, new_versions: ChannelVersions) -> RunnableConfig:
+        checkpoint = self._apply_reducer(checkpoint)
+        thread_id = config['configurable']['thread_id']
+        checkpoint_ns = config['configurable']['checkpoint_ns']
+        checkpoint_id = checkpoint['id']
+        parent_checkpoint_id = config['configurable'].get('checkpoint_id')
+        key = _make_firestore_checkpoint_key(thread_id, checkpoint_ns, checkpoint_id)
+
+        type_, serialized_checkpoint = self.firestore_serde.dumps_typed(checkpoint)
+        serialized_metadata = self.firestore_serde.dumps_typed(metadata)
+        data = {
+            'checkpoint': serialized_checkpoint,
+            'checkpoint_id': checkpoint_id,
+            "checkpoint_key": key,
+            'type': type_,            
+            'metadata': serialized_metadata,
+            'parent_checkpoint_id': parent_checkpoint_id if parent_checkpoint_id else ''
+        }
+        partition_collection = self._get_partition_collection(thread_id, checkpoint_ns)
+        partition_collection.document(checkpoint_id).set(data)
+        return {
+            'configurable': {
+                'thread_id': thread_id,
+                'checkpoint_ns': checkpoint_ns,
+                'checkpoint_id': checkpoint_id
+            }
+        }
+
+    def put_writes(self, config: RunnableConfig, writes: List[Tuple[str, Any]], task_id: str) -> None:
+        thread_id = config['configurable']['thread_id']
+        checkpoint_ns = config['configurable']['checkpoint_ns']
+        checkpoint_id = config['configurable']['checkpoint_id']
+
+        # Writes belong under the checkpoint itself
+        partition_collection = self._get_partition_collection(thread_id, checkpoint_ns)
+        # self.write_collection is not used anymore. 
+        writes_collection = partition_collection.document(checkpoint_id).collection("writes")
+  
+        for idx, (channel, value) in enumerate(writes):
+            key = _make_firestore_checkpoint_writes_key(
+                thread_id,
+                checkpoint_ns,
+                checkpoint_id,
+                task_id,
+                WRITES_IDX_MAP.get(channel, idx),
+            )
+            type_, serialized_value = self.firestore_serde.dumps_typed(value)
+            data = {"checkpoint_key": key, 'channel': channel, 'type': type_, 
+                    'value': serialized_value, 
+                    "task_id": task_id,
+                    "idx": WRITES_IDX_MAP.get(channel, idx)}
+            writes_collection.document(f"{task_id}_{idx}").set(data)
+
+    def get_tuple(self, config: RunnableConfig) -> Optional[CheckpointTuple]:
+        thread_id = config['configurable']['thread_id']
+        checkpoint_id = get_checkpoint_id(config)
+        
+        checkpoint_ns = config['configurable'].get('checkpoint_ns', '')
+
+        checkpoint_key = self._get_checkpoint_key(
+            thread_id, checkpoint_ns, checkpoint_id
+        )
+
+        if not checkpoint_key:
+            return None
+        checkpoint_id = _parse_firestore_checkpoint_key(checkpoint_key)["checkpoint_id"]
+        partition_collection = self._get_partition_collection(thread_id, checkpoint_ns)
+
+        doc_ref = partition_collection.document(checkpoint_id)
+        doc = doc_ref.get()
+        if not doc.exists:
+            return None
+
+        checkpoint_data = doc.to_dict()
+        
+        pending_writes = self._load_pending_writes(
+            thread_id, checkpoint_ns, checkpoint_id
+        )
+        return _parse_firestore_checkpoint_data(
+            self.firestore_serde, checkpoint_key, checkpoint_data, pending_writes=pending_writes
+        )
+
+    def list(self, config: Optional[RunnableConfig], *, filter: Optional[dict[str, Any]] = None, before: Optional[RunnableConfig] = None, limit: Optional[int] = None) -> Iterator[CheckpointTuple]:
+        thread_id = config['configurable']['thread_id']
+        checkpoint_ns = config['configurable'].get('checkpoint_ns', '')
+
+        partition_collection = self._get_partition_collection(thread_id, checkpoint_ns)
+
+        # Order by checkpoint_id descending (latest first)
+        query = partition_collection.order_by("checkpoint_id", direction=firestore.Query.DESCENDING)
+
+        if limit:
+            query = query.limit(limit)
+        
+        checkpoints = query.stream()
+
+        for checkpoint in checkpoints:
+            if not checkpoint.exists:
+                continue
+            checkpoint_data = checkpoint.to_dict()
+            checkpoint_id = checkpoint_data["checkpoint_id"]
+            pending_writes = self._load_pending_writes(thread_id, checkpoint_ns, checkpoint_id)
+            yield _parse_firestore_checkpoint_data(self.firestore_serde, checkpoint_data["checkpoint_key"],checkpoint_data, pending_writes)
+
+    def _load_pending_writes(self, thread_id: str, checkpoint_ns: Optional[str] , checkpoint_id: str) -> List[PendingWrite]:
+        
+        partition_collection = self._get_partition_collection(thread_id, checkpoint_ns)
+        writes_ref = partition_collection.document(checkpoint_id).collection("writes")
+
+        # Stream all write documents under this checkpoint
+        write_docs = [doc.to_dict() for doc in writes_ref.stream() if doc.exists]
+
+        if not write_docs:
+            return []
+
+        # Parse checkpoint keys and sort by idx
+        parsed_keys = [
+            _parse_firestore_checkpoint_writes_key(w["checkpoint_key"]) for w in write_docs
+        ]
+
+        # Sort by idx (to maintain deterministic replay order)
+        combined = sorted(zip(write_docs, parsed_keys), key=lambda x: x[1]["idx"])
+        
+        pending_writes = _load_writes(
+            self.firestore_serde,
+            {
+                (parsed_key["task_id"], parsed_key["idx"]): key
+                for key, parsed_key in combined
+            },
+        )
+        return pending_writes
+   
+    def _get_checkpoint_key(self, thread_id: str, checkpoint_ns: str, checkpoint_id: Optional[str]) -> Optional[str]:
+        if checkpoint_id:
+            return _make_firestore_checkpoint_key(thread_id, checkpoint_ns, checkpoint_id)
+
+        partition_collection = self._get_partition_collection(thread_id, checkpoint_ns)
+        docs = (
+            partition_collection
+            .order_by("checkpoint_id", direction=firestore.Query.DESCENDING)
+            .limit(1)
+            .stream()
+            )    
+        
+        if not docs:
+            return None
+
+        latest_doc = next(docs, None)
+        if not latest_doc or not latest_doc.exists:
+            return None
+
+        data = latest_doc.to_dict()
+        return data["checkpoint_key"]
+    
+    async def aget(self, config: RunnableConfig) -> Optional[Checkpoint]:
+        if value := await self.aget_tuple(config):
+            return value.checkpoint
+
+    async def aget_tuple(self, config: RunnableConfig) -> Optional[CheckpointTuple]:
+        return await asyncio.get_running_loop().run_in_executor(
+            None, self.get_tuple, config
+        )
+
+    async def alist(self, config: RunnableConfig) -> AsyncIterator[CheckpointTuple]:
+        loop = asyncio.get_running_loop()
+        iter = loop.run_in_executor(None, self.list, config)
+        while True:
+            try:
+                yield await loop.run_in_executor(None, next, iter)
+            except StopIteration:
+                return
+
+    async def aput(
+        self, config: RunnableConfig, checkpoint: Checkpoint, metadata: Optional[CheckpointMetadata] = None, new_versions: Optional[ChannelVersions] = None
+    ) -> RunnableConfig:
+        return await asyncio.get_running_loop().run_in_executor(
+            None, self.put, config, checkpoint, metadata, new_versions
+        )
+
+    async def aput_writes(
+        self, config: RunnableConfig, writes: List[Tuple[str, Any]], task_id: str
+    ) -> None:
+        return await asyncio.get_running_loop().run_in_executor(
+            None, self.put_writes, config, writes, task_id
+        )

langgraph_checkpoint_firestore/firestoreSerializer.py

@@ -0,0 +1,15 @@
+import base64
+
+class FirestoreSerializer:
+    def __init__(self, serde):
+        self.serde = serde
+    
+    def dumps_typed(self, obj):
+        type_, data = self.serde.dumps_typed(obj)
+        data_base64 = base64.b64encode(data).decode('utf-8')
+        return type_, data_base64
+
+    def loads_typed(self, data):
+        type_name, serialized_obj = data
+        serialized_obj = base64.b64decode(serialized_obj.encode('utf-8'))
+        return self.serde.loads_typed((type_name, serialized_obj))

langgraph_checkpoint_firestore-0.2.0.dist-info/METADATA

@@ -0,0 +1,191 @@
+Metadata-Version: 2.4
+Name: langgraph_checkpoint_firestore
+Version: 0.2.0
+Summary: LangGraph checkpoint saver for Google Firestore with built-in message history pruning via agentstate-reducer
+Author-email: Kamal <skamalj@github.com>
+Keywords: agent-state,checkpoint,firestore,google-cloud,langchain,langgraph,memory,message-reducer
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Requires-Dist: google-cloud-firestore
+Requires-Dist: langchain-core
+Requires-Dist: langgraph
+Provides-Extra: dev
+Requires-Dist: black; extra == 'dev'
+Requires-Dist: isort; extra == 'dev'
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Provides-Extra: reducer
+Requires-Dist: agentstate-reducer>=0.1.1; extra == 'reducer'
+Description-Content-Type: text/markdown
+
+# langgraph-checkpoint-firestore
+
+Google Firestore checkpoint saver for [LangGraph](https://github.com/langchain-ai/langgraph). Persists agent state between runs so your graphs can resume from any prior checkpoint.
+
+**What makes this checkpointer different:** it has message history pruning built in. Pass a `MessageReducer` and the checkpointer automatically caps your message list before writing to Firestore — no extra code in your graph, no state annotation changes required. This is the only LangGraph Firestore checkpointer with this capability.
+
+## Features
+
+- **Full checkpoint persistence** — save, retrieve, and list LangGraph checkpoints in Google Firestore
+- **Built-in message pruning** — optional `MessageReducer` prunes message history at the persistence layer, keeping checkpoints lean without changing your graph code
+- **Sync and async API** — `put`/`get_tuple`/`list` and their `aput`/`aget_tuple`/`alist` async counterparts
+- **Subgraph support** — correctly checkpoints parent and subgraph state independently
+- **Native Firestore hierarchy** — checkpoints stored in subcollections per thread, enabling efficient per-thread queries
+
+## Installation
+
+```bash
+pip install langgraph-checkpoint-firestore
+```
+
+With optional message pruning support:
+
+```bash
+pip install "langgraph-checkpoint-firestore[reducer]"
+```
+
+**Requires Python 3.10+**
+
+## Firestore Setup
+
+The saver uses Google Cloud Application Default Credentials. Set up auth with one of:
+
+```bash
+# Local development — authenticate with your Google account
+gcloud auth application-default login
+
+# Service account (CI / production)
+export GOOGLE_APPLICATION_CREDENTIALS="/path/to/service-account-key.json"
+```
+
+Your Firestore instance must be in **Native mode** (not Datastore mode). Collections are created automatically on first write — no manual setup required.
+
+## Quick Start
+
+```python
+from langgraph.graph import StateGraph, MessagesState, START
+from langchain_openai import ChatOpenAI
+from langgraph_checkpoint_firestore import FirestoreSaver
+
+model = ChatOpenAI(model="gpt-4o-mini")
+
+def call_model(state: MessagesState):
+    return {"messages": model.invoke(state["messages"])}
+
+builder = StateGraph(MessagesState)
+builder.add_node("call_model", call_model)
+builder.add_edge(START, "call_model")
+
+with FirestoreSaver.from_conn_info(project_id="my-gcp-project", checkpoints_collection="checkpoints") as checkpointer:
+    graph = builder.compile(checkpointer=checkpointer)
+
+    config = {"configurable": {"thread_id": "user-123"}}
+
+    # First run — state is saved to Firestore
+    graph.invoke({"messages": [{"role": "user", "content": "Hi, I'm Kamal"}]}, config)
+
+    # Second run — picks up where it left off
+    graph.invoke({"messages": [{"role": "user", "content": "What's my name?"}]}, config)
+```
+
+## API Reference
+
+### `FirestoreSaver(project_id, checkpoints_collection, reducer=None, messages_key="messages")`
+
+| Parameter | Type | Default | Description |
+|---|---|---|---|
+| `project_id` | `str` | required | Google Cloud project ID |
+| `checkpoints_collection` | `str` | `"checkpoints"` | Root Firestore collection name |
+| `reducer` | `MessageReducer` | `None` | Optional pruner — see [Message Pruning](#built-in-message-pruning) |
+| `messages_key` | `str` | `"messages"` | State channel name that holds the message list |
+
+You can also use the context manager factory:
+
+```python
+with FirestoreSaver.from_conn_info(
+    project_id="my-gcp-project",
+    checkpoints_collection="checkpoints",
+    reducer=reducer,
+    messages_key="messages"
+) as saver:
+    graph = builder.compile(checkpointer=saver)
+```
+
+### Sync methods
+
+| Method | Description |
+|---|---|
+| `put(config, checkpoint, metadata, new_versions)` | Save a checkpoint |
+| `put_writes(config, writes, task_id)` | Save pending writes for a checkpoint |
+| `get_tuple(config)` | Retrieve the latest (or a specific) checkpoint |
+| `list(config, *, before, limit)` | Iterate checkpoints for a thread |
+
+### Async methods
+
+All sync methods have async counterparts: `aput`, `aput_writes`, `aget_tuple`, `alist`.
+
+## Built-in Message Pruning
+
+Long-running agents accumulate message history with every turn. Left unchecked this inflates checkpoint size, increases Firestore storage costs, and eventually blows past LLM context limits.
+
+This checkpointer solves that at the persistence layer: pass a `MessageReducer` and it automatically prunes the message list inside `put()` before the checkpoint is serialised and written to Firestore. **Your graph code, state definition, and node logic stay untouched.**
+
+This is an alternative to — or complement of — the LangGraph `Annotated[list, reducer_fn]` pattern. Use the checkpoint-layer approach when:
+
+- You don't own the graph or state definition (e.g. using a pre-built LangGraph agent)
+- You want pruning to happen unconditionally at every save, regardless of which node triggered it
+- You want to keep all in-memory state intact and only prune what gets persisted
+
+### Install with reducer support
+
+```bash
+pip install "langgraph-checkpoint-firestore[reducer]"
+```
+
+### Usage
+
+```python
+from agentstate_reducer import MessageReducer
+from langgraph_checkpoint_firestore import FirestoreSaver
+
+reducer = MessageReducer(min_messages=10, max_messages=20)
+
+with FirestoreSaver.from_conn_info(
+    project_id="my-gcp-project",
+    checkpoints_collection="checkpoints",
+    reducer=reducer,        # prune before each checkpoint save
+    messages_key="messages" # state channel holding the message list (default)
+) as checkpointer:
+    graph = builder.compile(checkpointer=checkpointer)
+```
+
+When `len(messages) > max_messages`, the oldest `human`/`ai` messages are removed until `min_messages` remain. The following are **never** pruned:
+
+- Index 0 (typically the system prompt) — controlled by `preserve_first=True`
+- `system` and `function` messages
+- `tool` messages — unless their parent `ai` message is pruned (cascade behaviour, configurable)
+
+See [agentstate-reducer on PyPI](https://pypi.org/project/agentstate-reducer/) for full configuration: `preserve_first`, `cascade_tool_messages`, `summarize_fn`, and role alias support (`user`/`assistant`/`agent`).
+
+## Data Model
+
+Checkpoints are stored in a hierarchical Firestore structure:
+
+```
+{checkpoints_collection}/
+  {thread_id}_{checkpoint_ns}/          ← partition document
+    checkpoints/
+      {checkpoint_id}                   ← checkpoint document
+        writes/
+          {task_id}_{idx}               ← pending write documents
+```
+
+This structure enables efficient per-thread checkpoint queries and keeps checkpoint data co-located with its pending writes.
+
+## License
+
+MIT

langgraph_checkpoint_firestore-0.2.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+langgraph_checkpoint_firestore/LICENSE,sha256=6kbiFSfobTZ7beWiKnHpN902HgBx-Jzgcme0SvKqhKY,1091
+langgraph_checkpoint_firestore/__init__.py,sha256=pAPZVXuwPnlab62o-Q2nQMc62eeqRxSSaw3Zjm2GGYI,189
+langgraph_checkpoint_firestore/firestoreSaver.py,sha256=dZklpzOw6JDdwek1cGO7kSGeilYUCud0Mh5E_pOgb-A,14932
+langgraph_checkpoint_firestore/firestoreSerializer.py,sha256=xL2a7MVu47n0vxir4arpSkbP4mpSUWLiiFCEmQLPXJY,513
+langgraph_checkpoint_firestore-0.2.0.dist-info/METADATA,sha256=QVZ854MZauxBExnHxRxaMLVVgjymgAjrUuG3g4g1vAo,7685
+langgraph_checkpoint_firestore-0.2.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+langgraph_checkpoint_firestore-0.2.0.dist-info/RECORD,,

langgraph_checkpoint_firestore-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any