Add windows CLI testing

lib: For subgraphs / stream modes call stream.put as a callback in the original event loop

.github/ISSUE_TEMPLATE/bug-report.yml

@@ -1,5 +1,5 @@
 name: "\U0001F41B Bug Report"
-description: Report a bug in LangChain. To report a security issue, please instead use the security option below. For questions, please use the GitHub Discussions.
+description: Report a bug in LangGraph. To report a security issue, please instead use the security option below. For questions, please use the GitHub Discussions.
 labels: ["02 Bug Report"]
 body:
   - type: markdown
@@ -15,11 +15,11 @@ body:
         Relevant links to check before filing a bug report to see if your issue has already been reported, fixed or
         if there's another way to solve your problem:
         
+        [LangGraph documentation](https://langchain-ai.github.io/langgraph/).
         [LangChain documentation with the integrated search](https://python.langchain.com/docs/get_started/introduction),
-        [API Reference](https://api.python.langchain.com/en/stable/),
-        [GitHub search](https://github.com/langchain-ai/langchain),
-        [LangChain Github Discussions](https://github.com/langchain-ai/langchain/discussions),
-        [LangChain Github Issues](https://github.com/langchain-ai/langchain/issues?q=is%3Aissue),
+        [GitHub search](https://github.com/langchain-ai/langgraph),
+        [LangChain Github Discussions](https://github.com/langchain-ai/langgraph/discussions),
+        [LangChain Github Issues](https://github.com/langchain-ai/langgraph/issues),
         [LangChain ChatBot](https://chat.langchain.com/)
   - type: checkboxes
     id: checks
@@ -54,13 +54,13 @@ body:
         * Avoid screenshots when possible, as they are hard to read and (more importantly) don't allow others to copy-and-paste your code.
 
       placeholder: |
-        from langchain_core.runnables import RunnableLambda
+        from langgraph.graph import StateGraph
 
         def bad_code(inputs) -> int:
           raise NotImplementedError('For demo purpose')
           
-          chain = RunnableLambda(bad_code)
-          chain.invoke('Hello!')
+        chain = StateGraph(list)
+        chain.invoke('Hello!')
       render: python
   - type: textarea
     id: error
@@ -82,7 +82,7 @@ body:
 
         Write a short description telling what you are doing, what you expect to happen, and what is currently happening.
       placeholder: |
-        * I'm trying to use the `langchain` library to do X.
+        * I'm trying to use the `langgraph` library to do X.
         * I expect to see Y.
         * Instead, it does Z.
     validations:
@@ -102,7 +102,7 @@ body:
         
         python -m langchain_core.sys_info
       placeholder: |
-        "pip freeze | grep langchain"
+        "pip freeze | grep langgraph"
         platform
         python version
         

.github/ISSUE_TEMPLATE/config.yml

@@ -3,13 +3,13 @@ version: 2.1
 contact_links:
   - name: 🤔 Question or Problem
     about: Ask a question or ask about a problem in GitHub Discussions.
-    url: https://www.github.com/langchain-ai/langchain/discussions/categories/q-a
-  - name: Discord
-    url: https://discord.gg/6adMQxSpJS
-    about: General community discussions
+    url: https://github.com/langchain-ai/langgraph/discussions/categories/q-a
   - name: Feature Request
-    url: https://www.github.com/langchain-ai/langchain/discussions/categories/ideas
+    url: https://github.com/langchain-ai/langgraph/discussions/categories/ideas
     about: Suggest a feature or an idea
   - name: Show and tell
     about: Show what you built with LangChain
-    url: https://www.github.com/langchain-ai/langchain/discussions/categories/show-and-tell
+    url: https://github.com/langchain-ai/langgraph/discussions/categories/show-and-tell
+  - name: Slack
+    url:  https://www.langchain.com/join-community
+    about: General community discussions

.github/ISSUE_TEMPLATE/documentation.yml

@@ -1,5 +1,5 @@
 name: Documentation
-description: Report an issue related to the LangChain documentation.
+description: Report an issue related to the LangGraph documentation.
 title: "DOC: <Please write a comprehensive title after the 'DOC: ' prefix>"
 labels: [03 - Documentation]
 

.github/scripts/check_sdk_methods.py

@@ -0,0 +1,64 @@
+import ast
+import os
+from itertools import filterfalse
+from typing import List, Tuple
+
+ROOT_PATH = os.path.abspath(os.path.join(__file__, "..", "..", ".."))
+CLIENT_PATH = os.path.join(ROOT_PATH, "libs", "sdk-py", "langgraph_sdk", "client.py")
+
+
+def get_class_methods(node: ast.ClassDef) -> List[str]:
+    return [n.name for n in node.body if isinstance(n, (ast.FunctionDef, ast.AsyncFunctionDef))]
+
+
+def find_classes(tree: ast.AST) -> List[Tuple[str, List[str]]]:
+    classes = []
+    for node in ast.walk(tree):
+        if isinstance(node, ast.ClassDef):
+            methods = get_class_methods(node)
+            classes.append((node.name, methods))
+    return classes
+
+
+def compare_sync_async_methods(sync_methods: List[str], async_methods: List[str]) -> List[str]:
+    sync_set = set(sync_methods)
+    async_set = set(async_methods)
+    missing_in_sync = list(async_set - sync_set)
+    missing_in_async = list(sync_set - async_set)
+    return missing_in_sync + missing_in_async
+
+
+def main():
+    with open(CLIENT_PATH, "r") as file:
+        tree = ast.parse(file.read())
+
+    classes = find_classes(tree)
+  
+    def is_sync(class_spec: Tuple[str, List[str]]) -> bool:
+        return class_spec[0].startswith("Sync")
+
+    sync_class_name_to_methods = {class_name: class_methods for class_name, class_methods in filter(is_sync, classes)}
+    async_class_name_to_methods = {class_name: class_methods for class_name, class_methods in filterfalse(is_sync, classes)}
+
+    mismatches = []
+
+    for async_class_name, async_class_methods in async_class_name_to_methods.items():
+        sync_class_name = "Sync" + async_class_name
+        sync_class_methods = sync_class_name_to_methods.get(sync_class_name, [])
+        diff = compare_sync_async_methods(sync_class_methods, async_class_methods)
+        if diff:
+            mismatches.append((sync_class_name, async_class_name, diff))
+
+    if mismatches:
+        error_message = "Mismatches found between sync and async client methods:\n"
+        for sync_class_name, async_class_name, diff in mismatches:
+            error_message += f"{sync_class_name} vs {async_class_name}:\n"
+            for method in diff:
+                error_message += f"  - {method}\n"
+        raise ValueError(error_message)
+
+    print("All sync and async client methods match.")
+
+
+if __name__ == "__main__":
+    main()

.github/scripts/run_langgraph_cli_test.py

@@ -0,0 +1,115 @@
+import asyncio
+import json
+import os
+import pathlib
+import sys
+import langgraph_cli
+import langgraph_cli.docker
+import langgraph_cli.config
+
+from langgraph_cli.exec import Runner, subp_exec
+from langgraph_cli.progress import Progress
+from langgraph_cli.constants import DEFAULT_PORT
+
+
+def test(
+    config: pathlib.Path,
+    port: int,
+    tag: str,
+    verbose: bool,
+):
+    with Runner() as runner, Progress(message="Pulling...") as set:
+        # check docker available
+        capabilities = langgraph_cli.docker.check_capabilities(runner)
+        # open config
+        config_json = langgraph_cli.config.validate_config_file(config)
+
+        set("Running...")
+        args = [
+            "run",
+            "--rm",
+            "-p",
+            f"{port}:8000",
+        ]
+        if isinstance(config_json["env"], str):
+            args.extend(
+                [
+                    "--env-file",
+                    str(config.parent / config_json["env"]),
+                ]
+            )
+        else:
+            for k, v in config_json["env"].items():
+                args.extend(
+                    [
+                        "-e",
+                        f"{k}={v}",
+                    ]
+                )
+        if capabilities.healthcheck_start_interval:
+            args.extend(
+                [
+                    "--health-interval",
+                    "5s",
+                    "--health-retries",
+                    "1",
+                    "--health-start-period",
+                    "10s",
+                    "--health-start-interval",
+                    "1s",
+                ]
+            )
+        else:
+            args.extend(
+                [
+                    "--health-interval",
+                    "5s",
+                    "--health-retries",
+                    "2",
+                ]
+            )
+
+        _task = None
+
+        def on_stdout(line: str):
+            nonlocal _task
+            if "GET /ok" in line or "Uvicorn running on" in line:
+                set("")
+                sys.stdout.write(
+                    f"""Ready!
+- API: http://localhost:{port}
+"""
+                )
+                sys.stdout.flush()
+                _task.cancel()
+                return True
+            return False
+
+        async def subp_exec_task(*args, **kwargs):
+            nonlocal _task
+            _task = asyncio.create_task(subp_exec(*args, **kwargs))
+            await _task
+
+        try:
+            runner.run(
+                subp_exec_task(
+                    "docker",
+                    *args,
+                    tag,
+                    verbose=verbose,
+                    on_stdout=on_stdout,
+                )
+            )
+        except asyncio.CancelledError:
+            pass
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-t", "--tag", type=str)
+    parser.add_argument("-c", "--config", type=str, default="./langgraph.json")
+    parser.add_argument("-p", "--port", default=DEFAULT_PORT)
+    args = parser.parse_args()
+    test(pathlib.Path(args.config), args.port, args.tag, verbose=True)

.github/workflows/_integration_test.yml

@@ -12,8 +12,9 @@ jobs:
     strategy:
       matrix:
         python-version:
+          - "3.10"
           - "3.11"
-    name: "CLI integration test"
+    name: "CLI integration test (Linux)"
     defaults:
       run:
         working-directory: libs/cli
@@ -21,7 +22,7 @@ jobs:
       - uses: actions/checkout@v4
       - name: Get changed files
         id: changed-files
-        uses: Ana06/get-changed-files@v2.2.0
+        uses: Ana06/get-changed-files@v2.3.0
         with:
           filter: "libs/cli/**"
       - name: Set up Python ${{ matrix.python-version }} + Poetry ${{ env.POETRY_VERSION }}
@@ -38,22 +39,94 @@ jobs:
       - name: Install cli globally
         if: steps.changed-files.outputs.all
         run: pip install -e .
-      - name: Start service A
+      - name: Build and test service A
         if: steps.changed-files.outputs.all
+        working-directory: libs/cli/examples
         run: |
-          timeout 60 langgraph test -c examples/langgraph.json --verbose || (exit "$(($? == 124 ? 0 : $?))")
-      - name: Start service B
+          # The build-arg isn't used; just testing that we accept other args
+          langgraph build -t langgraph-test-a  --base-image "langchain/langgraph-trial"
+          cp .env.example .envg
+          timeout 60 python ../../../.github/scripts/run_langgraph_cli_test.py -c langgraph.json -t langgraph-test-a
+      - name: Build and test service B
         if: steps.changed-files.outputs.all
         working-directory: libs/cli/examples/graphs
         run: |
-          timeout 60 langgraph test --verbose || (exit "$(($? == 124 ? 0 : $?))")
-      - name: Start service C
+          langgraph build -t langgraph-test-b  --base-image "langchain/langgraph-trial"
+          timeout 60 python ../../../../.github/scripts/run_langgraph_cli_test.py -t langgraph-test-b
+      - name: Build and test service C
         if: steps.changed-files.outputs.all
         working-directory: libs/cli/examples/graphs_reqs_a
         run: |
-          timeout 60 langgraph test --verbose || (exit "$(($? == 124 ? 0 : $?))")
-      - name: Start service D
+          langgraph build -t langgraph-test-c  --base-image "langchain/langgraph-trial"
+          timeout 60 python ../../../../.github/scripts/run_langgraph_cli_test.py -t langgraph-test-c
+      - name: Build and test service D
         if: steps.changed-files.outputs.all
         working-directory: libs/cli/examples/graphs_reqs_b
         run: |
-          timeout 60 langgraph test --verbose || (exit "$(($? == 124 ? 0 : $?))")
+          langgraph build -t langgraph-test-d  --base-image "langchain/langgraph-trial"
+          timeout 60 python ../../../../.github/scripts/run_langgraph_cli_test.py -t langgraph-test-d
+
+      - name: Build JS service
+        if: steps.changed-files.outputs.all
+        working-directory: libs/cli/js-examples
+        run: |
+          langgraph build -t langgraph-test-e
+  
+  windows-build:
+    runs-on: windows-latest
+    name: "CLI integration test (Windows)"
+    defaults:
+      run:
+        working-directory: libs/cli
+        shell: bash
+    steps:
+      - uses: actions/checkout@v4
+      - name: Get changed files
+        id: changed-files
+        uses: Ana06/get-changed-files@v2.3.0
+        with:
+          filter: "libs/cli/**"
+      - name: Set up Python 3.11 + Poetry ${{ env.POETRY_VERSION }}
+        if: steps.changed-files.outputs.all
+        uses: "./.github/actions/poetry_setup"
+        with:
+          python-version: "3.11"
+          poetry-version: ${{ env.POETRY_VERSION }}
+          cache-key: integration-test-cli-windows
+      - name: Setup env
+        if: steps.changed-files.outputs.all
+        working-directory: libs/cli/examples
+        run: cp .env.example .env
+      - name: Install cli globally
+        if: steps.changed-files.outputs.all
+        run: pip install -e .
+      - name: Build and test service A
+        if: steps.changed-files.outputs.all
+        working-directory: libs/cli/examples
+        run: |
+          langgraph build -t langgraph-test-a  --base-image "langchain/langgraph-trial"
+          cp .env.example .envg
+          timeout 60 python ../../../.github/scripts/run_langgraph_cli_test.py -c langgraph.json -t langgraph-test-a
+      - name: Build and test service B
+        if: steps.changed-files.outputs.all
+        working-directory: libs/cli/examples/graphs
+        run: |
+          langgraph build -t langgraph-test-b  --base-image "langchain/langgraph-trial"
+          timeout 60 python ../../../../.github/scripts/run_langgraph_cli_test.py -t langgraph-test-b
+      - name: Build and test service C
+        if: steps.changed-files.outputs.all
+        working-directory: libs/cli/examples/graphs_reqs_a
+        run: |
+          langgraph build -t langgraph-test-c  --base-image "langchain/langgraph-trial"
+          timeout 60 python ../../../../.github/scripts/run_langgraph_cli_test.py -t langgraph-test-c
+      - name: Build and test service D
+        if: steps.changed-files.outputs.all
+        working-directory: libs/cli/examples/graphs_reqs_b
+        run: |
+          langgraph build -t langgraph-test-d  --base-image "langchain/langgraph-trial"
+          timeout 60 python ../../../../.github/scripts/run_langgraph_cli_test.py -t langgraph-test-d
+      - name: Build JS service
+        if: steps.changed-files.outputs.all
+        working-directory: libs/cli/js-examples
+        run: |
+          langgraph build -t langgraph-test-e

.github/workflows/_lint.yml

@@ -27,14 +27,13 @@ jobs:
         # Starting new jobs is also relatively slow,
         # so linting on fewer versions makes CI faster.
         python-version:
-          - "3.9"
-          - "3.11"
+          - "3.12"
     name: "lint #${{ matrix.python-version }}"
     steps:
       - uses: actions/checkout@v4
       - name: Get changed files
         id: changed-files
-        uses: Ana06/get-changed-files@v2.2.0
+        uses: Ana06/get-changed-files@v2.3.0
         with:
           filter: "${{ inputs.working-directory }}/**"
       - name: Set up Python ${{ matrix.python-version }} + Poetry ${{ env.POETRY_VERSION }}
@@ -44,7 +43,7 @@ jobs:
           python-version: ${{ matrix.python-version }}
           poetry-version: ${{ env.POETRY_VERSION }}
           working-directory: ${{ inputs.working-directory }}
-          cache-key: lint-with-extras
+          cache-key: lint-${{ inputs.working-directory }}
 
       - name: Check Poetry File
         if: steps.changed-files.outputs.all

.github/workflows/_test.yml

@@ -21,38 +21,38 @@ jobs:
           - "3.10"
           - "3.11"
           - "3.12"
+          - "3.13"
+
     name: "test #${{ matrix.python-version }}"
     steps:
       - uses: actions/checkout@v4
-      - name: Get changed files
-        id: changed-files
-        uses: Ana06/get-changed-files@v2.2.0
-        with:
-          filter: "${{ inputs.working-directory }}/**"
       - name: Set up Python ${{ matrix.python-version }} + Poetry ${{ env.POETRY_VERSION }}
-        if: steps.changed-files.outputs.all
         uses: "./.github/actions/poetry_setup"
         with:
           python-version: ${{ matrix.python-version }}
           poetry-version: ${{ env.POETRY_VERSION }}
           working-directory: ${{ inputs.working-directory }}
-          cache-key: core
+          cache-key: test-${{ inputs.working-directory }}
+      - name: Login to Docker Hub
+        uses: docker/login-action@v3
+        if: ${{ !github.event.pull_request.head.repo.fork }}
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_RO_TOKEN }}
 
       - name: Install dependencies
-        if: steps.changed-files.outputs.all
         shell: bash
         working-directory: ${{ inputs.working-directory }}
-        run: poetry install --with dev
+        run: |
+          poetry install --with dev
 
-      - name: Run core tests
-        if: steps.changed-files.outputs.all
+      - name: Run tests
         shell: bash
         working-directory: ${{ inputs.working-directory }}
         run: |
           make test
 
       - name: Ensure the tests did not create any additional files
-        if: steps.changed-files.outputs.all
         shell: bash
         working-directory: ${{ inputs.working-directory }}
         run: |

.github/workflows/_test_langgraph.yml

@@ -0,0 +1,75 @@
+name: test
+
+on:
+  workflow_call:
+
+env:
+  POETRY_VERSION: "1.7.1"
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version:
+          - "3.9"
+          - "3.10"
+          - "3.11"
+          - "3.12"
+          - "3.13"
+        core-version:
+          - "latest"
+        ff-send-v2:
+          - "false"
+        include:
+          - python-version: "3.11"
+            core-version: ">=0.2.42,<0.3.0"
+          - python-version: "3.11"
+            core-version: "latest"
+            ff-send-v2: "true"
+
+    defaults:
+      run:
+        working-directory: libs/langgraph
+    name: "test #${{ matrix.python-version }} (langchain-core: ${{ matrix.core-version }}, ff-send-v2: ${{ matrix.ff-send-v2 }})"
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Python ${{ matrix.python-version }} + Poetry ${{ env.POETRY_VERSION }}
+        uses: "./.github/actions/poetry_setup"
+        with:
+          python-version: ${{ matrix.python-version }}
+          poetry-version: ${{ env.POETRY_VERSION }}
+          cache-key: test-langgraph
+      - name: Login to Docker Hub
+        uses: docker/login-action@v3
+        if: ${{ !github.event.pull_request.head.repo.fork }}
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_RO_TOKEN }}
+
+      - name: Install dependencies
+        shell: bash
+        run: |
+          poetry install --with dev
+          if [ "${{ matrix.core-version }}" != "latest" ]; then
+            poetry run pip install "langchain-core${{ matrix.core-version }}"
+          fi
+
+      - name: Run tests
+        shell: bash
+        env:
+          LANGGRAPH_FF_SEND_V2: ${{ matrix.ff-send-v2 }}
+        run: |
+          make test
+
+      - name: Ensure the tests did not create any additional files
+        shell: bash
+        run: |
+          set -eu
+
+          STATUS="$(git status)"
+          echo "$STATUS"
+
+          # grep will exit non-zero if the target message isn't found,
+          # and `set -e` above will cause the step to fail.
+          echo "$STATUS" | grep 'nothing to commit, working tree clean'

.github/workflows/_test_release.yml

@@ -93,3 +93,5 @@ jobs:
           # This is *only for CI use* and is *extremely dangerous* otherwise!
           # https://github.com/pypa/gh-action-pypi-publish#tolerating-release-package-file-duplicates
           skip-existing: true
+          # Temp workaround since attestations are on by default as of gh-action-pypi-publish v1.11.0
+          attestations: false

.github/workflows/_test_scheduler_kafka.yml

@@ -0,0 +1,57 @@
+name: test
+
+on:
+  workflow_call:
+
+env:
+  POETRY_VERSION: "1.7.1"
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version:
+          - "3.11"
+          - "3.12"
+
+    defaults:
+      run:
+        working-directory: libs/scheduler-kafka
+    name: "test #${{ matrix.python-version }}"
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Python ${{ matrix.python-version }} + Poetry ${{ env.POETRY_VERSION }}
+        uses: "./.github/actions/poetry_setup"
+        with:
+          python-version: ${{ matrix.python-version }}
+          poetry-version: ${{ env.POETRY_VERSION }}
+          cache-key: test-scheduler-kafka
+      - name: Login to Docker Hub
+        uses: docker/login-action@v3
+        if: ${{ !github.event.pull_request.head.repo.fork }}
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_RO_TOKEN }}
+
+      - name: Install dependencies
+        shell: bash
+        run: |
+          poetry install --with dev
+
+      - name: Run tests
+        shell: bash
+        run: |
+          make test
+
+      - name: Ensure the tests did not create any additional files
+        shell: bash
+        run: |
+          set -eu
+
+          STATUS="$(git status)"
+          echo "$STATUS"
+
+          # grep will exit non-zero if the target message isn't found,
+          # and `set -e` above will cause the step to fail.
+          echo "$STATUS" | grep 'nothing to commit, working tree clean'

.github/workflows/baseline.yml

@@ -0,0 +1,37 @@
+name: baseline
+
+on:
+  workflow_dispatch:
+  push:
+    branches: [main]
+    paths:
+      - "libs/**"
+
+env:
+  POETRY_VERSION: "1.7.1"
+
+jobs:
+  benchmark:
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: libs/langgraph
+    steps:
+      - uses: actions/checkout@v4
+      - run: SHA=$(git rev-parse HEAD) && echo "SHA=$SHA" >> $GITHUB_ENV
+      - name: Set up Python 3.11 + Poetry ${{ env.POETRY_VERSION }}
+        uses: "./.github/actions/poetry_setup"
+        with:
+          python-version: "3.11"
+          poetry-version: ${{ env.POETRY_VERSION }}
+          cache-key: bench
+      - name: Install dependencies
+        run: poetry install --with dev
+      - name: Run benchmarks
+        run: OUTPUT=out/benchmark-baseline.json make -s benchmark
+      - name: Save outputs
+        uses: actions/cache/save@v4
+        with:
+          key: ${{ runner.os }}-benchmark-baseline-${{ env.SHA }}
+          path: |
+            libs/langgraph/out/benchmark-baseline.json

.github/workflows/bench.yml

@@ -0,0 +1,71 @@
+name: bench
+
+on:
+  pull_request:
+    paths:
+      - "libs/**"
+
+env:
+  POETRY_VERSION: "1.7.1"
+
+jobs:
+  benchmark:
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: libs/langgraph
+    steps:
+      - uses: actions/checkout@v4
+      - id: files
+        name: Get changed files
+        uses: Ana06/get-changed-files@v2.3.0
+        with:
+          format: json
+      - name: Set up Python 3.11 + Poetry ${{ env.POETRY_VERSION }}
+        uses: "./.github/actions/poetry_setup"
+        with:
+          python-version: "3.11"
+          poetry-version: ${{ env.POETRY_VERSION }}
+          cache-key: bench
+      - name: Install dependencies
+        run: poetry install --with dev
+      - name: Download baseline
+        uses: actions/cache/restore@v4
+        with:
+          key: ${{ runner.os }}-benchmark-baseline
+          restore-keys: |
+            ${{ runner.os }}-benchmark-baseline-
+          fail-on-cache-miss: true
+          path: |
+            libs/langgraph/out/benchmark-baseline.json
+      - name: Run benchmarks
+        id: benchmark
+        run: |
+          {
+            echo 'OUTPUT<<EOF'
+            make -s benchmark
+            echo EOF
+          } >> "$GITHUB_OUTPUT"
+      - name: Compare benchmarks
+        id: compare
+        run: |
+          {
+            echo 'OUTPUT<<EOF'
+            mv out/benchmark-baseline.json out/main.json
+            mv out/benchmark.json out/changes.json
+            poetry run pyperf compare_to out/main.json out/changes.json --table --group-by-speed
+            echo EOF
+          } >> "$GITHUB_OUTPUT"
+      - name: Annotation
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const file = JSON.parse(`${{ steps.files.outputs.added_modified_renamed }}`)[0]
+            core.notice(`${{ steps.benchmark.outputs.OUTPUT }}`, {
+              title: 'Benchmark results',
+              file,
+            })
+            core.notice(`${{ steps.compare.outputs.OUTPUT }}`, {
+              title: 'Comparison against main',
+              file,
+            })

.github/workflows/ci.yml

@@ -1,108 +1,128 @@
 ---
-    name: CI
+name: CI
 
-    on:
-      push:
-        branches: [main]
-      pull_request:
+on:
+  push:
+    branches: [main]
+  pull_request:
 
-    # If another push to the same PR or branch happens while this workflow is still running,
-    # cancel the earlier run in favor of the next run.
-    #
-    # There's no point in testing an outdated version of the code. GitHub only allows
-    # a limited number of job runners to be active at the same time, so it's better to cancel
-    # pointless jobs early so that more useful jobs can run sooner.
-    concurrency:
-      group: ${{ github.workflow }}-${{ github.ref }}
-      cancel-in-progress: true
+# If another push to the same PR or branch happens while this workflow is still running,
+# cancel the earlier run in favor of the next run.
+#
+# There's no point in testing an outdated version of the code. GitHub only allows
+# a limited number of job runners to be active at the same time, so it's better to cancel
+# pointless jobs early so that more useful jobs can run sooner.
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
 
+env:
+  POETRY_VERSION: "1.7.1"
+
+jobs:
+  lint:
+    name: cd ${{ matrix.working-directory }}
+    strategy:
+      matrix:
+        working-directory:
+          [
+            "libs/langgraph",
+            "libs/sdk-py",
+            "libs/cli",
+            "libs/checkpoint",
+            "libs/checkpoint-sqlite",
+            "libs/checkpoint-duckdb",
+            "libs/checkpoint-postgres",
+            "libs/scheduler-kafka",
+          ]
+    uses: ./.github/workflows/_lint.yml
+    with:
+      working-directory: ${{ matrix.working-directory }}
+    secrets: inherit
+
+  test:
+    name: cd ${{ matrix.working-directory }}
+    strategy:
+      matrix:
+        working-directory: [
+            "libs/cli",
+            "libs/checkpoint",
+            "libs/checkpoint-sqlite",
+            "libs/checkpoint-duckdb",
+            "libs/checkpoint-postgres"
+          ]
+    uses: ./.github/workflows/_test.yml
+    with:
+      working-directory: ${{ matrix.working-directory }}
+    secrets: inherit
+
+  # NOTE: we're testing langgraph separately because it requires a different matrix
+  test-langgraph:
+    name: "cd libs/langgraph"
+    uses: ./.github/workflows/_test_langgraph.yml
+    secrets: inherit
+
+  # NOTE: we're testing scheduler-kafka separately because it requires a different matrix
+  test-scheduler-kafka:
+    name: "cd libs/scheduler-kafka"
+    uses: ./.github/workflows/_test_scheduler_kafka.yml
+    secrets: inherit
+
+  check-sdk-methods:
+    name: "Check SDK methods matching"
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+      - name: Run check_sdk_methods script
+        run: python .github/scripts/check_sdk_methods.py
+
+  integration-test:
+    name: CLI integration test
+    uses: ./.github/workflows/_integration_test.yml
+    secrets: inherit
+
+  lint-js:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        working-directory:
+          - "libs/sdk-js"
+    defaults:
+      run:
+        working-directory: ${{ matrix.working-directory }}
+    steps:
+      - uses: actions/checkout@v3
+      - name: Setup Node.js (LTS)
+        uses: actions/setup-node@v3
+        with:
+          node-version: "20"
+          cache: "yarn"
+          cache-dependency-path: ${{ matrix.working-directory }}/yarn.lock
+      - name: Install dependencies
+        run: yarn install
+      - name: Run lint
+        run: yarn lint
+      - name: Build
+        run: yarn build
+
+  ci_success:
+    name: "CI Success"
+    needs: [lint, lint-js, test, test-langgraph, test-scheduler-kafka, integration-test]
+    if: |
+      always()
+    runs-on: ubuntu-latest
     env:
-      POETRY_VERSION: "1.7.1"
-
-    jobs:
-      build:
-        runs-on: ubuntu-latest
-        steps:
-          - uses: actions/checkout@v4
-          - uses: actions/setup-python@v5
-            with:
-              python-version: '3.10'
-
-      lint:
-        name: cd ${{ matrix.working-directory }}
-        needs: [ build ]
-        strategy:
-          matrix:
-            working-directory: [
-                "libs/langgraph",
-                "libs/sdk-py",
-                "libs/cli"
-            ]
-        uses: ./.github/workflows/_lint.yml
-        with:
-          working-directory: ${{ matrix.working-directory }}
-        secrets: inherit
-
-      test:
-        name: cd ${{ matrix.working-directory }}
-        needs: [ build ]
-        strategy:
-          matrix:
-            working-directory: [
-                "libs/langgraph",
-                "libs/cli"
-            ]
-        uses: ./.github/workflows/_test.yml
-        with:
-          working-directory: ${{ matrix.working-directory }}
-        secrets: inherit
-
-      integration-test:
-        name: CLI integration test
-        needs: [ build ]
-        uses: ./.github/workflows/_integration_test.yml
-        secrets: inherit
-
-      lint-js:
-        runs-on: ubuntu-latest
-        needs: [ build ]
-        strategy:
-          matrix:
-            working-directory:
-              - "libs/sdk-js"
-        defaults:
-          run:
-            working-directory: ${{ matrix.working-directory }}
-        steps:
-          - uses: actions/checkout@v3
-          - name: Setup Node.js (LTS)
-            uses: actions/setup-node@v3
-            with:
-              node-version: "20"
-              cache: "yarn"
-              cache-dependency-path: ${{ matrix.working-directory }}/yarn.lock
-          - name: Install dependencies
-            run: yarn install
-          - name: Run lint
-            run: yarn lint
-          - name: Build
-            run: yarn build
-
-      ci_success:
-        name: "CI Success"
-        needs: [build, lint, lint-js, test, integration-test]
-        if: |
-          always()
-        runs-on: ubuntu-latest
-        env:
-          JOBS_JSON: ${{ toJSON(needs) }}
-          RESULTS_JSON: ${{ toJSON(needs.*.result) }}
-          EXIT_CODE: ${{!contains(needs.*.result, 'failure') && !contains(needs.*.result, 'cancelled') && '0' || '1'}}
-        steps:
-          - name: "CI Success"
-            run: |
-              echo $JOBS_JSON
-              echo $RESULTS_JSON
-              echo "Exiting with $EXIT_CODE"
-              exit $EXIT_CODE
-    
+      JOBS_JSON: ${{ toJSON(needs) }}
+      RESULTS_JSON: ${{ toJSON(needs.*.result) }}
+      EXIT_CODE: ${{!contains(needs.*.result, 'failure') && !contains(needs.*.result, 'cancelled') && '0' || '1'}}
+    steps:
+      - name: "CI Success"
+        run: |
+          echo $JOBS_JSON
+          echo $RESULTS_JSON
+          echo "Exiting with $EXIT_CODE"
+          exit $EXIT_CODE

.github/workflows/codespell.yml

@@ -32,7 +32,7 @@
           - name: Codespell
             uses: codespell-project/actions-codespell@v2
             with:
-              skip: '*.ambr,*.lock,*.ipynb'
+              skip: '*.ambr,*.lock,*.ipynb,*.yaml,*.zlib'
               ignore_words_list: ${{ steps.extract_ignore_words.outputs.ignore_words_list }}
           # We do this to avoid spellchecking cell outputs
           - name: Codespell Notebooks

.github/workflows/deploy_docs.yml

@@ -22,8 +22,30 @@ concurrency:
   cancel-in-progress: false
 
 jobs:
-  deploy:
+  get-changed-files:
     runs-on: ubuntu-latest
+    outputs:
+      changed-files: ${{ steps.changed-files.outputs.added_modified }}
+    steps:
+      - uses: actions/checkout@v4
+      - name: Get changed files
+        id: changed-files
+        uses: Ana06/get-changed-files@v2.3.0
+        with:
+          filter: "docs/docs/**"
+
+  run-changed-notebooks:
+    needs: get-changed-files
+    uses: ./.github/workflows/run_notebooks.yml
+    secrets: inherit
+    with:
+      changed-files: ${{ needs.get-changed-files.outputs.changed-files }}
+
+  deploy:
+    # needs: run-changed-notebooks
+    runs-on: ubuntu-latest
+    env:
+      GITHUB_TOKEN: ${{ secrets.MKDOCS_GITHUB_TOKEN }}
     steps:
       - uses: actions/checkout@v4
         with:
@@ -38,13 +60,60 @@ jobs:
 
       - name: Install dependencies
         run: |
-          poetry install --with docs
+          poetry install --with test --no-root
+          poetry run pip install -U \
+            pytest \
+            pytest-check-links \
+            langsmith \
+            langchain \
+            GitPython \
+            "git+https://${GITHUB_TOKEN}@github.com/langchain-ai/mkdocs-material-insiders.git"
 
+      - name: Lint Docs
+        # This step lints the docs using the existing linting set up.
+        # It should be very fast and should not require any external services.
+        run: make lint-docs
       - name: Build site
         run: make build-docs
         env:
           MKDOCS_GIT_COMMITTERS_APIKEY: ${{ secrets.MKDOCS_GIT_COMMITTERS_APIKEY }}
 
+      - name: Check links in notebooks
+        env:
+          LANGCHAIN_API_KEY: test
+        run: |
+          if [ "${{ github.event_name }}" == "schedule" ] || [ "${{ github.event_name }}" == "workflow_dispatch" ] || ([ "${{ github.event_name }}" == "push" ] && [ "${{ github.ref }}" == "refs/heads/main" ]); then
+            echo "Running link check on all HTML files matching notebooks in docs directory..."
+            poetry run pytest -v \
+              --check-links-ignore "https://(api|web|docs)\.smith\.langchain\.com/.*" \
+              --check-links-ignore "https://x.com/.*" \
+              --check-links-ignore "https://github\.com/.*" \
+              --check-links-ignore "/.*\.(ipynb|html)$" \
+              --check-links-ignore "https://python\.langchain\.com/.*" \
+              --check-links-ignore "https://openai\.com/.*" \
+              --check-links-ignore "https://pepy\.tech/.*" \
+              --check-links $(find docs/site -name "index.html" | grep -v 'storm/index.html') 
+              
+          else
+            echo "Fetching changes from origin/main..."
+            git fetch origin main
+            echo "Checking for changed notebook files..."
+            CHANGED_FILES=$(git diff --name-only --diff-filter=d origin/main | grep 'docs/docs/.*\.ipynb$' | grep -v 'storm.ipynb' | sed -E 's|^docs/docs/|docs/site/|; s/\.ipynb$/\/index.html/' || true)
+            echo "Changed files: ${CHANGED_FILES}"
+            if [ -n "${CHANGED_FILES}" ]; then
+              echo "Running link check on HTML files matching changed notebook files..."
+              poetry run pytest -v \
+                --check-links-ignore "https://(api|web|docs)\.smith\.langchain\.com/.*" \
+                --check-links-ignore "https://x.com/.*" \
+                --check-links-ignore "https://github\.com/.*" \
+                --check-links-ignore "/.*\.(ipynb|html)$" \
+                --check-links ${CHANGED_FILES} \
+                || ([ $? = 5 ] && exit 0 || exit $?)
+            else
+              echo "No notebook files changed."
+            fi
+          fi
+
       - name: Configure GitHub Pages
         if: github.ref == 'refs/heads/main'
         uses: actions/configure-pages@v4
@@ -59,10 +128,3 @@ jobs:
         if: github.ref == 'refs/heads/main'
         id: deployment
         uses: actions/deploy-pages@v4
-
-      - name: Deploy Pull Request Preview
-        if: github.event_name == 'pull_request'
-        uses: actions/upload-artifact@v2
-        with:
-          name: pr-preview-${{ github.event.number }}
-          path: ./docs/site/

.github/workflows/link_check.yml

@@ -1,4 +1,4 @@
-name: Check Links
+name: Check Docs & Links
 
 on:
   pull_request:
@@ -26,46 +26,24 @@ jobs:
       - name: Check links in Markdown files
         uses: gaurav-nelson/github-action-markdown-link-check@v1
         with:
-          folder-path: "examples/"
+          folder-path: "docs/"
           check-modified-files-only: ${{ github.event_name != 'schedule' }}
           file-path: "./README.md"
           config-file: "./.markdown-link-check.config.json"
 
-  notebook-link-check:
+  check-readmes-synced:
+    # This checks that the repo README.md is identical to the libs/langgraph/README.md
     runs-on: ubuntu-latest
     steps:
       - name: Checkout code
         uses: actions/checkout@v4
-      - name: Set up Python 3.x + Poetry ${{ env.POETRY_VERSION }}
-        uses: "./.github/actions/poetry_setup"
         with:
-          python-version: "3.11"
-          poetry-version: ${{ env.POETRY_VERSION }}
-          cache-key: core
+          fetch-depth: 1
 
-      - name: Install dependencies
+      - name: Check README.md is in sync
         run: |
-          python -m pip install --upgrade pip
-          poetry install --with docs
-          poetry run pip install -U pytest pytest-check-links langsmith langchain GitPython
-
-      - name: Check links in notebooks
-        env:
-          LANGCHAIN_API_KEY: test
-        run: |
-          if [ "${{ github.event_name }}" == "schedule" ] || [ "${{ github.event_name }}" == "workflow_dispatch" ] || ([ "${{ github.event_name }}" == "push" ] && [ "${{ github.ref }}" == "refs/heads/main" ]); then
-            echo "Running link check on all notebooks in examples directory..."
-            poetry run pytest -v --check-links-ignore "https://(api|web)\.smith\.langchain\.com/.*" --check-links-ignore "https://x.com/.*" --check-links examples
-          else
-            echo "Fetching changes from origin/main..."
-            git fetch origin main
-            echo "Checking for changed notebook files..."
-            CHANGED_FILES=$(git diff --name-only origin/main | grep '\.ipynb$' || true)
-            echo "Changed files: ${CHANGED_FILES}"
-            if [ -n "${CHANGED_FILES}" ]; then
-              echo "Running link check on changed notebook files..."
-              poetry run pytest -v --check-links-ignore "https://(api|web)\.smith\.langchain\.com/.*" --check-links-ignore "https://x.com/.*" --check-links ${CHANGED_FILES} || ([ $? = 5 ] && exit 0 || exit $?)
-            else
-              echo "No notebook files changed."
+            if ! diff -q README.md libs/langgraph/README.md >/dev/null; then
+            echo "README.md is out of sync with libs/langgraph/README.md"
+            diff -C 3 README.md libs/langgraph/README.md
+            exit 1
             fi
-          fi

.github/workflows/release.yml

@@ -6,7 +6,7 @@ on:
       working-directory:
         required: true
         type: string
-        default: 'libs/langgraph'
+        default: "libs/langgraph"
 
 env:
   PYTHON_VERSION: "3.11"
@@ -99,12 +99,13 @@ jobs:
           TAG: ${{ needs.build.outputs.tag }}
         run: |
           if [ -z $SHORT_PKG_NAME ]; then
-            REGEX="^\\d+\\.\\d+\\.\\d+((a|b|rc)\\d+)?$"
+            REGEX="^\\d+\\.\\d+\\.\\d+((a|b|rc)\\d+)?\$"
           else
-            REGEX="^$SHORT_PKG_NAME==\\d+\\.\\d+\\.\\d+((a|b|rc)\\d+)?$"
+            REGEX="^$SHORT_PKG_NAME==\\d+\\.\\d+\\.\\d+((a|b|rc)\\d+)?\$"
           fi
           echo $REGEX
-          PREV_TAG=$(git tag --sort=-creatordate | grep -P $REGEX || true | head -1)
+          PREV_TAG=$(git tag --sort=-creatordate | grep -P $REGEX | head -1 || echo "")
+          echo $PREV_TAG
           if [ "$TAG" == "$PREV_TAG" ]; then
             echo "No new version to release"
             exit 1
@@ -135,8 +136,8 @@ jobs:
     needs:
       - build
       - release-notes
-    uses:
-      ./.github/workflows/_test_release.yml
+    permissions: write-all
+    uses: ./.github/workflows/_test_release.yml
     with:
       working-directory: ${{ inputs.working-directory }}
     secrets: inherit
@@ -196,9 +197,15 @@ jobs:
               "$PKG_NAME==$VERSION" \
           )
 
-          # Replace all dashes in the package name with underscores,
-          # since that's how Python imports packages with dashes in the name.
-          IMPORT_NAME="$(echo "$PKG_NAME" | sed s/-/_/g)"
+          if [[ "$PKG_NAME" == *checkpoint* ]]; then
+            # since checkpoint packages are namespace packages, import them with . convention
+            # i.e. import langgraph.checkpoint or langgraph.checkpoint.sqlite
+            IMPORT_NAME="$(echo "$PKG_NAME" | sed s/-/./g)"
+          else
+            # Replace all dashes in the package name with underscores,
+            # since that's how Python imports packages with dashes in the name.
+            IMPORT_NAME="$(echo "$PKG_NAME" | sed s/-/_/g)"
+          fi
 
           poetry run python -c "import $IMPORT_NAME; print(dir($IMPORT_NAME))"
 
@@ -263,6 +270,8 @@ jobs:
           packages-dir: ${{ inputs.working-directory }}/dist/
           verbose: true
           print-hash: true
+          # Temp workaround since attestations are on by default as of gh-action-pypi-publish v1.11.0
+          attestations: false
 
   mark-release:
     needs:

.github/workflows/run_notebooks.yml

@@ -0,0 +1,78 @@
+name: Run notebooks
+
+on:
+  workflow_dispatch:
+  workflow_call:
+    inputs:
+      changed-files:
+        required: false
+        type: string
+        description: "JSON string of changed files"
+  schedule:
+    - cron: '0 13 * * *'
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        lib-version:
+          - "development"
+          - "latest"
+
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Python + Poetry
+        uses: "./.github/actions/poetry_setup"
+        with:
+          python-version: 3.11
+          poetry-version: 1.7.1
+          cache-key: test-langgraph-notebooks
+
+      - name: Install dependencies
+        run: |
+          poetry install --with test
+          poetry run pip install jupyter
+
+      - name: Start services
+        run: make start-services
+
+      - name: Pre-download tiktoken files
+        run: |
+          poetry run python docs/_scripts/download_tiktoken.py
+
+      - name: Prepare notebooks
+        run: |
+          if [ "${{ matrix.lib-version }}" = "development" ]; then
+            poetry run python docs/_scripts/prepare_notebooks_for_ci.py --comment-install-cells
+          else
+            poetry run python docs/_scripts/prepare_notebooks_for_ci.py
+          fi
+
+      - name: Run notebooks
+        env:
+          # these won't actually be used because of the VCR cassettes
+          # but need to set them to avoid triggering getpass()
+          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
+          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+          TAVILY_API_KEY: ${{ secrets.TAVILY_API_KEY }}
+          LANGSMITH_API_KEY: ${{ secrets.LANGSMITH_API_KEY }}
+          NOMIC_API_KEY: ${{ secrets.NOMIC_API_KEY }}
+          COHERE_API_KEY: ${{ secrets.COHERE_API_KEY }}
+          FIREWORKS_API_KEY: ${{ secrets.FIREWORKS_API_KEY }}
+        run: |
+          if [ "${{ github.event_name }}" = "workflow_dispatch" ] || [ "${{ github.event_name }}" = "schedule" ]; then
+            echo "Running all notebooks"
+            ./docs/_scripts/execute_notebooks.sh
+          else
+            CHANGED_FILES=$(echo '${{ inputs.changed-files }}' | tr ' ' '\n' | grep '\.ipynb$' || true)
+            if [ -n "$CHANGED_FILES" ]; then
+              echo "Running changed notebooks: $CHANGED_FILES"
+              ./docs/_scripts/execute_notebooks.sh $CHANGED_FILES
+            else
+              echo "No notebook files changed, skipping execution"
+            fi
+          fi
+
+      - name: Stop services
+        run: make stop-services

.github/workflows/size.yml

@@ -0,0 +1,29 @@
+name: Check File Size
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+  workflow_dispatch:
+
+jobs:
+  file-size-check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Get changed files
+        id: changed-files
+        uses: tj-actions/changed-files@v44
+      - name: Filter by size
+        # TODO: roll back the web voyager hack
+        run: |
+          large_added_files=$(find ${{ steps.changed-files.outputs.added_files }} -maxdepth 0 -size +1M | grep -v "web_voyager" || true)
+          if [ -n "$large_added_files" ]; then
+            echo "Large files added: $large_added_files"
+            echo "# Large files added:" >> $GITHUB_STEP_SUMMARY
+            echo "$large_added_files" >> $GITHUB_STEP_SUMMARY
+            exit 1
+          fi

.gitignore

@@ -177,3 +177,5 @@ docs/docs_skeleton/yarn.lock
 Untitled*.ipynb
 
 Chinook.db
+
+libs/langgraph/out

CONTRIBUTING.md

@@ -0,0 +1,293 @@
+# Contributing to LangGraph
+
+Thank you for being interested in contributing to LangGraph!
+
+## General guidelines
+
+Here are some things to keep in mind for all types of contributions:
+
+- Follow the ["fork and pull request"](https://docs.github.com/en/get-started/exploring-projects-on-github/contributing-to-a-project) workflow.
+- Fill out the checked-in pull request template when opening pull requests. Note related issues and tag relevant maintainers.
+- Ensure your PR passes formatting, linting, and testing checks before requesting a review.
+  - If you would like comments or feedback, please open an issue or discussion and tag a maintainer.
+- Backwards compatibility is key. Your changes must not be breaking, except in case of critical bug and security fixes.
+- Look for duplicate PRs or issues that have already been opened before opening a new one.
+- Keep scope as isolated as possible. As a general rule, your changes should not affect more than one package at a time.
+
+### Bugfixes
+
+For bug fixes, please open up an issue before proposing a fix to ensure the proposal properly addresses the underlying problem. In general, bug fixes should all have an accompanying unit test that fails before the fix.
+
+### New features
+
+For new features, please start a new [discussion](https://github.com/langchain-ai/langgraph/discussions), where the maintainers will help with scoping out the necessary changes.
+
+## Contribute Documentation
+
+Documentation is a vital part of LangGraph. We welcome both new documentation for new features and
+community improvements to our current documentation. Please read the resources below before getting started:
+
+- [Documentation style guide](#documentation-style-guide)
+- [Documentation setup](#setup)
+
+## Documentation Style Guide
+
+As LangGraph continues to grow, the surface area of documentation required to cover it continues to grow too.
+This page provides guidelines for anyone writing documentation for LangGraph, as well as some of our philosophies around organization and structure.
+
+## Philosophy
+
+LangGraph's documentation follows the [Diataxis framework](https://diataxis.fr).
+Under this framework, all documentation falls under one of four categories: [Tutorials](#tutorials),
+[How-to guides](#how-to-guides),
+[References](#references), and [Explanations (aka conceptual guides)](#conceptual-guide).
+
+### Tutorials
+
+Tutorials are lessons that take the reader through a practical activity. Their purpose is to help the user
+gain understanding of concepts and how they interact by showing one way to achieve some goal in a hands-on way.
+
+They should **avoid** giving
+multiple permutations of ways to achieve that goal in-depth. Choice is burdensome. Instead, they should guide a new user through a recommended path to accomplishing a concrete goal. While the end result of a tutorial does not necessarily need to
+be completely production-ready, it should be useful and practically satisfy the the goal that you clearly stated in the tutorial's introduction.
+
+To quote the Diataxis website:
+
+> A tutorial serves the user’s *acquisition* of skills and knowledge - their study. Its purpose is not to help the user get something done, but to help them learn.
+
+In LangGraph, these are often higher level guides that show off end-to-end use cases.
+
+Some examples include:
+
+- [Build a Customer Support Bot](https://langchain-ai.github.io/langgraph/tutorials/customer-support/customer-support/)
+- [Build a SQL Agent](https://langchain-ai.github.io/langgraph/tutorials/sql-agent/)
+
+Here are some high-level tips on writing a good tutorial:
+
+- Focus on guiding the user to get something done, but keep in mind the end-goal is more to impart principles than to create a perfect production system.
+- Be specific, not abstract and follow one path.
+  - No need to go deeply into alternative approaches, but it’s ok to reference them, ideally with a link to an appropriate how-to guide.
+- Get "a point on the board" as soon as possible - something the user can run that outputs something.
+  - You can iterate and expand afterwards.
+  - Try to frequently checkpoint at given steps where the user can run code and see progress.
+- Focus on results, not technical explanation.
+  - Crosslink heavily to appropriate conceptual/reference pages
+- The first time you mention a LangGraph concept, use its full name (e.g. "human-in-the-loop"), and link to its conceptual/other documentation page.
+  - It's also helpful to add a prerequisite callout that links to any pages with necessary background information.
+- End with a recap/next steps section summarizing what the tutorial covered and future reading, such as related how-to guides.
+- Use phrases like "Next we can run X & Y. We will expect Z.". Then afterwards, use language like "Notice Z" that recalls our expectations and directs the reader's attention to the topic we are trying to teach.
+- Do not shy away from repetition.
+
+### How-to guides
+
+A how-to guide, as the name implies, demonstrates how to do something discrete and specific.
+It should assume that the user is already familiar with underlying concepts, and is trying to solve an immediate problem, but
+should still give some background or list the scenarios where the information contained within can be relevant.
+They can and should discuss alternatives if one approach may be better than another in certain cases.
+
+To quote the Diataxis website:
+
+> A how-to guide serves the work of the already-competent user, whom you can assume to know what they want to do, and to be able to follow your instructions correctly.
+
+Some examples include:
+
+- [How to add persistence to your graph](https://langchain-ai.github.io/langgraph/how-tos/persistence/)
+- [How to view and update past graph state](https://langchain-ai.github.io/langgraph/how-tos/human_in_the_loop/time-travel/)
+
+Here are some high-level tips on writing a good how-to guide:
+
+- Clearly explain what you are guiding the user through at the start
+- Assume higher intent than a tutorial and show what the user needs to do to get that task done
+- Assume familiarity of concepts, but explain why suggested actions are helpful
+  - Crosslink heavily to conceptual/reference pages
+- Discuss alternatives and responses to real-world tradeoffs that may arise when solving a problem
+- Use lots of example code, ideally within complete code blocks that the reader can copy and run.
+- End with a recap/next steps section summarizing what the tutorial covered and future reading, such as other related how-to guides
+
+### Conceptual guides
+
+LangGraph's conceptual guides fall under the **Explanation** quadrant of Diataxis. They should cover LangChain terms and concepts
+in a more abstract way than how-to guides or tutorials, and should be geared towards curious users interested in
+gaining a deeper understanding of the framework. Try to avoid excessively large code examples. The goal here is to
+impart perspective to the user rather than to finish a practical project. These guides should cover **why** things work they way they do.
+
+
+To quote the Diataxis website:
+
+> The perspective of explanation is higher and wider than that of the other types. It does not take the user’s eye-level view, as in a how-to guide, or a close-up view of the machinery, like reference material. Its scope in each case is a topic - “an area of knowledge”, that somehow has to be bounded in a reasonable, meaningful way.
+
+Some examples include:
+
+- [What does it mean to be agentic?](https://langchain-ai.github.io/langgraph/concepts/high_level/)
+- [Tool calling](https://langchain-ai.github.io/langgraph/concepts/agentic_concepts/#tool-calling)
+
+Here are some high-level tips on writing a good conceptual guide:
+
+- Explain design decisions. Why does concept X exist and why was it designed this way?
+- Use analogies and reference other concepts and alternatives
+- Avoid blending in too much reference content
+- You can and should reference content covered in other guides, but make sure to link to them
+
+### References
+
+References contain detailed, low-level information that describes exactly what functionality exists and how to use it.
+In LangGraph, this is mainly our API reference pages, which are populated from docstrings within code.
+References pages are generally not read end-to-end, but are consulted as necessary when a user needs to know
+how to use something specific.
+
+To quote the Diataxis website:
+
+> The only purpose of a reference guide is to describe, as succinctly as possible, and in an orderly way. Whereas the content of tutorials and how-to guides are led by needs of the user, reference material is led by the product it describes.
+
+Many of the reference pages in LangChain are automatically generated from code,
+but here are some high-level tips on writing a good docstring:
+
+- Be concise
+- Discuss special cases and deviations from a user's expectations
+- Go into detail on required inputs and outputs
+- Light details on when one might use the feature are fine, but in-depth details belong in other sections.
+
+Each category serves a distinct purpose and requires a specific approach to writing and structuring the content.
+
+## General guidelines
+
+Here are some other guidelines you should think about when writing and organizing documentation.
+
+We generally do not merge new tutorials from outside contributors without an actue need.
+We welcome updates as well as new integration docs, how-tos, and references.
+
+### Avoid duplication
+
+Multiple pages that cover the same material in depth are difficult to maintain and cause confusion. There should
+be only one (very rarely two), canonical pages for a given concept or feature. Instead, you should link to other guides.
+
+### Link to other sections
+
+Because sections of the docs do not exist in a vacuum, it is important to link to other sections as often as possible
+to allow a developer to learn more about an unfamiliar topic inline.
+
+This includes linking to the API references as well as conceptual sections!
+
+### Be concise
+
+In general, take a less-is-more approach. If a section with a good explanation of a concept already exists, you should link to it rather than
+re-explain it, unless the concept you are documenting presents some new wrinkle.
+
+Be concise, including in code samples.
+
+### General style
+
+- Use active voice and present tense whenever possible
+- Use examples and code snippets to illustrate concepts and usage
+- Use appropriate header levels (`#`, `##`, `###`, etc.) to organize the content hierarchically
+- Use fewer cells with more code to make copy/paste easier
+- Use bullet points and numbered lists to break down information into easily digestible chunks
+- Use tables (especially for **Reference** sections) and diagrams often to present information visually
+- Include the table of contents for longer documentation pages to help readers navigate the content, but hide it for shorter pages
+
+## Setup
+
+LangChain documentation consists of two components:
+
+1. Main Documentation: Hosted at [https://langchain-ai.github.io](https://langchain-ai.github.io/langgraph/),
+this comprehensive resource serves as the primary user-facing documentation.
+It covers a wide array of topics, including tutorials, use cases, integrations,
+and more, offering extensive guidance on building with LangGraph.
+The content for this documentation lives in the `/docs` directory of the monorepo.
+2. In-code Documentation: This is documentation of the codebase itself, which is also
+used to generate the externally facing [API Reference](https://langchain-ai.github.io/langgraph/reference/graphs/).
+The content for the API reference is autogenerated by scanning the docstrings in the codebase. For this reason we ask that developers document their code well.
+
+We appreciate all contributions to the documentation, whether it be fixing a typo,
+adding a new tutorial or example and whether it be in the main documentation or the API Reference.
+
+### 📜 Main Documentation
+
+The content for the main documentation is located in the `/docs` directory of the monorepo.
+
+The documentation is written using a combination of ipython notebooks (`.ipynb` files)
+and markdown (`.md` files). The notebooks are converted to markdown
+and then built using [MkDocs](https://www.mkdocs.org/).
+
+Feel free to make contributions to the main documentation! 🥰
+
+After modifying the documentation:
+
+1. Run the linting and formatting commands (see below) to ensure that the documentation is well-formatted and free of errors.
+2. Optionally build the documentation locally to verify that the changes look good.
+3. Make a pull request with the changes.
+
+### ⚒️ Linting and Building Documentation Locally
+
+After writing up the documentation, you may want to lint and build the documentation
+locally to ensure that it looks good and is free of errors.
+
+If you're unable to build it locally that's okay as well, as you will be able to
+see a preview of the documentation on the pull request page.
+
+From the **monorepo root**, run the following command to install the dependencies:
+
+```bash
+poetry install --with docs --no-root
+```
+
+#### Building
+
+The code that builds the documentation is located in the `/docs` directory of the monorepo.
+
+Before building the documentation, it is always a good idea to clean the build directory:
+
+```bash
+make clean-docs
+```
+
+You can build and preview the documentation as outlined below:
+
+```bash
+make serve-docs
+```
+
+#### Linting
+
+The documentation is linted from the **monorepo root**. To lint it, run the following from there:
+
+```bash
+make spellcheck
+```
+
+### ️In-code Documentation
+
+The in-code documentation is autogenerated from docstrings.
+
+For the API reference to be useful, the codebase must be well-documented. This means that all functions, classes, and methods should have a docstring that explains what they do, what the arguments are, and what the return value is. This is a good practice in general, but it is especially important for LangChain because the API reference is the primary resource for developers to understand how to use the codebase.
+
+We generally follow the [Google Python Style Guide](https://google.github.io/styleguide/pyguide.html#38-comments-and-docstrings) for docstrings.
+
+Here is an example of a well-documented function:
+
+```python
+
+def my_function(arg1: int, arg2: str) -> float:
+    """This is a short description of the function. (It should be a single sentence.)
+
+    This is a longer description of the function. It should explain what
+    the function does, what the arguments are, and what the return value is.
+    It should wrap at 88 characters.
+
+    Examples:
+        This is a section for examples of how to use the function.
+
+        .. code-block:: python
+
+            my_function(1, "hello")
+
+    Args:
+        arg1: This is a description of arg1. We do not need to specify the type since
+            it is already specified in the function signature.
+        arg2: This is a description of arg2.
+
+    Returns:
+        This is a description of the return value.
+    """
+    return 3.14
+```

Makefile

@@ -1,20 +1,39 @@
-.PHONY: build-docs serve-docs serve-clean-docs clean-docs codespell
+.PHONY: lint-docs format-docs build-docs serve-docs serve-clean-docs clean-docs codespell build-typedoc
 
-build-docs:
-	poetry run python docs/_scripts/copy_notebooks.py
+build-typedoc:
+	cd libs/sdk-js && yarn install --include-dev && yarn typedoc
+	cd libs/sdk-js && yarn --silent concat-md --decrease-title-levels --ignore=js_ts_sdk_ref.md --start-title-level-at 2 docs > ../../docs/docs/cloud/reference/sdk/js_ts_sdk_ref.md 2>/dev/null
+	#  Add links to the monorepo
+	sed -e '1,10s|@langchain/langgraph-sdk|[@langchain/langgraph-sdk](https://github.com/langchain-ai/langgraph/tree/main/libs/sdk-js)|g' docs/docs/cloud/reference/sdk/js_ts_sdk_ref.md > temp_file && mv temp_file docs/docs/cloud/reference/sdk/js_ts_sdk_ref.md
+
+build-docs: build-typedoc
 	poetry run python -m mkdocs build --clean -f docs/mkdocs.yml --strict
 
 serve-clean-docs: clean-docs
-	poetry run python docs/_scripts/copy_notebooks.py
 	poetry run python -m mkdocs serve -c -f docs/mkdocs.yml --strict -w ./libs/langgraph
 
-serve-docs:
-	poetry run python docs/_scripts/copy_notebooks.py
+serve-docs: build-typedoc
 	poetry run python -m mkdocs serve -f docs/mkdocs.yml -w ./libs/langgraph --dirty
 
 clean-docs:
 	find ./docs/docs -name "*.ipynb" -type f -delete
 	rm -rf docs/site
 
+## Run format against the project documentation.
+format-docs:
+	poetry run ruff format docs/docs
+	poetry run ruff check --fix docs/docs
+
+# Check the docs for linting violations
+lint-docs:
+	poetry run ruff format --check docs/docs
+	poetry run ruff check docs/docs
+
 codespell:
-	./docs/codespell_notebooks.sh .
+	./docs/codespell_notebooks.sh .
+
+start-services:
+	docker compose -f docs/test-compose.yml up -V --force-recreate --wait --remove-orphans
+
+stop-services:
+	docker compose -f docs/test-compose.yml down

README.md

@@ -3,7 +3,6 @@
 ![Version](https://img.shields.io/pypi/v/langgraph)
 [![Downloads](https://static.pepy.tech/badge/langgraph/month)](https://pepy.tech/project/langgraph)
 [![Open Issues](https://img.shields.io/github/issues-raw/langchain-ai/langgraph)](https://github.com/langchain-ai/langgraph/issues)
-[![](https://dcbadge.vercel.app/api/server/6adMQxSpJS?compact=true&style=flat)](https://discord.com/channels/1038097195422978059/1170024642245832774)
 [![Docs](https://img.shields.io/badge/docs-latest-blue)](https://langchain-ai.github.io/langgraph/)
 
 ⚡ Building language agents as graphs ⚡
@@ -17,6 +16,10 @@
 
 LangGraph is inspired by [Pregel](https://research.google/pubs/pub37252/) and [Apache Beam](https://beam.apache.org/). The public interface draws inspiration from [NetworkX](https://networkx.org/documentation/latest/). LangGraph is built by LangChain Inc, the creators of LangChain, but can be used without LangChain.
 
+[LangGraph Platform](https://langchain-ai.github.io/langgraph/concepts/langgraph_platform) is infrastructure for deploying LangGraph agents. It is a commercial solution for deploying agentic applications to production, built on the open-source LangGraph framework. The LangGraph Platform consists of several components that work together to support the development, deployment, debugging, and monitoring of LangGraph applications: [LangGraph Server](https://langchain-ai.github.io/langgraph/concepts/langgraph_server) (APIs), [LangGraph SDKs](https://langchain-ai.github.io/langgraph/concepts/sdk) (clients for the APIs), [LangGraph CLI](https://langchain-ai.github.io/langgraph/concepts/langgraph_cli) (command line tool for building the server), [LangGraph Studio](https://langchain-ai.github.io/langgraph/concepts/langgraph_studio) (UI/debugger),
+
+To learn more about LangGraph, check out our first LangChain Academy course, *Introduction to LangGraph*, available for free [here](https://academy.langchain.com/courses/intro-to-langgraph).
+
 ### Key Features
 
 - **Cycles and Branching**: Implement loops and conditionals in your apps.
@@ -25,6 +28,16 @@ LangGraph is inspired by [Pregel](https://research.google/pubs/pub37252/) and [A
 - **Streaming Support**: Stream outputs as they are produced by each node (including token streaming).
 - **Integration with LangChain**: LangGraph integrates seamlessly with [LangChain](https://github.com/langchain-ai/langchain/) and [LangSmith](https://docs.smith.langchain.com/) (but does not require them).
 
+### LangGraph Platform
+
+LangGraph Platform is a commercial solution for deploying agentic applications to production, built on the open-source LangGraph framework.
+Here are some common issues that arise in complex deployments, which LangGraph Platform addresses:
+
+- **Streaming support**: LangGraph Server provides [multiple streaming modes](https://langchain-ai.github.io/langgraph/concepts/streaming) optimized for various application needs
+- **Background runs**: Runs agents asynchronously in the background
+- **Support for long running agents**: Infrastructure that can handle long running processes
+- **[Double texting](https://langchain-ai.github.io/langgraph/concepts/double_texting)**: Handle the case where you get two messages from the user before the agent can respond
+- **Handle burstiness**: Task queue for ensuring requests are handled consistently without loss, even under heavy loads
 
 ## Installation
 
@@ -36,40 +49,49 @@ pip install -U langgraph
 
 One of the central concepts of LangGraph is state. Each graph execution creates a state that is passed between nodes in the graph as they execute, and each node updates this internal state with its return value after it executes. The way that the graph updates its internal state is defined by either the type of graph chosen or a custom function.
 
-Let's take a look at a simple example of an agent that can search the web using [Tavily Search API](https://tavily.com/).
+Let's take a look at a simple example of an agent that can use a search tool.
 
 ```shell
-pip install langchain_openai langchain_community
+pip install langchain-anthropic
 ```
 
 ```shell
-export OPENAI_API_KEY=sk-...
-export TAVILY_API_KEY=tvly-...
+export ANTHROPIC_API_KEY=sk-...
 ```
 
 Optionally, we can set up [LangSmith](https://docs.smith.langchain.com/) for best-in-class observability.
 
 ```shell
-export LANGCHAIN_TRACING_V2="true"
-export LANGCHAIN_API_KEY=ls__...
+export LANGSMITH_TRACING=true
+export LANGSMITH_API_KEY=lsv2_sk_...
 ```
 
 ```python
 from typing import Annotated, Literal, TypedDict
 
 from langchain_core.messages import HumanMessage
-from langchain_community.tools.tavily_search import TavilySearchResults
-from langchain_openai import ChatOpenAI
-from langgraph.checkpoint import MemorySaver
-from langgraph.graph import END, StateGraph, MessagesState
+from langchain_anthropic import ChatAnthropic
+from langchain_core.tools import tool
+from langgraph.checkpoint.memory import MemorySaver
+from langgraph.graph import END, START, StateGraph, MessagesState
 from langgraph.prebuilt import ToolNode
 
 
 # Define the tools for the agent to use
-tools = [TavilySearchResults(max_results=1)]
+@tool
+def search(query: str):
+    """Call to surf the web."""
+    # This is a placeholder, but don't tell the LLM that...
+    if "sf" in query.lower() or "san francisco" in query.lower():
+        return "It's 60 degrees and foggy."
+    return "It's 90 degrees and sunny."
+
+
+tools = [search]
+
 tool_node = ToolNode(tools)
 
-model = ChatOpenAI(temperature=0).bind_tools(tools)
+model = ChatAnthropic(model="claude-3-5-sonnet-20240620", temperature=0).bind_tools(tools)
 
 # Define the function that determines whether to continue or not
 def should_continue(state: MessagesState) -> Literal["tools", END]:
@@ -99,7 +121,7 @@ workflow.add_node("tools", tool_node)
 
 # Set the entrypoint as `agent`
 # This means that this node is the first one called
-workflow.set_entry_point("agent")
+workflow.add_edge(START, "agent")
 
 # We now add a conditional edge
 workflow.add_conditional_edges(
@@ -132,7 +154,7 @@ final_state["messages"][-1].content
 ```
 
 ```
-'The current weather in San Francisco is as follows:\n- Temperature: 60.1°F (15.6°C)\n- Condition: Partly cloudy\n- Wind: 5.6 mph (9.0 kph) from SSW\n- Humidity: 83%\n- Visibility: 9.0 miles (16.0 km)\n- UV Index: 4.0\n\nFor more details, you can visit [Weather API](https://www.weatherapi.com/).'
+"Based on the search results, I can tell you that the current weather in San Francisco is:\n\nTemperature: 60 degrees Fahrenheit\nConditions: Foggy\n\nSan Francisco is known for its microclimates and frequent fog, especially during the summer months. The temperature of 60°F (about 15.5°C) is quite typical for the city, which tends to have mild temperatures year-round. The fog, often referred to as "Karl the Fog" by locals, is a characteristic feature of San Francisco\'s weather, particularly in the mornings and evenings.\n\nIs there anything else you\'d like to know about the weather in San Francisco or any other location?"
 ```
 
 Now when we pass the same `"thread_id"`, the conversation context is retained via the saved state (i.e. stored list of messages)
@@ -146,7 +168,7 @@ final_state["messages"][-1].content
 ```
 
 ```
-'The current weather in New York is as follows:\n- Temperature: 20.3°C (68.5°F)\n- Condition: Overcast\n- Wind: 2.2 mph from the north\n- Humidity: 65%\n- Cloud Cover: 100%\n- UV Index: 5.0\n\nFor more details, you can visit [Weather API](https://www.weatherapi.com/).'
+"Based on the search results, I can tell you that the current weather in New York City is:\n\nTemperature: 90 degrees Fahrenheit (approximately 32.2 degrees Celsius)\nConditions: Sunny\n\nThis weather is quite different from what we just saw in San Francisco. New York is experiencing much warmer temperatures right now. Here are a few points to note:\n\n1. The temperature of 90°F is quite hot, typical of summer weather in New York City.\n2. The sunny conditions suggest clear skies, which is great for outdoor activities but also means it might feel even hotter due to direct sunlight.\n3. This kind of weather in New York often comes with high humidity, which can make it feel even warmer than the actual temperature suggests.\n\nIt's interesting to see the stark contrast between San Francisco's mild, foggy weather and New York's hot, sunny conditions. This difference illustrates how varied weather can be across different parts of the United States, even on the same day.\n\nIs there anything else you'd like to know about the weather in New York or any other location?"
 ```
 
 ### Step-by-step Breakdown
@@ -154,8 +176,8 @@ final_state["messages"][-1].content
 1. <details>
     <summary>Initialize the model and tools.</summary>
 
-    - we use `ChatOpenAI` as our LLM. **NOTE:** we need make sure the model knows that it has these tools available to call. We can do this by converting the LangChain tools into the format for OpenAI tool calling using the `.bind_tools()` method.
-    - we define the tools we want to use - a web search tool in our case. It is really easy to create your own tools - see documentation here on how to do that [here](https://python.langchain.com/docs/modules/agents/tools/custom_tools).
+    - we use `ChatAnthropic` as our LLM. **NOTE:** we need make sure the model knows that it has these tools available to call. We can do this by converting the LangChain tools into the format for OpenAI tool calling using the `.bind_tools()` method.
+    - we define the tools we want to use - a search tool in our case. It is really easy to create your own tools - see documentation here on how to do that [here](https://python.langchain.com/docs/modules/agents/tools/custom_tools).
    </details>
 
 2. <details>
@@ -214,6 +236,10 @@ final_state["messages"][-1].content
 
 * [Tutorials](https://langchain-ai.github.io/langgraph/tutorials/): Learn to build with LangGraph through guided examples.
 * [How-to Guides](https://langchain-ai.github.io/langgraph/how-tos/): Accomplish specific things within LangGraph, from streaming, to adding memory & persistence, to common design patterns (branching, subgraphs, etc.), these are the place to go if you want to copy and run a specific code snippet.
-* [Conceptual Guides](https://langchain-ai.github.io/langgraph/concepts/): In-depth explanations of the key concepts and principles behind LangGraph, such as nodes, edges, state and more.
+* [Conceptual Guides](https://langchain-ai.github.io/langgraph/concepts/high_level/): In-depth explanations of the key concepts and principles behind LangGraph, such as nodes, edges, state and more.
 * [API Reference](https://langchain-ai.github.io/langgraph/reference/graphs/): Review important classes and methods, simple examples of how to use the graph and checkpointing APIs, higher-level prebuilt components and more.
-* [Cloud (alpha)](https://langchain-ai.github.io/langgraph/cloud/): With one click, deploy LangGraph applications to LangGraph Cloud.
+* [Cloud (beta)](https://langchain-ai.github.io/langgraph/cloud/): With one click, deploy LangGraph applications to LangGraph Cloud.
+
+## Contributing
+
+For more information on how to contribute, see [here](https://github.com/langchain-ai/langgraph/blob/main/CONTRIBUTING.md).

docs/.gitignore

@@ -1,2 +1,2 @@
-*.ipynb
 site/
+docs/cloud/reference/sdk/js_ts_sdk_ref.md

docs/README.md

@@ -0,0 +1,61 @@
+# Setup
+
+To setup requirements for building docs you can run:
+
+```bash
+poetry install --with test
+```
+
+## Serving documentation locally
+
+To run the documentation server locally you can run:
+
+```bash
+make serve-docs
+```
+
+## Execute notebooks
+
+If you would like to automatically execute all of the notebooks, to mimic the "Run notebooks" GHA, you can run:
+
+```bash
+python docs/_scripts/prepare_notebooks_for_ci.py
+./docs/_scripts/execute_notebooks.sh
+```
+
+**Note**: if you want to run the notebooks without `%pip install` cells, you can run:
+
+```bash
+python docs/_scripts/prepare_notebooks_for_ci.py --comment-install-cells
+./docs/_scripts/execute_notebooks.sh
+```
+
+`prepare_notebooks_for_ci.py` script will add VCR cassette context manager for each cell in the notebook, so that:
+* when the notebook is run for the first time, cells with network requests will be recorded to a VCR cassette file
+* when the notebook is run subsequently, the cells with network requests will be replayed from the cassettes
+
+**Note**: this is currently limited only to the notebooks in `docs/docs/how-tos`
+
+## Adding new notebooks
+
+If you are adding a notebook with API requests, it's **recommended** to record network requests so that they can be subsequently replayed. If this is not done, the notebook runner will make API requests every time the notebook is run, which can be costly and slow.
+
+To record network requests, please make sure to first run `prepare_notebooks_for_ci.py` script.
+
+Then, run
+
+```bash
+jupyter execute <path_to_notebook>
+```
+
+Once the notebook is executed, you should see the new VCR cassettes recorded in `docs/cassettes` directory and discard the updated notebook.
+
+## Updating existing notebooks
+
+If you are updating an existing notebook, please make sure to remove any existing cassettes for the notebook in `docs/cassettes` directory (each cassette is prefixed with the notebook name), and then run the steps from the "Adding new notebooks" section above.
+
+To delete cassettes for a notebook, you can run:
+
+```bash
+rm docs/cassettes/<notebook_name>*
+```

docs/_scripts/copy_notebooks.py

@@ -1,207 +0,0 @@
-import json
-import os
-import re
-import shutil
-from pathlib import Path
-
-root_dir = Path(__file__).resolve().parents[2]
-
-examples_dir = root_dir / "examples"
-docs_dir = root_dir / "docs/docs"
-how_tos_dir = docs_dir / "how-tos"
-tutorials_dir = docs_dir / "tutorials"
-cloud_how_tos_dir = docs_dir / "cloud/how-tos"
-cloud_sdk_dir = docs_dir / "cloud"
-
-_MANUAL = {
-    "how-tos": [
-        "async.ipynb",
-        "stream-values.ipynb",
-        "stream-updates.ipynb",
-        "stream-multiple.ipynb",
-        "streaming-tokens.ipynb",
-        "streaming-content.ipynb",
-        "streaming-events-from-within-tools.ipynb",
-        "streaming-from-final-node.ipynb",
-        "persistence.ipynb",
-        "persistence_postgres.ipynb",
-        "visualization.ipynb",
-        "state-model.ipynb",
-        "subgraph.ipynb",
-        "force-calling-a-tool-first.ipynb",
-        "pass-run-time-values-to-tools.ipynb",
-        "dynamic-returning-direct.ipynb",
-        "managing-agent-steps.ipynb",
-        "respond-in-format.ipynb",
-        "branching.ipynb",
-        "dynamically-returning-directly.ipynb",
-        "configuration.ipynb",
-        "map-reduce.ipynb",
-        "create-react-agent.ipynb",
-        "create-react-agent-system-prompt.ipynb",
-        "create-react-agent-memory.ipynb",
-        "create-react-agent-hitl.ipynb",
-        "human_in_the_loop/breakpoints.ipynb",
-        "human_in_the_loop/time-travel.ipynb",
-        "human_in_the_loop/edit-graph-state.ipynb",
-        "human_in_the_loop/wait-user-input.ipynb",
-    ],
-    "tutorials": [
-        "introduction.ipynb",
-        "customer-support/customer-support.ipynb",
-        "tutorials/tnt-llm/tnt-llm.ipynb",
-        "tutorials/sql-agent.ipynb",
-    ],
-}
-_MANUAL_INVERSE = {v: docs_dir / k for k, vs in _MANUAL.items() for v in vs}
-_HOW_TOS = {"agent_executor", "chat_agent_executor_with_function_calling", "docs"}
-_HIDE = set(
-    str(examples_dir / f)
-    for f in [
-        "agent_executor/base.ipynb",
-        "agent_executor/force-calling-a-tool-first.ipynb",
-        "agent_executor/high-level.ipynb",
-        "agent_executor/human-in-the-loop.ipynb",
-        "agent_executor/managing-agent-steps.ipynb",
-        "chat_agent_executor_with_function_calling/anthropic.ipynb",
-        "chat_agent_executor_with_function_calling/base.ipynb",
-        "chat_agent_executor_with_function_calling/dynamically-returning-directly.ipynb",
-        "chat_agent_executor_with_function_calling/force-calling-a-tool-first.ipynb",
-        "chat_agent_executor_with_function_calling/high-level-tools.ipynb",
-        "chat_agent_executor_with_function_calling/high-level.ipynb",
-        "chat_agent_executor_with_function_calling/human-in-the-loop.ipynb",
-        "chat_agent_executor_with_function_calling/managing-agent-steps.ipynb",
-        "chat_agent_executor_with_function_calling/prebuilt-tool-node.ipynb",
-        "chat_agent_executor_with_function_calling/respond-in-format.ipynb",
-        "chatbots/customer-support.ipynb",
-        "rag/langgraph_rag_agent_llama3_local.ipynb",
-        "rag/langgraph_self_rag_pinecone_movies.ipynb",
-        "rag/langgraph_adaptive_rag_cohere.ipynb",
-        "dynamically-returning-directly.ipynb",
-        "force-calling-a-tool-first.ipynb",
-        "managing-agent-steps.ipynb",
-        "pass-run-time-values-to-tools.ipynb",
-        "respond-in-format.ipynb",
-        "quickstart.ipynb",
-        "human-in-the-loop.ipynb",
-        "learning.ipynb",
-        "managing-conversation-history.ipynb",
-        "docs/quickstart.ipynb",
-        "tutorials/rag-agent-testing.ipynb",
-        "state-context-key.ipynb",
-        "time-travel.ipynb",
-        "code_assistant/langgraph_code_assistant_mistral.ipynb",
-    ]
-)
-
-
-def clean_notebooks():
-    roots = (how_tos_dir, tutorials_dir)
-    for dir_ in roots:
-        traversed = []
-        for root, dirs, files in os.walk(dir_):
-            for file in files:
-                if file.endswith(".ipynb"):
-                    os.remove(os.path.join(root, file))
-            # Now delete the dir if it is empty now
-            if root not in roots:
-                traversed.append(root)
-
-        for root in reversed(traversed):
-            if not os.listdir(root):
-                os.rmdir(root)
-
-
-def update_notebook_links(notebook_path):
-    with open(notebook_path, "r", encoding="utf-8") as f:
-        notebook = json.load(f)
-
-    for cell in notebook["cells"]:
-        if cell["cell_type"] == "markdown":
-            for i, source in enumerate(cell["source"]):
-                # Update relative notebook links
-                cell["source"][i] = re.sub(
-                    r"\[([^\]]+)\]\(([^:)]+\.ipynb)\)",
-                    lambda m: transform_link(m.group(1), m.group(2)),
-                    source,
-                )
-
-    with open(notebook_path, "w", encoding="utf-8") as f:
-        json.dump(notebook, f, indent=2)
-
-
-def transform_link(text, link):
-    dir_path, filename = os.path.split(link)
-
-    # Remove the .ipynb extension
-    filename_without_ext = os.path.splitext(filename)[0]
-
-    # If it's a local link (starts with ./)
-    if link.startswith("./"):
-        # Change to parent directory and remove ./ prefix
-        new_link = f"../{filename_without_ext}/"
-    elif dir_path:
-        # If there's a directory path, keep it and add one more level up
-        new_link = f"../{dir_path}/{filename_without_ext}/"
-    else:
-        # If it's just a filename, simply go one level up
-        new_link = f"../{filename_without_ext}/"
-
-    return f"[{text}]({new_link})"
-
-
-def copy_notebooks():
-    # Nested ones are mostly tutorials rn
-    for root, dirs, files in os.walk(examples_dir):
-        if any(
-            path.startswith(".") or path.startswith("__") for path in root.split(os.sep)
-        ):
-            continue
-        if any(path in _HOW_TOS for path in root.split(os.sep)):
-            dst_dir = how_tos_dir
-        elif "sdk" in root.split(os.sep):
-            dst_dir = cloud_sdk_dir
-        elif "cloud_examples" in root.split(os.sep):
-            dst_dir = cloud_how_tos_dir
-        else:
-            dst_dir = tutorials_dir
-        for file in files:
-            dst_dir_ = dst_dir
-            if file.endswith((".ipynb", ".png")):
-                src_path = os.path.join(root, file)
-                if src_path in _HIDE:
-                    print("Hiding:", src_path)
-                    continue
-                dst_path = os.path.join(
-                    dst_dir, os.path.relpath(src_path, examples_dir)
-                )
-                for k in _MANUAL_INVERSE:
-                    if src_path.endswith(k):
-                        overridden_dir = _MANUAL_INVERSE[k]
-                        dst_path = os.path.join(
-                            overridden_dir, os.path.relpath(src_path, examples_dir)
-                        )
-                        print(f"Overriding: {src_path} to {dst_path}")
-                        break
-                # Avoid double nesting.
-                dst_path = dst_path.replace("tutorials/tutorials", "tutorials").replace(
-                    "how-tos/how-tos", "how-tos"
-                )
-                os.makedirs(os.path.dirname(dst_path), exist_ok=True)
-                print(f"Copying: {src_path} to {dst_path}")
-                shutil.copy(src_path, dst_path)
-                # Convert all ./img/* to ../img/*
-                if file.endswith(".ipynb"):
-                    with open(dst_path, "r") as f:
-                        content = f.read()
-                    content = content.replace("(./img/", "(../img/")
-                    content = content.replace('src=\\"./img/', 'src=\\"../img/')
-                    with open(dst_path, "w") as f:
-                        f.write(content)
-                    update_notebook_links(dst_path)
-                dst_dir = dst_dir_
-
-
-if __name__ == "__main__":
-    clean_notebooks()
-    copy_notebooks()

docs/_scripts/download_tiktoken.py

@@ -0,0 +1,5 @@
+import tiktoken
+
+# This will trigger the download and caching of the necessary files
+for encoding in ("gpt2", "gpt-3.5"):
+    tiktoken.encoding_for_model(encoding)

docs/_scripts/execute_notebooks.sh

@@ -0,0 +1,36 @@
+#!/bin/bash
+
+# Read the list of notebooks to skip from the JSON file
+SKIP_NOTEBOOKS=$(python -c "import json; print('\n'.join(json.load(open('docs/notebooks_no_execution.json'))))")
+
+# Function to execute a single notebook
+execute_notebook() {
+    file="$1"
+    echo "Starting execution of $file"
+    start_time=$(date +%s)
+    if ! output=$(time poetry run jupyter execute "$file" 2>&1); then
+        end_time=$(date +%s)
+        execution_time=$((end_time - start_time))
+        echo "Error in $file. Execution time: $execution_time seconds"
+        echo "Error details: $output"
+        exit 1
+    fi
+    end_time=$(date +%s)
+    execution_time=$((end_time - start_time))
+    echo "Finished $file. Execution time: $execution_time seconds"
+}
+
+export -f execute_notebook
+
+# Check if custom notebook paths are provided
+if [ $# -gt 0 ]; then
+    notebooks=$(echo "$@" | tr ' ' '\n' | grep -vFf <(echo "$SKIP_NOTEBOOKS"))
+else
+    # Find all notebooks and filter out those in the skip list
+    notebooks=$(find docs/docs/tutorials docs/docs/how-tos -name "*.ipynb" | grep -v ".ipynb_checkpoints" | grep -vFf <(echo "$SKIP_NOTEBOOKS"))
+fi
+
+# Execute notebooks sequentially
+for file in $notebooks; do
+    execute_notebook "$file"
+done

docs/_scripts/generate_api_reference_links.py

@@ -0,0 +1,246 @@
+import importlib
+import inspect
+import logging
+import os
+import re
+from typing import List, Literal, Optional
+from typing_extensions import TypedDict
+
+import nbformat
+from nbconvert.preprocessors import Preprocessor
+
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+# Base URL for all class documentation
+_LANGCHAIN_API_REFERENCE = "https://python.langchain.com/api_reference/"
+_LANGGRAPH_API_REFERENCE = "https://langchain-ai.github.io/langgraph/reference/"
+
+
+# (alias/re-exported modules, source module, class, docs namespace)
+MANUAL_API_REFERENCES_LANGGRAPH = [
+    (
+        ["langgraph.prebuilt"],
+        "langgraph.prebuilt.chat_agent_executor",
+        "create_react_agent",
+        "prebuilt",
+    ),
+    (["langgraph.prebuilt"], "langgraph.prebuilt.tool_node", "ToolNode", "prebuilt"),
+    (
+        ["langgraph.prebuilt"],
+        "langgraph.prebuilt.tool_node",
+        "tools_condition",
+        "prebuilt",
+    ),
+    (
+        ["langgraph.prebuilt"],
+        "langgraph.prebuilt.tool_node",
+        "InjectedState",
+        "prebuilt",
+    ),
+    # Graph
+    (["langgraph.graph"], "langgraph.graph.message", "add_messages", "graphs"),
+    (["langgraph.graph"], "langgraph.graph.state", "StateGraph", "graphs"),
+    (["langgraph.graph"], "langgraph.graph.state", "CompiledStateGraph", "graphs"),
+    ([], "langgraph.types", "StreamMode", "types"),
+    (["langgraph.graph"], "langgraph.constants", "START", "constants"),
+    (["langgraph.graph"], "langgraph.constants", "END", "constants"),
+    (["langgraph.constants"], "langgraph.types", "Send", "types"),
+    (["langgraph.constants"], "langgraph.types", "Interrupt", "types"),
+    ([], "langgraph.types", "RetryPolicy", "types"),
+    ([], "langgraph.checkpoint.base", "Checkpoint", "checkpoints"),
+    ([], "langgraph.checkpoint.base", "CheckpointMetadata", "checkpoints"),
+    ([], "langgraph.checkpoint.base", "BaseCheckpointSaver", "checkpoints"),
+    ([], "langgraph.checkpoint.base", "SerializerProtocol", "checkpoints"),
+    ([], "langgraph.checkpoint.serde.jsonplus", "JsonPlusSerializer", "checkpoints"),
+    ([], "langgraph.checkpoint.memory", "MemorySaver", "checkpoints"),
+    ([], "langgraph.checkpoint.sqlite.aio", "AsyncSqliteSaver", "checkpoints"),
+    ([], "langgraph.checkpoint.sqlite", "SqliteSaver", "checkpoints"),
+    ([], "langgraph.checkpoint.postgres.aio", "AsyncPostgresSaver", "checkpoints"),
+    ([], "langgraph.checkpoint.postgres", "PostgresSaver", "checkpoints"),
+]
+
+WELL_KNOWN_LANGGRAPH_OBJECTS = {
+    (module_, class_): (source_module, namespace)
+    for (modules, source_module, class_, namespace) in MANUAL_API_REFERENCES_LANGGRAPH
+    for module_ in modules + [source_module]
+}
+
+
+def _make_regular_expression(pkg_prefix: str) -> re.Pattern:
+    if not pkg_prefix.isidentifier():
+        raise ValueError(f"Invalid package prefix: {pkg_prefix}")
+    return re.compile(
+        r"from\s+(" + pkg_prefix + "(?:_\w+)?(?:\.\w+)*?)\s+import\s+"
+        r"((?:\w+(?:,\s*)?)*"  # Match zero or more words separated by a comma+optional ws
+        r"(?:\s*\(.*?\))?)",  # Match optional parentheses block
+        re.DOTALL,  # Match newlines as well
+    )
+
+
+# Regular expression to match langchain import lines
+_IMPORT_LANGCHAIN_RE = _make_regular_expression("langchain")
+_IMPORT_LANGGRAPH_RE = _make_regular_expression("langgraph")
+
+
+def _get_full_module_name(module_path, class_name) -> Optional[str]:
+    """Get full module name using inspect"""
+    try:
+        module = importlib.import_module(module_path)
+        class_ = getattr(module, class_name)
+        module = inspect.getmodule(class_)
+        if module is None:
+            # For constants, inspect.getmodule() might return None
+            # In this case, we'll return the original module_path
+            return module_path
+        return module.__name__
+    except AttributeError as e:
+        logger.warning(f"Could not find module for {class_name}, {e}")
+        return None
+    except ImportError as e:
+        logger.warning(f"Failed to load for class {class_name}, {e}")
+        return None
+
+
+def _get_doc_title(data: str, file_name: str) -> str:
+    try:
+        return re.findall(r"^#\s*(.*)", data, re.MULTILINE)[0]
+    except IndexError:
+        pass
+    # Parse the rst-style titles
+    try:
+        return re.findall(r"^(.*)\n=+\n", data, re.MULTILINE)[0]
+    except IndexError:
+        return file_name
+
+
+class ImportInformation(TypedDict):
+    imported: str  # imported class name
+    source: str  # module path
+    docs: str  # URL to the documentation
+    title: str  # Title of the document
+
+
+def _get_imports(
+    code: str, doc_title: str, package_ecosystem: Literal["langchain", "langgraph"]
+) -> List[ImportInformation]:
+    """Get imports from the given code block.
+
+    Args:
+        code: Python code block from which to extract imports
+        doc_title: Title of the document
+        package_ecosystem: "langchain" or "langgraph". The two live in different
+            repositories and have separate documentation sites.
+
+    Returns:
+        List of import information for the given code block
+    """
+    imports = []
+
+    if package_ecosystem == "langchain":
+        pattern = _IMPORT_LANGCHAIN_RE
+    elif package_ecosystem == "langgraph":
+        pattern = _IMPORT_LANGGRAPH_RE
+    else:
+        raise ValueError(f"Invalid package ecosystem: {package_ecosystem}")
+
+    for import_match in pattern.finditer(code):
+        module = import_match.group(1)
+        if "pydantic_v1" in module:
+            continue
+        imports_str = (
+            import_match.group(2).replace("(\n", "").replace("\n)", "")
+        )  # Handle newlines within parentheses
+        # remove any newline and spaces, then split by comma
+        imported_classes = [
+            imp.strip()
+            for imp in re.split(r",\s*", imports_str.replace("\n", ""))
+            if imp.strip()
+        ]
+        for class_name in imported_classes:
+            module_path = _get_full_module_name(module, class_name)
+            if not module_path:
+                continue
+            if len(module_path.split(".")) < 2:
+                continue
+
+            if package_ecosystem == "langchain":
+                pkg = module_path.split(".")[0].replace("langchain_", "")
+                top_level_mod = module_path.split(".")[1]
+
+                url = (
+                    _LANGCHAIN_API_REFERENCE
+                    + pkg
+                    + "/"
+                    + top_level_mod
+                    + "/"
+                    + module_path
+                    + "."
+                    + class_name
+                    + ".html"
+                )
+            elif package_ecosystem == "langgraph":
+                if (module, class_name) not in WELL_KNOWN_LANGGRAPH_OBJECTS:
+                    # Likely not documented yet
+                    continue
+
+                source_module, namespace = WELL_KNOWN_LANGGRAPH_OBJECTS[
+                    (module, class_name)
+                ]
+                url = (
+                    _LANGGRAPH_API_REFERENCE
+                    + namespace
+                    + "/#"
+                    + source_module
+                    + "."
+                    + class_name
+                )
+            else:
+                raise ValueError(f"Invalid package ecosystem: {package_ecosystem}")
+
+            # Add the import information to our list
+            imports.append(
+                {
+                    "imported": class_name,
+                    "source": module,
+                    "docs": url,
+                    "title": doc_title,
+                }
+            )
+
+    return imports
+
+
+class ImportPreprocessor(Preprocessor):
+    """A preprocessor to replace imports in each Python code cell with links to their
+    documentation and append the import info in a comment."""
+
+    def preprocess(self, nb, resources):
+        self.all_imports = []
+        file_name = os.path.basename(resources.get("metadata", {}).get("name", ""))
+        _DOC_TITLE = _get_doc_title(nb.cells[0].source, file_name)
+
+        cells = []
+        for cell in nb.cells:
+            if cell.cell_type == "code":
+                cells.append(cell)
+                imports = _get_imports(
+                    cell.source, _DOC_TITLE, "langchain"
+                ) + _get_imports(cell.source, _DOC_TITLE, "langgraph")
+                if not imports:
+                    continue
+
+                cells.append(
+                    nbformat.v4.new_markdown_cell(
+                        source=f"""
+<div>
+<b>API Reference:</b>
+{' | '.join(f'<a href="{imp["docs"]}">{imp["imported"]}</a>' for imp in imports)}
+</div>
+                    """
+                    )
+                )
+            else:
+                cells.append(cell)
+        nb.cells = cells
+        return nb, resources

docs/_scripts/notebook_convert.py

@@ -0,0 +1,126 @@
+import os
+import re
+from pathlib import Path
+
+import nbformat
+from nbconvert.exporters import MarkdownExporter
+from nbconvert.preprocessors import Preprocessor
+
+from generate_api_reference_links import ImportPreprocessor
+
+
+class EscapePreprocessor(Preprocessor):
+    def preprocess_cell(self, cell, resources, cell_index):
+        if cell.cell_type == "markdown":
+            # rewrite markdown links to html links (excluding image links)
+            cell.source = re.sub(
+                r"(?<!!)\[([^\]]*)\]\((?![^\)]*//)([^)]*)(?:\.ipynb)?\)",
+                r'<a href="\2">\1</a>',
+                cell.source,
+            )
+            # Fix image paths in <img> tags
+            cell.source = re.sub(
+                r'<img\s+src="\.?/img/([^"]+)"', r'<img src="../img/\1"', cell.source
+            )
+
+        elif cell.cell_type == "code":
+            # escape ``` in code
+            cell.source = cell.source.replace("```", r"\`\`\`")
+            # escape ``` in output
+            if "outputs" in cell:
+                filter_out = set()
+                for i, output in enumerate(cell["outputs"]):
+                    if "text" in output:
+                        if not output["text"].strip():
+                            filter_out.add(i)
+                            continue
+
+                        value = output["text"].replace("```", r"\`\`\`")
+                        # handle a funky case w/ references in text
+                        value = re.sub(r"\[(\d+)\](?=\[(\d+)\])", r"[\1]\\", value)
+                        output["text"] = value
+                    elif "data" in output:
+                        for key, value in output["data"].items():
+                            if isinstance(value, str):
+                                value = value.replace("```", r"\`\`\`")
+                                # handle a funky case w/ references in text
+                                output["data"][key] = re.sub(
+                                    r"\[(\d+)\](?=\[(\d+)\])", r"[\1]\\", value
+                                )
+                cell["outputs"] = [
+                    output
+                    for i, output in enumerate(cell["outputs"])
+                    if i not in filter_out
+                ]
+
+        return cell, resources
+
+
+class ExtractAttachmentsPreprocessor(Preprocessor):
+    """
+    Extracts all of the outputs from the notebook file.  The extracted
+    outputs are returned in the 'resources' dictionary.
+    """
+
+    def preprocess_cell(self, cell, resources, cell_index):
+        """
+        Apply a transformation on each cell,
+        Parameters
+        ----------
+        cell : NotebookNode cell
+            Notebook cell being processed
+        resources : dictionary
+            Additional resources used in the conversion process.  Allows
+            preprocessors to pass variables into the Jinja engine.
+        cell_index : int
+            Index of the cell being processed (see base.py)
+        """
+
+        # Get files directory if it has been specified
+
+        # Make sure outputs key exists
+        if not isinstance(resources["outputs"], dict):
+            resources["outputs"] = {}
+
+        # Loop through all of the attachments in the cell
+        for name, attach in cell.get("attachments", {}).items():
+            for mime, data in attach.items():
+                if mime not in {
+                    "image/png",
+                    "image/jpeg",
+                    "image/svg+xml",
+                    "application/pdf",
+                }:
+                    continue
+
+                # attachments are pre-rendered. Only replace markdown-formatted
+                # images with the following logic
+                attach_str = f"({name})"
+                if attach_str in cell.source:
+                    data = f"(data:{mime};base64,{data})"
+                    cell.source = cell.source.replace(attach_str, data)
+
+        return cell, resources
+
+
+exporter = MarkdownExporter(
+    preprocessors=[
+        EscapePreprocessor,
+        ExtractAttachmentsPreprocessor,
+        ImportPreprocessor,
+    ],
+    template_name="mdoutput",
+    extra_template_basedirs=[
+        os.path.join(os.path.dirname(__file__), "notebook_convert_templates")
+    ],
+)
+
+
+def convert_notebook(
+    notebook_path: Path,
+) -> Path:
+    with open(notebook_path) as f:
+        nb = nbformat.read(f, as_version=4)
+
+    body, _ = exporter.from_notebook_node(nb)
+    return body

docs/_scripts/notebook_convert_templates/mdoutput/conf.json

@@ -0,0 +1,5 @@
+{
+  "mimetypes": {
+    "text/markdown": true
+  }
+}

docs/_scripts/notebook_convert_templates/mdoutput/index.md.j2

@@ -0,0 +1,33 @@
+{% extends 'markdown/index.md.j2' %}
+
+{%- block traceback_line -%}
+```output
+{{ line.rstrip() | strip_ansi }}
+```
+{%- endblock traceback_line -%}
+
+{%- block stream -%}
+```output
+{{ output.text.rstrip() }}
+```
+{%- endblock stream -%}
+
+{%- block data_text scoped -%}
+```output
+{{ output.data['text/plain'].rstrip() }}
+```
+{%- endblock data_text -%}
+
+{%- block data_html scoped -%}
+```html
+{{ output.data['text/html'] | safe }} 
+```
+{%- endblock data_html -%}
+
+{%- block data_jpg scoped -%}
+![](data:image/jpg;base64,{{ output.data['image/jpeg'] }})
+{%- endblock data_jpg -%}
+
+{%- block data_png scoped -%}
+![](data:image/png;base64,{{ output.data['image/png'] }})
+{%- endblock data_png -%}

docs/_scripts/notebook_hooks.py

@@ -0,0 +1,40 @@
+import logging
+from typing import Any, Dict
+
+from mkdocs.structure.pages import Page
+from mkdocs.structure.files import Files, File
+from notebook_convert import convert_notebook
+
+logger = logging.getLogger(__name__)
+logging.basicConfig()
+logger.setLevel(logging.INFO)
+
+
+class NotebookFile(File):
+    def is_documentation_page(self):
+        return True
+
+
+def on_files(files: Files, **kwargs: Dict[str, Any]):
+    new_files = Files([])
+    for file in files:
+        if file.src_path.endswith(".ipynb"):
+            new_file = NotebookFile(
+                path=file.src_path,
+                src_dir=file.src_dir,
+                dest_dir=file.dest_dir,
+                use_directory_urls=file.use_directory_urls,
+            )
+            new_files.append(new_file)
+        else:
+            new_files.append(file)
+    return new_files
+
+
+def on_page_markdown(markdown: str, page: Page, **kwargs: Dict[str, Any]):
+    if page.file.src_path.endswith(".ipynb"):
+        logger.info("Processing Jupyter notebook: %s", page.file.src_path)
+        body = convert_notebook(page.file.abs_src_path)
+        return body
+
+    return markdown

docs/_scripts/prepare_notebooks_for_ci.py

@@ -0,0 +1,215 @@
+"""Preprocess notebooks for CI. Currently adds VCR cassettes and optionally removes pip install cells."""
+
+import logging
+import os
+import json
+import click
+import nbformat
+
+logger = logging.getLogger(__name__)
+NOTEBOOK_DIRS = ("docs/docs/how-tos","docs/docs/tutorials")
+DOCS_PATH = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+CASSETTES_PATH = os.path.join(DOCS_PATH, "cassettes")
+
+BLOCKLIST_COMMANDS = (
+    # skip if has WebBaseLoader to avoid caching web pages
+    "WebBaseLoader",
+    # skip if has draw_mermaid_png to avoid generating mermaid images via API
+    "draw_mermaid_png",
+)
+
+NOTEBOOKS_NO_CASSETTES = (
+    "docs/docs/how-tos/visualization.ipynb",
+    "docs/docs/how-tos/many-tools.ipynb"
+)
+
+NOTEBOOKS_NO_EXECUTION = [
+    # this uses a user provided project name for langsmith
+    "docs/docs/tutorials/tnt-llm/tnt-llm.ipynb",
+    # this uses langsmith datasets
+    "docs/docs/tutorials/chatbot-simulation-evaluation/langsmith-agent-simulation-evaluation.ipynb",
+    # this uses browser APIs
+    "docs/docs/tutorials/web-navigation/web_voyager.ipynb",
+    # these RAG guides use an ollama model
+    "docs/docs/tutorials/rag/langgraph_adaptive_rag_local.ipynb",
+    "docs/docs/tutorials/rag/langgraph_crag_local.ipynb",
+    "docs/docs/tutorials/rag/langgraph_self_rag_local.ipynb",
+    # this loads a massive dataset from gcp
+    "docs/docs/tutorials/usaco/usaco.ipynb",
+    # TODO: figure out why autogen notebook is not runnable (they are just hanging. possible due to code execution?)
+    "docs/docs/how-tos/autogen-integration.ipynb",
+    # TODO: need to update these notebooks to make sure they are runnable in CI
+    "docs/docs/tutorials/storm/storm.ipynb",  # issues only when running with VCR
+    "docs/docs/tutorials/lats/lats.ipynb",  # issues only when running with VCR
+    "docs/docs/tutorials/rag/langgraph_crag.ipynb",  # flakiness from tavily
+    "docs/docs/tutorials/rag/langgraph_adaptive_rag.ipynb",  # Cannot create a consistent method resolution error from VCR
+    "docs/docs/how-tos/map-reduce.ipynb"  # flakiness from structured output, only when running with VCR
+]
+
+
+def comment_install_cells(notebook: nbformat.NotebookNode) -> nbformat.NotebookNode:
+    for cell in notebook.cells:
+        if cell.cell_type != "code":
+            continue
+
+        if "pip install" in cell.source:
+            # Comment out the lines in cells containing "pip install"
+            cell.source = "\n".join(
+                f"# {line}" if line.strip() else line
+                for line in cell.source.splitlines()
+            )
+
+    return notebook
+
+
+def is_magic_command(code: str) -> bool:
+    return code.strip().startswith("%") or code.strip().startswith("!")
+
+
+def is_comment(code: str) -> bool:
+    return code.strip().startswith("#")
+
+
+def has_blocklisted_command(code: str, metadata: dict) -> bool:
+    if 'hide_from_vcr' in metadata:
+        return True
+    
+    code = code.strip()
+    for blocklisted_pattern in BLOCKLIST_COMMANDS:
+        if blocklisted_pattern in code:
+            return True
+    return False
+
+
+def add_vcr_to_notebook(
+    notebook: nbformat.NotebookNode, cassette_prefix: str
+) -> nbformat.NotebookNode:
+    """Inject `with vcr.cassette` into each code cell of the notebook."""
+
+    # Inject VCR context manager into each code cell
+    for idx, cell in enumerate(notebook.cells):
+        if cell.cell_type != "code":
+            continue
+
+        lines = cell.source.splitlines()
+        # skip if empty cell
+        if not lines:
+            continue
+
+        are_magic_lines = [is_magic_command(line) for line in lines]
+
+        # skip if all magic
+        if all(are_magic_lines):
+            continue
+
+        if any(are_magic_lines):
+            raise ValueError(
+                "Cannot process code cells with mixed magic and non-magic code."
+            )
+
+        # skip if just comments
+        if all(is_comment(line) or not line.strip() for line in lines):
+            continue
+
+        if has_blocklisted_command(cell.source, cell.metadata):
+            continue
+
+        cell_id = cell.get("id", idx)
+        cassette_name = f"{cassette_prefix}_{cell_id}.msgpack.zlib"
+        cell.source = f"with custom_vcr.use_cassette('{cassette_name}', filter_headers=['x-api-key', 'authorization'], record_mode='once', serializer='advanced_compressed'):\n" + "\n".join(
+            f"    {line}" for line in lines
+        )
+
+    # Add import statement
+    vcr_import_lines = [
+        "import nest_asyncio",
+        "nest_asyncio.apply()",
+        "import vcr",
+        "import msgpack",
+        "import base64",
+        "import zlib",
+        "import os",
+        "os.environ.pop(\"LANGCHAIN_TRACING_V2\", None)",
+        "custom_vcr = vcr.VCR()",
+        "",
+        "def compress_data(data, compression_level=9):",
+        "    packed = msgpack.packb(data, use_bin_type=True)",
+        "    compressed = zlib.compress(packed, level=compression_level)",
+        "    return base64.b64encode(compressed).decode('utf-8')",
+        "",
+        "def decompress_data(compressed_string):",
+        "    decoded = base64.b64decode(compressed_string)",
+        "    decompressed = zlib.decompress(decoded)",
+        "    return msgpack.unpackb(decompressed, raw=False)",
+        "",
+        "class AdvancedCompressedSerializer:",
+        "    def serialize(self, cassette_dict):",
+        "        return compress_data(cassette_dict)",
+        "",
+        "    def deserialize(self, cassette_string):",
+        "        return decompress_data(cassette_string)",
+        "",
+        "custom_vcr.register_serializer('advanced_compressed', AdvancedCompressedSerializer())",
+        "custom_vcr.serializer = 'advanced_compressed'",
+    ]
+    import_cell = nbformat.v4.new_code_cell(source="\n".join(vcr_import_lines))
+    import_cell.pop("id", None)
+    notebook.cells.insert(0, import_cell)
+    return notebook
+
+
+def process_notebooks(should_comment_install_cells: bool) -> None:
+    for directory in NOTEBOOK_DIRS:
+        for root, _, files in os.walk(directory):
+            for file in files:
+                if not file.endswith(".ipynb") or "ipynb_checkpoints" in root:
+                    continue
+
+                notebook_path = os.path.join(root, file)
+                try:
+                    notebook = nbformat.read(notebook_path, as_version=4)
+
+                    if should_comment_install_cells:
+                        notebook = comment_install_cells(notebook)
+
+                    base_filename = os.path.splitext(os.path.basename(file))[0]
+                    cassette_prefix = os.path.join(CASSETTES_PATH, base_filename)
+                    if notebook_path not in NOTEBOOKS_NO_CASSETTES:
+                        notebook = add_vcr_to_notebook(
+                            notebook, cassette_prefix=cassette_prefix
+                        )
+
+                    if notebook_path in NOTEBOOKS_NO_EXECUTION:
+                        # Add a cell at the beginning to indicate that this notebook should not be executed
+                        warning_cell = nbformat.v4.new_markdown_cell(
+                            source="**Warning:** This notebook is not meant to be executed automatically."
+                        )
+                        notebook.cells.insert(0, warning_cell)
+
+                        # Add a special tag to the first code cell
+                        if notebook.cells and notebook.cells[1].cell_type == "code":
+                            notebook.cells[1].metadata["tags"] = notebook.cells[1].metadata.get("tags", []) + ["no_execution"]
+
+                    nbformat.write(notebook, notebook_path)
+                    logger.info(f"Processed: {notebook_path}")
+                except Exception as e:
+                    logger.error(f"Error processing {notebook_path}: {e}")
+    
+    with open(os.path.join(DOCS_PATH, "notebooks_no_execution.json"), "w") as f:
+        json.dump(NOTEBOOKS_NO_EXECUTION, f)
+
+
+@click.command()
+@click.option(
+    "--comment-install-cells",
+    is_flag=True,
+    default=False,
+    help="Whether to comment out install cells",
+)
+def main(comment_install_cells):
+    process_notebooks(should_comment_install_cells=comment_install_cells)
+    logger.info("All notebooks processed successfully.")
+
+
+if __name__ == "__main__":
+    main()

docs/cassettes/LLMCompiler_0b3a0916-d8ca-4092-b91c-d9e2b05259d8.msgpack.zlib

@@ -0,0 +1 @@
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 truncated

docs/cassettes/LLMCompiler_152eecf3-6bef-4718-af71-a0b3c5a3b009.msgpack.zlib

@@ -0,0 +1 @@
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 truncated

docs/cassettes/LLMCompiler_15dd9639-691f-4906-9012-83fd6e9ac126.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/LLMCompiler_31854dfd-b82f-4c24-9b58-6bae66777909.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/LLMCompiler_38d3ea91-59ba-4267-8060-ed75bbc840c6.msgpack.zlib

@@ -0,0 +1 @@
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 truncated

docs/cassettes/LLMCompiler_391d6931.msgpack.zlib

@@ -0,0 +1 @@
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 truncated

docs/cassettes/LLMCompiler_55142257-2674-4a47-988e-0d2810917329.msgpack.zlib

@@ -0,0 +1 @@
+eNrtPAtwXNV1AiYp0NKQKSakgfayNciSd1f7drU/OYJIq49l6y9ZH1tm9fa9u9pnvX1veR/tro0CIRTSUJzZOkDKhBhqWSYuGCd2KZ+QEKYpDAm0M0xjzBA65EOHksQUUkImk6HnvHvffiwZO6SdSWfZ8Vj73j333PM/57695914YIEapqJrZ92vaBY1RMmCC3PPjQcMeq1NTeum5Sy1Mrq8NDw0Nr7PNpTjzRnLypltLS1iTvHrOaqJil/Ssy0LQouUEa0W+J5TqYNmKaXLxRc/sm6XJ0tNU5yjpqeNbNvlkXRYS7PgwtOrLFCNiMQ2qUFgRaPoJZJBRYvCzZwqasTSiamrC5QoFskrVoZYGUpsK6ubFsmJhqiqVFV2iilFVayin3SLUoZNNDO6rcoE6TEUE/DBOg57JG3oWQdNWldVPa9ocyRErGKOmm0zmuAnlrigqMWkSUVDyiQNatqqZSZ3mLq2ziGxfcaDs9k4o3rG00R8QDK/R7U5RaP+GW1GC/pJVrQy63KGnlJpto2YlgE8oggKVhsZyiFJorpNVUxrG4xt3w6YriJpVRctIAewjiH7pkMwIFlQZCo7KAlH6XegZvnVLJGA0xQlFIQFQgWaFNRIzRSyjvrn/GTGI5D1JITE6wiZ1w15BUhGz8NcrUjEHKAxiWhQpAX+V9L8C94Klcc1mQT5BWBm1E3rNtKl6Rb8USVbRQ1nQa4KkkYLOZAy2qFJFI3oGkUo1U96gCxFMy1Rk6iXzDqCbHRo9sIa60lrY9MskXVYFTED+fN+0pcmRVhNoyAmMJ73Xs57MqyKLGVBj2hbFlWLRFXmac3SuCYyCYCaO+AS4zA7oGhKVtnpiIlodjYFatDTDHSWGyHIyQSKwFbgb04HakDoJzOM36go42QkDQ3VNacZTx68jSjMLoTAFQi0VkBVlmlz2AmVJ6xF6tcGAYRxPbBlbJzBnAJpDVZOi5fkMwpQnVdgnkFlWzqZTcfOOJM1yic6t3UQKjdksDm0e5wGpg/8OWKZ5d4xizrJUDXnrADxQ7N4LOC+4Fg/KrxihmUlcxxmjYJFzcwDlTjdCW9ADpMFkufS5BgAkLGCNu5o1WpkckDjMykjS7etnO3MYkTSBUW3zbLWbQ3cghHlrgeBrZppvyMvRzlVFJ0Ob43YlFoXkHWmFCBXsSoqcZYY7J7oHi0vNMvi16wTDTnuRpOvbTKhLIiGIoLk0VORlErgEY05OwtK8pPxDNgQ/EtRSYTQXsFrUMs2kFyClJKUqqcACdgc0i6CjTkoFS2tG0AyClhMwerOXcAMId7rSFssG5wBBKk2xTXBBmAeRRMF66+WQNnctCo5lolifFY5Ra1mxCrJuiwi0hpDYK5LCyLGWi+BLMKwg091QiSR5slQSsyKNf5ZcTuw7SpPM7lWRMxOVPaTLSDCFcC1aMsppX0bevqMZ3vZZZnGJ12ZiOY8sOSaP5dvmUMvMXNUUtJFlmc1xTJPjkqVKFEooBFkqDKXsa6e8aAyTh7Mgn+ggeJwVTirBoMhTJQQqHboirauqY0kIC9TyWK5BBJ4CpKpSXgiZukbcjqmrHKYcXjs0Eh//wCPFIAbgxsYgJ1Dy9cW9HmMoGwRVCDPkGkFYpIbriuFCHKTF8EEbLA7lXkd1BUsAdIClWyLctkiSrfeENW8WETLd2aoIkQQHiq4vyASr8OZEztS1CUTx/NQ7UhQUwF3WIwQQtaJTTzRutGL53eZQsGWBcnIJFUkcyLygvxVggUXlQUaN5FfEAvFpMZqH+QaZQrCMbFUwbVSq6yF7la7XBUjGq6Yy4hgoCnH+RwT49KpyMxPem1wKBX1yIoap07jgpGpKRlKCjCDMS7QSixQNOCihXusU6A5cmPwTjJhdPOAlrVB2BirJQtSjCg7SQH4ZiEFceDsGnRpdNoKKWV04xlaS12OhVlOmoNyrsxSVcguL89qSwDUzWrQSmzCuGiVl+HJpVosVWJ2jauMHRSCVRLPBkxsDkforHxhSoaLsLyGRC9g8EQGVmG4dlWHi4y4gLkZ3B9cgfR1uVkffKpMgqJhoW6CATAkfRozuYpbOpbKnSzlqBVDCMAASI2FQjaTqIym5AoDsHH/sSzHDE0IPK7EWHIgaxWW3ShYKBvo6zpFfgTyUQ1c9a7fle2CMdDBPNepiByPFs338mE/GROLpPGT3YNdyaGe5HB/x+BVjURMI72spOB4mIg10zYqHgGxvODUiOYqmxhnwpAGMnY5Ltf9nAyuaqh8RB6sKo4qyjJWtxj3TB4PTKeWhPjHsDHm+F5IZ+WQhukYwnOOG+IghZ0hTLIM3anxNJovq1V3NAppmwlDR7N2KfRDJvIYukpxd2cWAWPWs+glNZu+SQj9jUy2MJzDmISyAaLGeoghKiZL2jgewg0JJEHj6mq8GKRXYB2lWYolgZcMDfZP88gmV/aMGAZZRceVKOkG2J3Fzely0g37HQhOilyALaCuq+sg2Sc1MUvb4YvZtBpj2+FeVgfXxptzOcvX6gNWUrrPsT+axzkajAnwFxyHilm4sAwb9OGpYh1uBvzRxQMZyI6wH3+54cIlsFerdKh2j/2gKEkUFqGapKO3lB6Y26nkvOABadzgHARhaNTRUengPKU5H6S1BbrMZpUO45ZMkZyqqgU3s/dz4fnQmlYOH0Qp+5xcWjo6BER09LXwgCL4W2P+wOGCz8RgiAWtD2x6rrScc8Yfqx7IQZECSHz8QUNpmU0+VA2jm6X9A6I0NFaDEsun0n7RyEZaj1TfNzAhZ2npQGJ45XJ8sLJcyC8E/a1fq0FsFjWptD8tqib9x5rJ1DKKPkkHHKV7A8uSDhUDLR1/M5mU0slUtr1r60ihkC4Kk0JkQc+PT21Jdo2OROeE3LVC3m/35dL6xmFhOjM2rm7xCdFgNBSJhKMxn+AP+AW/4IsXE0OhiQGrs6t7c/ekPNQzMZeyIzFjXkrbozuHJjo7M6OJPlHum0wXe/s7+9P6xOSI1THS2RoOZCJmVu1pDUT0rRuVsdGebv+OyfiIaMY7NhCgzgbna9fMiYFix/z81HRPT35grhCf2rFxpLNL7RmeNgvjUqK3uLEzmxjr9vdPV5EXCwu+AKcwEmiNBfBzyLUNlWpzVqa0FIrFAve51cJnl0Fmlm3euASGSL/39AH+fOfvhjZXbHjNUhcYZenx8YwNm/UIGaM5EgwEW4kQaQuE2gIC6R0Yvz/B1xlHGzzu7ApaKGYrH/OXDUTKiIZJrXbbSvtiXxs3oJxIg2F2u05wQMrY2jyVDyZWNf/H0fxBt8gQuK8PNv+QCnyczNL9U75R9qjL19d1hPmaTzfmRA3isYPrq2jaQISiHeXDEOsQJSzuy5qlfZFA7BAfca3uIDAa8AkBX0B4hCVMn4WE53QDGIPiyIA4XzruhSyAHtYeEsKhCIh9A2ZV1ZbpmJ3q0rNYBG3AXKbqovxowec8kYC0AWpx/ucP6cB7BFTawyshLIj5mlk6EHS0GvhmNYRBcQHkooxnKQ6fb6wO5KISACQQDT5aCwUaqqDZF8maD68c5xiWgtGseX/BBfcpcun4WrhICnHA3SqkxbBAI4FUNC2nUnI4nU6JYjAKVw8menwJKFWob8wxv9KBrunBjoG+xENTvmo78rGHajCu6aampNPLY9QA1ZQOSqpuyxAsDboMuEY7pktHY1K8NZpqjcVoPC6E4zHf2KbEAVEFNS1IpSOZULunrbU15NkAGbs9FmkNBJynmp9ZZs8EXmzcKYuW2AapSJE9bR58BCrBFtDX0an2dC8YUiEsq51j062JQUsengiqMcWYL3i8Hj21A2yVz/BXHpr6HWsGAPYUFHC6nhoLeN1cw1NNQAiGK5mGJ6UkFPZz1ID9EaZFzVZVwJXRFQmfvm4DMjWZFjxtgAxQWaKnbRfPah4RTNop0HB1N6964AK21bYpqgzbotej6nO45zdd9LCiYuKDUhHSBofavnj++f//JVMRg+CpU8b99co4/gxQr7wrarFeWec/+9Qt+/wpW93yj1ufemWe/bxZr9y3z3jqlXXYkBj4rW5TfdWzmHqVgVK3YY+MifXLe48hapJiSnq9SmDG0zRTt+oPfrCtrTeHx1MEdVvg8rMqH5S4dcd6oW4dvrm5blmvV8ZD9VvMeevW2PkRvrrNbdvqN7mt9Xzws1y9BbrtdbxtDX2wba237IaHFut229r0yXplvXuwq25/ihzqqVvW8TR1vTJ/VV0xfnpePaal5zxV3G7rGhrs3n7++afuUn68ukmZtfM6TcrsbAfrSz7ro7s8MJycp0U8vW0tqEVfPpeL7MjqyrCa2bgjoI5MCFnaqU6EzNjgpsCkthHPc7PfyGEG/9F0xRl2Uav6UQUPiIuF8qkKfhScdRbLNGdlEJMoL2BrlYzQ/ABoUmbHP7FjGk+Z08Kqt11o1q4Dd51DzVUDhphPVg7JnzyqZHlXtjNQPoB+88EtePa7wzn7/RA71F0+3dkS9Ifg34Md7DB69+qH0ZfZcGlfc0vzKU7mHnLPbPazM8b7wNJqzwOvOJP+25xA/kv31Od+bMYunOY0cnjlaeSVJ+LPkI+wEKs9JHr2h3e5ZnOGVuNh7UNJO5d0O/XK7uHqml25KgRz8JStDDzNUiznVGcNYi9JdJBJ6vSKESBbVlhHx3Xlm1vAQY05Q7c1sEaPbaC/u86Uz+f9ebsC4LhUnk1ssc0WSWwxRc2XrmKjEtUSnG93IWw8GdZztioCJUAGNYmfrCQ2HCVPHiY9ZEA3sekogQd4ixvIgKhB5LKwk25wmkTCDMgdHZMyiqrCIsOiMe8lff1kXSQgRCNNJBxjkD2iYmwgnYAUGz8HOkhEqEWxUbfZ2PgUiXL0fr8fA52kY8dGwB+PB0PxUCuIvdrHWGR2dOFYahLbESCO+uORxf/N1yqc+8fv8VoF55S8yt6iUNP3D2FZh3uVDnjefctfGcC7GnnnEGuvaDSx1xZnEFVJGaJRZA2ptU3Jhs16AS3Line truncated

docs/cassettes/LLMCompiler_5bc4584a-e31c-4065-805e-76a6db30676a.msgpack.zlib

@@ -0,0 +1 @@
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 truncated

docs/cassettes/LLMCompiler_730490c6-6e3a-4173-82a1-9eb9d5eeff20.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/LLMCompiler_942dab42-ad42-4ba2-90d5-49edbe4fae68.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/add-summary-conversation-history_048805a4-3d97-4e76-ac45-8d80d4364c46.msgpack.zlib

@@ -0,0 +1 @@
+eNrtV3lUE9caV5GKuBRXFHn1GlRKJSEhIRCKIIuyqIAQFyoWJzM3ZGQyE2cmQERkKS4V+mzUqrza50IAi4hoq9C6YpXiUrVuFXd9tVi1Yl37tNR3ZwiKbd9pe07fe+e8Y/7Imbn3ft/3+37fMt/NL0+HLEcydMdKkuYhi+E8euEW55ezcKYZcnxBmRHyBoawxcclakvMLNk4zMDzJi7QxwczkTKM5g0sYyJxGc4YfdIVPkbIcVgq5Gw6hrCccSjLkhixzBSeSYM0JwkECrmvyhtI2k6hlalZEpahIHqSmDnIStAuziAoNC8sGcghINrTCHSMTpLtDZ6dxTiO5Hhk/mcCUZCiGBDG6JAc78kBmsQh4BlghJAHFsYsA1FMBsAxGkSDVh3CKjpBYJaQ5038CpwMAyYoNVoAjRlhyO+DlIT0cxhJCIZYURCQnADRG3AM4JFK4Z03wNa9aJBBUhSCiP5EwKEcQHBD2/AiA97oEMHQnjxA8TKjgxZgwNIhwEAGZhG8JWkCmiD6o3m0h0JM6i3tzEuRvEABQ6PdVAboLEDwrJUJRCBiSwbiKYhxEFCINySSRiPaSL14pNUWbQEMAs0CMU+ErLFrNUDKhHzgDUN+k08SUGQaFH3HIcWTODfk93GqbQ1EKgsRbN6O3ZMVKNALjulFnWEMxzM0CLerBlq0Zn8BmHjYgLQzLImD2LBQoGcxGkcrUESPdtGGAfAsRpCCf4JWzozjKHdlYLJgk2BEPiA9g7EAIzIGMB1j5oEOknQqkm+zhSCFgAimHXloKR3Z5SEwUZgFkciwSIEReYdi91SuFd3vyEs7jwYUI6NZwGyAKKQkLcmeJlQbQ0BKOIZTmJmAUqXUgJFpZqkvKka5Uu4vyS43QIxAjWCRzYC8sG76RWlvxJDfJl4KaZwhkHPWDamzSJM3IKCewnhYgbDQUOwd1oo0CE1SjCLTYVmrlLUaM5koEseEfZ8ZHENX2rFLeYsJ/nK7QnBRihoEzVtrQttw+MRbUCeigVymVMl8qzOlKDFImkLhkFIYglRmEve3td8wYXga0iO1dzlrWatwVfszDGctHY/hcYnPqcRY3GAtxVijWvVR+3XWTPOkEVrLw+N/ac6++cycUqZQyDSbnlPMWWjcWqrHKA5uekryU5EKFBWlVK6WyhVVbSxRkE7lDdYSjVK1joWcCdUafKsMqeTNXL4NRQQeaii399S1cWPbollki0Cxse7QGszewFcNEqEJCDEHCmWgUh2okoPI8drKcLsR7a+GYpMWFQWnR+EY3Rb6ctxgptMgURH+q0GvsH85pCRh3Y6eU+QKTeQ4whgJLXwYTEocozYR+inpuP+WTClOMWZCiioMh1LR2Uze2gg0UKHTyyFE2enrq/TTEHKNEuowPa5SQ7Wa8C1JJzFrhUKmQL2LSaXgxvAx0nAMN0BpokiJtTwiKTZ0fHR45RRpAqNjeE6qxVKtNpqhYVkiZBHV1grRNEpeFpYh8YTQJOvHAbhGiamgrz8BMZVSpZeOnpxQ3UbPU/dtQuaLn7c8FAIWLe3r9N7gQqcO4s8hObGOPqd2aXnPy2dnQ+HJwPv1n+4LfdfmtHDtFxu8iqwBi8vG9ph42OBfcTnHp+F8bWzs0KjDWcyFoODAB1Uzl/R8+eyjlpnLcpoydmUbmxcNDt5Rc/zy8YstFyYePlV8Z0TCvrzkqwnd/9lhYlKPfclXy6551dabO7rGfeX/lccd7JMLxoyNW/3PFh0brejNfbFq0UWXd3Z+c2az6tbdBeml1QvKl2Ijt+bNyT/iUTfVuf6DPQsi85dFAefQm3Vj8r0q8mTTIitaeq+Oe/V8Q4yz9+0bLYMGJEnLzA45e9++NGrEvdPFnbbO3JQ/c0htfp/C6u7Tu44cFEnubHD95PBrp5QtXs5g6HXdnfjmbqH+V1Rc379YTl3Pmbipy9J+RaYzhFOsS3yPIqkLHzBhWe1ZOoWZYys+mtjxbw5Vm5rHKh+7bb5y+rOf+i+NL3n11bEZc9yc5s+9VOCcfSj4UbL24o5PW1654PBm0OWexyQDq6t2Na/VXghaUt133qNbTRs6LZx/dsMkl4bwbWGr8/aO6Bzsco5zuv14bcwQrWnw1MxBrtPWJ9wf6+4YfElhipxfuG7R4vNDFVO6Hm/cef961LuGsP4HZqTGDN0z4JK7R9yH+V1fhtqQFdrmncNKMlvWvl15ybIbuv19UaW7463dmRLHXba7UrdrRQmqOYc+ce+9Jm+0oavLLO8qrFi68nS9e10vlxMJSy8Xpw4/Ei45s737nX7TD+YZv8ictvTHRVHelUf3kcM9ruGB5RGFI3J3TAhkkuoSj+wZgzkWLOuyQtFYmhY7iiUdmorl1LnjKe8lFt4Nfy22tt76Q5epi2sPzj0W0i06sso6rOCA9Op6/0V/hW/erLuSFzEtcdeFiTLZgztUzdmQkS1dOnR48sShw+bO47rFdO7Q4U8a4rqwL4a4F0PciyHufzfE/QEyzbTw5Uf7BKaj4PNsiah1EAo5A9voFT22M6I3U8/44wQnBEbtDshAIiPkEAKlRxnL2WninxnwFNDSAmtP6Q5MppNpqYDCnt0ZKAQoJhBnWAIo/EUDuAEzmoTcM5AmzvsZKoRQSFAeYkaZoIJkAYWhdZ7kKZRrYg3SaKKRB8h+bsaIBiBRkRAZRq8XnfFXAAExUuuvBhwqDCHdOZLGW4+iUkk1I4QYijUj8EgIQgqNSv28eqJ9yqGJT1CoUDzvhSipfGoEvQkWFBo/udAHCKCWI0cpZAFVLQXRoEtwrdEPE9pGgpnjUAV7C/0FhDNmzuItSsUwBhpEYeloQoNpdlDRtMCmkHMWiLGt9Fk8EQUsNKKREwpoTZCFKDAYakhiwqAU8UYUpYmh+hlJCt+2zBC5bueEgOBpgMVoEGQ6KQytQAOEsZcDhJlt3UV1xZkwWsQY3a7IUZtqV96YGNvWQuWElMcAmqgYpKHNjgkSJBKFsvaJ7IlSj6RIXuySyCOhIFqbJPp+mSCqRz2qRDFLOJEVgOl5VJ7iI+rS6NJC0qhskQAGdCSygrG83WvkFeKn1Q00C0OMkv1m4YYLvglucWajEWMtbQSiI8JULw7TQrWkw8AXF7L/pwuZTaGRq//MG5nvf+tGFmbQZyoC4AQmKS1D66dUG4yzIiLV//ZGplJqMB3Uq1U6lVzvC3G1TqknoJ+eUOs0uMJX/R++kRFKnYr4Yzeykmc3MkpbR7v7d2/pF+aaUl9ftQTcTnZmEm0dF66eLxn1ZeeXJn820Gv9kHLJ1fu7b+9yPTbLNfieKjcqeMfDH1RHZD2rMj6Kffn971Zd/Ob74/PhyhrLo/SM8lUh556kPzxuPnxq7gzXD69EVHFJCSNHnVw3j6riPuq+NLl59h7fo/e33cj9Pr6K8a9p9m9WD57WtL261/s3nliCPdxGnmx88O355qVd13bKX2ap355fBIa95TrHVmmYMEA7fe+5nKbmH2v6LqCS5l0hcyfGTIrxWL0n9kFuUK6Octw9LlcumRzfrfPrE/rMS/FKuuecdcKh8ZXETh4rmUvdxhU3XDOv7DIqZ7pmuNtwt92d3tjWa0DTmCzPxz1Vm8snbT+WPn79pIJhB3F3Q61GWTOq+72PiYRsByevV5zy3TFZsKpI+Tn+9YERS2R7HHpUpwzZ62ULcCwMyjswLjV7Y/hkl6b00bNtzru3+ET47U9LhAPnT/ngu9zSNarh/Q1zc81RA1x8LfsdqJA9X50f+UPu3d5z/faOHjQu7XwfhVNKwKG1k2om42EU6Si9sOT6lN5FAxvnr7O5DOx9WXvtUGXxvckg4KhzYYTaOGj7Cv6NpsYVn57CXXbD/V97uPndxV/a4h00rWCVln/n++UHY2J3bpkdPHD6soTsricWm0rfLSi/4XZvTfHsxaaFy9f025CXVfLoxq2fYuLOfJlVvLyv39HbY0xLHka7HVy3vLbk4bCSCW/U/UNX2nX4CsWdxoInWb1gxyV9Em48cvwJvFW8ur7fldPdX4+J/sxrqvLknFXyz2c67vcrmDjuvHJjf0mc/62rkU0nCEtDwWs3Z0UGBU3Zf/PNbjFP+uviqpoWJzTFPNbcOyK7k3Cz7utRlVU5Odu+Xdk3K2vrjrM7t/9ov5/dT3r05Wx0P/sX2/sgiQ==

docs/cassettes/add-summary-conversation-history_0a1a0fda-5309-45f0-9465-9f3dff604d74.msgpack.zlib

@@ -0,0 +1 @@
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 truncated

docs/cassettes/add-summary-conversation-history_40e5db8e-9db9-4ac7-9d76-a99fd4034bf3.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/add-summary-conversation-history_57b27553-21be-43e5-ac48-d1d0a3aa0dca.msgpack.zlib

@@ -0,0 +1 @@
+eNrtV31QE2caR716radU56i1SusS5LgWNskmIR9eBcNXQEAo4U7QE32z+yZZ2ezG7AaIlbaio3XwsNuqM1Q9FAN4EZCITk8pIn61Vqlezyqe1rZaUEav+HF+UZR7E8DiaOeuM/Zmzun+sbP7Pl+/5/e87/PMW1ydDx08zbFDamhWgA5ACuiHf6+42gHnOyEvLKmyQcHKUe6MdGPWJqeDPhVmFQQ7P1kmA3ZaCljB6uDsNCklOZssn5DZIM8DC+TdJo5ynXK8LrGBwjkClwdZXjIZI+QKVSQmGVBCK7Nelzg4BqIviZOHDgmSkhxCwgq+JSsdgiWH2zATZ5IUzfZZchRkfBKSAU4K4krcCug8J65AjuVKuUZSVG2FgEI5rXRbOV4QvQ+h3ApIEtoFHLIkR9GsRay1LKDtkRgFzQwQoAeFZ6GfBtGTB6EdBwydD6v6rMR6YLczNAl8ctk8nmNr+uHigssOHxZ7fFnhKFlWED/QD+CQZbgQqSwmlypVUkV9Ic4LgGYZRAvOAASpyu6XNw4W2AGZh/zg/QUTq/qM6wbrcLxYmQbIdOMDLoGDtIqVwGFTqxoGrzucrEDboFgdl/FwuH7h9+GUUoKQ6rwPOOZdLClWmgHDQ+99ku+beFBVlLhcjcuJugGWGMhaBKu4iSBUmx2Qt6PNBhdXIZeCky92o4rAIx9X9++PivSUgWqucMej2ohNWVZnJKZQY0Zox3w1xwjlZKV6slKDGdKyauL6g2Q9shTeLAdgeTMqR8JA6atJq5PNg5Qn7pFF9/QfApymxA/R9xw5ERtVCONTUqYlUfGZBRkLXFkp8SlK7Y5CnGQ4J4UL6ARB3J9soSCewnRaNaCoKAgplVaj0iq0AAAlQSjlhE6rUCuUm/JpIHoIKYFZOM7CwK1xiXgcIK0QN/opEavjc6br05LjarLxTM7ECTyeBSyim+VYWGWEDkS16PGHRpvXAauQeaY+R9yuJXVKoKK0ZiA3q5QqM54wI7N+gJ776bt9O99/UhehEjjQ0v7bE0ueDvA/w1JX6lP2TQ1a0vvJ5Odls5KNCW0p+oyZ3s9mBUrA2qLjlWuLiO/GToi91+h+pXD87bNHXjUvKZBb/+6VrmnMWn3n6ufRXd8G7jsb88+jsjrPhpA4Q0NJ5jZDceJRMFwdVr4/cVHi4dKhI9+f27DpwLyr4O7Lsk8qPsT/cGCKanxp7Gtzzx5sTtx4fV3T2y1LY+fe2LMsYsfqS+4KLumZLWuSju+5k2i7nRKl9tR2u6YYwy5frj/4rzpxSeOu8LXavW9VbAm7NaZ5WXx5mSlOTizbIMryjjw9sTFyx5XlpuKcNePXtce8UkJ3Dw8I6O0dFjDjXHJbxJCAgMfT8f4x5KnH2fIise91Ac/T6JwgrQcNkiDDcFgsZ0J2QjiPsTQJMYHDbBAKmItzSrEkrgAjAYslY30+fKtIgwKumAdDPAJOgRX4nNpcGAtsMObnLvxEdWGFmnicXVj7v+rCibEJkJyRWWg16JIKcxbE69VJqQrVD3ZhpQKYdRpSLo/SmiGp02pMBDATFFQrgRKAn7wLA0iqNT+mCx8YAga14dfS8k5PHX03YivfCV8MiqD1mupVJ47F1VUFNYi/OXHu8xUV6/+0jbjXlTB9pmN8R1HgkeWxhlGjOuu31hU057IFMezp8hu3uBvHms9ydSe3huq2Ka5VnFvVs+jQ39zzhyycFlL2fKhhcX7wXzaqu89c9eTeiA6+Pm92LefZ1T2tdOZzJDHvjfJ7YeObI88etlqrXzi0LDDh+i+uDguddKZzcVxmdpftVO0FDVui2//2iY/+qq2rT75S3Dq2t8vRVmG8w1yphRNJfVf5Cy81yOQJ75Qa1pQeMLUo07/2Ltw8B5Sc+FWWqUV/NUMuswS1ykvHDJvzdfS29BUfL100P2j9mJdk734gfTnjkmuvsYPShzVV3ww2HGnpThfunf9tWel3y4syNy7N3tXUnnxxfVLPqpyZVYmOFaXX2p9rXV684tTNKsOa+Na09qSGoiW7j1+4Piegr98Pn7Fz98XH1++H5jzh/f6/gZSD/POApnyBHH5DjOZ9ECMxnsME5NL3L1hhnywZK6AZBkFELz9gPY8huPoBvChAJFKiODZcwNCNxIkUXZgV5EMMYAXA5cuWZiloh+jFCkiGDiBtdg0KjyN7HwUci6QWDjO5MF9mfUwgAhFbUiyDgYCHGIN4QyZ5LKKNNvtV+mKxLoxDoB2Yf5/47kX9Xq2QsaMcBGvIf+STxhg6D/pzJyEj0CQf8vMMfaJmqFr+/zlDFSoNkZ0AU8yZFMjSTdPEGaLsIO0HZ6gZmAFFEiSIkps0alKljlIo1GatSQvUOqACpp94hkKNFpp/3AydNWiGZszOm6Af2RPhyb3mkEY3quyykPy1H01tCdteOQ6mX/iiY/qumu3Jz57vzf30zob0WOWmMr0hFVdr20BzzZsLv8yNfuOu+kSM5nfna/9YcGNUrTe2PPHPv2cSf3lwRMNN5VTzoXX7vXv1s771thwz0i5vbvy0Z6F3Zl00fvJwSo18s7aEvH7pdsfFnoLdU1YOLxB79n71Tlnwq+/uc7dLlKOFSRteLKTaNu8cwey8FXR52GVJMz7VMj+1433jW6dbo4SySfupkUcPhY7+JkhSWKV2fdawZfXotsuhZ1rLaj/17rlmCB93PPhibsm+KeG6gCaLc9KMK+0JwZ2dle3vdXwzkkz/teXYyMWBkYGdTVfyGjtHpDdHqE7OLy9LfWoCRd/K3fZVBOjJzh5KhlZ2RUReuKUxpCrGftkYXT9O7WzyZJT0riyqS69+s396pq5+ZuMXaHr+G6xJTi8=

docs/cassettes/add-summary-conversation-history_7094c5ab-66f8-42ff-b1c3-90c8a9468e62.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/agent-simulation-evaluation_32848c2e-be82-46f3-81db-b23fea45461c.msgpack.zlib

@@ -0,0 +1 @@
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 truncated

docs/cassettes/agent-simulation-evaluation_6f80669e-aa78-4666-b67c-a539366d5aab.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/agent-simulation-evaluation_f58959bf-2ab5-4330-9ac2-c00f45237e24.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/agent_supervisor_45a92dfd-0e11-47f5-aad4-b68d24990e34.msgpack.zlib

@@ -0,0 +1 @@
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 truncated

docs/cassettes/agent_supervisor_56ba78e9-d9c1-457c-a073-d606d5d3e013.msgpack.zlib

@@ -0,0 +1 @@
+eNrtWXtUE1caF6wuba0Lsp621uqYVUAlIYEEEuoKGsNDBBGiEAXCMLlhBiYzYeaGECjbVotttS4NWvf46G5FBEvVAmXFHhV84LoVsR6qtfjco+2p1gOeta1b6oO9MwnykD48q3s8Wzj8MZn73e/93d9vZpZW5QOOp1jGYxvFQMDhBEQ/+DVLqziQZwM8fLXSAiDJmioS5yfrN9s4qn0KCaGVDw8Kwq2UDGcgybFWipARrCUoXxFkATyPZwO+Ios1OU57dhZJLHiBEbK5gOEl4ZhCHqwMxCQ9UujOkiIJx9IAXUlsPOAkaJVgkSsMFG6lkDj05zFIAozPs+EcwDiWhRhrxpTBEZLidEEXawK0IEvQuM0EpCFSlZRnGQZAKY1DFIKgknfwEFgEKQNrwwQ9OMbbrIDLp3iWwyDO5wITZqcgiVlwBs+mmGwkgRwR0oMLOcGyALQDwIi+mFmaZu2CkJ3lcpEIisOfAzzAOYIEnH8g5k8gtzj/dBkWTeXfs0uIFHNnOBBd8FaWcZsXBF1KMchiqB4YAwqgDNPhBNmzYKdoGkPOm1nOgtwUvMdwpGCgIkowwttoyIvLPMShjZdhKSRyyEwxFE8C0wDzUbEJsckxMiFnkGVpI0GyFCFUp0gCHVaxTMJ9YZ3BLeLvJNaGOkdS7N7iLuqAVbRoAjzBUVYhmWJp7wbJCSLChSvSWDPGsD2JRfeASfSyR6iPhxRjtUEjj1Juwfu5yGblAEIsvBV1J+AgJfYa8gpZEC8AYxPaYYmkt2qu1jO5LlxWJEKD9SjlIYdqJykWAhVqR3HAJKoQlaYXF6cXV5EARwr488O8K0iWh87ae4bkA5wggBVKAYNsIX3O7dmFlDUQMwGz0K7VhNC64hQ6q3MBsEpxGjVQpWuXswa3WmmKEDsyKAe1+Tb3sEgFL+9drhY6TYpGjYHOhlk9fgQlOtBMM5hcFqKRyWsKpKgzKIZGQ4lGBrlUaRXXd/ddsOJELtIjdZ8XzkrX5h19ZVjeuSUeJ+Yn91MpZNe5BecsocoP+97nbAykLMBZpU2815x7sddciEyhkGlq+ynmHQzh3GLGaR7U3k3y3S3VwfLgEKk8VCpXNPRTDSDnkBIssuDcJN/Rk0AaMNmQdG4OU8m3ukaCB8sqXTOztEJojKP/qHIfXOXz43pL7VMxBxXOuVdvA4GYQoMlsPkYMq3E5MHhcnW4UoNFx+u3ad1m9IPWqVbP4QxvRrXS9fRFFUHaGHQqVWsH7Yh2SW/EHLJPUxYKSt1nCqqj8NNZoZTL5e1+PynJoeFBZwGyWBGi0Wh+Rq8wLtBZL8QnVSikCo3eHaV6cTs22E7X0e/2p1LwB3k0+Scke/3pkcZ+UvpH/NEsrnY7LaVMzj3o2ihXqFLz9XmopPEkm6QPLShYnBAValBuzqdwZ7VCpsCyWTabBh9oo6RadNwCabJYfWfVHEPCrPhY7bZUaRKbxaI06HGULoZlQGUywhDAOasJmrWZ0AhzoBJtT5plcNargZLAw9RECKFSESEASHUpSTU9fXC3zhXC/Itw+Uql64hp7pq40muY+DdcX3pubnPkqJILU04lk7vT8a8+Az7fzn6i7vWYdR3N575WUhvejFjTuHue7njLxi9e1GQvP7asJONYfEbaxL8vykhPb7l8++btmojG8QmlmZFNI+elBFw85jXSb3SsVfLO1t+PGP6HolGZm56SFR4NbQ/19ZvdemTPthV7AvdHtlTEPHGDulMyjSfLJ389bkpr7ccrLwH7Jfbqa9fnbE2vLZ1oL2xf6sEVXz85fmzVF+WTpn3+rFeEakRmqW9gy4ceCyasf/wd+e3uetljh18/IUldMemZ13M1L3R7P/dl2GSPJekdo6wnmk5XLl7Lohi7u4cPG7t8n/kFj2HDHhTv8H1EeMcggOg6W40csNLGHigdAI0LeYR0JMULcAcKACEgn2sbJpxDIpibWMRUICnCpQNxGjtKiSDPAyC6jeASgaPgMY7l4zQ6m9IYzP0nyPMka6NNmBU1HMQoKMi7GECmeCtAJpNNzZRhesEN9I94EpVFiwAsaBdSNjgEDwBcwV/xYkCIerJ/SH0iRZcIr4Aw6oKnHEaQOAddlOTnoFg01xe03UxgCJz/P8BZFaJ4oOCsUvwqwFnzaIGzSjEYOKfk6hLy8uKj4/Tq3LB4OzCzfJ6Be7jgrAmRgzDz/YDzIY/YPuicaJh/INL7zvQNDp+y2e9GNjdKMiYtjyy/6DRbohe3d9L2bN/aKy+FLSFOVH3USJjHBfAx73I3oXKmrqvwVtpnDfbvcvjGgvr3Nxz80yTPmeNGBcCETh9JTcVsbXhK+NrwzGlHFszyXFc28/B+k/w5dds4h3fpxSsFvzvsPStq/YKQyfNbSwMuRWf7zPY85T/3Dc+3faKvS1ZP+2Zu8BOyxF2n41YeGFP7bphiVYl9y/mV3zmfbNOSm40LJG8XPr2oo/PJv82PvtRV9sn5IPvKDnPWB52ndhV9XvbRy1712zw/gUnv6Ta37Xv8RcsMbVtklOPlNW9PaikvS5uRS8S17n3rt+mWj8JW3Swmz/zZa/zqWOnc6B+6Z57bh3csyPZ648Zc3T93N/m1Niw5AiM7sHUJZp+3vmra6zi70+hG+x3WRZ/ufHBo/9iYh4v2gVjvbpznKXTsMLC/CqQfuh4tJbH+6OGcBLRVhFkCpwmbgB2Da0dAKrwPcJ2x/SBOVCea7vvcbUTe9332HoxMiJDcF3wllMXKclDkC2mMC95F7sDncTBAGTx1qvjwTpl6rNjQNKp1UJMTbdAmJ4VwMSmJwJCazFqjEPXpl457k7lkgMOuFxADEp5sQ4jJ82YbTTt6cN8UnsZkZma6IkpjftZnUTqNSYYmRF3CsVCZUi0PU8pDNWqlPEwdmsbcfYeBnDT+ouCEJPBGwHEsh6RF6ELxDpG9IbI3RPb+92SvQiFXBj9Ythf8a2B7iF09WmwveDC2p9QCIsHMk3Z7qsq+KJTMUsWQMO4hsz0zrjEF39ermJu9ZG9eaWvOQbn3q0bdUcPouovqNxjpq7OLrmz6ImmFzw2/vNy4nfYRscsu7J1cf/zTfWER8pT6p8YXzlzkdyHs9vd1Zyd8efPbGZ0TWs599enVOx7juGcvr5WYX5pMzqvd7fHJ2brvseOXCe3z478+VrW8Duw8ol4eWWYgVp5NfXJV+MhNmPXaqaYFm77Z/senX2vwnTph9V9j4hUrVvxmYerJuusH5Yf4M0WbOsuP6GoVVw+sOROPf7aBe6VLu2zK6JNz/kK8PLykskw54ta4eUR5om9aTHqVs9N4dqzlmTL9mKYA+dnqo6qssu6jpx13PFz0zHRC9cO0B0fPhmf+d/SsL6MQSFEgdpdr/QLi9mNb9YPSMQR+6Dzg2ALKIrS34x5aIZPcDyMY+uw09Nlp6LPTENn5BW+21KHKB8t1Qn4VXCf4EeM6IYNxHa0qK8ag5rWpUaZFdkM+BfMK8ATLw+U6eKg8C03v/XCd230/OxnjDkZ6Nze1zDBi3fSX539IrPVeWr/Q2+ldtmWt325VQ8r2SRfSZZLLl4513jLnN9eW6K6NXrhxTXv0v6xzm9Zf5Fo3HDqT07VL1iA/fnXdgbGalIleI5fBWVvfeSF8uwE/Hhf3fOD6HTekOgP01eB+q9rUravV8fhxr+m1BxrfbEoce2XaNU/bjjFm46GPM9SGINkpvGtjp+nmnOnns0eM2tW5jJ2eQXnJZhaVPL//2/dqdp1Zs+HcHyqvnNz33sb3X8nxvxWRk6Eu/HfzU/vrroUPj3gp+/BE0xZOkl/T1dEWuefOyboX1ze62U4b87hyBrr+D6cPbus=

docs/cassettes/async_4b369a6f.msgpack.zlib

@@ -0,0 +1 @@
+eNqVeQdYE03X9iJNpSug0quo9N5BCB0EBKSEZkgChJJAAqGDioAoxaD0pgIiQkCqIKAiCEgJVXqvivTe+aNP8Xm/63m///pmd2fPzmn3zDkzO5vcy8XC0RgECklSgEB6wdEQqBfxAYO7l4uGe3rDMV73X7rDvZxRsCxtTbMsbzRi6JSos5eXB0ZBVNQdjnaHIGAiCKSrKMLdSVTP1FwWYiHtAdNAOcH9YO4O2vKSVhLOzlDkTaQRQl1WT8JQHIoEu+n5o5z0JHw9HNzNnaEImLyjpZib3k0PJNRdywcCUr9looHRB5nLO0IlTYi6Jo6Wfs4Oxjpqgpbi8v4wbS0/mJa8ozFI3sfYTczDyAUlA3Z384NK3tQHWWghwRbSYvraf95vovSsLAzFIBby3sQ2F5i2G9YB4frLNpHvaikuh7Lw9yXa+ftZzkCS6MfUVcbIxQNjZWkoBnJyc7SUNBSzstQTI/KdDEzFBHX/tG/k89u+LkjMyxih7gyWMPeG/cT/JxZiO5EH9rZCGvoYSRhiHZAmHg5Iczc9d2kEVFJNVhck9UvPSpLYLiElS/T3hw2QmpcBQs3dwV3PH6rh5ebgfvNPGuNkgCBi0Pob808dFwdtLX+omIkbGKHuCrYAO8MsfMV0tcEeDto+MroSVn5gF3V3MMIXQ4yPm4GFsxvEAoYixsnXwEWXiNXwZ1/9TbTN3X/qQJGGf+l6OUgSsUm4icHNUD7/w8+v8fntQ8/dygXsbuWDUlZ1cAKh3FBoZW4fZ4QXPNsBBfP7mOsMh8CIqXb/9S0MHC2s5gRHeuEqPPyIuYUU/jPXMKISIpLEs0gNCoV7eAlrIqEoGALphMM7+SM8hLhgcEc3iBf85R9sXNY10WuvQSgkEv4raXGvXeFwD2GIGwILf4WGYzyIeQwPfYnxgnh5Y+5lE03B25pz3eEYDMQJ/sJI/y9EsQVEG15EOMJmfh5w3GuEO5Ev6uIBd6r+6QiDEf7JR6PchNXc3FA+wkZohBMCiXt+7SVIS9hEzQpXJgeVl4TISklBHcQkpCTF5IU1LUwK/zJqAEc6eTnjsuVlJGTwIAjUGf6XPVyRO8RXmOhMWUJGVk5KTCxbg9g7XK2Zs7cQl4QMlyncg0uCaJFLXFJBUk5BXIZL+4bZS1M4mjhlca+hbihvGHE80PA8E7gHCk2Ej8IN7gTwwJEwDxRxMmN4FKwDeLzRbjwKPH9MWRtRG1GICBLuJvJbWQSKcrcRRf+yYCOKlVLFKBvKy2lBUQ7mav4aNz0R0lIuFqb6ksYgkJGkEURCDgSCGTqgYZbOmhg3J29zLbi7uZGWJVjbxMFYXJ5fQl1P3QzrKGvkaOKH9hK7aSFxU0IGSmwGaYhL8ktoefh7+cPUHZEYcxNPSVME1AVuYEzkyhhLe/hrOmlZEEV0jeV9fDDuYjf5JTWIJ0+QrRCPExrl7UHsB9RRmAifR4iHOHL2xJHjUZARk5ITEwvKMtQ0wA0qBfBgvH/FzN7xz6WMR0FMiOeP7tl7of43E9nmELQf7u0f4RXi+h85WEQM9h/RM/2VULgsHV2zLGIa415Ki4kRVw68AQTjJXyDKOyIgMNwtVpoBDGKYv+IopyClLiClNzPKP6XtMX/6dQEgnSCY3A5Dn5ecMyv+XOXmMdoIozP/CknAycTAL2elq4WQEICACTEAziZIhnQBYHsjU2MtHQNNP9gNAPEQiYGAO7EdDPRVueytAJzUU78ofGzQKAYD+C/F6LUdt8fsj3CwP+9nIHBMVDifZV48aGJzokmGYk0o9Mf9JWftMMftNJP2sfLw4tIG/+k0WYmICINI9JXnP5BO/yDhnqgf8pHEWkldzdv6G/cADUcecuUeD9NvNgADGACaAPqP/v/hwjqBQDIbQEA6ePfbQ7JAPA2DAAuDv1u43sGAHT3AaCi43fb7zHxgKAhv5rIiNcpR0cAWM8FABorADjfCQBnrf8aiP+CjesXNm0ARTycADcATmzRBZAAFBAhUhKAGCAOyJwMAyCA9NSpnyexkBFP8tPk5GRk5GcpKSlOU5+lpqY6S0VFQ3uOnoaWgZaKip6ZnuE8IxMTEzXdhYvMjBfPMTIx/jRCQkrUISM/Q05+hpGGiobx/1xOPgIMp0kYgANSEh7gFAMJKQPJSQPATuwSKUBKQkLyd9zJKShJyU6TnDpDZJvSAyRkJET0FNRnKU5TkP4cgVPELlAwUJ7jPi/OxMyj9rTrNOMFiZtmt8whnt09vDKmXt53457El0nJqptgivn4JaVBuOzSixraUNj953X1RKMsRGf/4ZFo9RQpORklkSfJQExvUhJycgoKUpK/eQzcZOfEb3qeZ4Tgungl1UyfF6ubOMSV1ElMrq6dDAHURNFTDKQMgCpwnPeC5xQPF8+v6opQBXg06k7DFCioqoXTcSR6LiaLzsdoSWe5Br8MXFB8Wdf/MrnQ88yDFke/KfylOMQlRmhthwcQXJJFeP0ptLi1k3Ijwb9fnYNz0ma7/XGBZKLMwHDLXcUO2/1T8lZb4nhO9ZVdfBjpUReoK3kBPNXmmfxEu4PlTaaQ8eZL/57GAoFWRuWrGeU7n91EvzAqX8rIXrOmWtek03LKU46N7VJQ8f16f88hIkeyL0MaomL5/LvBVtF7QUiwzvNvbVsCDwfs4674SyrrLgYGh8f+LZEbbWmUcMXfVNl15W+JqYoLMw85ojpMAjg5n2eVGolq8+jkY2vjlDpb+k8AnG05OUb9+/D06oBSQPqcb0Fj7QcdDyB08947dBNGM9RBfnFW7PaKlKRieUZqyAfW2s0o9tlC/o9IsGFdWJWm/02F9UwzB4F73Y/WGAsyZHRZh/lQJO0BhpMfd+gtlvw6eX6P+D8quobuitOZvIQ2qH5aMMAUENF1Sard7emzAJTwcfGbyfez3QCY9gQYvQ2l7PyYizK/gLAsNPzkPHpJ1XIQ9I2KovHhJ8ypQYd8tnPl9Q6DvGyxrEG0rhEL1k1V+WzTB0Z1Kg9rX+9G5Hhdei0t87L+e49r6tAx8wcmu+FEJNKwqz4V6bjy1kds1+z0ttpqWVn1qKAO+h6JCkf+G9Wa/bN1RM/nK9OjJu3OJYB4TY61bMJ2PZ967jZrVAhbJQbrDLDNvUWzTFenUXzcsiK831af99pGhYtPS11+lkGjj56xEO/pu6e4SF8ned/AdVE6OkQKchAHhiK4hx9TR5yTjomd2sZlUuVenaj8uN3OVuFRGa12K8G18cxQG2qJkndg2TZWki6+q75DO69+7KqDVwRVaWJxj0u6Zo7kW/cPNNCr5wt9VXwL1BiRZeu8Cc7JQgGVj9mLF4x8XZQ0p3OQlypb47r2S+Ykzrp/CBCMaZJwKeNR3LhkO3RKn1TXI0qpzHuZO1gyo5naUNYWlO2ZxLad29YeGSpLX28RtqaQXaIiLoDgK3AeKMW0aU22z84p3n28FnHfvzUSHHGrI67ToHeRMHE7/y4WJErl8j2V9m57morEdDsXrm7KMmV92fwt9u672tWQiP1UyoYUq7ZG9oGhUDUHsZILA+HqrY/1FV8+avYTuL3NAZlJ32evAxQP2acNfR6AV+xur4ON+NUzLkhLnx3k0GG1kxsko2Vo0Vj2i2/UVmIuTYxvHwmtZOWp37zvR6BfY32AcRKXnugcbKvq8B2WMaxh+i7VGy6gKYVWUuLwvU4LvG0lw5VU0sFEqeiOc76dANNfg9co7jzERU0n0kpasQwc+tBLlR9sw9zEbuWn4PlKapscy/GuXzwFnpHmWXgxRdOVU8y+iR4ARVYNWLj6DL5RkdFn1Tp2jJQnJmTBQmkO61LUXN770YOrKJnTX1iRPGFRnpx0iQRVk1JRzRPALyP5x4OOr4gpHp6N1/82Ba41tGNjvoArB0Yv0y6Guyqn6qcbQt9IrO9NYYerkXifp2quGXNWXQjNgKrIPn5xkQLHDHCN+cXbVaTD7Wz4WVwhJYHOk9PkYGIokyliB9r73N1Zyab0i7K2dYMRN/9yo1UgjZ8A2qYxQ113I2FlvD/PRlvDaO7rpclN7FrQUA+6dzWfHdpzmRsans30RRzEBtvkjyZBv34bef7we0fwseg7o3MCez0ZR4f2XunpHzo2n07J46+U1DpFtUyUc4TmmJrNKVITXPSYD6yezy2mxlTfRgdT+9nm+B5zCqTmpoEPdTLnDQN21oK6sdgTQLXbQFs6fa3CnLn2+ZLykscIU91Ei9MJcJVyuSnP4resL06VkLazMnWQvbh0HJKdFONKdeVWdF07nsqGduLBR24N+Ma6EWQ3TTAZKhSYzD+ccU1YeSURpdKEbRrbeIvxyxh7+8C4oxo5h/GZ4oUyJo6et93atkk9sgtR1VSO/txb3+vuIv0izzYbxyZEw5qx0VOTKb+RW5plmf79e+7RBIKukZXBnvQRXv2VD4RUXs1vDhPrh4lNb4jT3YjTW34hdNkxr23NTEMTePDg9IM7/15JHvMnRCM+BTuoKaQE20b4rcoYfedwP+bMJ0iRZ66JhrDtGhUjxySNPoghT4Blt0zskc/+u6UPqd7PuP59qfwfFfVO5DN21083xvqW8uYH5M7ZHud82WRX4FRNfaZ6szMhoGHMnt1Xt4prt0NlWDao4y46ZH3/yFX9uoYGmcb/Wt0qILwqZ9YywPKkyQp/ZPlxbjDpM7XSMPNbj/4LSjE1z7xYkVrTvuO0rnQPJo6uoartXmNdFqK+szueDxtl4q1PqZ+SU9VLXe75m/pajQ+cJlArlS8WbLuqho4gP31vBdN+3kZUt7VavEPTPLCHDexNcEeLVT+J386QJVt24K1q7Q9U6bVit33hUVVTwfn5YO9sW+llsY5hhUrfUTxmz7q6SmcEHR0zXThcIBh13DToO1mw6ZhN6KyX6UsrHUoalAp7C6FMUru8dtC59sEorL6jsv9QvkCFN3Qz7/2S4i88It/yONj6OBnq9s3GsRl/U+l97z3nKS54mVUspGvGIjJ5H2Ypa3kn1m3DvNpLine truncated

docs/cassettes/async_8edb04b9-40b6-46f1-a7a8-4b2d8aba7752.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/async_cfd140f0-a5a6-4697-8115-322242f197b5.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/async_f544977e-31f7-41f0-88c4-ec9c27b8cecb.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/branching_1d0e6c56.msgpack.zlib

@@ -0,0 +1 @@
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 truncated

docs/cassettes/branching_66f52a20.msgpack.zlib

@@ -0,0 +1 @@
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 truncated

docs/cassettes/branching_83320227-8ab3-44c0-b6cf-064a7a425b9f.msgpack.zlib

@@ -0,0 +1 @@
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 truncated

docs/cassettes/branching_932c497e.msgpack.zlib

@@ -0,0 +1 @@
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 truncated

docs/cassettes/breakpoints_51923913-20f7-4ee1-b9ba-d01f5fb2869b.msgpack.zlib

@@ -0,0 +1 @@
+eNqNVXtsFEUYr4AvxMTUR0SJDCeKYve61+0dd62PlKMtFSiVO3m1tcztzt0t3ZtZdmZLz1ojBY2viItGwBgFOa5Yim21agQJlQRBJYgS1OIDlSjGR4xKECK1zi53baEEvT/u9ma+x+/7fr/v25bWBmRQleAL2lXMkAFlxv9Qq6XVQEtMRNmKdAKxOFFSVbND4Q2mofbeFGdMp0X5+VBX3RCzuEF0VXbLJJHf4MlPIEphDNFUhCjJQyMXN7kSsLGOkXqEqasIeMSCwjzgylrxk+oml0E0xJ9cJkWGi9/KhEPBzD6iCBpyHESJAVgcgaUI8h8DqBjQKMBkqas5DwwGgJSqlHFMZ0bhKRhqdOIFkcGgirXkBFAxSdPAWfFl0zC4z9A8IYhBmQGxrFKZOIZJYrrBTMRAAgEO2XHMxjGx00DAuKmKFX6nUh6FuyWgfeG2kbGk7sB1QDkFDJwQotXxmLYVhgk02AL7RMW6aVfR5OLUGEn78r8A2+FdqpKNbdaJnunllXeTpGfeQm/lND8uLVtKgnOr5ruaa89o5XAuqs+CaSBqamd12lVd46pgkyigJsbJYWjyQMRkdv9ABDGuNqARUg8IP1Oj9vEkAwEIylFCxSqoMRW/pPBvJPrdNa5ap3OZ/tT9r5Ls0mkdMgxicOso1CjiVdba+iMK0pz+aZAnECTBK1CCMWJCAVeo6CsQs+kyGh3OhoKobKi6zaqjLMjlxGmnphHNaDXiHmCtjspxlIAOeTofGC5D1ZH/IJeD7aXMUHHM1WxzZ4+haiC73OqMae0QCZHIYiRzEfG6WuMIKnyYV6bihDKra9h4dkBZRjoTEJaJwhNYW2L3q3oeUFBUgwy1yXYDHPlabfUI6QLU1AaUPu1ldUJd11TZUXH+Yt6s9gztgo1l+HWbrSCBDzlm1lslWRz5VUm+TTAQ3VKhu6CzUaDOOPJ1IGiQQ0rrzv22oRc6lOt5HCGzqaz0aedXh9oQam2cBeXZoTNC2lRZG6GR8BW+PvTcMDFTE8hqDVYNT5e5HEwnuT0ed6DrjMA0iWVroyOproEmD7i0cRFJgugTRM+r2S5pCMdY3Nrgn1K4iY+OzrcsWp7mIZlJW1KcEbR3T2tmL748e0aWza9zclPTODvW9nDczAMFPhBCOrBFCjxSkeQt8vpA+axwezCTJnxOMrrCfARplBNSmiW/VY6buB4pbcFz0t7rGizL4Pk1NaEyIfNS4GTZf61UoSiKvTef19LgsufjzDOmpEAg8B9xeWcQs7rt+gQxIBT4wnaVviJv4cJecC7P02+WDJ60jYcjmngey0E8WWtwXutz4bG7vrAtA1pQFesd/sz30EwpJkWSJKJLsfq59wQrFS8Ox3xvNAqyRkxFYPz1igRHEI3M6gURSZoyJRrxiT4ZomhAVKLQG4mIouIVpSiKyhsaVGi1edweECMkpqGOYJkQhHyRCCFHNlbrtAWVJbMqgu3zhTkkQnj/wpD3GROM0iFkcDlabU5qPuAGSnP3OSULrG6/HJCgJEMJigFRhgVC6bw5nVkBDQgkZW8H5zW+LH16I+26YO/4Jy7JcT4j2aqS+utLxjzc//j+m1ab+lep9U23XnXoih+3rK96PvLs2N7ixrlG2fP+6gP990W/+i74vrro2MTtf62/Mf3oHU+9WZt/+MuyprdPHmehjilHTpTu+O3Oy7/tG118TP1o1q5oN/qlM47HK8/trRhXPM5rvHdDMH1d8veGJdvFq2Fd+3ObN3+/7WBu8ZjJ+777vN//z/U/nfrk0NHW3SuVcSUXPrBITOdedIvm3WbqFy8bdbz0pZCypnvnhJM5Fb6FZX+kRhzbdPDoD1Uz4BK/eLLnwlU983JP1Eyf+tq6vuW37+nr6Ri9LvXrN+D+h5RF9ypbV/w9YeyTMyNPn9r5EFDSI6z0M2ubo79fyg4UadN3rk58XHvl+O4TOS+/qFx259P9L+WuWlFzYzlYNvngZLTu2tCM8rEtT8kzzA+SH8qrRu0ovHn0IvW2T989MgYsoMJPVf4/pceW//zOby/89eSWrrxT4d4Xjrzf6V0CwdoH4o8EvhjT55paWYyPNFy+b+zJzRPf6Paso976Nasf7Dl8V3HhZ31bxbWjj+/J/ey+J7453OKdnXtt0yuBpfOP/v3zyjVKXfOvW2XPLx3/7PlyavmtO7pHLdi7v2fTm9dw2vr7R+bsTvfuOzwiJ+dfAXrkAQ==

docs/cassettes/breakpoints_6098e5cb.msgpack.zlib

@@ -0,0 +1 @@
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 truncated

docs/cassettes/breakpoints_9b53f191-1e86-4881-a667-d46a3d66958b.msgpack.zlib

@@ -0,0 +1 @@
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 truncated

docs/cassettes/breakpoints_cfd140f0-a5a6-4697-8115-322242f197b5.msgpack.zlib

@@ -0,0 +1 @@
+eNqFVH1sE2UY77IER8ISnBqDQLgVMBO4rtfryjpiZJaBhMFY122yyfDt3dPesevd7e5ttzEnbMOEAAqHYCAhgKxrWZmw8SEmQKICQT6MQjDblK9oRFH/QMQPEhJ8r2vZCIj9p++9z+95fs/z/J73aY9HQNNFRc7oEWUMGuIw+dCN9rgGDWHQ8epYCLCg8NHFZRW+zrAmDk4VMFb1ovx8pIo2JGNBU1SRs3FKKD/C5IdA11EQ9Khf4Zu/zXC3WEOoaRlW6kHWrUUUY3c4Z1DWNIrc1LZYNUUCcrKGddCsxMopJBUZm1c6II0TqICiUVgAqhEQ+dMoUab0ACUrjdbWpWY4hQfJhHMSCvNAs3QBrSuyDJh2EEK7y2E342JFkVKUMgrBcHzTyIPOaaJqlm8aPEiSKKxQelgLpKj9NhMnymoYL9M5AUKIAFusKqkfNCwmq2mxkq5pzckTblaHOLAmykFrayvxNrsqasCbWaSgZgFpqOJfDhwm0KWtcQEQT7TZEBUUHRt9j3R7P+I4UDENMqfwhMD4KLhCVGdQPAQkhCHBmQ1Iymkk6gFUGkliBGJDXkYvUlVJ5JBpz19OmtWT6jpt5vKoOWGKQxPNZGwcKU7nkb+4mQyHTNltrNPm6G2idYxEWSLq0hIiKcXUpP3oSIOKuHoSh04NnhEbct43EqPoRtdCxJVVPBTSlMroQlrI5Tw48l4Ly1gMgRH3LH6ULmUcpmNtDGNz9z0UWG+WOaMrgCQd+h40+YFLggwRS9tdtJ3Zl+6SBHIQC0Yny7B7NNBV8migI0ZC4rDeHiWKwPkv4qkx3122IK3mVUtOdA5RxzjuE8IzKIeLqgCVMoeUYtgitqCogKXmLfT1eFI0vseK0efTkKwHiCAlafHjnBCW64FPeB4r+6B1uCyN8EtiSMR06o0TscxPI+q02+2DLz4RqZGxF2WTMcq63e7/iUs6A9g4ZNZH2920w+VLVemsGaQe5zm0KFL5xMx8SEZTnoAczieNpp6I/o982JpEKmla5I1j5LzMzpSWVlYH9Igyd0lEdwHjb6rxesPlh5toTlLCPI3JtgQ6ORBN2Bik2AAHjNvlcjNQOBN4vxMcvB3YwpkMW+gu4AOdEREZCcbGUEFFCUqw3zOX9iCySOiK5NgY8TlLFhUvnO/peZ32Kn6F9M+HSJ9lRYZYBWhkHI1Ekpo8cA1ixN1bvMQ4VMi5WcT6A27eUWjnkIMuqfb2pgfowYBEze2Q3MptsaGNdCqjdtK6LEvyl7m6/NyiE7PH3Nty6nlb7eZRZyfPO1u7auya2zlrq7q/6xkYgP69OZV3Gw91T7t+8syBl7kNp6f3VuTtGv2HY/zVN377sXr/waO/a463t02acG3C5f67k4WNkbbR7+RudbeP+sr2XGmWa01uRnZ22YXijC1sw9qOK58JY7dmwcbg3bqPdwZ3fejPmdL2fejwuGn/bPm5Ne/N9XXrp/bL3edCP/lm/7C35suB6d3llRdappQvcHo7qz+41JEbvpFd6fJdzqx9b9YvL5QU7PF/uuOTbc9055yLrv7m/EXf/FDHASd3beulgbZF91/jIjDm5vWrXZtPO8bXbb9W1zDrrRUTr+yYcPHm4KbT7x8Nfj07Nv/YnwdO7i55Nq/q1rgLR85sX3nH03+8PuvzdRc7R5eurLzz7qqdT3e/mpdXFM/965WXqn4Ndd16yrvK34ijbZ339k28sfTvbIvl/v1MS0Nm34nbGRbLv8xd7PE=

docs/cassettes/configuration_070f11a6-2441-4db5-9df6-e318f110e281.msgpack.zlib

@@ -0,0 +1 @@
+eNqFVFlsG0UYDqqKq1akiEOoeSCLoYjDY++u76iIGrdEzdFEsasmLlE0nh17N17vbnbHkd1Sobr0kKgoQyvxVkTio7LSNlFd9aFUSByiHBIPvGAesEQkaCUkVIEA9YEyduwkVaKwT7P/9X3///0z+fI0Ni1F1x6aUzSCTYgI+7FovmziqQy2yNulNCayLhWGhyLR2Yyp1HbKhBhWj8sFDcUJNSKbuqEgJ9LTrmnBlcaWBZPYKsR1KVd744g9DbMTRE9hzbL3cAIvehycvR3ELIeO2E1dxexkz1jYtDMv0hkTjTRMsmI/Ot5I0CWsNgxIhRkJA9Ep2I+WZQwlxv5sQdYtQhfW8LkCEcIGAVhDuqRoSXopeVgxHJyEEyokuMKANNxsmFZSGBsAqso0Li1l0XloGKqCYMPvmrR0ba5FDJCcgde6Kw3+gLWlEXo91ObhGs6x8Wkc73R7nOJ8FlgEKprKBgBUyCiVjKb/xmqHAVGK1QEtaWhpKfny6hjdosVBiIYiD5SEJpJpEZppn+fqaruZ0YiSxrQcHl4L13KuwLmdguAMLjxQ2MppiBYTULXwwvKQl1MqIi+6Ae8DvHC5PSUVa0ki05mgeNHElsG2Ch8vsYokY+ULTBD87a1yaxFmhvrbYv7U8VhhDxOH3ozKGQcn+rgINjhW3sMJ7h63v0cUud7B6Fy4hRJdV4uFqAk1K8H02NvWvozkjJbCUiW8ruo1+0pXJsNXlbRCQOsSMK0av7Qg8jxfe37DSBOn2dAaiAUhGAz+T102GUxotdEf4INA9EWXuvR6YjVuvcylq9TiU/Lwja/23AaRK3za0dyG0evzEcVYpUUaKBL9mJ0neGEgEhqDU6FYrG8wm/UL+uj+yZHe0WtZgFQ9IwHCnhMMmvuQJbTGJRIogVDQ7xb8iQDyegOSJyHFAxIUsB+5A57ZaQXSiuAUuKSuJ1V8Jfw6CEMkYxBprg0t7xnbHxrcF54bBSN6XGfzi0I2Z03XcCmCTbaNtNKEZvfbxCWWPhIao9UACrqhNyH64pDhBgSw9+DIfHuBlhek0Hgcms/WMbamJjN9/mX3O1s6mt+mgXdDqeO7Hz3xVn89d6hafOW3S7b+Oy++t3v7R7dmHp8dT55xb3v47idP7Tx24ek3f1+8m6h6dx1Of+2of3jq58U/M7fvfTD5t7OODg7c22q70VmNFbq68p+9MLU5dO3ANtW4XSxtOfvSyej3i39EOk/1/XD6kX8D9d4zpQP1TxfPxc/bHK92Tornn9385Enb1Hisa8f11+68f/rl/K9PzIZ/vPDPDrD9q75zE/ET37lt+/7qvgm+6WaM79/f1HHxmV1f/MLO/wGUNlTq

docs/cassettes/configuration_718685f7-4cdd-4181-9fc8-e7762d584727.msgpack.zlib

@@ -0,0 +1 @@
+eNqFVF1oHEUcTxOEEhWkqCBiuz1r8SFzt1/3sdGHhGsqbc0lJNfGRkOZzM7dbm9vdrM7G3MNLTaJIliUKehDBSnt5a6cZ5vQD5VqbGxAwaBPgvdgCwr1RSxCfClInLvcJSkJcZ9m/5+//+/3n5kojmLXM22yrWwSil2IKP/x2ETRxSM+9uhUIYupYev53p7+5EXfNSsvGJQ6XnsoBB0zCAk1XNsxURDZ2dCoFMpiz4Np7OWHbT1XeWM8kIVjx6idwcQLtAuSKKttQqARxC2vjwdc28L8FPA97Aa4F9kcCaFVk2EGTg5VE2wdW1UDsqCvYyAHpcDJooGhztF/kDdsj7LZDXiuQISwQwEmyNZNkmafpU+YTpug45QFKS7xRgTXBmalDMYOgJY5igsrWWwGOo5lIlj1h457NinXgQGac/BGd6mKH/CxCGWfdzZwhHpznD4iiEFFDcozY8Cj0CQWJwBYkEMqODX/zfUOB6IMrwPq0rDCSvLl9TG2x6a7Ierpf6gkdJHBpqGbjahX19tdn1Azi1kx3ruxXd251k4JSlJQm32osJcjiE2noOXh2VWSV1NKsigrQIwAUbrcYMnCJE0NdkGTL7nYc/hW4ckCr0h9byLPBcGL3xfri3Ch51BDzDtNO/L7uDjs66ThtwlyROjHjsDLq4KktCvRdn54pTtZjte7JDfVYjbpQuKluB5dDe2LyPBJBuul+KaqVwJrU7m8v2VmTQrql4BrVf1leVkUxcreLSNdnOWkVTvmJU3T/qcuZwZTdq06HxA1IEeSK1OG1cGKsFnmylWq4ymoYvWr7Nkicg1PI1rYMnpzPLI6WKqDBqbOvuLnY6KU6DqSGemWnf0Gob6PkwMwd5ykr48BZNm+Dih/TjCo7cMYZRUhCmNhRRfRcEROQTU6rGjRsBRVVE1TJQWlwhdHTchKUlAS0radtvCV+H4Qh8jAoL+2Nqy472iis/tAvPwa6LOHbc5fEnKeiU1woR+7fBtZqdaa328XF3h6X+dRdi2GNAWGUwhpMSWGYhLoGuibaSzQ6oLkq49D7dk6zdfU5aaF+V3vbW+qfS2vvj/fOtHxZNc30zc/Cbw9uCi/OLi0rW/qsQeieQLNRVPvLu882Pnpo3/sDL7ZMfTtb7sPzyVGK/c+ei72690HA/5fiaEjd69Pnp579lzbjpGn5s8/fqo5kX/aL4tjU2dfbmu9P3zgB/rhrfPbywut48+cev7gv/mf4Mie+7ebf/+5Q1VzhxLNtye+WAzfOGPvXjqz8Mi8u3RH+LHnz7fOfXzpy3demr21NzP5xD+7st/93dLUtLzc0nS2c+aXexz3f2MeVKE=

docs/cassettes/configuration_e043a719-f197-46ef-9d45-84740a39aeb0.msgpack.zlib

@@ -0,0 +1 @@
+eNqFVFlsG0UYdtUXVDVSWomoD0hdVgUByth75XBaEMHuATRNSEyTFqFqPDv2Ll7PLDvjkBAqlJRKASTKShQegCIljl2s0CS0KA+cIqAURLnUAuZSqbjKCw9FgifKrGMnqRKFfZr9z+//vn9mpNiPPWZTsm7SJhx7EHHxw/yRoocfzmHGnyhkMbeome/q7EmM5zy7fJPFucvaIhHo2mFIuOVR10ZhRLORfjWSxYzBNGb5JDUHy48NyVk4cIjTDCZMbpNURTMaJbkWJCwPDMkedbA4yTmGPVl4ERVICA9Mli0ffjBIoCZ2AgNyYM7EQAurQSQbZBxnA7uHmUuJKdlEsjl0bEjkw0ULQ1NMdyxvUcb9mRV4pyBC2OUAE0RNm6T919KP2m6jZOKUAzkuCSAEVwjxSxmMXSAK9+PCQpY/DV3XsREM/JGHGCWTVeCAD7p4pbsUzAfE2IT7s+01HJGuQUEvkZSwboS16QHAOLSJIwgCDhSQCm7F/+ZyhwtRRtQBVen8wkLyqeUxlPkTHRB19lxTEnrI8iegl202Ti+3eznC7Sz2i7Gule2qzqV2elhVw9GZawqzQYL8iRR0GJ5ZJHkxpaQpmg6UZqCop2osOZikueWPq5pxckE+ho8UREmeYyN5oQj+5GyxuiljnffW1PwxtDkfF+r4byesXKOkNUs92JVEfUNS9Ta9pU0cdnckJmPVNolVxZhJeJCwlBBkZ038IrJyJIPNUmxV2cvy0lie6O/YWZuD6i0RYgW/fl5TFKV885qRHs4K1oKOeTUajf5PXcEM5v6ZYD6gRIHWnFiYssk4WJZWy1y4a1U8BUMJvvK2NSKX8NSipTWjV8ejGQdLVdDANv23xPmQovbpSaruV/fdn9n1iKHtgfGEh6jxxgBADs2ZgIv3BoPKQgxwvyxpGtQ1nGoxkI5aUbOqq62qopsmjrZEURJq4/029EtqWJXSlKYdPBXbBWIQWRj0VNbGL8YP7GvvuDs22Qe6aZIK/hJQ8EwowYUe7Il19EuV1uKCe7gg0rvbD/hnWlFUh02pVItp4FbUqoKdvd3TtQVaXJB88DpU3rVhsaaeMH0wt/Xp60KVb/3eZ2Y2vH9nffzdD1/tVG+75esnT758dPSo/NPe5+t3/J3s7zz/7OMvjI5ceO/FeaXu4xsaem/9Er6+Y3I2/e3380Mnpp764VLTHZ/t377l99Njn8qbeus3/nFx+8X4PffNbziSOfvRnHwl/Ov5rXWbt5jDx/vgsXM0fvmLy69M9z0X/uvzExvjseNf/bxNaRy9kkDn/mm4a3bPS5sad/9Zd+m30WyXd33TBffGhm/MZP3Yv+P2d++sC4WuXl0fun14zvtFIP8PysRiVQ==

docs/cassettes/configuration_ef50f048-fc43-40c0-b713-346408fcf052.msgpack.zlib

@@ -0,0 +1 @@
+eNqFVF1oW1UcjxRkdhOKfdnL2PWiE2fPzf1I0ySWQZu01WmW2oS16zbGyb3n5p725t67e09C45jTbvgy5jyMgSgI29JkDXFLcOLEj+HHcIKgwl6CdIqCsBdR9MUHqSdp0na01Pt07v/z9///fufMl/PI9bBtPVTFFkEuVAn78eh82UXHc8gjZ0pZRAxbK44nkqkrORc3njQIcbyI3w8dLECLGK7tYFVQ7aw/L/mzyPNgBnnFtK0VGkdO8Fk4d4zYs8jy+AgniXKgj+M7Qcxy+ATv2iZiJz7nIZdnXtVmSCzSNBmYP3m0mWBryGwaVBPmNARkQeJPlg0ENYb+fNGwPULrG/Bch6qKHAKQpdoatjL0vczL2OnjNKSbkKAKa2Sh1sC0MouQA6CJ86i0kkVr0HFMrMKm3z/j2Va1DQyQgoM2uitN/ICNZRH64VAHh3+8wNZncaKgBAS5Ngc8ArFlsgUAEzJIJafl/3i9w4HqLKsD2tTQ0krytfUxtkcX4lBNJB8oCV3VoAvQzQYD76+3uzmL4Cyi5ej4xnZt51o7RZAkIVx/oLBXsFS6oEPTQ/XVJa+mVGRRVoAYBKJ0rbMlE1kZYtDLYfmqizyHqQqdLrGKJOfNFxkh6Ns75bYQLide6JB5z/dYMcbIoZ+mjFwfJwe5JHI4Vj7ASUpEGYjICjcWT1Wj7S6pTbmop1xoeTrjY6TDfVk1ctYs0irRTVlv8GtTuay/ibOYgPYlYFw1f2lRFkWxsWfLSBdl2dKaHYtSOBz+n7psM4jQG835gBgGcjC1MmV/YLrBbZa5cpXaeEoBsfk1ntgicg1PJ5rbMnpzPLIyXWmDBlijn7DzMVEazs+kjJnRgzp+aSCkY01PH8fS6AdzQDXtnAYIe04QaOlhjtAG1x9QQkGoy4qoyyENBZRgOBxS5aCip9WQruhX8hjSiiRIXMa2Mya6Hh0FUagaCCRbsqHl2KEDQ/Hno9UpMGGnbba/FGR7tmwLlZLIZWqklVZrdr9dVGLpE0OH6I2QGlZgv96vhwIwpIYkMDI5UesIaFUgxebj0Hq2XmMydZnpqy93n93ma31dL77xefcXYk/s1u3wWL27+6NCz0jP4N0Lzz1yn799c3Hp3MH9y0f3dr/78L3B1++PX6zd/GbhLf2f6rR/cl/ir6/hrWcHz7/ykzAgfj8ZPz3C/z4sGumdr/YuxnY9s8OqF33bdx/Ziwff0cQ/6MUpmFiyY4u7/k5MmU+fCQ2fCvacy/3w5oU7NU7YHn/018PblnrrT00deHxn8bveHy/9EsGX/tzfV2vc5fb8O3b2s1NdPt/ycpdvx9s/7/uNIf8P86BOOQ==

docs/cassettes/configuration_f2f7c74b-9fb0-41c6-9728-dcf9d8a3c397.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/create-react-agent-hitl_740bbaeb.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/create-react-agent-hitl_83148e08-63e8-49e5-a08b-02dc907bed1d.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/create-react-agent-hitl_9ffff6c3-a4f5-47c9-b51d-97caaee85cd6.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/create-react-agent-memory_187479f9-32fa-4611-9487-cf816ba2e147.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/create-react-agent-memory_9ffff6c3-a4f5-47c9-b51d-97caaee85cd6.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/create-react-agent-system-prompt_9ffff6c3-a4f5-47c9-b51d-97caaee85cd6.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/create-react-agent_187479f9-32fa-4611-9487-cf816ba2e147.msgpack.zlib

@@ -0,0 +1 @@
+eNptVX1wG0cVtxNm2k75I5Q0BYaPQxT+SH3SSSfrKzGpkD9qO65tyYntmFSz2ltJJ9/dXu72ZMnBZeLCTKEZ0mshbT46E2JZMq4T2xOTmCYuhJlCKC0ktMxgk5jpBw1N0uIATek0TNg7y6k9yc5Id7vvt7/33r7fvhssZZGmi1ipHBMVgjQACZ3o5mBJQzsMpJPvFWVE0lgotLXGOoYMTZxdnyZE1UMuF1BFJ1aRAkQnxLIr63bBNCAu+q5KyKYpJLCQn6s0djpkpOsghXRHiOnZ6YCY+lIInTj60phJGKJEmDw2NjmqGIeGJWRZDB1pjoHtdEXGApKspZRKWC+2QAqduulTJxoCMp0kgaQjukCQrNI0iKFZJJyTs9YwlsqeSV61yZOGYmdqcd18DzE7HQqQbUAKkXgfAiRNg6AYAelQE9UyzLFFRwxJizpDMEORTBnJiEoSazKwYE5rmwo0ykfPVbfJVY2el0ZEtDiFIsnbL0gxrBx6HEoeWtv0pMPKeylYmqSopBwDA9bp0LKIGhJsuE2wHIkTGQQJRQ5sHyilERCo5/mKNYU01ol5dGXBxgGEiB4oUiAWKL95JNUvqlWMgJISIGiUFklB9sGYo70IqSyQxCwqLu4yJ4CqSiK0U3VldKyMlYvKWrHcah61yslSCSjEnGqlQYQbXW15qiyFcTu9ASc3kWN1AkRFokphJUDjKaq2/eRygwpgLyVhy6o1i4ubjy7HYN0cbgGwNbaCEmgwbQ4DTfZ5jy1f1wyFiDIyS5G2W92VjZ+4451utzM4uYJYzyvQHLYFeGLFZkS0PAsx5TB/yhUhxr0iMmf/FY/DZDwh13gfatwa9ZI6Up3fKnbuaA9wwYa+Di3ToLdznQnJ2NpVz4ej6c3ddVtYt9/j56v9Ab6adTs5p9vpZsXIjs5wXT1NP1cfTjws8UEf9sUAJ2xriqbzXd3ZeHOz0KT2eTQYxFxtWPNG+FbEtzqbW2ItbVsVdUujFySi8d54Y6Chw+d01macXakNDI3OyIpCTa7Pi9S8Kqj+FqEr15/JkkAT2dwBxBS/rS6p5XbIqUatrbd+20NwWXgejme5coQ+zhvgrHF0SRsSUlIkbQ7xfn5EQ7pKewR6rEiPjBj6YIHqEL1yplTuFYdbmz+R8L2FWqpJc6YjbVQxHh8TQyrj4Txexs2HeH/IHWQaWjrGImU3HbeV4GSHBhQ9SWVYtyT5EkwbSi8SRiO3FfuMJXZaSSt82pZYlFOxjthyVOZYFxtd7JJsY+2xxZvFYi0FFLHfdmv+zBIy7YqiMlU20xZgUVLnrKybQ36f52jZsqSxUZoXx7o5lnP/wrr5kF4pK3AVa4TVEaQ9mOTN2SoZ5Kz7VMO7q3kfPeQNtPtAyRBQzEjUYpn61DcwqoYkDIQXciztiUgSZZEWwf4v93d6V9xWiaZvRRDci+inYITnFseLyyEasjxYadwkKgTpOHV70BKXx8IE/cEXVsJ0tCygIZ+sT99qL1Mc5vSx3BKYFQVz9n46ifsCXp6DMCj4gjznATDAAY+n2hOsdnuroRdx45F6NgJgGrExW21mqbb74XBLY+R4F7tcNmyruvgFLClYV8RkshhDGi2NOQolbAi0NWqoSLmi4W5zKgCDPKgWAh6UBO5gIMDWdUYnlthuiqxg9VX7U7iruNjKX6p87itP3Flhj9X0d+MGaT+dOc+tPfXxA18OjT8Gf5s7eaLwY9+aO4N7o7urNv117sw/73pXnpP/8l3XtdDlt5984jS/HyTne1cdkp7PHnrl0Eu754dP9F3773sn8aPRyWdK0t82bvz3nlLm+p/WvtX5831rz185d+bApZcX/vGlH6LQa984tO7gt8efP7X+5UyPlEq8ve7C/ZdnCv6D73Q/+nQS9W+v+vWuI6dHsgsPVFbknvtlrDZzdXwufDwfqd/d/uFI9pmGivUTB9YMw6l27w/mxgrgnkLwg5rr5z6z99mzX3zj3NcuzOMHI796PPRsZeA/+69sqvnz4I9e/Wri7s1n37w7dG1v/9nXB5W4d99HrsffG5uc2/X18EVpj7DmU68+eGV60yMzez47saG25kj4jovrrpN3L05/uOvA9MJ9p44Jb7Xd8bopXrrn+zP7Z2OrFnbOX10AX/j76j2PZN5IFX43UfXHbKbmfNM7v/9NU9dUz9VLsfYLh9OX3zzZM6J/s/l/mSe3f+sP7JaN9acn36/64HPfmbj4Gnnx/eP5Tl/3vs//5OBTN+warK64L5/79NCqior/AwjHnq8=

docs/cassettes/create-react-agent_9ffff6c3-a4f5-47c9-b51d-97caaee85cd6.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/create-react-agent_fa16de4c-aac0-4ff4-ab69-60d399f75423.msgpack.zlib

@@ -0,0 +1 @@
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 truncated

docs/cassettes/cross-thread-persistence_c871a073-a466-46ad-aafe-2b870831057e.msgpack.zlib

@@ -0,0 +1 @@
+eNqFVG1sU1UYLkIIGkA0GkkY7Fid8Qenve1tR9uQYO0Ax6gbW0GKEXJ27rnttfeLe07HPiTKwKAjkVxJGCrG6LqWlA26AGrAKYmQGPWHhhgsBELUGP/4C6KJBua5XcsgW2Z/NPee9+t5n+c5t7/QRSyqGPqcEUVnxEKY8Rdq9xcssjNLKNuX1whLG1KurbUjMZS1lHJDmjGTRrxeZCoepLO0ZZgK9mBD83b5vBqhFKUIzXUaUk/5hz63hrp3MCNDdOqOAJ/gD6wE7loSP3m5z20ZKuFP7iwllptHscGR6Mw5ekF5ErQTjWidxIoArQfoSCNAoeB5o9O9+xWnlSER1UnFKspKBIowCKmh64RBPx8mNPoFpyftoYxoTl7SyAJkEYBAmqimnFUBolShjG8CGFIzip4CzAAsTYADyAM283+g6LLBi3cX0gRJnLGDubRBmT02jYOTCGNiMkh0bEi8lz2a6lXMlUAisooYKWIHW4Vku5ghxIRIVbpIfrLKLiHTVBWMnLj3Vb7HSJUMyHpMMj1cdCBCTqXO7M+iNRzeth4umQ4Ejxjw+EvdkG+n6ConHaqIQ8qblfi5ewMmwhneB1btYOcni0/cm2NQeziOcGvHfS2RhdP2MLK0xsCpe8+trM4UjdiFWNv0cdXg1DjR4/N5wmP3NaY9OraHZaRSMnaX5LslRa6vCIVGKPhO1FhSiZ5iaXvIL4SOWYSa3Mpkb563ZFnan+OKkO+/KVTd90lrS03N665Hc01cHXt8naWsBEIAtGIGHP8AXyjiD0cEP1gfT4zEqmMSM4oxlrCQTmUuyNqa+AWczuoZIhVjM8pedk+tZfH5qqIpDFZvHhfLebVzAUEQys/MmmkRjbPmTMyJ4XD4f/pyZgizTzv7QZ8AhUBicstgYFsZzFQ5eX+rePIOHo7o6Vkyp/DUssGs2TPjEfzbilXQUJHsL/jzDsHXviqeifokRuM0bMbFYCiTNMPBM90Qq0ZWgox/wwisGKKb2WXQKRA50BiSRTEoiqIkBcOyLAeCZJUoyVK4kQx1Kcgu+jw+kDKMlEpOxtbBGMJpAjsqtrELTckXo/Hm2MhW2G50Gpy/BOI864ZO8h3E4na0i5XR/IJbJM/L26NJ+3QIS6tE7MeBkBwMiGEM177UXqoZ6K5Bcs7XofKt3MNtavGji3OW1B9Y4Kr85iYORlu+fm7JmxPfhga3N767Dp59IvrYlQMLBgbc6NDCIBM7dsmjw7e+aimuWL3otZvXfx1f/tfy3jqWHLx0NXmz+9LqNQmvcqb52q2bvXSC7V+snctvWltEzX8IzXXRtj9/emBZpC439NaKq0ut9Rebd245Jhx6fHPyw8Onik37R0uPLPvn8rUdx368nF5Td5AObLqx4f2ntv7ctOffw+fnzXfvHf0Nb93Yua9p7qJFDaW/zRsPhhbOG3/nOj7y3fwr50tvfDQwNG/j2dL4hdsfxILJy2/3PzS0/pcTnx5d+nr9hvr3Pm+4dRSzIw8fv724b3vqeHzLhYEvI7ueLd/5+MDtO8tcromJua7fPfHBjjku1385MZ/f

docs/cassettes/cross-thread-persistence_d362350b-d730-48bd-9652-983812fd7811.msgpack.zlib

@@ -0,0 +1 @@
+eNqFVHlsFFUcXiyIgTYg3gFkWO7j7c7sbrtsRcyy3KVsabdCMUJe37zdme7szHTe2x5UgpRLhEgmHiTGEAPbXdm00NoiIaAGFAE1QkgIbEgANQT/kIQQDFY5fLPd5QgNzh+Tmd/5/b7f915rqgEbRNbUAe2ySrEBEWU/xGxNGbg+jgndkIxhKmlioiJYFdodN+TMBIlSnZQ6nVCXHVClkqHpMnIgLeZsEJwxTAiMYJKo1cTmzPct9hhsWkW1KFaJvZQTeJdnOmfPBzHLWy12Q1Mw+7LHCTbszIs0hkSllqlRgpSTCRdr5lQYw2/Y17xtpWsiViw3UmBcxMANigHRVBVT4GIN+BIXb9UhzYTimBVXo8U5aGAOchJW9HBc4SAhMqEMPUehEpXVCEc1jkqYs0A4uGr25mQ1rLHkNSkJQ5GxtD0haYSaXY/NvQ8ihHUKsIo0kdUyOyKrZX06J+KwAilOIwtbllgzHcVYB1CRG3CyL8vshLquyAhafmcdm6M9RwCgzTp+3J22IAJGn0rNA/48DmdFM1uTyvEOt8fh6mwCbDpZVRjRQIEMUlLP+g897NAhirI6ICcBM9mXvPfhGI2YbeUQBaseKQkNJJlt0IiVeLofthtxlcoxbKYCFY+3yzkftHM7BMHh63qkMGlWkdkWhgrBXfdJvp+SZvt1A74E8MLePEsKViNUMncLvpIvDEx0Jl+8PslK0jhpTbCN4J9PpHKK2xUsy2/zom1EYg7bjvn1PEOezvEeLogoZ+mHE2aUunylzDK/PNQeyLUJ9buMrpABVRJmC5mbX34KSXE1isV0oN+1Z+wPxjJYf0WOyRTkThtblvVrJjw8z2cmPjHSwDHGmtUx4fb5fP9TlzGDqdljzQcEHvCeUN+UxZ4VGa6/zL4zm8OTtPAwROOfEPkATz6ae2J0/3h4z4p0DjSQRfMw+17FCxXRCEKLPdF6b039kmhZXXFj06Jo/f4mgBQtLgLK7i0MsoJoomaG87p8XkEQisPe8AyvKIphEYsC9kIXqnXBWgR3N8jQTAsOgYtoWkTB+wLzQAAiCYOqrGzM1JyaJf7yhYH25aBSq9UYfyHIeFY1FSersMHkaKazrdkBN3CSpVf6a8yeGUj0upHb40VY9Lh9CMxdVtmZF9B9gSSs2yF7P65jMjWY6diAyJitz9iyT4Fi+qMj/YUb771/+tiOev2r+OQWtw8c3DBqSGxKeOa4C4Fw28kFvzeg25d++jQJJkzakkoFh9Efnu86vnTYhbPXrg5effuj386du44O9M6+9c1rsz4uKu3Zc/pPe/Vaji6fcKp1WXndzqLRH4yYgraP/fdFuRceXJnmPwSHqm/Vx891nIbDS2q/u3uht6juJln57SevDr4+98tRZ6b5zhevH7Dr+tHLfwQH7py04PCO0tVlRy83nimcKL9wfjstGDnoVOcrl4OuW2PGDqwc9NzkUPX5q43vlu+Z6vmluzgz2z90Y0/wyNWZ/j3GItM+flMvHT5r6dlpvz696c4o6dmxqYhBhh1xv3ylcNydoqE7xxVu/QzO12+2LSbp5MCTF08IspR2v+S8NDq9MPPmjanbXh9xvGP/j3+3fH7zzHsF8BSIbL72T/vdbVvKujtOurtqL3WMXtS9tu3QX1duDLXZ7t0rsCWnrXtnyFM223+sv8iH

docs/cassettes/cross-thread-persistence_d862be40-1f8a-4057-81c4-b7bf073dc4c1.msgpack.zlib

@@ -0,0 +1 @@
+eNqFVG1oHEUYvlDQ+sMPqggGwfFoU5HM3e7d5i4XBY2XxLQ1HyZX8iGlndudvd3e7uy6O5fetUZqEm1sSdulCIKlBXO5K9eYJm3qB7Ui2B+KFhTqj6MqVBAs8YcW/KxtnL3cJSkJcVmW2Xm/nvd5n5mh/AC2bNUgVZMqodhCImU/tjOUt/DLKWzTkZyOqWJI2c6O7th4ylKLmxRKTbvB70em6kOEKpZhqqJPNHT/AO/XsW2jBLazcUPKFK/s8+oovZMaSUxsbwPguYBQC7wVJ7bz0j6vZWiYrbwpG1teZhUNhoRQd2uPgihQbaBnAEE6fsY7uMMNNySsuWZRQykJwyCsg7ZBCKYwwApwoQDn5rEzNsW669dnpACyMEBAwZoppzSAbFu1KUMPKNKSKkkAagCqYOCC8IHt7AtUIhsNC0u3uIvjOSPuHcwrGEmMtSNZxbCpM7OChzNIFLFJISaiIbHcznuJvapZCyQsa4jiguhiLRHtFJIYmxBp6gDOLUQ508g0NVVErt2/m/U1WSYE0oyJV5oLLmTI6CTU+aCxgsPfmWFjI4DzBQVfYDoNWbcq0RjxUEMMUs4s2S8sN5hITLI8sCwJJ7cQPLXcx7CdiTYkdnTfkRJZouJMIEsPCeeW71spQlUdO/lo58pyZeNSuaCP532RmTsS2xkiOhMy0mw8s0jyYkiBzTsIuRDk+KkKSxomCao44wE+cMrCtsnkjIdzLCVN2UNZNhH81ef5sgLf7dhWmeYPng3ZJjYd52KLpdYCTgAdIgWungBf3xCINHAB8HxbbDJaLhNbdRgzMQsRW2YDaa4MPy8qKZLEUiG66tiL3qW2LFZfU3WVwvLpY8Nyf52swHFcsWZNTwvrjDW3YjYYiUT+Jy9jBlNn1u0P8hzkhNhCl3VCfxGsFrlwhst4ci4ehmjjGp5LeCreYE3v1fFwgf5CGTRUJedjtt7J8W1Iifa0b+sVd0vp7e2tAdqeDCvy+TQUNSMlQcruMQxLgkhTpwjiclyuY28wGBLCKBQOcjyW5XBIkgUUiGBhfEBFToH38SBhGAkNn4m2wCgSFQy7S7Jx8k197Y1tW6KTvbDLiBuMvxhiPBOD4Fw3tpgcnUKpNDvgFs6x8K7GPme2XpTCQTHIx+vrOSEYEWFzT9d0RUCLAsm6t0PpvnyNydRiW5euPnZovaf0rHvh8FPJz559YGT+4Nv/PCQVM39t7al5/7TAPz56iOgjEzuaLyQ2jNzed3QL+PbT8P1y04PXvrn+0ZMPX50jF38+4c/fuvGr9f0vP8798Vt6//Dgn0K+te74PfcNzwbXF8b6dw1HNzv96St6q3MDv3ryNHfsJ/zi1MEDZ/dHoXbprvnQ7bHqwcu/v5N+dNO9jxw4fLbl3Ngr36G9ezqPfVL9xCnu6VERq7v+rd568s0Pa9Lt+txRsvnW6Bs3pbe+eL332pfnhzfePHIid/1uj2d+fp3n76+rL1dVeTz/AbjckGA=

docs/cassettes/customer-support_72fceb01-b0ab-4bef-a22f-a2fce6ee33ef.msgpack.zlib

@@ -0,0 +1 @@
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 truncated

docs/cassettes/customer-support_783a548d-029a-47b7-9ac0-9c5203ec92c7.msgpack.zlib

@@ -0,0 +1 @@
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 truncated

docs/cassettes/customer-support_96469e95-5070-4169-bedd-45db94b43d97.msgpack.zlib

@@ -0,0 +1 @@
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 truncated

docs/cassettes/customer-support_b7443751.msgpack.zlib

@@ -0,0 +1 @@
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 truncated

docs/cassettes/delete-messages_3975f34c-c243-40ea-b9d2-424d50a48dc9.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/delete-messages_57b27553-21be-43e5-ac48-d1d0a3aa0dca.msgpack.zlib

@@ -0,0 +1 @@
+eNrtVH1sE2UY35wgBkTQZQRh46xDCOzaXtu13SLMrWNStrqtnWgFxLd3b3u3tnfH3XWsQyCU8TGHzJsONyEat67VZsAWUIJjY3OQKUGMQY0DYtAwNChIwiYfAefbfcAW8A8T/UPj/fXe8/08v+f5BcIlUBAZjo1tYlgJCoCU0I9YHQgLcJUPilJ5yAslmqOCBfm2ogafwPTMpiWJF9NVKsAzSsBKtMDxDKkkOa+qhFB5oSgCFxSDDo7y9whrFF5QulLi3JAVFekYodboUjDFiBGSLFujEDgPRC+FT4SCAmlJDlXCSlERzTyOmed4MQfnUKxdEfXkKOiJakgP8FEQ1+I0YNw+XIMCq7Vqg2JtmIaAQj1VBWlOlOSWu6rcC0gS8hIOWZKjGNYl73aVMXwKRkGnB0gwgtKzcHAMcsQNIY8DD1MCQ0NecjPgeQ9DgqheVSxybNNwubjk5+Hd6ki0Kxw1y0rygcyROlQFfjRUFlMrtTqlprkUFyXAsB40FtwDUEkhflDfOlrBA9KN4uDDgMmhIec9o204UW60ADLfNiYkEEhabgSCV6/bN1ou+FiJ8UI5bCq4O92w8k46rZIglGktYwKLfpaUG53AI8KW20O+7RJBqGhxtR5XE3tGpuSBrEui5QaC0L0vQJFHywY3hlBIyScGgggRePzT8PB+1OfnjqC5LZiNsJHbimhfCqbRYzbIY1HMMUKbrjWkq3XYM5aiJtNwkqJ7QtFSJABWdCI4Fo1AHyZpH+uGVMR0T9Ajw0eAM5R8CL1Xqoms7FKryc35AWmhsrJ9VpeQWpZLfFiKkx7OR+ESuiCIDzZbKsk9mEanh4TekZZmBEadg9AYtUYCOgzQQekJvdqpayhhgBwhlATm4jiXB+415eAmQNIQtw2ORA5n25/NtJhNTS/gVs7BSSJeBFxykOVYGLJBAY1ajgymRssrwBByt2ba5f1GMk0LUg1OAwU0evTAFz1vbR4Zz+32g9HNH7zUDQgCAYmOXJ9VOSFm8IvLqyrM7Xp6SvnAsTRV+/LZlk0X2iYEvg3Ed04rTF4u5s4o69l9cIH7oeu/VkfOnuw4oN2XV/Vkx3uWnZHahbP6KtpfSjrdvOLzrv7uW103WN+4iQsuMVLhknWm5p+St3eEv0rub2qmZxeUmxLXTtbVWT5q7+k1299862hTbVd9wlLHpjUXBx6rWdj9i3lmQnxD7TL7u3WN78zpslhyju7PLt5erTqeNTn0m2fH+R/7F7+25HL3jElcghmu9J17Qz1zq6nxIHkz6ZE21w9vnzV203K+e3nV5qv2+TWJqwI7dyRU92fMqwTXxsfEDAzExXzWkv7N/NiYmL+H8k7Fjvs7OS8Fu2MLRJFBh4Ksxjoshh4Ph2VxDuQnzRExliEhJnGYF0IJ83M+JbaYW42RgMXM2FCMqBRZUMCfMTbFPcpZTYNoUK8fY4EXZvxPw/8pGtboiX8lDRN5Rrup0MHbeGgo03MOv4vKA0v/lIZ1iG6h1ml0Oim1AWgIrT5VnWZwUEa106iFqY5/loaNBGHUqP8SDfePpuHMKA1vGjimmaaaYT8ZaDactnXavty4tTx1emtudZ1Ou8ya9XtrcF5p2eXvriYdmm6NSypLe+4SyMi7mLu99VbfjV26I1d6r0mv3D+xLJFvLEjeNSVl25ndOVPM9RviU/rOvPxA0gXlufGVlqmmYrHwY+FnPbvig7p4c+fhL9ZXvnryVFvFFsOJnKzi4zVX6Ll9dHVt4voXn/Doxrc92jB1ff3Giu8D5yu7aw5v6e0KzH34662ZtR1xVhuT9OC6uE4xJzL1qd49+17nuJuTKjY31QiVyWcPnLjPdYurYe3tsUMU3Gf6ZFKUgv8AZIo4lA==

docs/cassettes/disable-streaming_2.msgpack.zlib

@@ -0,0 +1 @@
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 truncated

docs/cassettes/disable-streaming_4.msgpack.zlib

@@ -0,0 +1 @@
+eNqdVd1uG0UUpuKu99yvLKQCyti73vVfogglTtokbeI2TmhShKzx7rF3kt2ZzcysE7fKBYV7WMQL0KZOCSEtagWlUN6ABwgXPARPwFl7TRKlV/jC9sw5c36/75yHhz2Qigl+5ZhxDZK6Gg8qeXgoYScGpb8chKB94R3cbjTXHseSnX7kax2pyUKBRiwvIuCU5V0RFnpWwfWpLuD/KIChmYO28PqnyYNcCErRLqjcpPHpg5wr0BXXeMj5YtcIKe8b8poyqASDcUNpSXfbIGX/49yEkZMigFQ1ViBz+5/hTSg8CNIrYZFIQo/BbqrI8crCX3wPNMSDljHgWUMYYWY6lqkdK2/uH/pAPcz7qwNfKJ2cXMzkGXVdiDQB7gqP8W7yY/c+iyYMDzoB1XCE4XMY1ik52gaICA1YDwajV8lzGkUBc2kqL2wpwY+zdInuR3BZfJTmRbA4XCcvGxjEzGLhdh9LzjFUp5o3n+8RpSnjAdaQBBTjGURD+W/nBRF1t9EIydqZDEaPT87rCJU8WaZuo3nBJJWunzyhMiw7L87fy5hrFkJyWL992V0mPHNn5y0rX/vpgmHV527ypEMDBb9ceAxa9okr0EbynXkyrk8AvKv95LHllJ5KUBECCL4Y4DMdq4cH2Av488rXhxmUfpilnrE6wui4nX+/897BHHYoebPmxxNGsWw0ITKKZtExLHvSsSfxz43lteN65nDtrQ05GYtvZfEUneJR/a09f5P2HBNKM0CYEtiLhAKShZMcb5AsQrI492IEMCJkl3J2f+gv+T7tJ7KG8ZeZOJIiNYmwI6FKHlnmSSYYV/oI8zGJZRLT+hWRzlwElqQcyyU1UeAiRXU/OZ0I6V6KqmnbKtll0zSnkFpuEHvQjNtzIkSXaspA9gSCeq/3CPIDAhYybMPwO6O/Sg5K+PjVZQUttgEHxVPbHH3+OK8iIXWQJnFmx6nVar+/XWlsq1hLPxXn9UU1BefjsYqhenVZIbPxyFTHe2Ntwrzk9H08tNqWW6VQpHbJqZRqDq2US65XqtbaFVorta3qs/p1UqeuD6Q5xFtyOLe5MrO8WD9qou26ENsMvvnryrutlttptcNp+0Z1vnNrZqfUqvHNzfb8WnPzjr+05S3utMwdfXO3ZdsueH6/f1MQq1Ks2KVq0XQIDp+8lbdIJ1y4U/WkKfSit6Xu3tlYWVpRze31ap/NLc3FzUbTh3Z31Q/WW6ZTsXul+s7SRrvtFrf6Vr6xXF52Fjpabu3OrDjK32rszfNSp9jFflLtTxemDAQiw7JMZzwgyAOSssCZtMYsmDK8IQqm8xen35SxgPO9wYP+FNIH4QT4S0NoMg3TK4LD6bdYg7jHvOkbuzs9Z7k7e/NW99696536J0sLS+2QLVj5rfJe2Z4tbtP719c34V7PPVeEcsUiZlaHsulUh+g5C/1/RvXzBjlPa9KIRovskAvFWaczaIJECiVHbiBiDwe5hAH2fHVmM3lZdWs2BbcGnZptIk7I/N3V4er6fJAyjHdP/3lw1TByuJKExBWSHvCYTaJ0Ea1zFUcpA8EzejSIYdK4NlpD1zAhUAYX2shUhmvJ2GXaN7TPlDHcZnkjzQ0vIF0zNA608cFwcH44smeg4n8u8rmJUQTpRkndM45KzGtlsG+NAs2UIiqH23C8F7PrdJ4O1+pZ6K2hqxzK96/u/wtcP/+g

docs/cassettes/disable-streaming_8.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/dynamic_breakpoints_9a14c8b2-5c25-4201-93ea-e5358ee99bcb.msgpack.zlib

@@ -0,0 +1 @@
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 truncated

docs/cassettes/edit-graph-state_51923913-20f7-4ee1-b9ba-d01f5fb2869b.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/edit-graph-state_85e452f8-f33a-4ead-bb4d-7386cdba8edc.msgpack.zlib

@@ -0,0 +1 @@
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 truncated

docs/cassettes/edit-graph-state_cfd140f0-a5a6-4697-8115-322242f197b5.msgpack.zlib

@@ -0,0 +1 @@
+eNqFVH1sE2UYXx2J8yMaQUQiCZcGdTG87V2vPdomGGo3iENg6+qAAeLbu7e9Y9e74+7t6LaMj4EJCUG4RYIE5MN1rTQFNmUZinwlKOiMgjFKiVkIC4ZERCUaVAR8r2sZhAX7T997n9/z/J7n+T3v05FpRrohqYotJykY6ZDH5MMwOzI6Wp5ABl6XjiMsqkKqdl59uCuhS/nnRYw1w+90Qk1yQAWLuqpJvINX485mxhlHhgFjyEhFVKHlvM3XZo/D5FKsNiHFsPsphna5p1L2EorcLGqz66qMyMmeMJBuJ1ZeJako2LoyENR5kYqqOoVFRK1AkPzplKRQRpRS1BX29iVWOFVAsgXnZZgQEGCBBxiqoiAMXISQ5ly0FRerqlykVGAcjcS3jAIyeF3SrPItQxDKMoVVykjo0SJ1xGHhJEVL4KUGL6I4JMA2u0bqRzqWCtW02UnX9JbCCbdowxxYl5SYvb2deFtdlXQkWFkUoVYBJagaWYZ4TKBL2jMiggLRZlNKVA1s9t7X7QOQ55GGAVJ4VSAE5r5Yq6RNpQQUlSFGWd5qQEFOM9uEkAagLDWj9LCX2QM1TZZ4aNmdy0izcsWuAyuX+81ZSxxANFOw2R8o5eGsbSHDoVC0g3U7XD1JYGAoKTJRF8iQpJTWCvbDdxs0yDeROKA4eGZ62Hn/3RjVMLvnQH5e/T0hLanMbqjHOfdHd9/rCQVLcWRmgrX30xWNI3Ssg2Ecvt57AhstCm92R6FsoN47Tb7jkiVDxAKaAzSzv9QlGSkxLJpdLMN+oCNDI48GrU2TkDhhdKSIIuir05nimL8/b3ZJzcGysakqoo55JCwmplIujqpHGmUNKcWwfpbz0xw1a044FyzShEcVozesQ8WIEkGqS+JneDGhNCEhGxxV9rx9pCyd8MtSXMKg+MaJWNanmXLTNJ1/4YFInYy9pFiMKdbn8/1PXNIZhM2DVn2A9gEXFx6u0uNuzFOjeQ4vimI+aSsfktGUByBH8imhqQeiR8+H5hqzxaSBJJifkvNSmqlq1jiIF7BJ7/yG6kCdUvt6Szwa7UsCXlYTAsBkWyJQGIgkNvOUG0bcLOt1RQWWRx7E+VhvRPC6BOjhXR4Pw3Q1S9DMMg6GiqlqTEYHgjNBEJJFAuoLY2NmqhbODcx5NZhbAEJqRCX9C0PSZ0VVULoe6WQczWyBmjxwHaWJeyiw0Dzo5X0sdDMMhNMivJv1ger5oZ7SAN0ZkJS1HQpbeU16eCN9Zps/eUNFWeFXvq7uRE154PGbW5gJzkX57xvwpprxvW9kK+wfvtafv3oun3pP6Om7cmwgt7712tPXOrde75x0HOxZ3dCAXt4x8Oc/nT8fbvUf6K9fMTToHHymYuLllWv3PlZ95SXbmvaHcuvH9aU2BwZm/1E741J88cULmJ5YMW7PEzP/Fnfs2qif3h0JTXnr4qXfpoeXb73cXnnh0bWNs1auEpRNR6Z1cOGNe33Pxs+EmTFTPL+KfSfenLTt4dk/+Rdkd4R/nHbVt/PdiVnpbNWJnX9NfzHU/fYXldvPn/1WHDrpzfoOcuPn7h5YmWNuuGoaDx0LfclvezK2IQoOPffNruahUzd+OZVM3lr8w2Zbnvv96MmxG7i6Pd7jXORcZujfocmfXPWU1w2+Y9tH30ycnTCm/6m9r1RWtu4KXFkVmnT0u5pLns4Zy/0fn17ddevzr2ctuf5IWdnt2+VlzPYz6Wu2srL/AMEX7ks=

docs/cassettes/hierarchical_agent_teams_6b8badbf-d728-44bd-a2a7-5b4e587c92fe.msgpack.zlib

@@ -0,0 +1 @@
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 truncated

docs/cassettes/hierarchical_agent_teams_912b0604-a178-4246-a36f-2dedae606680.msgpack.zlib

@@ -0,0 +1 @@
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 truncated

docs/cassettes/hierarchical_agent_teams_9860fd46-c24d-40a5-a6ba-e8fddcd43369.msgpack.zlib

@@ -0,0 +1 @@
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 truncated