langgraph_checkpoint_firestore 0.2.0__tar.gz

langgraph_checkpoint_firestore-0.2.0/.gitignore

@@ -0,0 +1,42 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Distribution / packaging
+dist/
+build/
+*.egg-info/
+
+# Virtual environments
+venv/
+env/
+.env/
+.venv/
+ENV/
+
+# IDE specific files
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Unit test / coverage reports
+htmcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# Environment variables
+.env
+
+# Local development settings
+*.log
+.DS_Store

langgraph_checkpoint_firestore-0.2.0/CHANGELOG.md

@@ -0,0 +1,18 @@
+# Changelog
+
+## [0.1.7]
+### Changed
+- Subgraph support
+- Performance fix
+- Update for langraph 1.0.1
+
+## [0.1.4]
+### Changed
+- Async support
+
+## [0.1.3]
+
+- **Added**: Configurable checkpoint and writes collection feature.
+- **Fixed**: List function bug.
+
+This version introduces a new configurable checkpoint and writes collection feature

langgraph_checkpoint_firestore-0.2.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,167 @@
+# 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/pyproject.toml

@@ -0,0 +1,57 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "langgraph_checkpoint_firestore"
+version = "0.2.0"
+description = "LangGraph checkpoint saver for Google Firestore with built-in message history pruning via agentstate-reducer"
+authors = [{name = "Kamal", email = "skamalj@github.com"}]
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "langchain-core",
+    "langgraph",
+    "google-cloud-firestore"
+]
+keywords = [
+    "langgraph", "checkpoint", "firestore", "google-cloud",
+    "message-reducer", "agent-state", "memory", "langchain"
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+
+[project.optional-dependencies]
+reducer = [
+    "agentstate-reducer>=0.1.1",
+]
+dev = [
+    "pytest>=7.0",
+    "pytest-cov",
+    "black",
+    "isort",
+    "mypy"
+]
+
+[dependency-groups]
+dev = [
+    "pytest>=7.0",
+    "pytest-cov",
+    "langchain-openai",
+    "langgraph-checkpoint-firestore[reducer]",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/langgraph_checkpoint_firestore"]
+
+[tool.black]
+line-length = 88
+target-version = ['py39']
+
+[tool.isort]
+profile = "black"
+multi_line_output = 3

langgraph_checkpoint_firestore-0.2.0/readme.md

@@ -0,0 +1,167 @@
+# 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/src/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-0.2.0/src/langgraph_checkpoint_firestore/__init__.py

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