Add windows CLI testing

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

.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

@@ -14,7 +14,7 @@ jobs:
         python-version:
           - "3.10"
           - "3.11"
-    name: "CLI integration test"
+    name: "CLI integration test (Linux)"
     defaults:
       run:
         working-directory: libs/cli
@@ -22,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 }}
@@ -39,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,6 +21,8 @@ jobs:
           - "3.10"
           - "3.11"
           - "3.12"
+          - "3.13"
+
     name: "test #${{ matrix.python-version }}"
     steps:
       - uses: actions/checkout@v4
@@ -30,14 +32,21 @@ jobs:
           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
         shell: bash
         working-directory: ${{ inputs.working-directory }}
-        run: poetry install --with dev
+        run: |
+          poetry install --with dev
 
-      - name: Run core tests
+      - name: Run tests
         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,114 +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",
-                "libs/checkpoint",
-                "libs/checkpoint-sqlite",
-                "libs/checkpoint-postgres"
-            ]
-        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",
-                "libs/checkpoint",
-                "libs/checkpoint-sqlite",
-                "libs/checkpoint-postgres"
-            ]
-        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

@@ -26,49 +26,11 @@ jobs:
       - name: Check links in Markdown files
         uses: gaurav-nelson/github-action-markdown-link-check@v1
         with:
-          folder-path: "examples/,docs/"
+          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:
-    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
-
-      - name: Install dependencies
-        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 --diff-filter=d 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."
-            fi
-          fi
   check-readmes-synced:
     # This checks that the repo README.md is identical to the libs/langgraph/README.md
     runs-on: ubuntu-latest

.github/workflows/release.yml

@@ -270,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

@@ -18,8 +18,9 @@ jobs:
         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)
+          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

.gitignore

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

Makefile

@@ -1,4 +1,4 @@
-.PHONY: build-docs serve-docs serve-clean-docs clean-docs codespell build-typedoc
+.PHONY: lint-docs format-docs build-docs serve-docs serve-clean-docs clean-docs codespell build-typedoc
 
 build-typedoc:
 	cd libs/sdk-js && yarn install --include-dev && yarn typedoc
@@ -6,23 +6,34 @@ build-typedoc:
 	#  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 docs/_scripts/copy_notebooks.py
 	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: build-typedoc
-	poetry run python docs/_scripts/copy_notebooks.py
 	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

@@ -16,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.
@@ -24,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
 
@@ -59,7 +73,7 @@ from langchain_core.messages import HumanMessage
 from langchain_anthropic import ChatAnthropic
 from langchain_core.tools import tool
 from langgraph.checkpoint.memory import MemorySaver
-from langgraph.graph import END, StateGraph, MessagesState
+from langgraph.graph import END, START, StateGraph, MessagesState
 from langgraph.prebuilt import ToolNode
 
 
@@ -107,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(
@@ -222,7 +236,7 @@ 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 (beta)](https://langchain-ai.github.io/langgraph/cloud/): With one click, deploy LangGraph applications to LangGraph Cloud.
 

docs/.gitignore

@@ -1,4 +1,2 @@
-*.ipynb
 site/
-docs/tutorials/**/*.png
 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,222 +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": [
-        "state-context-key.ipynb",
-        "async.ipynb",
-        "stream-values.ipynb",
-        "stream-updates.ipynb",
-        "stream-multiple.ipynb",
-        "streaming-tokens.ipynb",
-        "streaming-tokens-without-langchain.ipynb",
-        "streaming-content.ipynb",
-        "streaming-events-from-within-tools.ipynb",
-        "streaming-events-from-within-tools-without-langchain.ipynb",
-        "streaming-from-final-node.ipynb",
-        "persistence.ipynb",
-        "input_output_schema.ipynb",
-        "pass_private_state.ipynb",
-        "memory/manage-conversation-history.ipynb",
-        "memory/delete-messages.ipynb",
-        "memory/add-summary-conversation-history.ipynb",
-        "persistence_postgres.ipynb",
-        "persistence_mongodb.ipynb",
-        "persistence_redis.ipynb",
-        "visualization.ipynb",
-        "state-model.ipynb",
-        "subgraph.ipynb",
-        "force-calling-a-tool-first.ipynb",
-        "pass-run-time-values-to-tools.ipynb",
-        "tool-calling.ipynb",
-        "tool-calling-errors.ipynb",
-        "pass-config-to-tools.ipynb",
-        "many-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",
-        "human_in_the_loop/review-tool-calls.ipynb",
-        "node-retries.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",
-        "respond-in-format.ipynb",
-        "quickstart.ipynb",
-        "human-in-the-loop.ipynb",
-        "learning.ipynb",
-        "docs/quickstart.ipynb",
-        "tutorials/rag-agent-testing.ipynb",
-        "tutorials/rag-agent-testing-local.ipynb",
-        "tutorials/tool-calling-agent-local.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 @@
+eNqdWA1sG9UdT4FsqO00ECAEbOrDgiUtPufsOLaTkNLESZo0cZ3GWdPQFvf5/Gxfcr477t3ZcaoI2gJFsAmZ8bXRtQXSpE0/aEf4KNAV8b0B5UPQrWUNWxkgEGLjU9Mm6P7v7uw4TdgQlhLfvfd//4/f//N541iGaFRU5Dl7RFknGhZ0eKH5jWMaudYgVL9hNE30lBIf6QpHeh4wNPHYopSuq7SuqgqroktRiYxFl6CkqzLuKiGF9Sp4ViVishmJKfHc8Xlt6x1pQilOEuqoQ6vXOwQFZMk6vDgiipQhCCNTGJxBWKZZoolyEumYDrhQG9FgH/6okiYoaYhxIokyoXVrZMShdhnpKYIaKRWpjmUdRQQN60JKxXEnyikGyoqShGJwUMwQGWmEGpJOkZIAkaqEZZMmhUEFMkgEQydxpCu2DiZngxKtghbVc5lSe1KKkUzpSCYkTtkBjWDKdI8phm4eK5oTwxR4Kpaa4Rhwy2ATGyTKyM15ECUMC4FQi3V7UlbAWFHTiEQyzCLLJQXVbaqEyY/5SNSAvygnFC1tMkYiRSoQA1unaTVYCngLIiUoBtrZ7oFlOY5SRFIThlQ0WPl2m0Ekw4p5wpBxTCKM2uZPQTJNgKKKlkMJURZpijnQ4uoENU2oGT3Rv1VxF+omVFVktmgSJRRJUrKMkUUDHl8j29DXoStnYM7ipehhZl02BaELZhV9TI1EQhREgGYaYtM9XjB78Rq50YQeZNk+YPjgAcJ2MliUTBTsjGHhWOleiFpN6ytN/UUZl0KrEd3Q5FKQF9bZi9RcskmZ6haIhBYNY06o9CwEjBiWlRaIDAALaAgx09RpZkE2WvHP3GyiYPoBJ7EIaAfhMca8x9LJzAg5hyQiJ/UU6CXKVNcMAZDMpnIoS1DaoLrtSYcTOTRFIix/aY7qJO0YdqJpad0Lsits7UlahcICZhLm2Ugr0rBIrURj+9VaHKkKGH5VKV8Gzwyuq9dXGJpUUYcqCjUom826soYcJ1pSU+DbrERZghkYVQatEnAVxTKX0DDLAEGpcKIKmyFjEzQgzyAaeq0TLNBQl6IaEtZQUNRFcIALRQCo1gIDJwo2oho/WmPwfIxHrSikUF3KoaCkGPFcPQphGUyHUuREy/uQr2aKsEAREVLgExDWhbUBJ2rvRJU+3u33LUQ1gSnqVixq9agJmCvAKtSIfO6ZrNoUw9rvWYX8JaJcLlfF8FoGp4zTJpw6zohSLkoJ1oRU1E6SaD/ETynoCUM2o3kG8O5Ajbu2upQhxFjqOx3tV0S59GDh/f8e/Dk1mwDLi5gCyQtFLSOCwYWMc6I4EaAbFNPcTDEzwsGLVgK5WNnCkAHfoVq6UB9kSBrnSs8WS0cax9k/SBHwLkS0btZ9oIybvEtZZkVomFCTqCFAWQc9cTwtwqti5qlmFzlGBapjnWROy9uizKQZlKAwnSoZSAD7soo2ADkJdplc4ICL1cbZ8nItrKUV6JlsManqnJeDTIwpnAknyZqugT03fKtYA6yIFNUVRYoK8Mz6dQJLlMAu1AOC0yULJYkNq7zLz9bMkylFFNjaeoeeU6d72VnyzAgKYbEMwiJs6KqhU8fwsM3JHhe+FxOgiRMqaKJqkzma/0e4lLYKhnChVhfLuOU2SlwOGygYi2ByMsWrGoxBGqsWls1WizKfT1OhB/jBkARlUGEd3Joipuo4Kz9MJIXeL7BZBBftLWAAXgBKliwOPAUAxGU4YYE1i8TpFlRZbcYyZLrmBRLLDFG3Qqm7sDqLGkyPQl4x+VMsWOAVWbQyDWbjo8T6wVIr909TJgHDVQwLA7Ph2AjscjDyWTCW1oZCclqpBt0gTeS4PXGx3GQ9sTi2xRg2gyRuYjGlbEHwd7G3qOU0e7uLffJ0Q9fOZFGIlymXrp3l4DAcHUsRKEMavW0kBY0hv2/6BP4ghnoDGQ7TpBIHbfN7k0OiyspkQoIyMw61VSamgPz4ACEqhyUY30atU/n9WFUlUTChqmKNYY9dizmmycztcVaNOJjpZT0/EQYlGturunJgC4y1Lm/Axe8f5GAkF2UJaiAHaCTzo6q5/0TphgrYARPOvobkR63D+0ppFJrfEcJCODKNJetk+R1YS/u8D5Wua4asi2mSHwt2zRRnb06Jq3a5PS7vgWmMaU4W8jvMMvfotMNE13KcAHOGnr+P31fAx5qZ8iOeQCCwsxD/m0bhnG7QjSPgDPLyi2P2Dej+cEfBi5NlF440g2Pyh3pShhN5fChCVOThPV7k9tXx1XVuHi0N9ewJ2nJ6ZvXDgR4YTWgCfNFS8PuYkDLkARIfD87q8UPY7Esc0x/aBUcGVYUSztYqv2cV123d/bj25oes8OIULYllccgUm9/FvGmWsQl7G1KXsQThXJoCEn6Pb5+9VUB6HAzjOTfP8e6DLJsECCymuapoOkfh7qWJei5/zJnGgyyqGqrdNdU+nufroTcKkhEnESPWrKRBKK1n+S4pOP74IAf9B+6D0F856799bYWIccNh/rGZFLoyQOCGO+bhzc/vSyk0wgQwM4p8Rmrh8+TsRAVWbiCpCfCPT6eipESdB3xp+tjMfZvDiNuTpnsGC+ScGM8fuwxeooLbV+0XYn7i8/qx2xvHQozn44mA31NT66+tFR4MtnJBLKQIFzHDLT/W3Le8MdQeHI8A96CiDIjk9uNzzoxGhUQ0lm5Y5hHFQLRXMKKhRsnbUt2VDSY6kk2Z5pWxQU8nr18dodlkW2dHR9TLuf0ef7XPV1MLbnPxLrfLzbUacmZld3t0effS/khLTK9ZMegiq5Y2N1ZH5GaJD6WWD7hIwNO+qiesReVrw226gj3JaLu/Nt02lBCxrMVWuJsDQrZF5nvElqZm6g3zK8CfMOk0VNXDJVyFskgb7ITgICE4Kx2qC+lQj+JmFDS4plc/mIbhThCWJTZis3Ai8A1dOiLqpGG5IpNjdwAGRkaMN2hyW58WbluWre3oDXdq/TTqHfRkwtgTjF095FabdNLc51nWEs9ppSDAA8fbOPh4b8CMninVv6dWj6ziSvObC6vWDzBjskJlMZEYjRANUig/LrCZHwq5RkbB592NffmJgFDr9cf8Pm+t3yMkPB4usiy4v8CtWA1GWBcYwxJkWUbIP5SqbnDUeb3VjnoYZxsCPi/Pmz/TbBi1etxzZ8xdcOvZZebnTPg7dWoi8rZ8fMk5wx9c0fr5/LM333PrO0sWjb/hzR//7LU3Lzju3HTow6Hsw/WuS2++7iP/Fy8tuiT2kzcXH/3x0aEjW2tfoMeyZV173XPuOLiuL3Di3le+PPlu1+ShK1+eDCUXnPy4/Z1fXDN51d0vvaddf+IWvGBb22dX7K5K/8174Hfvn90R3rjrjxf/8sHnn3m9cmtn//b9A29cwNG/PPHJj+7f/dgHV37dM9HgprsvK+/86+oflq2LHr7itkTo1Xue2v6fixdWnpU/92evXF72xcrec8+/dOdTT/OZV7dP3PSHnkdCu4x56wa+XDZ376tPv5B8p27bvMsnrkmPeg+fuPPTTQc/j62/7t5XDi93fPjAXZPuL4+8dZNvRz604erB88KuZ8teu/n+9ydXkU86MpdvnldXNnfbneUX7dvz7uKWI+lfv7cldvvJu7dcv0v9e/ndW5dc9C/nfOeTfHe52Fh+8wuHr+P+/c/2nUsG1s3bct78ry/ecuL2fxzdtrVp18HHfxo6mar7eOzPoRVvPh/p/Grh0Nwjv1lyavVX6lP+8oD+TeabyY/2joUuumFxzdfnX+WNjKTff3J4/oXBDZeQnhd7tzbvvHfThr31/b11D59xl/KDc3776I3vXvD2gvj4DZ+u01/e/EG5eN+vznvxrhvl55b+6VRs79Fnm96KHHc+//p9nmO1z2w/0Heq4qa16xatvIR4PjuyO1Fet/nIAtPhZ5Y11DQZc84qK/svuKhyGQ==

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 @@
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 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 @@
+eNrtWXl0FFXWj+yQgGwChq0IgQCmQ3f2RIGskIQlQGIgskh11evuSldXFbWk00QcARGQJbQHCYsTWUJiEgQCIoggmxgVRJhBUNwBEdwiw6aoZO571d1JWI7OOfN95/vOif+Yrqp319/93fsuc8vzkaxwovDAZk5QkUwzKvxQXphbLqOZGlLUZ8scSLWJbOn4zKzsjZrMfTLApqqSEj90KC1xYbSg2mRR4pgwRnQMzTcNdSBFoa1IKTWLrOusf7PCIAdd8KQq2pGgBMVTJmN4ZCgV5P0KnkwpDJJFHsFfQZqC5CB4y4hgiqDiRxzFc3ZE2UQn5dAYG6XakItyckLQ7FCq/iCtKJyigi13nM620WqIQmkCC07Ce5Y286gflW1DVDLiVY5RKBudjygzQgIlCogSLVgD5RAVlVI0hgEzLRpPWWRaYGycghSKE6hxSYkU/FBF2RVGZYkORNnBKAuETqFos6ipRIZHQQi2VuAEK6XKNMvh6MZPFaYKBmyFS1fvFAWKpmTEiDJLmWKIAsZGOyScChsnKaH1VoGFtOCiVEQ7wrAITqZ4Gp6rnMojiqHBGjAx3GiMDbtTjYNmEREk8bRLtFiIMzEmClsMYmOiKQXRCqikFE5g9E95RFs1sJBWKIuI48jiQ6a4yOjG4llwQI8Jx1CyJmCBJlNjL8jJCJ8S+IU1mOKijBA3gaWijeAoDxrMLvifFQmsomc/ieN5aqKmKIjnQ6kk0Uwli5riCiWnMkSbQKXR+TzHILvHqHQBRxNAQLkQLevhc4VACGTkoDkBYWslJCNIDM1TOmAAIqEQIjtJ1R1BMoV7kUFi3cAJbIEvwSQbLJfP4YKi4iAngHOKhaIhb2nAlEQLxMZ0jEurjOCZKgL+wCALTaJGk9yCUNWGIWiDB4oqiyDBq0dCLAdHUVhDIIcA9DieU11YHniECwICwLvgh0NCKoL8yTpKFBIVirZAvet/cmAlsnACpyI4QFNmDrTQsurxGryC+Ohu0JKEaD6scf3do3Cdeuk5XJQAmBzx1+o1V9TAfJ6lAMVgF8+BgSRuLlGTiSBsKgAglFLEux7+NaOocSPH6CFmiQhQwAl2Kp1A7T+wk+VYIUQFSwVc07gosSCrhwEglz49Xg+IBmJ5OujGh0lZIkHUrDaAGSTIQRNhegotHKtnECpQUSinjQM0+KRigQ7OalMbogf4iJQujgxIwNyuS7SRAmYgJiwQnR46OMKKDh0XAKQkoBd45SVGM63YkWqmofSwvlCf0U6IB7YQagVhPyFImkPSg0B8J8KxnZKMLLjKgEYJnj0v4bmYz7G+omjgeRiVbsGfhLB65YMaxUbL6F7Oy6KoYuPBshAHOChJBPssp4Cbii6aVBF8HEZlgouyEygcfw4+KeCkHX+PjfWcucMFbyQ8cdIEHqeh3gHMyGAai1Sa45U/R5+nlxFyoVWZE1WlX9Dsabgdiizi8ScMT2ssMkQYbDRn1wzh0C2NEcYYLEhxQUE78EdZmsNByy5cnI1y7KmYeCoNgo5rApij/tO7IAE4tNAyaUYYz9D+ZZHVGAAI9h64FriI1BUhOYXmyAsKZ8NHVn+OG8go5jkgIM9xkEUzdkF0AtNb4eH96tvTggiLYDXkbYPgs2Fey+EtOF8AaFOUBgLvnhx8NgKTYrvggCSSngYdxwa1xON6wrhUcFf3+OcjWM5BVHC4Y3uo2DMGEK98/T2UEkTVh271r7d5Iub+A0kjVr/vdOLp2N4BBQcJtwk8okgiJFkhGfQFSU9nA6hDqYmY5cFOjlaR4mkAd/Qg3Qu9A6f7UqLHjUC+ADhQxhMDsR8jAfLIgwgDGcRIkHUXdHiptKopGHANvIYA4RaCfacZ3MZ4TrGBlnqHiXspIrESkOOFO3ytyTRpZgwtqZqsVx3u/d4g3KsiNAkTApFEvhpBjUGY4SkMV4ojzARZ1HgPOzkIQUHNypwFakzGIMTONGgHwArlNkTj+bOo1AaeuKvvGpu3grlIUg1AlCIOjPtV6yxOCsUtmQcnKsFGAZG53F1pR0gy0DxgsEw/5d4GuYLZh3gwNA+Gks0eyjGoLgnd/boSM5MBhm9Bde9K9NoxdDzYC3YbwyIiw8K3FeAscYTwDDwNJpVJ5P2bDV9IUMcgx+C5QbjL9MNbGn4jKu5NY2kmM6uRSFpmbO5NtOyIjtzR8DkMjnhmcpcnj79bnedlvbqIMJMpLK66kWDFJTDuTRaaV1C1L8i+I5VAqBEGY7TBaNrijRKPBKtqc5eGx5piX9EZQUHzynRAzi2FlKBj75Z7LiwbMkd707mkNAWS496XbdNCqfBoKgtJFOZrmA7jI6LjI6OoUWOzNyd7tGTfMxfV2YBkBXqkIdWb+3LGpgl2xFYm3zPrlZ5rmYFj3Xvh7yeNphSTNWqCyIVrj8ekxAlPxNrzk2TbpJ0FBoYXNdYAtMQgg6cm3Z9QbByijVHhDGOMMyIja44xRbDRKDqaNTJREWYLuzGfo92VpjATZRVFK4+2Jo80JNOMDRmySEjc5Sm54xLHpidvnmyYKJqhiRmyaau7VIDCLctCMsTaXUlUA3plVAbHJybmul+LZeIi6CijKcpsZCMjIi2G1EkTt3nD43O/FEOf3B3nQArwxHmkeUDfxW38yH/N+RWJYq+YgPl17aoWDz0/n4kR3twlTNjIZcWkvkTZsnpMXRTROaf/stS8mi6H6/YtP71sV0KmvzT48pXCoqsz5kbYI96XCm98V/zlD+VHzzw5/DY34tjfpk2fvee3686bjOnvJ9GGs6lBscsvj7k42X9Q5xRTxeVj7y7bkNuzZ3Vs/L7Y6z3yv7n2+w+/f7pj8Y7aMdbQkE2llj9uHr66NOPmdf633LUj8nerxm1JJ8SvZqetnPG1vD0k7bF5BccuJAzLMyQHPNrseoszkYc/5Bau6rU3+YM5j1PBCd/ObTVuXcCUdpzfs326SF8uc0xe0eX3lAnzXvxJurLC1bdX24BjP33fvsf6iv2TDhiKbzzdanXsruIV4Yve/0659ZLw2L6FB8bMGPzIc127H3j7u8HzHpxX5J9WvTLlVuf1H67a/GBS74LPJm2KCNn97E20IaBnSX/bibRme8s/O5U5qF18ROz2S2k50nmuYvPrKW1jT1596cwkMbPFmhEHXAe6vjWjd0b8xys7PmRU0rdcH5k0KvepVd9xmZcOhD/x4NqO/flBrb6f93li6uxJxke+MZzt/dnPbdYuEbiALwYt2d3/gfXBqt/iZr8s+b3t1KIK+7jjUzc0XzJxdrPimUJJ+uo85sj6muwF28qzR/eb17VCfe+Bz6c8786zVe6pTmmfFbytT03FsikL3h/QO23Ypx3q2i6teb/oo+aLzkW3unKBWpI10L0tZFVyxuNFhgmjB7rWONa0YV784d2WizM6BE1ZoqXEtdg5cOSgG60TQvoHdJq29rZ9y7xerY+7zQtrXG++Ncs/I/bQioryqaOmHezZMnNm5x5tMyovDh6++pPiHomhmYZ2Ne4fTXF9Hl0179bpW/sjAxcePnfKuqlip9tY07Krs0VWh2XfVe6bvHOu0z0+b8VreWc/+qj9j782nz7Gv9eNhGHFB6sitz7S4it1+SfMv7S6WQK99eE1Dw8sGVwYljTUv/8jV3/JtKa49nzw7KH3Nrcf4KwaEHL12oIT0ypeOxb/Yo9Hs85a+T9mJK15/oshtYMW5e6//fVvx6WT58/+WrW4puZvD/j51dU190vrO2rfwJZ+fv+lxcyDh5oWM02LmabFTNNipmkx07SYaVrM3GMx81fwlmmnge2s4C+n9vOkGEcJ0IOvjCREd24kyM0WOalUwcpjlhrvUYn5jGb1TqRzD0Ht/Vctobpgj88KntdZnwQvfeJ7eH3k4HYjE03AMDBDKL71gM8InFMGyeRGhfcaIk6Pvhy599IhFBcLthQ3S7gGacDfYKiT93KamI9kT2xxO3QCEhADHU8hNEnY/842D3AiF38W8XCtttICN4ugEFw2axzfaLXA69cx6GP4NL6cgeNwX9GbUxKC9mPDiMKhnqkBdyLZDBdXKhuQkwSd3+WhfVI20GFhHPKsR2i8QfOE3BM4yEVogy0AXDNJj2Bl2klypmgS/tDbqnxRtcLVTfBuUjRyXwVcoAIGGicuQ2KdQ4O0SnhYaNCccc9WGjUUqhFo9DEJskRBPmGK0jck91hVMSBdk5Gn/vRuQcoSmhZcSeEQLzLwCFz0dHfvGlAPEJQy4FVf4vlwjZeM9YDTC+5OsiG8UM84wCTAr4iHsQMaRP0ESAIGyAIGYESJQKEhZPVaD9WJQ71fNEgg9MLBanVSYHjcsoCDMC9KMuYHKLX6VIVR4+ELBUPprm0PCS+e6/Q6wFQJzK7U818Dzrbh+vOQNsYQIF0SnUiGM/CzwdLqTwkpGwe2wT7LUxaNGgdOHaStadvbtO1t2vb+X9n2YgNTC/ClhZjgtdBMyAdHAfSIxD1N0G+jAkwC3ks3Zs58FP8X/02oabH8/2OxDNmK/G8ulmP/txbLYyaYRieNkVLEXLuYjcKtsyYoTi3uvovlcJPRZI6LjoiKjjLFMREoMtoSFY3MrCUaGcOZuJj/4cUyQnRs1H+2WPavXyyr2QeFz0YG/PGQOeytd5+zl39gFseeXDelVDjRatA/yoyXHs4ItL094bleR3serps+/omd+c+UBI8P/vL8+Y19pgUItSMvC0P3/3rDegv99E7trS+HP/jNnLqCfb9d/vDz41Hjirrkdls0Y9SWmQNC/NeldU3NObPb1DpDqH3qUOCl32/trYk9dbXqaNWk4jPFW6edf8oyIGdX3fczv3/l2oydR5nap3v//HFC0Hz3M31WxD5zo8XEmk5HO0Umsy/nrRuwpF/K0tWmROrIKrZu0YgrN1+dOKfjkUnud3v3Ugw/Nx+wdPq61A4uPrTNoOYtVxWeilowM3jVhMCEDpLfy6P7bb3cZv5jZSkjrWOf69M85fQLyde7rpy1/lSzdnvLine 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 @@
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

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 @@
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

docs/cassettes/async_4b369a6f.msgpack.zlib

@@ -0,0 +1 @@
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 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 @@
+eNqVeQdcU8u2dxAQkC4iHZFiAemhNyH03kIJTUhCCCEhpFAVEI6AVEEFpEvvSC9SRJpSpUtHQKqAiICi6Bf0nnvOu+/e+3vfZO+ZtWdWm1n/mT2THVLgDcfhkZ4YslIkhgDHOUMJpAd8fEgBDu5FhOMJf+Sj4QQ3T1iOjpZlDhGHnD5D60YgYPGK4uJoOA7tjISJITEocSQaIa5vYSXnbC2DhWl6IuB+MLSLjoK0rZSbGxRjhjFBasjpSxlLQjEQD31/T4S+lC/WBW3lBkXCFFxtJDz0zbAYKFrbxxmkATbXxBuArBRcodLmJFlzVxs/NxdTXXURG0kFf5iOth9MW8HVFKTgY+ohgTVx95SFoD38oNJmBiBrLU9bCxSp1PO0RZ6WRp62fqelmScEdFqCPSGn7STdEGsZlI2kvKe1vy9Jzz+f5Q2lSXYsULIm7li8rY2xBAjh4WojbSxha6MvQWpHGFpIiOjpaMmR6pF6IAmCKVLDw8THU9/WT51gaAlEQCzxp/b+wQc+5fP4B5+rjZQVEULy/Re/BYkfecqjd8rjRuIhnsrb+p/Ka5HkgacyqF+8Ur5uUGljLYi1LQKiY4W2tbHCw0AaaGdrX7wJ0hhthLb1gaBt8S46HkSIhaQnxNoD46xrJmtkAfQj6XZ30dH2h0qYe0CQJBkbff8/ZQ2tFXxsrY2xMF2UrJH6/7RzKvM3G0gIWk8KgjYyUHNBgDw9PHEql33ckAR4rosnzO9FgRvcGUaC0R/FYDwcJ6qOgGMI8XVYPxJuMKL/wBFeXEpMmnRVqEOhcCxBVAsD9YQhMYj4MoQ/EnuDDwZ39XAmwPN/N8fnCIsLF4M8MRj4L0DGF6PgcKyoswfSG16Ig+OxJIzCQ/PxBGcCER+SS1IF739VgIbj8c4IeLaJwZ8exeWDtEXN1W3ja+ShCtLOsjKuks4SspJycElRLWvzHGMtw/gp5QB+PJFkFY93cv0H/vkVJW7w4+BYTxzBieDJr8gPdRXFwD34b/CjnX2dSCb4FWUlgPISEndySJ2Nz5eRUJCVlyky/yUhaukZP/U1gB+OgWE9SZMKz69oF8BPxHmQ9PyeOvbi9uLOYiSFYlAPTyKM1HEcXAzqibYX/23TXtwbqIZX0Qeag2VdEaZgIyTI1RelI42w0NEzRbn7ogwwxgYyVlBJN1shKW0DHQ1XqJaJpKm0LhDhoUGEGbqbewCN0TiQt7GGr7WkpISRiYY7jMSp5S0kpYEA6RIlPTykEFZgUpWntAkpNyUA/bXdsFLqKHVvd9KztKGvlaW5tKWFGcjDFeaFEJLWJF38dxxu8CNwnkTsfxuRfAs4jrSmxBf/1bdSUiAJJEyIWvph4fHFSDSJX9wdC0eUgZyhbnDR02acp0d8BUmXKKlNRUpWTh4oIVFm6IwniBqRcOKKhMPiW7RxyBt8UhJ8FnAsqZAC8knKKkpIKcoA+XSMLCtIkf6tzuIXKuJzdPUs/wOEyv90yBCOQRDc4vMkJeTk5J+r/0LBn+6Iqnt4ePqImuCQCCQm/qlwriYJn/Etlm5EkhOyf3NCWlFaTlFa4dSJXCtnnF98/W+ZG3z/gvWyfzybO2MQcHx8nosfAY7/NYXukqCMI3F0CXP+fPtzEcCkr62nDSAjAwDISD/AzyWyt3ogkJOpuYm2nqHW74ZXAFKikAAA0CR3zXU0+GxsIXxUi78lTpMzFI8F/OdE4jqc+M07Kgr4/080MDgeSio/km5BHMk4SeUFEn0B8Zu+dkq7/KaVT2kfApZAok1PaZylOYhEw0j0NcTfaJe/0VAs7pQ/mkQroz2I0L/8BtDBMWALUklNurkBeIA5QAegcdr/3yye2QCA/AEAQP7grzqXJwBA/T0AgH36rzrBLACA8Q8AoG7or7q/xgTrjHP+VUVBus+4ugIAnwoAAHpbAIDlDQBwzu7PgfgPvvH98k0H4En6IQAeADipRg+AAUABYiRKCiABkATI/pwBgADkZ86cXqREQbooqSkpKSgoz1FRnaWmO0dHR3uOlpae4TwTPQMzAy0t00UmZpYLrKysdIxs7BcvsJ+/wHrhVAkZOUmGgpKGkpLmAj0t/YX/7/TzBYCZmuwZYJ2cjB9whpmMnJnsZyeAh9QlcgA5GRnZP+NOeZaKnIL6DM1pM5gJQEZ+6jsNDQ3dOfJfI3CG1AXms+epLrNIql9gvcgva+b8aJiaTQpsRXhYNcouALTE4Yl3qwVl5DTMvR4/raxpH6ERuiZt4QILiR/7I/sdSS0XydypTbK/ofUMOSXFWSpSowwzCeHkACpKqjNUZP9sZKa4LCmt7hV/3sy5sp2SNELmT4f53wlIWbjcTfj48uc0gI6c5BozOTNADXBioalJoXnzdwYujiyeM7OQEa3LNyDWUSUXNGhPPLniu7KqYXwTsKKwwnsrbJ9yYCRSyZHp0QGYKEMOKnbnL0BuSjUDL30vT7pn5RR7TQWeMT6S8+5Heo7fI8j1YmE9ynFw9M79eR2rDdjs/oT/kPvOFxH4l4zQ8ScfIC79Xk82eKvclYWrvnupb904LPhTx9hHq749FaoS6bcZ56YCr2YduAawfFFVg23+n1mhZu/AScuRjLaI2r9kQuqc7q+r2GZ0/lMms33vG2f6NGTTfZVt1FLLdHhiPYNbrQhffOIYPDpucl523ETPVMoOrDm/9iT3IF7QF7vJ03L3tvmE1UZvrz9XOqhk3Z2XP6+hMVglTuARfplc8DtbMJkgMHg7X/eDhdUO8cik4IS6B9cdEUVBHREcEfEvGV9t12CAcWJ5SvyS4hT59aIVgcsP9Q+7uCI+K2wLG497FFTbId2ucwyPWmi/zcHgbpKTX605DrC8xJx8+3xhEdngBelRe27Ouc46muUnb3kKmB/DUaEp3CPUAnyx4+vpVtC0rzo7GYyb/OKKFwb59qJ0sU3+1DKib4ctJ2kumZjQ3xiXaonuPvpwLw4L9aFrCB7OgIPzjrRtnZej7VWIPPg/Jprc18uZZjbfQ99nOJRGb/9RWxm27fVk8C1tlB5l7LmWnbR8Ig8848ilDsV+ME7PalM9X1NWM9E5yRPe6D4VMnohlk5VCSvL0lhQUUbfYYEMVNhIty4C1k7ktKUIxw7bCoXdP4g3s7cz34DHGj2R7DkaDX/etWcC5BS6dKmGNbDho4bI4cxeUcL9BwM6ymZ6yn4LLFcILleb0T6RkyyvPjmpEc6GBWY12Sw2ga3m0PgBEzsDkHtpIVE5XhvmG6TDEtynPu2foY7yYdLYd/i0UHrAum9svckl29a4+Vz7eUFFgw43C60Qa5PipKycefeIQBpBLHrn1u20FTE+uGcaYHS8Tqng4pXyujFTxXdlKOGshGwqnTkJTv9br9l1uZIN7MnDtNU/Z+0GZDa8V++JoTe6k/+0uA6cSDU2YmRg+mpJDN+hidfj4pK7gif4AQ6WLyP7GI+ELO1vKIvXuQUMZrbYekJwCteLcyue3ras5k0xVKSJmBLR7aga8WNt4BN7vDlKeTxq7VlE0WHBEdNVwIDxT6NepZbni70VrLFTcR8OY1bV4+bg4rRf482isrXKd71yRTYihs0n5WteWe1jrfyyYY/CG+ye+iO2V1S4Uj5cz4O86xeP0pqBxZdDi0O3ZOWdBzZyCVnMb7V/ONtaJWXzb5sZ9w+lINwioi78L7iGvv/gUYrnfXMof6u2gy9OEoxC44E3w0Zxj59NtzPbba14veUaewvzWpmMCxkxiZb87hGKsse38xiKh7nN3DAH1u61PB3AqtwKnbhYY83MYgRZsjhfsBlI68aD8knYChpOFBnv1a6NK6mo7wKW07O7ieH1XnA/sj2SxWYFM9J/riR/MJDP4HQCvtusmpUr0FKbJKLs9yoksnKJed0DM9sdB7pJs2ik01tyNAo61D+Jwle1Vn55HeFDSLw/enxu+pt3apWpjZvgo8FjFFGJL2aEicwPdZPjchnHZ0rZ4h8UY7eL2+4A1WAZf1E7C5OHD5nna/h7l+vnnLrcYxSJRmstw1MuFciNyxuK1iYCjKpxi+9yqiuUx6tfpMQ9tt7ND//wcG7m+MeIi9JcmVNWzSTTtcXcsQku4o9EGkWbp43mVd6SXwSwDFRUFNHHYMuAVF/TN4vynnnB2PYzo1SSk98zb1oxnnFXBTu1plyqMvmL8vHc+qYXsYtFqjK5oanwd3qMNmiFwlr22B3AmKxIGjpYCMT+DQMNyliFDGcvDJ3UMHBg9jjU8LaeACa8npmh0MR5B9LOKgAMApmVFBgZyw7sy4nWtGN+CiHvrNZefjgI15ToYQSlBJWWCJpJUT/h9vDwena2NoadnrwQEA+0m9Rc9YfuH8qA1unoGNSDzNjSz/Dz8fP/h2zolsDO3VIOpWa20KSfADFPky+iNIhnCFLdZk8ok1/1F/u2Mjfdf7ce/ksm/Yrqm/pEeocqbXsf908A7RM3lHLoJQKPZ2a7r5La5uo2hPO/+fE7K7B0/1bWa+vgnJWTEinXJGntYPqlcxBV11BZBr3vqs51n6P7pujlnvC2po492ktlA4eoSU7RQfm4fZqO7sSfAJ+B+ZI5pi0LXwvTOQMljnyjosnEkN6wseYEp9kTWy8e++DekzOObvlHakYGO5GFS99EDzHf+7Te+Fwi6PN7fPNWzOKNe8f+cRZaITao/1bpW6kaU+Xx7IJrwTvUbuwzZx8tk5zxI/1zyXaB9SMWI4aHndO9nOG9AgGxnIKo5JGJhJuzNKvaN7nH251x41ZrB+wvIqIE/8uohSq8a5/LKmVQcY3kD0qrEeEs+7jwil5ln7210Eprqq2lIu1rvvcr0vwWaVaXHz46r9hho5O16z5sRewUFyh3SlgoH88uRnIVKww9FsEyM+PHmZnJmJn+bcbWWVVFnXmjwsOrMm8wYJD85pbgIQXHAv334NEFyajNezBwKxfTzqWNJQb1p+EUgbp/2e97BVYcMk33ySfWpZaOheo71KbeiM3YL6SrOYjXMxM8L8sLine 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 @@
+eNqVeQc8XM3e/wqC6BHRRZBG9NVbWL23VVYLu4vFrrVFD8ITRA1JED16W6KXKBEt0bvoguglIkgkkv9K7nOf573vvffz/mfPmfmdmV+b+X1nzsyekAIvOAaL8ECRlCJQODjGAYojPmDjQwowcE88HIv7Ix8Jx7l4wHI01c1y8BjE9DlqFxwOjZUTEUHCMUgHBEwYgXITQSCdRXRMzaUdLCTRMDUPZ7gvDOmoKSthJe7iAkUZowwRqtI64gZiUBTEXcfPw1lH3AftiDR3gSJgsk6Wou46xmgUFKnh7QBSBZuoYXVB5rJOUAkToqyJk6Wvi6ORloqgpZisH0xTwxemIetkBJL1NnIXRRu6ekhBkO6+UAljXZCFuoeVqRux1PawQpyV+h5WvmelsQcEdFaCPSBn7UTdEAtJN0sxGQ8LPx+inn8+y+hJEO2YukkZuqKxVpYGoiBndydLCQNRK0sdUWK7s56pqKC2pro0sR6hDRLFGSFU3Q29PXSsfFVwemZAZ4gZ9szeP/jAZ3zu/+BzshQ3x0OIvv/iNyXyI854tM94XIg8+DN5K78zeXWiPPBMxu0Xr7iPC1TCQB1iYeUM0TRHWlmaY2EgVaSDhQ/WEGGA1EdaeUOQVlhHTXc8xFTMA2LhjnLQMpbSNwX6EnW7Ompq+EFFTdwhCKKMpY7fn7J6FrLeVhYGaJiWm5S+yv+0cybzNxsICFJbHILU11V2dAZ5uHtgFK96uyBw8FxHD5jvqwIXuAOMCKM/isFYOEZIxRmOwsXXon2JuEEJ/QNHWBFxYQniVa4ChcLROCF1FNQDhkA5xxOc/RDo2zwwuJO7Aw6e/7s5PkdARKAY5IFCwX8BMr7YDQ5HCzm4I7zghRg4Fk3EKDw0H4tzwOGxIblEVfC+NwVIOBbr4AzPNtT906O4fJCGkImKVXy1DFRWwkFK0kkWLu0EFHeECalbmOQYqOvFTyn482LxRKtYrL3TP/DPKyd6mxcDR3tgcPY4D145XqiTEAruznubF+ngY080wSsnJQqUERW9l0PsbHy+pKislIxkkckvCSEzj/ipA39eOAqG9iBOKiyvnLU/Lx7jTtTze+rYiNiIOAgTFQpD3T3wMGLHMXBhqAfSRuS3TRsRL6AyVhHvKyYJUgcZu0kBZfVFcbJGUH1jT18ZJ4wqCK8hidRDGOv6eV4TV4UQbzcTI12ojISxg5O5FQ4moy1lpu0KdhE3MIWYqDsaO8tC0UgvWRmEJsjbSQfugNVCo+A6OJSFmJUfHAVGOOuYIXTNZYwgKFVXojItUwtLEMgLrK5hfE1CjXjx3rO9zeuM8cCj/9tY5JvCMcTVJL74r16VEkOII6JByMwXDY8vRiCJ/CKuaLgzAeQAdYELnTVjPNzjy4m6hIhtiuJS0jJAUVGCngMWJ6RPRIgTAg6Lb9bAIG7ziIvymMLRxEIcyCMmJScqLicJ5NHUNysnxvi3OtNfeIjP0dI2+w/gKfvTIT04yhnnEp8nJiotLfNS5Vf8/3RHSMXd3cNbyBCDcEag4p8L5KoRkRnfbOaCJzoh9TcnJOQkpOUkZM+cyDV3wPjG1/2Wuc3zLygn/OPZxAHlDMfG5zn64uDYX5PnPhHEGCJHpwD7z3c/FwEMOhraGgASEgCAhPgD/FwieacNAtkbmRhqaOup/254AyAmMlEAAEl010RTlcfSCsJDsfhb4iw5QLFowH9ORK6jid+8o0KA//9EBYNjocTyI/HmxxCNE1VeItKXnH/TN89ox9+0whntjUPjiLTRGY0xMwERaRiRvun8N9rxbzQUjTnjjybSCkh3PPQvvwE0RLyaEktK4s0JwAJMAJoA1bP+/2bxyAYAZA4BANJHf9U5PgMA6h4AAKzTf9XxZwEA9H8AALWDf9X9NSZoB4zDryoy4n3OyQkA+FQAANBaAQBMQwDABes/B+I/+MbzyzdNgAfx5wxwB8CJNdoAFAAKECZS4gBRgBhA6ucMAAQgPXfu7CImMuJFTklOTkZGfoGC4jwlzQUaGuoL1NS0dBcZaOkY6aipGS4zMDJdYmZmpqFnYb18ifXiJeZLZ0pISIkyZORU5ORUl2ipaS/9f6efrwCMlCQvAOukJLyAc4wkpIwkPzsAXMQukQJISUhI/hl38vMUpGSU56jOmsEMABLSM9+pqKhoLpD+GoFzxC4wnr9IcZVJTOUS82VeKWOHJ8OULOJgc9zjylFWPqAZBou/X8UvKa1q4vn0eUV12wjVtZsSpo6wkPixP7LfE9VyEM2d2ST5G1rPkZKTnacgNkoyEhFOCqAgpzhHQfLPRkayq2ISKp7xF40dKtrIiSNk8nyY9z2fuKnj/YSPr39OA2hIia4xkjIClAGnpmpqZGp3fmfg4sjiOWNTSaHafF18LUVyQb3GxLPrPiurqgZ3ACuyK9x3ww7I+0ci5e0YnhyC8ZKkoGJX3gLEpngT8Mr3sqQH5vaxNxXhGeMjOe9/pOf4PoHcKhbQJh8HR+8+nNc034DNHkz4DbrufhGEf8kIHX+2DXHs83y2wV3pqiBQ+d1TZev2UcGfOsY+mvfuK1KUSLzLuDAVeCPr0Mmf6YuSMmzz/8wKNX4PTlqOpLdyrvlLJqTW/uG6olVGxz9lMtv2v7GnT0M2XVdZRs3UjYYn1jM4lYuwxad2waPjhhelxg21jcStwWrza89yD+P5fdCbXM33A0wmzDd6evw40kEl667cvHn1DcGKcXxPsMuk/N9Zgkn4gcE7+Vrbpua7+GPDglPKbkxXRBQZZURwRMS/ZDw1nQP+BollKfFLclOkt4pW+K4+1jnq5Ij4LLsjYDDuXlBljXC5xTY8aqrxLgeFuUNKeqP6xN/sCmNywMXCIpKBSxKjNpzscx21VMvP3nEVMD6Fu4WmcI5Q8vHEjq+nm0PTvmruZtBv8orIXRrg2Y/SQjf6UUoKvRs2m6S6YmhIe3tcvDm663j7QRwa6k1THzycAQfnHWtYOSxH2yjiubB/TDS6rpcxzGx+gH7IsC2N3vmjpiJsx/PZwDvqKG3y2AvNu2n5eC54xrFjrRvr4Tgts2XVfDWheqJjkiu8wXUqZPRSLI2SPFqKqaGgnEDbbooIlN1ItygC1kzktKYIxA5bXQt7eBhvbGNtsgGP1X8m1n08Gv6yc98QyH7typVq5sD6j6qCRzP7RQkPH/VrKhhrK/guMF3HOd5oQnpHTjK9+WSvjDsfFpjVaLnYCDafQ2L7Da11Qa6lhXiFeA2YT5AmU3CvyrRfhoqbN4Pqge2nhdJD5gMDi00OqdaGzZcaLwvK6zU5maivMTfKTUpJm3SN8KXhhKN37wakrQjzwD3SAKPjtfIFl6+X1Y4Zyb0nuAlkJWRTaM6JsvvdfcuqxZGsa0MapqHyOWvPP7P+g0p3DK3+vfznxbXgRIqxEX1dozdLwth2Naw2B4f0dSzOF3C4fBXRS398zczmtoJIrYv/QGazlQcEI3urOLf8eYBZFXeKnhxVxJSgVnvliC9zPY/w081R8pNRC48isnZTtpjOAjqUXxrlKqUMT+zdYNXd8odwGKOSNicbB7vNGncWhZV5vtP161IRMSzeKV/zCDVP1fMJw+6Ft1k9dEasritypGzfyoO87xOJUp+BxZdBi0O3pGQc+jdycVmM7zR+OFiZJ2Xz7hgb9A2mOLtERF36X3AN/bDtXorlHjqSuVvTzhMnBnZDYoF3wkYxT19MtzFab614vuMYewfzXJmMCxkxjBb77h7qZoNt49ITCXOZuW0CrNlvft6PVrwbOnG52oKRSR+yZHqxYDOQ2oXLzTthK2g4UXC8R6MmrqS8rhNYRsvqIozVfsX5xOpYCp0VTE/7uYL0UX8+nf0p+H6TUlYuX3NNkqCC75uQyIolxnV31GxXHOgO1aK+Zk/J8SjoSOc0ClvZUvHlbYQ3LvHh6MmF6W9eqZVGli78TwZO3PDyPDEjDCS+bnfYrhLYPpNLFf8gGwsobr0HVIZl/EXtLkwePWacr+btWa6bs+90jZHD6681D085liM2rm7IWRjy0SvFLb7PqSpXGK96lRL31GIvP3z78dzMyY8RR/k5gn1W9STDzcXcsQkO/I9EKjnL5w0mlV5iX/jQdBQUZNEnYDP/VB+joUUZj7xgdNu5UQqxye+Zd8zpz7kqge1bUq5UGv5FeXtsfdOO2EMjlBhckBTYe936G9TXwpr3WW3BqKxIKhpYCMRmiI7KzUCRBGMjAJ1U1bVldD9S9bKYACa8nZkhU8N4BVLPygJ0AxnlZenpCYc2ZXgL6jFf2ZD35muvtw/D1US76UEpQaUl/MbilM843d09X5yviWGlJS0ExAOtJ9VW/aAHR5KgdRoaOpUgY5b0c7w8vLz/IRu8y7d7v5RNvoklNOknQNjD8IsQlfMLZ2LdZncog2/VF5tWgovWv1sP/yWTeEPxTWUivV2Juq2X8yeA+pmLm0LoFRyXR2abj7zy5uoOhP2/+fE7KzBz/UbosbJ1yMpJiZRuFLOwNfrSMeBWW19BgD50UuF4yNZ1R+hqd3hrY/s+9RVC/5HbJLvQgEzcAVV7V+JPgHf/fMkcw5apj6nRnK48W75+0WRiSE/YWFOC/eyplSeXTXDP6Tk7l/xjZX3d3cjCpW9CR6jvvepD3ldwOrzu37zksrjj3rN+nIWWCw/ovJP/VqrMUHEyu+BU8N5tL/aFg7e6Yc74sc6FZOvAuhHTEb2jjuke9vAePv9Ydn635JGJhDuzVKsadzjH2xww4+Zrh6yvIqL4/8uohcq+b5vLKqVTdIrkDUqrFmQnfFx4Q6t4wNpSaK4+1dpcnvY13+sNcX4LNqnIDB9flGu31Mzacx02x3eI8JXZJyyUjWcXIziKZQefCqIZGbHjjIwkjAz/NmPpqKykzLxd7u5ZkTfgP0B6Z4v/iIxtgfZ78OiCWNTmAxi4hYNh98rGEp3K83CyQK2/7Pe+AcsNGqV75+NrU0vHQnVsa1Jvx2YcFNJUH8ZrG/NflOII0qyLine truncated

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

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

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 @@
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

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 @@
+eNrsfQV8E9n2P7a4Lb7oUKxA00YaaaFAqbtChUKZJJMmbTKTZpK0KVsWFlucootLkeLuDsvi7sVli7st/r/3zkySliK7P/bt4/2zn/d2m8ydK+eee873yD35eZ6ZMNAaiiy5SEMaCQOuMIIP9PkSbX+eZyDSTQRt7D9XRxjVlHJ2ZERMbK7JoDnbRm006mlPNzdcr3Gl9ASJa1wVlM7NLHBTqHGjG/hbryVQR7PllNKSX/qXXk46gqbxFIJ28sS69XJSUGA00gg+OCVQJgw3EBiO0SY9YTBraMqAGXE6jVBiGRqjGtPhJJ6iIVNAC/AanC8O+8bkhDGDIEjMqCYwFaXVUhmwUQZlSANNwCitDARN4AaFOtlI4LpWLlirDIPGCNown7u7YgEa8wfvm2jCgLFLdwF/0HqKZCcCGzLdY0YKA6TCSCLT6Ir54Qo19yBDo9ViYBkqyqADE4brwHDQQdGONHAQ2qQ10ugxbcSNJtoVi1ODCak0pIZWE8oiw/sHhQfFBLo6uWBOBkpLQNrRFtpI6JyyXbBCJI1mF455B2GA5iQ7CFw+pLPcoCFUoG89ZTBiuJwyGeGMdIV6hmRwyu4OvtFRSkILv0rRG3nuFGxEgo8C8F89bsC1WkKbbKQobbIC/A23V4VraQI8pY0GQGe7L8BUAWXAQg1wCL6rFH6H3lRTGgX8rpeT0aJH46tMJGJFOJz1b9iAxHWoQTSYNpxiNtsJy1h/9X3wWEnQCoNGz7ZwirPusAE2gX8w2xykwkiK4y/wHaFEW8Q1stseSBdwaECzQmui5KmEwogaGMCxMRg1BNMA9o/+IEgTJFg3J6YztCH2TAy/sGdiJ7hBXPeA3uB7hiKQgTUGQok6Q913z87O7p49T03gSjCvkbPVFG3MWVL4BC/FFQoC7DJBKigl6CtncUqWRu+CKQmVFjcSCwCLkQQiZc6CNILQ83AtOEFzmbdyluF6vVajQIfTLZWmyEUsS/LgDD98vADyGA/xZ86qCDAJ7yC3SAsQNSQmcBXzXQXLMnngXGhILRAdPC0O5jNXj55vtH+gxxVpoBMeK8hy5jIvL7FvQ9E5c8JwRURMoS4hWXPm4AadxH2l/fcGE2nU6IiceT6RHw7HPrQNJ3IVCFw9lhfqmLaQipw5iO/XFnqZMBosPAUF+siZyV/C0UdLkClGdU6uB989jznyNNFvLiMTfp4N9oI4sGceK0BnRYRwm3ixRN3ZvmBfcjbHmsD5Enhg4ZQZE/KF7hhf6CkQeII/AsJiF/mww8QWuw3LYw04SavAVvhx2z5PoTaRQP4u8Cl2wzfDDQergdMH8oJHZOopmuCxs8pZFM+LZuQnL8h3JcNdPMqQgpOaLDRszny4mUBVaMhV7GNwIGCXYHCejs7JFXqIl7BPODovAOvi8wR8Hl+wIZMHpAih1eg0gHbo36zABtss4IN/1n3YwkilESSdkyfiM/9ssW9iIHRgMnB0a0ezPcA/m4pvxPUlhG1kHoUnBA+s3YRyJTp63YfP2S5m8elFmVxjnkaZc7Y5+JBMiJTuQrGCrxS7CyQSqUKEu4tkMpFAIJUIpe4e/PXwrCtAL3DroBjn0YQCqGajJeesiw7PhKfKSyQQiyRgpe0wDanQmpREjEnuS8E10O0wvYHQUrhyqY8/zweoL4IXg7gtZ55vQrh3WJDPghgwSR+KStMQo/NLlk5OVqiS5TqvCA0ZlpCVEGIw+4SRgVRauiEwxC9Ykir3ptMkqnCzLj4CJ8NM8VHeFE8gFQk8ZEKhzJ0ncAUn0lXA88sUdO3qakqPoszRcR6BYm8fOkTm3YX2IbvEZ5gjRcqEBHVWmtA3pXNUuknlLTWofHwiA4z+0qgMVbK5i8I7w0dqIsODUjqLiMQYeVBEhq/elAFWgxvVXm7tMMCJQOrRXux54IHzwGNOgzt3GtphSkQDL9fCsq8dFghQTQSptbTDYiAxCfBfIMVjgM70CqdI4uxYQAOTWaP0ivWLUwUqPPidQ0TJRl1IgEHVWeDj6+tKZhhcBcaMTFdFZHyYkDCpCHsiSGRCHp+lg4TvLkNcaJv635zVmnie/fHmRSA9BvaRpGhSo1LNjQGQijDkLFBoKZMSiHEDMRfsebR3Qs4qGeGuwOVihQLnS6UKmZLnFxe9jOvNKgxmQx0wD9cCHjMrclaqRV5Onu7uIqd2AJh5ySTufD4CeX3nMvpnV8mCJkPLl0D/lB4W033hOX7l7MNL+VlkwKTxkoPn1ikU/Ra/Ltjh+fM158EPGp5bWVvd+u2DZkHUaHMjl2q/37zZMGj3vtY9KyurVigdlV5jdZcnEy5d09ceJznX+82KdlsKrr5o2Xv1ufZedaiLHXcsIn69W+E7r5U9ysd0G9B8+H38yqiaaxYMPWhYPjzXuYepk84Qy1u8yj15oqWW/0JLvcM7nw2I/6H1EZ8dvcsME5hvH1rjN/VayRp1Dk1rJs46HNJfGSivPCVKV2bdi2M1T5dZ+X0t/5q316RdcBaX3FNvXMUlJ+LXvQ8f8/pmzbg2J1Ub6acPH87v/aJr15DekZe2kAev7pzdwy17VXcfv9xdlw+XaXJ1b5jg905PNlzrLakycyMuLHt+XNjwSflLrqwqN7xcvs+KcoMar6/ZJXjPHa8pV4ZYqt6/8FP4G328+7SFQ6Mm/GnR95h4zHPMywbNZo5KfNXGtCdbWj1TuGbphVO32nSin6l7Tp3Pm6PsPZP8ru7CvNP90uf5G7O376keFxPdfmOzCQWBSeaRnndzLs/a8ePsEa9/m5w0qUL10IHvNk7slf/2cvSE9806luo8o8WBmDv8CVezLgsO4q93v22r469Pq/fmaM1TmqamwYc8z/K8akku1LpTeUK8smmZG5ergQ19/750iUtD+SPfli5R4qsaCJn/ioHAICtkGRDyZIACcdC/wzBwGAbfgmHA7CSyCGzM+7cNgoslqjtMgn/fJJirQJAr5+xjDnH5Ef4RMYKsUBHETVkmkb+QL/H29RNkURFx8bSHt4dawpckZMqiA/lWsCHhWxFXSLyElMVERAtEyf5aubqzuyxM3SU+kQrPSjakxkoSfV2VomCBIRrPSDQGUu6R+ixXD5lG6h0YIEowh8rMCVHGIDzTkOqTqBMlWEQeXRP4uriodhiHhcK1Ap2vPiExRhPrGiH3iQv0dY0PietiiQgJT1N2pQMJfZfUlChzDGGh7aYnELl/iIU+MIdkMtlfM4fqfMYcEn+r5pBA8g2ZQ+5f3RwSSURyubtSwlcoFDKhQqVSiPkATwMI7q4QCGTCf94c+r/DbAlfinvIZWAFXwlmX7eH2WEjj/Orb74BJAIZOTnszOgGbYiZNWq4NBkUXcsyNShVr90/bUbvvPeNWtxqqWldwyP+1CYLpZrWancfwSiP2ZV/Gz8mb1HF5J8mR4xZe2fcw8Hxr3fNy7i/bETK0D8mP+7ZpOcx/oHjEbWeHshqGkrUHu2+od8An/AzeYfuP1AtLYhyj0icIfRYMLBrYkVFTf/jzlXnPdG/ehx6vj7A2fu2lAM4W3t4LsDZVaMlU9sHtHk6bUJ5zfTf6slyJ5XXP5jTakmFlqWdh7U8EXZ6Q9fUMqMEbWomzZ+pf9Eo4MX2Vktinz+6v/Nx2tvXfS8uHbK5R/ve8+/eX5aU3fjkndkv1ujy8lbffPvDlez2m9v8Xk/dY/X5gJiaG9q2VGzrnhCXN/9W/RENjqzLrTK7wcM9U8+Ql8vUHRujv/NOoey/c9bzpKmNPHdHbP5j39hTE1v99AdWKzpk68GGhkvhpaYNu5cqNeVXjEzeVCc+pU3IDxOT8xpsT2hoyuK7HO/TMmVY5XRxywsR5B7Co8aEe2nPKzVfd0beIXKQ31WT68Hy5f193l84wLtH6ufvf5/TpETTIzUKJpp+DUn3eDiqYNnLk+/GnZp8XlK594MKCxeN2uCbMlW7tlHFybsGO4+WBYyoPuXnjizI5l39YfPzrwyyS4V+AmT/p5DhF2O/vwrbjLhZo7Uks85SFkInQ4leDJTzxtjVAk2jIQmMAk90mixgUAB4jkHKGQgAuGkg3V0AngeyBMgrF0QRo8EEoLWSA+muWBeaUJm06MUMCNItwFyBGBCZAiSdASAj2kG4ESzpQH8GQGKMMENCAwBJ6sG3tJoyaZXAaoGWDjM98KLBUhxyLIITUTv0V5GF2vcDJ6QF8AIz6Z2+BCUyndoDShanOoCjAzj+VwNH8dcGjpJvEzjOFoi+IeToIZF9fUe6UiXCJRKRkC9WSpQyQuYhECnkAqUHH1d54ErFN4EchXICl3095FgqyYYcEdw4EBsWca5T9c2v4xYVTIkdUWH7Xl5s9e/UQ52DoybtSzylSNmZlXG2e7nQse97nH25rPRi3zmNH25fcePgpomWY5vGBZR/WK9smTNTPMdrjjYO7/z+z1eDKtxvMm3u8YVBK36ssMXVbWtye9O16onEgA3JGL1xQUQokTjjWjDZUzXK0yWhXauAqb3rlbmS/p2yjX/U+Dn5qzcuaPSn99p7g3Rb1/KmtD10ZEefN0/LN1V22bz/e2LYYT7WO63u3iOJk5wqPw/q3ydq1rASq8d3C5jTr2sVYYtG+wypEysdLTEl2kke+8uGRwUJ4i1pU/Oq51zv22PYwbU5onn3N8k6ViKXrDh6UpN7aeCGIyc7Bbme7TG97JaR1XqIm5VpfnBBYsCEpFo5fqln2gvV9BXtqmXUmfIlU4+197m1L6ynuN/uhmGCfiUnbteHqhM7+/KOunh0yNlWbYRq2cDS403XqAtZE+r71O7QYfIR6RJ61a8d8ld1G+b66sqfpRc2zfO5EzgspFZwXFD/kOihT7euWj/8cIfJ51KmDBq6cX9dQeslG2/dmrD3QrlTA1N5slxCGhL7OGLW3a0/iase6Dm6W5s1E25sPlatf/DqqBfPTxKdd7RY+0fjE117SaudPGda+KpT78vfzRi+b9XQKVmdEo49X7ul5OqYkz3rkd7zGtYLine 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

docs/cassettes/information-gather-prompting_1b1613e0.msgpack.zlib

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

docs/cassettes/information-gather-prompting_25793988-45a2-4e65-b33c-64e72aadb10e.msgpack.zlib

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

docs/cassettes/introduction_03a09bfc-3d90-4e54-878f-22e3cb28a418.msgpack.zlib

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

docs/cassettes/introduction_051dc374-67cc-4371-9dd1-221e07593148.msgpack.zlib

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