ci: ensure python 3.14 compatibility

* docs: add AI SDK integration documentation

- Add comprehensive AI SDK documentation in docs/sdks/integrations/ai-sdk.md
  - Detailed description of all three memory tools (retain, recall, reflect)
  - Complete parameter documentation and return types
  - Advanced usage patterns (streaming, multi-user, ToolLoopAgent)
  - HTTP client example for zero-dependency usage
  - TypeScript types and API reference
  - Best practices and system prompt examples

- Update AI SDK README to brief quickstart with link to docs
  - Single source of truth: comprehensive docs in documentation site
  - README now focuses on quick setup and points to full docs
  - Maintains features list and basic example for npm page

* fix

.github/workflows/release.yml

@@ -188,6 +188,55 @@ jobs:
         path: hindsight-integrations/openclaw/*.tgz
         retention-days: 1
 
+  release-ai-sdk-integration:
+    runs-on: ubuntu-latest
+    environment: npm
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Set up Node.js
+      uses: actions/setup-node@v4
+      with:
+        node-version: '22'
+        registry-url: 'https://registry.npmjs.org'
+
+    - name: Install dependencies
+      working-directory: ./hindsight-integrations/ai-sdk
+      run: npm ci
+
+    - name: Build
+      working-directory: ./hindsight-integrations/ai-sdk
+      run: npm run build
+
+    - name: Publish to npm
+      working-directory: ./hindsight-integrations/ai-sdk
+      run: |
+        set +e
+        OUTPUT=$(npm publish --access public 2>&1)
+        EXIT_CODE=$?
+        echo "$OUTPUT"
+        if [ $EXIT_CODE -ne 0 ]; then
+          if echo "$OUTPUT" | grep -q "cannot publish over"; then
+            echo "Package version already published, skipping..."
+            exit 0
+          fi
+          exit $EXIT_CODE
+        fi
+      env:
+        NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+
+    - name: Pack for GitHub release
+      working-directory: ./hindsight-integrations/ai-sdk
+      run: npm pack
+
+    - name: Upload artifacts
+      uses: actions/upload-artifact@v4
+      with:
+        name: ai-sdk-integration
+        path: hindsight-integrations/ai-sdk/*.tgz
+        retention-days: 1
+
   release-control-plane:
     runs-on: ubuntu-latest
     environment: npm
@@ -415,7 +464,7 @@ jobs:
 
   create-github-release:
     runs-on: ubuntu-latest
-    needs: [release-python-packages, release-typescript-client, release-openclaw-integration, release-control-plane, release-rust-cli, release-docker-images, release-helm-chart]
+    needs: [release-python-packages, release-typescript-client, release-openclaw-integration, release-ai-sdk-integration, release-control-plane, release-rust-cli, release-docker-images, release-helm-chart]
     permissions:
       contents: write
 
@@ -444,6 +493,12 @@ jobs:
         name: openclaw-integration
         path: ./artifacts/openclaw-integration
 
+    - name: Download AI SDK Integration
+      uses: actions/download-artifact@v4
+      with:
+        name: ai-sdk-integration
+        path: ./artifacts/ai-sdk-integration
+
     - name: Download Control Plane
       uses: actions/download-artifact@v4
       with:
@@ -487,6 +542,8 @@ jobs:
         cp artifacts/typescript-client/*.tgz release-assets/ || true
         # OpenClaw Integration
         cp artifacts/openclaw-integration/*.tgz release-assets/ || true
+        # AI SDK Integration
+        cp artifacts/ai-sdk-integration/*.tgz release-assets/ || true
         # Control Plane
         cp artifacts/control-plane/*.tgz release-assets/ || true
         # Rust CLI binaries

.github/workflows/test.yml

@@ -9,42 +9,11 @@ concurrency:
   cancel-in-progress: true
 
 jobs:
-  build-python-packages:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        include:
-          - name: hindsight-all
-            path: hindsight
-          - name: hindsight-api
-            path: hindsight-api
-          - name: hindsight-client
-            path: hindsight-clients/python
-          - name: hindsight-embed
-            path: hindsight-embed
-
-    steps:
-    - uses: actions/checkout@v4
-
-    - name: Install uv
-      uses: astral-sh/setup-uv@v5
-      with:
-        enable-cache: true
-
-    - name: Set up Python
-      uses: actions/setup-python@v5
-      with:
-        python-version-file: ".python-version"
-
-    - name: Build ${{ matrix.name }}
-      working-directory: ./${{ matrix.path }}
-      run: uv build
-
   build-api-python-versions:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ['3.11', '3.12', '3.13']
+        python-version: ['3.11', '3.12', '3.13', '3.14']
 
     steps:
     - uses: actions/checkout@v4
@@ -105,6 +74,29 @@ jobs:
       working-directory: ./hindsight-integrations/openclaw
       run: npm run build
 
+  build-ai-sdk-integration:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Set up Node.js
+      uses: actions/setup-node@v4
+      with:
+        node-version: '22'
+
+    - name: Install dependencies
+      working-directory: ./hindsight-integrations/ai-sdk
+      run: npm ci
+
+    - name: Run tests
+      working-directory: ./hindsight-integrations/ai-sdk
+      run: npm test
+
+    - name: Build
+      working-directory: ./hindsight-integrations/ai-sdk
+      run: npm run build
+
   build-control-plane:
     runs-on: ubuntu-latest
 
@@ -790,6 +782,54 @@ jobs:
       working-directory: ./hindsight-embed
       run: ./test.sh
 
+  test-hindsight-all:
+    runs-on: ubuntu-latest
+    env:
+      HINDSIGHT_API_LLM_PROVIDER: groq
+      HINDSIGHT_API_LLM_API_KEY: ${{ secrets.GROQ_API_KEY }}
+      HINDSIGHT_API_LLM_MODEL: openai/gpt-oss-20b
+      # For test_server_integration.py compatibility
+      HINDSIGHT_LLM_PROVIDER: groq
+      HINDSIGHT_LLM_API_KEY: ${{ secrets.GROQ_API_KEY }}
+      HINDSIGHT_LLM_MODEL: openai/gpt-oss-20b
+      # Prefer CPU-only PyTorch in CI
+      UV_INDEX: pytorch=https://download.pytorch.org/whl/cpu
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Install uv
+      uses: astral-sh/setup-uv@v5
+      with:
+        enable-cache: true
+        prune-cache: false
+
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version-file: ".python-version"
+
+    - name: Build hindsight-all
+      working-directory: ./hindsight
+      run: uv build
+
+    - name: Install dependencies
+      working-directory: ./hindsight
+      run: uv sync --frozen --extra test --index-strategy unsafe-best-match
+
+    - name: Cache HuggingFace models
+      uses: actions/cache@v4
+      with:
+        path: ~/.cache/huggingface
+        key: ${{ runner.os }}-huggingface-all-${{ hashFiles('hindsight/pyproject.toml') }}
+        restore-keys: |
+          ${{ runner.os }}-huggingface-all-
+          ${{ runner.os }}-huggingface-
+
+    - name: Run unit tests
+      working-directory: ./hindsight
+      run: uv run pytest tests/ -v
+
   test-doc-examples:
     runs-on: ubuntu-latest
     needs: test-rust-cli
@@ -1044,4 +1084,52 @@ jobs:
           git diff --stat
           exit 1
         fi
-        echo "✓ All generated files are up to date"
+        echo "✓ All generated files are up to date"
+
+  check-openapi-compatibility:
+    runs-on: ubuntu-latest
+    env:
+      UV_INDEX: pytorch=https://download.pytorch.org/whl/cpu
+
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        fetch-depth: 0  # Fetch full git history to access base branch
+
+    - name: Install uv
+      uses: astral-sh/setup-uv@v5
+      with:
+        enable-cache: true
+
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version-file: ".python-version"
+
+    - name: Install hindsight-dev dependencies
+      run: |
+        cd hindsight-dev && uv sync --frozen --index-strategy unsafe-best-match
+
+    - name: Check OpenAPI compatibility with base branch
+      run: |
+        # Get the base branch (usually main)
+        BASE_BRANCH="${{ github.base_ref }}"
+
+        if [ -z "$BASE_BRANCH" ]; then
+          echo "⚠️  Warning: No base branch found (not a PR?). Skipping compatibility check."
+          exit 0
+        fi
+
+        echo "Checking OpenAPI compatibility against base branch: $BASE_BRANCH"
+
+        # Extract the old OpenAPI spec from base branch
+        git show "origin/$BASE_BRANCH:hindsight-docs/static/openapi.json" > /tmp/old-openapi.json
+
+        if [ ! -s /tmp/old-openapi.json ]; then
+          echo "⚠️  Warning: Could not find OpenAPI spec in base branch. Skipping compatibility check."
+          exit 0
+        fi
+
+        # Check compatibility using our tool
+        cd hindsight-dev
+        uv run check-openapi-compatibility /tmp/old-openapi.json ../hindsight-docs/static/openapi.json

docker/standalone/Dockerfile

@@ -208,6 +208,10 @@ ENV HINDSIGHT_API_LOG_LEVEL=info
 ENV HINDSIGHT_ENABLE_API=true
 ENV HINDSIGHT_ENABLE_CP=false
 ENV PYTHONUNBUFFERED=1
+# Suppress verbose transformers/HuggingFace model loading warnings
+ENV TRANSFORMERS_VERBOSITY=error
+ENV HF_HUB_VERBOSITY=error
+ENV TOKENIZERS_PARALLELISM=false
 
 CMD ["/app/start-all.sh"]
 
@@ -336,6 +340,10 @@ ENV HINDSIGHT_CP_DATAPLANE_API_URL=http://localhost:8888
 ENV HINDSIGHT_ENABLE_API=true
 ENV HINDSIGHT_ENABLE_CP=true
 ENV PYTHONUNBUFFERED=1
+# Suppress verbose transformers/HuggingFace model loading warnings
+ENV TRANSFORMERS_VERBOSITY=error
+ENV HF_HUB_VERBOSITY=error
+ENV TOKENIZERS_PARALLELISM=false
 
 CMD ["/app/start-all.sh"]
 

helm/hindsight/Chart.yaml

@@ -2,8 +2,8 @@ apiVersion: v2
 name: hindsight
 description: Hindsight helm chart
 type: application
-version: 0.4.7
-appVersion: "0.4.7"
+version: 0.4.9
+appVersion: "0.4.9"
 keywords:
   - ai
   - memory

hindsight-api/hindsight_api/__init__.py

@@ -46,4 +46,4 @@ __all__ = [
     "RemoteTEICrossEncoder",
     "LLMConfig",
 ]
-__version__ = "0.4.7"
+__version__ = "0.4.9"

hindsight-api/hindsight_api/api/http.py

@@ -5,6 +5,7 @@ This module provides the create_app function to create and configure
 the FastAPI application with all API endpoints.
 """
 
+import asyncio
 import json
 import logging
 import uuid
@@ -35,7 +36,7 @@ from pydantic import BaseModel, ConfigDict, Field, field_validator
 
 from hindsight_api import MemoryEngine
 from hindsight_api.engine.db_utils import acquire_with_retry
-from hindsight_api.engine.memory_engine import Budget, fq_table
+from hindsight_api.engine.memory_engine import Budget, _get_tiktoken_encoding, fq_table
 from hindsight_api.engine.reflect.observations import Observation
 from hindsight_api.engine.response_models import VALID_RECALL_FACT_TYPES, TokenUsage
 from hindsight_api.engine.search.tags import TagsMatch
@@ -45,6 +46,8 @@ from hindsight_api.models import RequestContext
 
 logger = logging.getLogger(__name__)
 
+MAX_QUERY_TOKENS = 500  # Maximum tokens allowed in recall query
+
 
 class EntityIncludeOptions(BaseModel):
     """Options for including entity observations in recall results."""
@@ -863,6 +866,7 @@ class ListDocumentsResponse(BaseModel):
                         "updated_at": "2024-01-15T10:30:00Z",
                         "text_length": 5420,
                         "memory_unit_count": 15,
+                        "tags": ["user_a", "session_123"],
                     }
                 ],
                 "total": 50,
@@ -1134,6 +1138,7 @@ class CreateMentalModelRequest(BaseModel):
     model_config = ConfigDict(
         json_schema_extra={
             "example": {
+                "id": "team-communication",
                 "name": "Team Communication Preferences",
                 "source_query": "How does the team prefer to communicate?",
                 "tags": ["team"],
@@ -1143,6 +1148,9 @@ class CreateMentalModelRequest(BaseModel):
         }
     )
 
+    id: str | None = Field(
+        None, description="Optional custom ID for the mental model (alphanumeric lowercase with hyphens)"
+    )
     name: str = Field(description="Human-readable name for the mental model")
     source_query: str = Field(description="The query to run to generate content")
     tags: list[str] = Field(default_factory=list, description="Tags for scoped visibility")
@@ -1153,7 +1161,8 @@ class CreateMentalModelRequest(BaseModel):
 class CreateMentalModelResponse(BaseModel):
     """Response model for mental model creation."""
 
-    operation_id: str = Field(description="Operation ID to track progress")
+    mental_model_id: str | None = Field(None, description="ID of the created mental model")
+    operation_id: str = Field(description="Operation ID to track refresh progress")
 
 
 class UpdateMentalModelRequest(BaseModel):
@@ -1718,6 +1727,15 @@ def _register_routes(app: FastAPI):
         handler_start = time.time()
         metrics = get_metrics_collector()
 
+        # Validate query length to prevent expensive operations on oversized queries
+        encoding = _get_tiktoken_encoding()
+        query_tokens = len(encoding.encode(request.query))
+        if query_tokens > MAX_QUERY_TOKENS:
+            raise HTTPException(
+                status_code=400,
+                detail=f"Query too long: {query_tokens} tokens exceeds maximum of {MAX_QUERY_TOKENS}. Please shorten your query.",
+            )
+
         try:
             # Default to world and experience if not specified (exclude observation)
             fact_types = request.types if request.types else list(VALID_RECALL_FACT_TYPES)
@@ -1832,6 +1850,15 @@ def _register_routes(app: FastAPI):
             raise HTTPException(status_code=e.status_code, detail=e.reason)
         except (AuthenticationError, HTTPException):
             raise
+        except (asyncio.TimeoutError, TimeoutError):
+            handler_duration = time.time() - handler_start
+            logger.error(
+                f"[RECALL TIMEOUT] bank={bank_id} handler_duration={handler_duration:.3f}s - database query timed out"
+            )
+            raise HTTPException(
+                status_code=504,
+                detail="Request timed out while searching memories. Try a shorter or more specific query.",
+            )
         except Exception as e:
             import traceback
 
@@ -1889,17 +1916,17 @@ def _register_routes(app: FastAPI):
                 directives = []
                 for fact_type, facts in core_result.based_on.items():
                     if fact_type == "directives":
-                        # Directives have different structure (id, name, content)
+                        # Directives are dicts with id, name, content (not MemoryFact objects)
                         for directive in facts:
                             directives.append(
                                 ReflectDirective(
-                                    id=directive.id,
-                                    name=directive.name,
-                                    content=directive.content,
+                                    id=directive["id"],
+                                    name=directive["name"],
+                                    content=directive["content"],
                                 )
                             )
-                    elif fact_type == "mental_models":
-                        # Mental models are MemoryFact with type "mental_models"
+                    elif fact_type == "mental-models":
+                        # Mental models are MemoryFact with type "mental-models" (note: hyphen, not underscore)
                         for fact in facts:
                             mental_models.append(
                                 ReflectMentalModel(
@@ -2386,6 +2413,7 @@ def _register_routes(app: FastAPI):
                 name=body.name,
                 source_query=body.source_query,
                 content="Generating content...",
+                mental_model_id=body.id if body.id else None,
                 tags=body.tags if body.tags else None,
                 max_tokens=body.max_tokens,
                 trigger=body.trigger.model_dump() if body.trigger else None,
@@ -2397,7 +2425,7 @@ def _register_routes(app: FastAPI):
                 mental_model_id=mental_model["id"],
                 request_context=request_context,
             )
-            return CreateMentalModelResponse(operation_id=result["operation_id"])
+            return CreateMentalModelResponse(mental_model_id=mental_model["id"], operation_id=result["operation_id"])
         except ValueError as e:
             raise HTTPException(status_code=400, detail=str(e))
         except (AuthenticationError, HTTPException):

hindsight-api/hindsight_api/engine/consolidation/consolidator.py

@@ -143,6 +143,9 @@ async def run_consolidation_job(
         "skipped": 0,
     }
 
+    # Track all unique tags from consolidated memories for mental model refresh filtering
+    consolidated_tags: set[str] = set()
+
     batch_num = 0
     last_progress_timings = {}  # Track timings at last progress log
     while True:
@@ -176,6 +179,11 @@ async def run_consolidation_job(
         for memory in memories:
             mem_start = time.time()
 
+            # Track tags from this memory for mental model refresh filtering
+            memory_tags = memory.get("tags") or []
+            if memory_tags:
+                consolidated_tags.update(memory_tags)
+
             # Process the memory (uses its own connection internally)
             async with pool.acquire() as conn:
                 result = await _process_memory(
@@ -284,10 +292,12 @@ async def run_consolidation_job(
         perf.log(f"[4] Timing breakdown: {', '.join(timing_parts)}")
 
     # Trigger mental model refreshes for models with refresh_after_consolidation=true
+    # SECURITY: Only refresh mental models with matching tags (or all if no tags were consolidated)
     mental_models_refreshed = await _trigger_mental_model_refreshes(
         memory_engine=memory_engine,
         bank_id=bank_id,
         request_context=request_context,
+        consolidated_tags=list(consolidated_tags) if consolidated_tags else None,
         perf=perf,
     )
     stats["mental_models_refreshed"] = mental_models_refreshed
@@ -301,15 +311,20 @@ async def _trigger_mental_model_refreshes(
     memory_engine: "MemoryEngine",
     bank_id: str,
     request_context: "RequestContext",
+    consolidated_tags: list[str] | None = None,
     perf: ConsolidationPerfLog | None = None,
 ) -> int:
     """
     Trigger refreshes for mental models with refresh_after_consolidation=true.
 
+    SECURITY: Only triggers refresh for mental models whose tags overlap with the
+    consolidated memory tags, preventing unnecessary refreshes across security boundaries.
+
     Args:
         memory_engine: MemoryEngine instance
         bank_id: Bank identifier
         request_context: Request context for authentication
+        consolidated_tags: Tags from memories that were consolidated (None = refresh all)
         perf: Performance logging
 
     Returns:
@@ -318,22 +333,52 @@ async def _trigger_mental_model_refreshes(
     pool = memory_engine._pool
 
     # Find mental models with refresh_after_consolidation=true
+    # SECURITY: Control which mental models get refreshed based on tags
     async with pool.acquire() as conn:
-        rows = await conn.fetch(
-            f"""
-            SELECT id, name
-            FROM {fq_table("mental_models")}
-            WHERE bank_id = $1
-              AND (trigger->>'refresh_after_consolidation')::boolean = true
-            """,
-            bank_id,
-        )
+        if consolidated_tags:
+            # Tagged memories were consolidated - refresh:
+            # 1. Mental models with overlapping tags (security boundary)
+            # 2. Untagged mental models (they're "global" and available to all contexts)
+            # DO NOT refresh mental models with different tags
+            rows = await conn.fetch(
+                f"""
+                SELECT id, name, tags
+                FROM {fq_table("mental_models")}
+                WHERE bank_id = $1
+                  AND (trigger->>'refresh_after_consolidation')::boolean = true
+                  AND (
+                    (tags IS NOT NULL AND tags != '{{}}' AND tags && $2::varchar[])
+                    OR (tags IS NULL OR tags = '{{}}')
+                  )
+                """,
+                bank_id,
+                consolidated_tags,
+            )
+        else:
+            # Untagged memories were consolidated - only refresh untagged mental models
+            # SECURITY: Tagged mental models are NOT refreshed when untagged memories are consolidated
+            rows = await conn.fetch(
+                f"""
+                SELECT id, name, tags
+                FROM {fq_table("mental_models")}
+                WHERE bank_id = $1
+                  AND (trigger->>'refresh_after_consolidation')::boolean = true
+                  AND (tags IS NULL OR tags = '{{}}')
+                """,
+                bank_id,
+            )
 
     if not rows:
         return 0
 
     if perf:
-        perf.log(f"[5] Triggering refresh for {len(rows)} mental models with refresh_after_consolidation=true")
+        if consolidated_tags:
+            perf.log(
+                f"[5] Triggering refresh for {len(rows)} mental models with refresh_after_consolidation=true "
+                f"(filtered by tags: {consolidated_tags})"
+            )
+        else:
+            perf.log(f"[5] Triggering refresh for {len(rows)} mental models with refresh_after_consolidation=true")
 
     # Submit refresh tasks for each mental model
     refreshed_count = 0
@@ -385,7 +430,8 @@ async def _process_memory(
     memory_id = memory["id"]
     fact_tags = memory.get("tags") or []
 
-    # Find related observations using the full recall system (NO tag filtering)
+    # Find related observations using the full recall system
+    # SECURITY: Pass tags to ensure observations don't leak across security boundaries
     t0 = time.time()
     related_observations = await _find_related_observations(
         conn=conn,
@@ -393,6 +439,7 @@ async def _process_memory(
         bank_id=bank_id,
         query=fact_text,
         request_context=request_context,
+        tags=fact_tags,  # Pass source memory's tags for security
     )
     if perf:
         perf.record_timing("recall", time.time() - t0)
@@ -666,17 +713,20 @@ async def _find_related_observations(
     bank_id: str,
     query: str,
     request_context: "RequestContext",
+    tags: list[str] | None = None,
 ) -> list[dict[str, Any]]:
     """
     Find observations related to the given query using optimized recall.
 
-    IMPORTANT: We do NOT filter by tags here. Consolidation needs to see ALL
-    potentially related observations regardless of scope, so the LLM can
-    decide on tag routing (same scope update vs cross-scope create).
+    SECURITY: Filters by tags using all_strict matching to prevent cross-tenant/cross-user
+    information leakage. Observations are only consolidated within the same tag scope.
 
     Uses max_tokens to naturally limit observations (no artificial count limit).
     Includes source memories with dates for LLM context.
 
+    Args:
+        tags: Optional tags to filter observations (uses all_strict matching for security)
+
     Returns:
         List of related observations with their tags, source memories, and dates
     """
@@ -685,14 +735,19 @@ async def _find_related_observations(
     from ...config import get_config
 
     config = get_config()
+
+    # SECURITY: Use all_strict matching if tags provided to prevent cross-scope consolidation
+    tags_match = "all_strict" if tags else "any"
+
     recall_result = await memory_engine.recall_async(
         bank_id=bank_id,
         query=query,
         max_tokens=config.consolidation_max_tokens,  # Token budget for observations (configurable)
         fact_type=["observation"],  # Only retrieve observations
         request_context=request_context,
+        tags=tags,  # Filter by source memory's tags
+        tags_match=tags_match,  # Use strict matching for security
         _quiet=True,  # Suppress logging
-        # NO tags parameter - intentionally get ALL observations
     )
 
     # If no observations returned, return empty list

hindsight-api/hindsight_api/engine/consolidation/prompts.py

@@ -32,13 +32,16 @@ BAD examples:
 
 ## MERGE RULES (when comparing to existing observations):
 1. REDUNDANT: Same information worded differently → update existing
-2. CONTRADICTION: Opposite information about same topic → update with history (e.g., "used to X, now Y")
-3. UPDATE: New state replacing old state → update with history
+2. CONTRADICTION: Opposite information about same topic → update with temporal markers showing change
+   Example: "Alex used to love pizza but now hates it" OR "Alex's pizza preference changed from love to hate"
+3. UPDATE: New state replacing old state → update showing the transition with "used to", "now", "changed from X to Y"
 
 ## CRITICAL RULES:
 - NEVER merge facts about DIFFERENT people
 - NEVER merge unrelated topics (food preferences vs work vs hobbies)
-- When merging contradictions, capture the CHANGE (before → after)
+- When merging contradictions, the "text" field MUST capture BOTH states with temporal markers:
+  * Use "used to X, now Y" OR "changed from X to Y" OR "X but now Y"
+  * DO NOT just state the new fact - you MUST show the change
 - Keep observations focused on ONE specific topic per person
 - The "text" field MUST contain durable knowledge, not ephemeral state
 - Do NOT include "tags" in output - tags are handled automatically"""

hindsight-api/hindsight_api/engine/cross_encoder.py

@@ -9,6 +9,7 @@ Configuration via environment variables - see hindsight_api.config for all env v
 import asyncio
 import logging
 import os
+import warnings
 from abc import ABC, abstractmethod
 from concurrent.futures import ThreadPoolExecutor
 
@@ -162,11 +163,28 @@ class LocalSTCrossEncoder(CrossEncoderModel):
             except Exception as e:
                 logger.warning(f"Failed to detect GPU/MPS, falling back to CPU: {e}")
 
-        self._model = CrossEncoder(
-            self.model_name,
-            device=device,
-            model_kwargs={"low_cpu_mem_usage": False},
-        )
+        # Suppress verbose transformers warnings during model loading
+        # This suppresses the "UNEXPECTED" warnings from CrossEncoder which are harmless
+        # but look alarming to users (e.g., "embeddings.position_ids | UNEXPECTED")
+        with warnings.catch_warnings():
+            warnings.filterwarnings("ignore", category=UserWarning)
+            warnings.filterwarnings("ignore", message=".*was not found in model state dict.*")
+            warnings.filterwarnings("ignore", message=".*UNEXPECTED.*")
+
+            # Also suppress transformers library logging temporarily
+            transformers_logger = logging.getLogger("transformers")
+            original_level = transformers_logger.level
+            transformers_logger.setLevel(logging.ERROR)
+
+            try:
+                self._model = CrossEncoder(
+                    self.model_name,
+                    device=device,
+                    model_kwargs={"low_cpu_mem_usage": False},
+                )
+            finally:
+                # Restore original logging level
+                transformers_logger.setLevel(original_level)
 
         # Initialize shared executor (limited workers naturally limits concurrency)
         if LocalSTCrossEncoder._executor is None:

hindsight-api/hindsight_api/engine/embeddings.py

@@ -11,6 +11,7 @@ Configuration via environment variables - see hindsight_api.config for all env v
 
 import logging
 import os
+import warnings
 from abc import ABC, abstractmethod
 
 import httpx
@@ -157,11 +158,28 @@ class LocalSTEmbeddings(Embeddings):
             except Exception as e:
                 logger.warning(f"Failed to detect GPU/MPS, falling back to CPU: {e}")
 
-        self._model = SentenceTransformer(
-            self.model_name,
-            device=device,
-            model_kwargs={"low_cpu_mem_usage": False},
-        )
+        # Suppress verbose transformers warnings during model loading
+        # This suppresses the "UNEXPECTED" warnings from BertModel which are harmless
+        # but look alarming to users (e.g., "embeddings.position_ids | UNEXPECTED")
+        with warnings.catch_warnings():
+            warnings.filterwarnings("ignore", category=UserWarning)
+            warnings.filterwarnings("ignore", message=".*was not found in model state dict.*")
+            warnings.filterwarnings("ignore", message=".*UNEXPECTED.*")
+
+            # Also suppress transformers library logging temporarily
+            transformers_logger = logging.getLogger("transformers")
+            original_level = transformers_logger.level
+            transformers_logger.setLevel(logging.ERROR)
+
+            try:
+                self._model = SentenceTransformer(
+                    self.model_name,
+                    device=device,
+                    model_kwargs={"low_cpu_mem_usage": False},
+                )
+            finally:
+                # Restore original logging level
+                transformers_logger.setLevel(original_level)
 
         self._dimension = self._model.get_sentence_embedding_dimension()
         logger.info(f"Embeddings: local provider initialized (dim: {self._dimension})")

hindsight-api/hindsight_api/engine/memory_engine.py

@@ -625,11 +625,19 @@ class MemoryEngine(MemoryEngineInterface):
 
         source_query = mental_model["source_query"]
 
+        # SECURITY: If the mental model has tags, pass them to reflect with "all_strict" matching
+        # to ensure it can only access other mental models/memories with the SAME tags.
+        # This prevents cross-tenant/cross-user information leakage by excluding untagged content.
+        tags = mental_model.get("tags")
+        tags_match = "all_strict" if tags else "any"
+
         # Run reflect to generate new content, excluding the mental model being refreshed
         reflect_result = await self.reflect_async(
             bank_id=bank_id,
             query=source_query,
             request_context=internal_context,
+            tags=tags,
+            tags_match=tags_match,
             exclude_mental_model_ids=[mental_model_id],
         )
 
@@ -3304,7 +3312,8 @@ class MemoryEngine(MemoryEngineInterface):
                     created_at,
                     updated_at,
                     LENGTH(original_text) as text_length,
-                    retain_params
+                    retain_params,
+                    tags
                 FROM {fq_table("documents")}
                 {where_clause}
                 ORDER BY created_at DESC
@@ -3360,6 +3369,7 @@ class MemoryEngine(MemoryEngineInterface):
                         "text_length": row["text_length"] or 0,
                         "memory_unit_count": unit_count,
                         "retain_params": row["retain_params"] if row["retain_params"] else None,
+                        "tags": row["tags"] if row["tags"] else [],
                     }
                 )
 
@@ -3663,12 +3673,14 @@ class MemoryEngine(MemoryEngineInterface):
 
         # Load directives from the dedicated directives table
         # Directives are hard rules that must be followed in all responses
+        # Use isolation_mode=True to prevent tag-scoped directives from leaking into untagged operations
         directives_raw = await self.list_directives(
             bank_id=bank_id,
             tags=tags,
             tags_match=tags_match,
             active_only=True,
             request_context=request_context,
+            isolation_mode=True,
         )
         # Convert directive format to the expected format for reflect agent
         # The agent expects: name, description (optional), observations (list of {title, content})
@@ -3737,7 +3749,16 @@ class MemoryEngine(MemoryEngineInterface):
         # Extract memories from recall tool outputs - only include memories the agent actually used
         # agent_result.used_memory_ids contains validated IDs from the done action
         used_memory_ids_set = set(agent_result.used_memory_ids) if agent_result.used_memory_ids else set()
-        based_on: dict[str, list[MemoryFact]] = {"world": [], "experience": [], "opinion": [], "observation": []}
+        # based_on stores facts, mental models, and directives
+        # Note: directives list stores raw directive dicts (not MemoryFact), which will be converted to Directive objects
+        based_on: dict[str, list[MemoryFact] | list[dict[str, Any]]] = {
+            "world": [],
+            "experience": [],
+            "opinion": [],
+            "observation": [],
+            "mental-models": [],
+            "directives": [],
+        }
         seen_memory_ids: set[str] = set()
         for tc in agent_result.tool_trace:
             if tc.tool == "recall" and "memories" in tc.output:
@@ -3839,38 +3860,15 @@ class MemoryEngine(MemoryEngineInterface):
                         )
                 # List all models lookup - don't add to based_on (too verbose, just a listing)
 
-        # Add directives to based_on["mental-models"] (they are mental models with subtype='directive')
-        for directive in directives:
-            # Extract summary from observations
-            summary_parts: list[str] = []
-            for obs in directive.get("observations", []):
-                # Support both Pydantic Observation objects and dicts
-                if hasattr(obs, "content"):
-                    content = obs.content
-                    title = obs.title
-                else:
-                    content = obs.get("content", "")
-                    title = obs.get("title", "")
-                if title and content:
-                    summary_parts.append(f"{title}: {content}")
-                elif content:
-                    summary_parts.append(content)
-
-            # Fallback to description if no observations
-            if not summary_parts and directive.get("description"):
-                summary_parts.append(directive["description"])
-
-            directive_name = directive.get("name", "")
-            directive_summary = "; ".join(summary_parts) if summary_parts else ""
-            based_on["mental-models"].append(
-                MemoryFact(
-                    id=directive.get("id", ""),
-                    text=f"{directive_name}: {directive_summary}",
-                    fact_type="mental-models",
-                    context="directive (directive)",
-                    occurred_start=None,
-                    occurred_end=None,
-                )
+        # Add directives to based_on["directives"]
+        # Store raw directive dicts (with id, name, content) for http.py to convert to ReflectDirective
+        for directive_raw in directives_raw:
+            based_on["directives"].append(
+                {
+                    "id": directive_raw["id"],
+                    "name": directive_raw["name"],
+                    "content": directive_raw["content"],
+                }
             )
 
         # Build directives_applied from agent result
@@ -4719,11 +4717,19 @@ class MemoryEngine(MemoryEngineInterface):
         if not mental_model:
             return None
 
+        # SECURITY: If the mental model has tags, pass them to reflect with "all_strict" matching
+        # to ensure it can only access other mental models/memories with the SAME tags.
+        # This prevents cross-tenant/cross-user information leakage by excluding untagged content.
+        tags = mental_model.get("tags")
+        tags_match = "all_strict" if tags else "any"
+
         # Run reflect with the source query, excluding the mental model being refreshed
         reflect_result = await self.reflect_async(
             bank_id=bank_id,
             query=mental_model["source_query"],
             request_context=request_context,
+            tags=tags,
+            tags_match=tags_match,
             exclude_mental_model_ids=[mental_model_id],
         )
 
@@ -4736,6 +4742,7 @@ class MemoryEngine(MemoryEngineInterface):
                         "id": str(fact.id),
                         "text": fact.text,
                         "type": fact_type,
+                        "context": fact.context,  # Include context to distinguish directives from mental models in UI
                     }
                     for fact in facts
                 ]
@@ -4924,6 +4931,7 @@ class MemoryEngine(MemoryEngineInterface):
         limit: int = 100,
         offset: int = 0,
         request_context: "RequestContext",
+        isolation_mode: bool = False,
     ) -> list[dict[str, Any]]:
         """List directives for a bank.
 
@@ -4935,6 +4943,9 @@ class MemoryEngine(MemoryEngineInterface):
             limit: Maximum number of results
             offset: Offset for pagination
             request_context: Request context for authentication
+            isolation_mode: When True and tags=None, only return directives with no tags.
+                This prevents tag-scoped directives from leaking into untagged operations.
+                Default False (normal API behavior - returns all directives when tags=None)
 
         Returns:
             List of directive dicts
@@ -4944,6 +4955,8 @@ class MemoryEngine(MemoryEngineInterface):
 
         async with acquire_with_retry(pool) as conn:
             # Build filters
+            from .search.tags import build_tags_where_clause
+
             filters = ["bank_id = $1"]
             params: list[Any] = [bank_id]
             param_idx = 2
@@ -4951,15 +4964,23 @@ class MemoryEngine(MemoryEngineInterface):
             if active_only:
                 filters.append("is_active = TRUE")
 
+            # Apply tags filter:
+            # - If tags provided: use standard filtering (with strict modes support)
+            # - If tags=None and isolation_mode=True: only include directives with NO tags
+            #   (prevents tag-scoped directives from leaking into untagged reflect/refresh)
+            # - If tags=None and isolation_mode=False: no filtering (normal API behavior)
             if tags:
-                if tags_match == "all":
-                    filters.append(f"tags @> ${param_idx}::varchar[]")
-                elif tags_match == "exact":
-                    filters.append(f"tags = ${param_idx}::varchar[]")
-                else:  # any
-                    filters.append(f"tags && ${param_idx}::varchar[]")
-                params.append(tags)
-                param_idx += 1
+                tags_clause, tags_params, param_idx = build_tags_where_clause(
+                    tags=tags, param_offset=param_idx, table_alias="", match=tags_match
+                )
+                if tags_clause:
+                    # Remove leading "AND " from clause since we're building filters list
+                    filters.append(tags_clause.replace("AND ", "", 1))
+                    params.extend(tags_params)
+            elif isolation_mode:
+                # Isolation mode: only include directives with empty/null tags
+                # This ensures tag-scoped directives don't apply to untagged operations
+                filters.append("(tags IS NULL OR tags = '{}')")
 
             params.extend([limit, offset])
 

hindsight-api/hindsight_api/engine/providers/claude_code_llm.py

@@ -291,61 +291,202 @@ class ClaudeCodeLLM(LLMInterface):
         tool_choice: str | dict[str, Any] = "auto",
     ) -> LLMToolCallResult:
         """
-        Make an LLM API call with tool/function calling support.
+        Make an LLM API call with tool/function calling support using Claude Agent SDK.
 
-        Note: This is a simplified implementation. Full tool support would require
-        integrating with Claude Agent SDK's tool system.
+        This implementation uses ClaudeSDKClient (not query()) because custom tools via
+        SDK MCP servers are only supported with the client. Tools are converted from OpenAI
+        format to SDK MCP tools, and tool names are formatted as mcp__hindsight_tools__{name}.
 
         Args:
             messages: List of message dicts. Can include tool results with role='tool'.
             tools: List of tool definitions in OpenAI format.
-            max_completion_tokens: Maximum tokens in response.
-            temperature: Sampling temperature.
+            max_completion_tokens: Maximum tokens in response (not used by Claude Agent SDK).
+            temperature: Sampling temperature (not used by Claude Agent SDK).
             scope: Scope identifier for tracking.
             max_retries: Maximum retry attempts.
             initial_backoff: Initial backoff time in seconds.
             max_backoff: Maximum backoff time in seconds.
-            tool_choice: How to choose tools - "auto", "none", "required", or specific function.
+            tool_choice: How to choose tools (not used by Claude Agent SDK).
 
         Returns:
             LLMToolCallResult with content and/or tool_calls.
         """
-        # For now, use regular call without tools
-        # Full implementation would require mapping OpenAI tool format to Claude Agent SDK tools
-        logger.warning(
-            "Claude Code provider does not fully support tool calling yet. Falling back to regular text completion."
+        from claude_agent_sdk import (
+            AssistantMessage,
+            ClaudeAgentOptions,
+            ClaudeSDKClient,
+            SdkMcpTool,
+            TextBlock,
+            ToolUseBlock,
+            create_sdk_mcp_server,
         )
 
-        result = await self.call(
-            messages=messages,
-            response_format=None,
-            max_completion_tokens=max_completion_tokens,
-            temperature=temperature,
-            scope=scope,
-            max_retries=max_retries,
-            initial_backoff=initial_backoff,
-            max_backoff=max_backoff,
-            return_usage=True,
+        start_time = time.time()
+
+        # Convert OpenAI tool format to Claude Agent SDK SdkMcpTool format
+        sdk_tools: list[SdkMcpTool] = []
+        tool_names: list[str] = []
+
+        for tool in tools:
+            func = tool.get("function", {})
+            tool_name = func.get("name", "")
+            tool_description = func.get("description", "")
+            parameters = func.get("parameters", {})
+
+            # Create a handler with proper closure to avoid transport issues
+            def make_handler(name: str):
+                async def handler(args: dict[str, Any]) -> dict[str, Any]:
+                    # Return immediately with success - tool execution happens externally
+                    return {
+                        "content": [
+                            {
+                                "type": "text",
+                                "text": f"[Tool {name} called successfully]",
+                            }
+                        ]
+                    }
+
+                return handler
+
+            sdk_tools.append(
+                SdkMcpTool(
+                    name=tool_name,
+                    description=tool_description,
+                    input_schema=parameters,
+                    handler=make_handler(tool_name),
+                )
+            )
+            tool_names.append(tool_name)
+
+        # Create an MCP server with the tools
+        mcp_server = create_sdk_mcp_server(
+            name="hindsight_tools",
+            version="1.0.0",
+            tools=sdk_tools if sdk_tools else None,
         )
 
-        if isinstance(result, tuple):
-            text, usage = result
-            return LLMToolCallResult(
-                content=text,
-                tool_calls=[],
-                finish_reason="stop",
-                input_tokens=usage.input_tokens,
-                output_tokens=usage.output_tokens,
-            )
-        else:
-            # Fallback if return_usage didn't work as expected
-            return LLMToolCallResult(
-                content=str(result),
-                tool_calls=[],
-                finish_reason="stop",
-                input_tokens=0,
-                output_tokens=0,
-            )
+        # Build system prompt and user content from messages
+        system_prompt = ""
+        user_content = ""
+
+        for msg in messages:
+            role = msg.get("role", "user")
+            content = msg.get("content", "")
+
+            if role == "system":
+                system_prompt += ("\n\n" + content) if system_prompt else content
+            elif role == "user":
+                user_content += ("\n\n" + content) if user_content else content
+            elif role == "assistant":
+                # Include previous assistant messages as context
+                user_content += f"\n\n[Previous assistant response: {content}]"
+            elif role == "tool":
+                # Tool results are already in tool_results_map, append to user context
+                tool_call_id = msg.get("tool_call_id", "")
+                user_content += f"\n\n[Tool result for {tool_call_id}: {content}]"
+
+        # Format tool names for SDK MCP servers: mcp__{server_name}__{tool_name}
+        # This is required by the Claude Agent SDK for MCP server tools
+        allowed_tool_names = [f"mcp__hindsight_tools__{name}" for name in tool_names]
+
+        # Configure SDK options with MCP server
+        options = ClaudeAgentOptions(
+            system_prompt=system_prompt if system_prompt else None,
+            max_turns=1,  # Single-turn for API-style interactions
+            mcp_servers={"hindsight_tools": mcp_server} if sdk_tools else {},
+            allowed_tools=allowed_tool_names if allowed_tool_names else [],
+        )
+
+        # Call Claude Agent SDK with retry logic
+        last_exception = None
+        for attempt in range(max_retries + 1):
+            try:
+                full_text = ""
+                tool_calls: list[LLMToolCall] = []
+
+                # Use ClaudeSDKClient for tool calling support
+                # Note: query() does NOT support custom tools, only ClaudeSDKClient does
+                async with ClaudeSDKClient(options=options) as client:
+                    # Send the query
+                    await client.query(user_content)
+
+                    # Receive response
+                    async for message in client.receive_response():
+                        if isinstance(message, AssistantMessage):
+                            for block in message.content:
+                                if isinstance(block, TextBlock):
+                                    full_text += block.text
+                                elif isinstance(block, ToolUseBlock):
+                                    # SDK returns tool names with MCP prefix (mcp__hindsight_tools__{name})
+                                    # Strip the prefix to return original tool name expected by caller
+                                    tool_name = block.name
+                                    if tool_name.startswith("mcp__hindsight_tools__"):
+                                        tool_name = tool_name.replace("mcp__hindsight_tools__", "", 1)
+
+                                    tool_calls.append(
+                                        LLMToolCall(
+                                            id=block.id,
+                                            name=tool_name,
+                                            arguments=block.input,
+                                        )
+                                    )
+
+                # Record metrics
+                duration = time.time() - start_time
+                metrics = get_metrics_collector()
+
+                # Estimate token usage (Claude Agent SDK doesn't report exact counts)
+                estimated_input = sum(len(m.get("content", "")) for m in messages) // 4
+                estimated_output = len(full_text) // 4
+
+                metrics.record_llm_call(
+                    provider=self.provider,
+                    model=self.model,
+                    scope=scope,
+                    duration=duration,
+                    input_tokens=estimated_input,
+                    output_tokens=estimated_output,
+                    success=True,
+                )
+
+                # Log slow calls
+                if duration > 10.0:
+                    logger.info(
+                        f"slow llm call: scope={scope}, model={self.provider}/{self.model}, time={duration:.3f}s"
+                    )
+
+                return LLMToolCallResult(
+                    content=full_text if full_text else None,
+                    tool_calls=tool_calls,
+                    finish_reason="tool_calls" if tool_calls else "stop",
+                    input_tokens=estimated_input,
+                    output_tokens=estimated_output,
+                )
+
+            except Exception as e:
+                last_exception = e
+
+                # Check for authentication errors
+                error_str = str(e).lower()
+                if "auth" in error_str or "login" in error_str or "credential" in error_str:
+                    logger.error(f"Claude Code authentication error: {e}")
+                    raise RuntimeError(
+                        f"Claude Code authentication failed: {e}\n\n"
+                        "Run 'claude auth login' to authenticate with Claude Pro/Max."
+                    ) from e
+
+                if attempt < max_retries:
+                    backoff = min(initial_backoff * (2**attempt), max_backoff)
+                    logger.warning(f"Claude Code tool call error (attempt {attempt + 1}/{max_retries + 1}): {e}")
+                    await asyncio.sleep(backoff)
+                    continue
+                else:
+                    logger.error(f"Claude Code tool call error after {max_retries + 1} attempts: {e}")
+                    raise
+
+        if last_exception:
+            raise last_exception
+        raise RuntimeError("Claude Code tool call failed after all retries")
 
     async def cleanup(self) -> None:
         """Clean up resources (no HTTP client to close for Claude Agent SDK)."""

hindsight-api/hindsight_api/engine/providers/codex_llm.py

@@ -177,6 +177,9 @@ class CodexLLM(LLMInterface):
             schema_msg = f"\n\nYou must respond with valid JSON matching this schema:\n{json.dumps(schema, indent=2)}"
             system_instruction += schema_msg
 
+        # gpt-5.2-codex only supports "detailed" reasoning summary
+        reasoning_summary = "detailed" if "5.2" in self.model else self.reasoning_summary
+
         # Build Codex request payload
         payload = {
             "model": self.model,
@@ -192,7 +195,7 @@ class CodexLLM(LLMInterface):
             "tools": [],
             "tool_choice": "auto",
             "parallel_tool_calls": True,
-            "reasoning": {"summary": self.reasoning_summary},
+            "reasoning": {"summary": reasoning_summary},
             "store": False,  # Codex uses stateless mode
             "stream": True,  # SSE streaming
             "include": ["reasoning.encrypted_content"],
@@ -283,13 +286,20 @@ class CodexLLM(LLMInterface):
                         "Run 'codex auth login' to re-authenticate."
                     ) from e
 
+                # Log the actual error message from the API
+                error_detail = e.response.text[:500] if hasattr(e.response, "text") else str(e)
+
                 if attempt < max_retries:
                     backoff = min(initial_backoff * (2**attempt), max_backoff)
-                    logger.warning(f"Codex HTTP error {status_code} (attempt {attempt + 1}/{max_retries + 1})")
+                    logger.warning(
+                        f"Codex HTTP error {status_code} (attempt {attempt + 1}/{max_retries + 1}): {error_detail}"
+                    )
                     await asyncio.sleep(backoff)
                     continue
                 else:
-                    logger.error(f"Codex HTTP error after {max_retries + 1} attempts: {e}")
+                    logger.error(
+                        f"Codex HTTP error after {max_retries + 1} attempts: Status {status_code}, Detail: {error_detail}"
+                    )
                     raise
 
             except httpx.RequestError as e:
@@ -379,8 +389,22 @@ class CodexLLM(LLMInterface):
         """
         Make API call with tool calling support.
 
-        Note: This is a basic implementation. Full tool calling support for Codex
-        may require additional SSE event parsing.
+        Parses Codex SSE stream to extract tool calls from response.output_item.done events.
+        Tools are converted from OpenAI format to Codex format (flat structure at top level).
+
+        Args:
+            messages: List of message dicts. Can include tool results with role='tool'.
+            tools: List of tool definitions in OpenAI format.
+            max_completion_tokens: Maximum tokens in response.
+            temperature: Sampling temperature.
+            scope: Scope identifier for tracking.
+            max_retries: Maximum retry attempts.
+            initial_backoff: Initial backoff time in seconds.
+            max_backoff: Maximum backoff time in seconds.
+            tool_choice: How to choose tools - "auto", "none", "required", or specific function.
+
+        Returns:
+            LLMToolCallResult with content and/or tool_calls.
         """
         start_time = time.time()
 
@@ -413,20 +437,22 @@ class CodexLLM(LLMInterface):
                 )
 
         # Convert tools to Codex format
+        # Codex expects tools with type and name/description/parameters at top level
         codex_tools = []
         for tool in tools:
             func = tool.get("function", {})
             codex_tools.append(
                 {
                     "type": "function",
-                    "function": {
-                        "name": func.get("name", ""),
-                        "description": func.get("description", ""),
-                        "parameters": func.get("parameters", {}),
-                    },
+                    "name": func.get("name", ""),
+                    "description": func.get("description", ""),
+                    "parameters": func.get("parameters", {}),
                 }
             )
 
+        # gpt-5.2-codex only supports "detailed" reasoning summary
+        reasoning_summary = "detailed" if "5.2" in self.model else self.reasoning_summary
+
         payload = {
             "model": self.model,
             "instructions": system_instruction,
@@ -434,7 +460,7 @@ class CodexLLM(LLMInterface):
             "tools": codex_tools,
             "tool_choice": tool_choice,
             "parallel_tool_calls": True,
-            "reasoning": {"summary": self.reasoning_summary},
+            "reasoning": {"summary": reasoning_summary},
             "store": False,
             "stream": True,
             "include": ["reasoning.encrypted_content"],
@@ -451,8 +477,16 @@ class CodexLLM(LLMInterface):
 
         url = f"{self.base_url}/codex/responses"
 
+        # Debug logging for troubleshooting
+        logger.debug(f"Codex tool call request: url={url}, model={payload['model']}, tools={len(codex_tools)}")
+
         try:
             response = await self._client.post(url, json=payload, headers=headers, timeout=120.0)
+
+            # Log response details on error
+            if response.status_code != 200:
+                logger.error(f"Codex API error {response.status_code}: {response.text[:500]}")
+
             response.raise_for_status()
 
             # Parse SSE for tool calls and content
@@ -512,13 +546,30 @@ class CodexLLM(LLMInterface):
                     if event_type == "response.text.delta" and "delta" in data:
                         content += data["delta"]
 
-                    # Extract tool calls
-                    elif event_type == "response.function_call_arguments.delta":
-                        # Handle tool call events (implementation depends on actual Codex SSE format)
-                        pass
+                    # Extract completed tool calls from response.output_item.done
+                    elif event_type == "response.output_item.done":
+                        item = data.get("item", {})
+                        if item.get("type") == "function_call" and item.get("status") == "completed":
+                            tool_name = item.get("name", "")
+                            arguments_str = item.get("arguments", "{}")
+                            call_id = item.get("call_id", "")
 
-                except json.JSONDecodeError:
-                    pass
+                            try:
+                                arguments = json.loads(arguments_str)
+                            except json.JSONDecodeError:
+                                logger.warning(f"Failed to parse tool arguments: {arguments_str}")
+                                arguments = {}
+
+                            tool_calls.append(
+                                LLMToolCall(
+                                    id=call_id,
+                                    name=tool_name,
+                                    arguments=arguments,
+                                )
+                            )
+
+                except json.JSONDecodeError as e:
+                    logger.warning(f"Failed to parse SSE data: {e}, data_str: {data_str[:200]}")
 
         return content if content else None, tool_calls
 

hindsight-api/hindsight_api/engine/reflect/agent.py

@@ -871,21 +871,21 @@ async def _execute_tool(
         query = args.get("query")
         if not query:
             return {"error": "search_mental_models requires a query parameter"}
-        max_results = args.get("max_results") or 5
+        max_results = int(args.get("max_results") or 5)
         return await search_mental_models_fn(query, max_results)
 
     elif tool_name == "search_observations":
         query = args.get("query")
         if not query:
             return {"error": "search_observations requires a query parameter"}
-        max_tokens = max(args.get("max_tokens") or 5000, 1000)  # Default 5000, min 1000
+        max_tokens = max(int(args.get("max_tokens") or 5000), 1000)  # Default 5000, min 1000
         return await search_observations_fn(query, max_tokens)
 
     elif tool_name == "recall":
         query = args.get("query")
         if not query:
             return {"error": "recall requires a query parameter"}
-        max_tokens = max(args.get("max_tokens") or 2048, 1000)  # Default 2048, min 1000
+        max_tokens = max(int(args.get("max_tokens") or 2048), 1000)  # Default 2048, min 1000
         return await recall_fn(query, max_tokens)
 
     elif tool_name == "expand":
@@ -904,18 +904,18 @@ def _summarize_input(tool_name: str, args: dict[str, Any]) -> str:
     if tool_name == "search_mental_models":
         query = args.get("query", "")
         query_preview = f"'{query[:30]}...'" if len(query) > 30 else f"'{query}'"
-        max_results = args.get("max_results") or 5
+        max_results = int(args.get("max_results") or 5)
         return f"(query={query_preview}, max_results={max_results})"
     elif tool_name == "search_observations":
         query = args.get("query", "")
         query_preview = f"'{query[:30]}...'" if len(query) > 30 else f"'{query}'"
-        max_tokens = max(args.get("max_tokens") or 5000, 1000)
+        max_tokens = max(int(args.get("max_tokens") or 5000), 1000)
         return f"(query={query_preview}, max_tokens={max_tokens})"
     elif tool_name == "recall":
         query = args.get("query", "")
         query_preview = f"'{query[:30]}...'" if len(query) > 30 else f"'{query}'"
         # Show actual value used (default 2048, min 1000)
-        max_tokens = max(args.get("max_tokens") or 2048, 1000)
+        max_tokens = max(int(args.get("max_tokens") or 2048), 1000)
         return f"(query={query_preview}, max_tokens={max_tokens})"
     elif tool_name == "expand":
         memory_ids = args.get("memory_ids", [])

hindsight-api/hindsight_api/engine/reflect/prompts.py

@@ -463,9 +463,12 @@ def build_final_prompt(
     parts.append(
         "\n## Instructions\n"
         "Provide a thoughtful answer by synthesizing and reasoning from the retrieved data above. "
-        "You can make reasonable inferences from the memories, but don't completely fabricate information."
+        "You can make reasonable inferences from the memories, but don't completely fabricate information. "
         "If the exact answer isn't stated, use what IS stated to give the best possible answer. "
-        "Only say 'I don't have information' if the retrieved data is truly unrelated to the question."
+        "Only say 'I don't have information' if the retrieved data is truly unrelated to the question.\n\n"
+        "IMPORTANT: Output ONLY the final answer. Do NOT include meta-commentary like "
+        '"I\'ll search..." or "Let me analyze...". Do NOT explain your reasoning process. '
+        "Just provide the direct synthesized answer."
     )
 
     return "\n".join(parts)
@@ -480,4 +483,10 @@ Your approach:
 - Be helpful - if you have related information, use it to give the best possible answer
 
 Only say "I don't have information" if the retrieved data is truly unrelated to the question.
-Do NOT fabricate information that has no basis in the retrieved data."""
+Do NOT fabricate information that has no basis in the retrieved data.
+
+CRITICAL: Output ONLY the final synthesized answer. Do NOT include:
+- Meta-commentary about what you're doing ("I'll search...", "Let me analyze...")
+- Explanations of your reasoning process
+- Descriptions of your approach
+Just provide the direct answer."""

hindsight-api/hindsight_api/engine/reflect/tools.py

@@ -54,19 +54,18 @@ async def tool_search_mental_models(
         Dict with matching mental models including content and freshness info
     """
     from ..memory_engine import fq_table
+    from ..search.tags import build_tags_where_clause
 
     # Build filters dynamically
     filters = ""
     params: list[Any] = [bank_id, str(query_embedding), max_results]
     next_param = 4
 
+    # Use the centralized tag filtering logic
     if tags:
-        if tags_match == "all":
-            filters += f" AND tags @> ${next_param}::varchar[]"
-        else:
-            filters += f" AND (tags && ${next_param}::varchar[] OR tags IS NULL OR tags = '{{}}')"
-        params.append(tags)
-        next_param += 1
+        tag_clause, tag_params, next_param = build_tags_where_clause(tags, param_offset=next_param, match=tags_match)
+        filters += f" {tag_clause}"
+        params.extend(tag_params)
 
     if exclude_ids:
         filters += f" AND id != ALL(${next_param}::text[])"

hindsight-api/hindsight_api/engine/retain/orchestrator.py

@@ -158,6 +158,13 @@ async def retain_batch(
                 # Handle document tracking even with no facts
                 if document_id:
                     combined_content = "\n".join([c.get("content", "") for c in contents_dicts])
+                    # Collect tags from all content items and merge with document_tags
+                    all_tags = set(document_tags or [])
+                    for item in contents_dicts:
+                        item_tags = item.get("tags", []) or []
+                        all_tags.update(item_tags)
+                    merged_tags = list(all_tags)
+
                     retain_params = {}
                     if contents_dicts:
                         first_item = contents_dicts[0]
@@ -172,7 +179,7 @@ async def retain_batch(
                         if first_item.get("metadata"):
                             retain_params["metadata"] = first_item["metadata"]
                     await fact_storage.handle_document_tracking(
-                        conn, bank_id, document_id, combined_content, is_first_batch, retain_params, document_tags
+                        conn, bank_id, document_id, combined_content, is_first_batch, retain_params, merged_tags
                     )
                 else:
                     # Check for per-item document_ids
@@ -186,6 +193,13 @@ async def retain_batch(
 
                     for doc_id, doc_contents in contents_by_doc.items():
                         combined_content = "\n".join([c.get("content", "") for _, c in doc_contents])
+                        # Collect tags from all content items for this document and merge with document_tags
+                        all_tags = set(document_tags or [])
+                        for _, item in doc_contents:
+                            item_tags = item.get("tags", []) or []
+                            all_tags.update(item_tags)
+                        merged_tags = list(all_tags)
+
                         retain_params = {}
                         if doc_contents:
                             first_item = doc_contents[0][1]
@@ -200,7 +214,7 @@ async def retain_batch(
                             if first_item.get("metadata"):
                                 retain_params["metadata"] = first_item["metadata"]
                         await fact_storage.handle_document_tracking(
-                            conn, bank_id, doc_id, combined_content, is_first_batch, retain_params, document_tags
+                            conn, bank_id, doc_id, combined_content, is_first_batch, retain_params, merged_tags
                         )
 
         total_time = time.time() - start_time
@@ -252,6 +266,13 @@ async def retain_batch(
                 # Legacy: single document_id parameter
                 combined_content = "\n".join([c.get("content", "") for c in contents_dicts])
                 retain_params = {}
+                # Collect tags from all content items and merge with document_tags
+                all_tags = set(document_tags or [])
+                for item in contents_dicts:
+                    item_tags = item.get("tags", []) or []
+                    all_tags.update(item_tags)
+                merged_tags = list(all_tags)
+
                 if contents_dicts:
                     first_item = contents_dicts[0]
                     if first_item.get("context"):
@@ -266,7 +287,7 @@ async def retain_batch(
                         retain_params["metadata"] = first_item["metadata"]
 
                 await fact_storage.handle_document_tracking(
-                    conn, bank_id, document_id, combined_content, is_first_batch, retain_params, document_tags
+                    conn, bank_id, document_id, combined_content, is_first_batch, retain_params, merged_tags
                 )
                 document_ids_added.append(document_id)
                 doc_id_mapping[None] = document_id  # For backwards compatibility
@@ -294,6 +315,13 @@ async def retain_batch(
                             # Combine content for this document
                             combined_content = "\n".join([c.get("content", "") for _, c in doc_contents])
 
+                            # Collect tags from all content items for this document and merge with document_tags
+                            all_tags = set(document_tags or [])
+                            for _, item in doc_contents:
+                                item_tags = item.get("tags", []) or []
+                                all_tags.update(item_tags)
+                            merged_tags = list(all_tags)
+
                             # Extract retain params from first content item
                             retain_params = {}
                             if doc_contents:
@@ -316,7 +344,7 @@ async def retain_batch(
                                 combined_content,
                                 is_first_batch,
                                 retain_params,
-                                document_tags,
+                                merged_tags,
                             )
                             document_ids_added.append(actual_doc_id)
 

hindsight-api/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hindsight-api"
-version = "0.4.7"
+version = "0.4.9"
 description = "Hindsight: Agent Memory That Works Like Human Memory"
 readme = "README.md"
 requires-python = ">=3.11"

hindsight-api/tests/conftest.py

@@ -220,3 +220,34 @@ async def memory(pg0_db_url, embeddings, cross_encoder, query_analyzer):
             await mem.close()
     except Exception:
         pass
+
+
+@pytest_asyncio.fixture(scope="function")
+async def memory_no_llm_verify(pg0_db_url, embeddings, cross_encoder, query_analyzer):
+    """
+    Provide a MemoryEngine instance that skips LLM connection verification.
+
+    This fixture is useful for tests that override the LLM configuration
+    after initialization (e.g., to test specific providers).
+    """
+    mem = MemoryEngine(
+        db_url=pg0_db_url,
+        memory_llm_provider="mock",  # Use mock provider as placeholder
+        memory_llm_api_key="",
+        memory_llm_model="mock",
+        embeddings=embeddings,
+        cross_encoder=cross_encoder,
+        query_analyzer=query_analyzer,
+        pool_min_size=1,
+        pool_max_size=5,
+        run_migrations=False,
+        task_backend=SyncTaskBackend(),
+        skip_llm_verification=True,  # Skip verification - will be overridden by test
+    )
+    await mem.initialize()
+    yield mem
+    try:
+        if mem._pool and not mem._pool._closing:
+            await mem.close()
+    except Exception:
+        pass

hindsight-api/tests/test_llm_provider.py

@@ -1,5 +1,10 @@
 """
-Test LLM provider with different models using actual memory operations.
+Test LLM provider with different models using actual Hindsight memory operations.
+
+Tests validate that providers work correctly with:
+1. Retain (memory ingestion with fact extraction)
+2. Reflect (memory retrieval with tool calling)
+3. Mental models (consolidated knowledge generation)
 """
 import os
 from datetime import datetime
@@ -33,6 +38,12 @@ MODEL_MATRIX = [
     # Ollama models (local)
     ("ollama", "gemma3:12b"),
     ("ollama", "gemma3:1b"),
+    # Claude Code (uses Claude Agent SDK with Claude models)
+    ("claude-code", "claude-sonnet-4-20250514"),
+    # OpenAI Codex (uses MCP with Codex-specific models)
+    ("openai-codex", "gpt-5.2-codex"),
+    # Mock provider (for testing)
+    ("mock", "mock"),
 ]
 
 
@@ -48,6 +59,165 @@ def get_api_key_for_provider(provider: str) -> str | None:
     return os.getenv(env_var) if env_var else None
 
 
+def should_skip_provider(provider: str, model: str = "") -> tuple[bool, str]:
+    """Check if provider should be skipped and return reason."""
+    # Never skip mock provider
+    if provider == "mock":
+        return False, ""
+
+    # Skip claude-code and openai-codex in CI (require local auth)
+    if os.getenv("CI") and provider in ("claude-code", "openai-codex"):
+        return True, f"{provider} not available in CI (requires local authentication)"
+
+    # Skip Ollama in CI (no models available)
+    if provider == "ollama" and os.getenv("CI"):
+        return True, "Ollama not available in CI"
+
+    # Skip Ollama gemma models (don't support tool calling)
+    if provider == "ollama" and "gemma" in model.lower():
+        return True, f"Ollama {model} does not support tool calling"
+
+    # Other providers need an API key
+    if provider not in ("ollama", "claude-code", "openai-codex", "mock"):
+        api_key = get_api_key_for_provider(provider)
+        if not api_key:
+            return True, f"No API key available (set {provider.upper()}_API_KEY)"
+
+    return False, ""
+
+
+@pytest.mark.parametrize("provider,model", MODEL_MATRIX)
+@pytest.mark.asyncio
+async def test_llm_provider_api_methods(provider: str, model: str):
+    """
+    Test all LLM API methods used by Hindsight at runtime.
+    This validates that the provider correctly implements the LLMInterface.
+
+    Tests:
+    1. verify_connection() - Connection verification
+    2. call() with plain text - Basic LLM call
+    3. call() with response_format - Structured output (used in fact extraction)
+    4. call_with_tools() - Tool calling (used in reflect agent)
+    """
+    # Skip mock provider - it's a test stub, not a real LLM implementation
+    if provider == "mock":
+        pytest.skip("Mock provider is a test stub, not a real LLM")
+
+    should_skip, reason = should_skip_provider(provider, model)
+    if should_skip:
+        pytest.skip(f"Skipping {provider}/{model}: {reason}")
+
+    api_key = get_api_key_for_provider(provider)
+
+    llm = LLMProvider(
+        provider=provider,
+        api_key=api_key or "",
+        base_url="",
+        model=model,
+    )
+
+    print(f"\n{provider}/{model} - API methods test:")
+
+    # Test 1: verify_connection()
+    try:
+        await llm.verify_connection()
+        print("  ✓ verify_connection()")
+    except Exception as e:
+        pytest.fail(f"{provider}/{model} verify_connection() failed: {e}")
+
+    # Test 2: call() with plain text
+    try:
+        response = await llm.call(
+            messages=[
+                {"role": "system", "content": "You are a helpful assistant."},
+                {"role": "user", "content": "What is 2+2? Answer in one word."},
+            ],
+            max_completion_tokens=50,
+        )
+        assert response is not None, "call() returned None"
+        assert len(response) > 0, "call() returned empty string"
+        print(f"  ✓ call() plain text: {response[:50]}")
+    except Exception as e:
+        pytest.fail(f"{provider}/{model} call() plain text failed: {e}")
+
+    # Test 3: call() with response_format (structured output)
+    try:
+        from pydantic import BaseModel
+
+        class TestResponse(BaseModel):
+            answer: str
+            confidence: str
+
+        response = await llm.call(
+            messages=[
+                {"role": "system", "content": "You are a math assistant."},
+                {"role": "user", "content": "What is the capital of France?"},
+            ],
+            response_format=TestResponse,
+            max_completion_tokens=100,
+        )
+        assert isinstance(response, TestResponse), f"Expected TestResponse, got {type(response)}"
+        assert hasattr(response, "answer"), "Structured output missing 'answer' field"
+        assert hasattr(response, "confidence"), "Structured output missing 'confidence' field"
+        print(f"  ✓ call() structured output: answer={response.answer}, confidence={response.confidence}")
+    except Exception as e:
+        pytest.fail(f"{provider}/{model} call() structured output failed: {e}")
+
+    # Test 4: call_with_tools() (tool calling)
+    try:
+        tools = [
+            {
+                "type": "function",
+                "function": {
+                    "name": "get_weather",
+                    "description": "Get the weather for a location",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "location": {"type": "string", "description": "City name"},
+                            "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]},
+                        },
+                        "required": ["location"],
+                    },
+                },
+            }
+        ]
+
+        result = await llm.call_with_tools(
+            messages=[
+                {"role": "system", "content": "You are a helpful assistant with access to tools."},
+                {"role": "user", "content": "What's the weather like in Paris?"},
+            ],
+            tools=tools,
+            max_completion_tokens=200,
+        )
+
+        assert result is not None, "call_with_tools() returned None"
+        assert hasattr(result, "tool_calls"), "Result missing 'tool_calls' attribute"
+
+        # Nano models may hit token limits before making tool calls - that's acceptable
+        is_nano_model = "nano" in model.lower()
+        if is_nano_model and len(result.tool_calls) == 0:
+            # Check if it hit length limit (expected for nano models)
+            if hasattr(result, "finish_reason") and result.finish_reason == "length":
+                print(f"  ✓ call_with_tools(): nano model hit token limit (expected)")
+            else:
+                pytest.fail(f"Nano model made 0 tool calls but didn't hit length limit (finish_reason={getattr(result, 'finish_reason', 'unknown')})")
+        else:
+            assert len(result.tool_calls) > 0, f"Expected at least 1 tool call, got {len(result.tool_calls)}"
+
+            # Verify tool call structure
+            tool_call = result.tool_calls[0]
+            assert hasattr(tool_call, "name"), "Tool call missing 'name'"
+            assert hasattr(tool_call, "arguments"), "Tool call missing 'arguments'"
+            assert tool_call.name == "get_weather", f"Expected 'get_weather', got '{tool_call.name}'"
+            assert "location" in tool_call.arguments, "Tool call arguments missing 'location'"
+
+            print(f"  ✓ call_with_tools(): {tool_call.name}({tool_call.arguments})")
+    except Exception as e:
+        pytest.fail(f"{provider}/{model} call_with_tools() failed: {e}")
+
+
 @pytest.mark.parametrize("provider,model", MODEL_MATRIX)
 @pytest.mark.asyncio
 async def test_llm_provider_memory_operations(provider: str, model: str):
@@ -55,16 +225,16 @@ async def test_llm_provider_memory_operations(provider: str, model: str):
     Test LLM provider with actual memory operations: fact extraction and reflect.
     All models must pass this test.
     """
+    # Skip mock provider - it's a test stub, not designed for real operations
+    if provider == "mock":
+        pytest.skip("Mock provider is a test stub, not designed for real operations")
+
+    should_skip, reason = should_skip_provider(provider, model)
+    if should_skip:
+        pytest.skip(f"Skipping {provider}/{model}: {reason}")
+
     api_key = get_api_key_for_provider(provider)
 
-    # Skip Ollama tests in CI (no models available)
-    if provider == "ollama" and os.getenv("CI"):
-        pytest.skip(f"Skipping {provider}/{model}: Ollama not available in CI")
-
-    # Other providers need an API key
-    if provider != "ollama" and not api_key:
-        pytest.skip(f"Skipping {provider}/{model}: no API key available")
-
     llm = LLMProvider(
         provider=provider,
         api_key=api_key or "",
@@ -122,3 +292,115 @@ async def test_llm_provider_memory_operations(provider: str, model: str):
 
     assert response is not None, f"{provider}/{model} reflect returned None"
     assert len(response) > 10, f"{provider}/{model} reflect response too short"
+
+
+@pytest.mark.parametrize("provider,model", [
+    ("claude-code", "claude-sonnet-4-20250514"),
+    ("openai-codex", "gpt-5.2-codex"),
+])
+@pytest.mark.asyncio
+async def test_llm_provider_consolidation(memory_no_llm_verify, request_context, provider: str, model: str):
+    """
+    Test LLM provider with consolidation (automatic mental model generation from observations).
+    This validates that the provider can generate synthesized knowledge from raw memories.
+
+    This test is limited to claude-code and codex since they're the critical providers
+    that needed tool calling fixes for reflect and consolidation operations.
+    """
+    should_skip, reason = should_skip_provider(provider, model)
+    if should_skip:
+        pytest.skip(f"Skipping {provider}/{model}: {reason}")
+
+    # Use provider-specific LLM for this test
+    api_key = get_api_key_for_provider(provider)
+    memory_no_llm_verify._consolidation_llm = LLMProvider(
+        provider=provider,
+        api_key=api_key or "",
+        base_url="",
+        model=model,
+    )
+    # Also need retain LLM for ingesting data
+    memory_no_llm_verify._retain_llm = memory_no_llm_verify._consolidation_llm
+
+    test_bank_id = f"llm_test_consolidation_{provider}_{model}_{datetime.now().timestamp()}"
+
+    # Enable observations for this bank
+    from hindsight_api.config import get_config
+    config = get_config()
+    original_value = config.enable_observations
+    config.enable_observations = True
+
+    try:
+        # Retain memories to consolidate
+        test_content = """
+        Bob prefers functional programming with Rust and Haskell.
+        He emphasizes immutability and pure functions in code reviews.
+        Bob advocates for type safety and compile-time guarantees.
+        He avoids mutable state and prefers declarative code patterns.
+        """
+
+        await memory_no_llm_verify.retain_async(
+            bank_id=test_bank_id,
+            content=test_content,
+            context="Team coding preferences",
+            event_date=datetime(2024, 12, 1),
+            request_context=request_context,
+        )
+
+        print(f"\n{provider}/{model} - Consolidation test:")
+
+        # Run consolidation to generate observations (mental models)
+        from hindsight_api.engine.consolidation.consolidator import run_consolidation_job
+
+        result = await run_consolidation_job(
+            memory_engine=memory_no_llm_verify,
+            bank_id=test_bank_id,
+            request_context=request_context,
+        )
+
+        print(f"  Processed: {result.get('memories_processed', 0)} memories")
+        print(f"  Created: {result.get('observations_created', 0)} observations")
+        print(f"  Updated: {result.get('observations_updated', 0)} observations")
+
+        # Verify consolidation ran successfully
+        assert result["status"] in ["success", "no_new_memories"], f"{provider}/{model} consolidation failed"
+
+        # If observations were created, verify they contain relevant content
+        if result.get("observations_created", 0) > 0:
+            observations = await memory_no_llm_verify.list_mental_models_consolidated(
+                bank_id=test_bank_id,
+                request_context=request_context,
+            )
+
+            assert len(observations) > 0, f"{provider}/{model} consolidation created 0 observations"
+
+            # Check first observation contains relevant information
+            obs_content = observations[0].get("content", "").lower()
+            relevant_terms = ["bob", "functional", "rust", "immutab", "type"]
+            matches = [term for term in relevant_terms if term in obs_content]
+
+            print(f"  Observation preview: {observations[0].get('content', '')[:200]}...")
+            print(f"  Found {len(matches)} relevant terms: {matches}")
+
+            assert len(matches) >= 2, (
+                f"{provider}/{model} consolidated observation doesn't contain relevant info. "
+                f"Expected at least 2 of {relevant_terms}, found {len(matches)}: {matches}"
+            )
+
+    finally:
+        # Restore original config
+        config.enable_observations = original_value
+
+
+# NOTE: The tests above validate the critical Hindsight operations:
+#
+# test_llm_provider_memory_operations (ALL providers):
+#   - Fact extraction (retain): tests structured output generation
+#   - Reflect: tests memory retrieval and reasoning (uses tool calling for claude-code/codex)
+#
+# test_llm_provider_consolidation (claude-code and codex only):
+#   - Consolidation: tests automatic mental model generation from observations
+#   - Requires MemoryEngine fixture with working LLM (from .env or env vars)
+#   - Run your local LLM server OR set HINDSIGHT_API_LLM_PROVIDER/API_KEY/MODEL env vars
+#
+# For full end-to-end integration tests using the HTTP API, see tests/test_http_api_integration.py

hindsight-api/tests/test_mental_models.py

@@ -312,6 +312,49 @@ class TestDirectiveTags:
         # Cleanup
         await memory.delete_bank(bank_id, request_context=request_context)
 
+    async def test_list_all_directives_without_filter(self, memory: MemoryEngine, request_context):
+        """Test that listing directives without tags returns ALL directives (both tagged and untagged)."""
+        bank_id = f"test-directive-list-all-{uuid.uuid4().hex[:8]}"
+
+        # Ensure bank exists
+        await memory.get_bank_profile(bank_id, request_context=request_context)
+
+        # Create untagged directive
+        await memory.create_directive(
+            bank_id=bank_id,
+            name="Untagged Directive",
+            content="This has no tags",
+            request_context=request_context,
+        )
+
+        # Create tagged directive
+        await memory.create_directive(
+            bank_id=bank_id,
+            name="Tagged Directive",
+            content="This has tags",
+            tags=["project-x"],
+            request_context=request_context,
+        )
+
+        # List ALL directives (no tag filter, isolation_mode defaults to False)
+        all_directives = await memory.list_directives(
+            bank_id=bank_id,
+            request_context=request_context,
+        )
+
+        # Should return BOTH tagged and untagged directives
+        assert len(all_directives) == 2
+        directive_names = {d["name"] for d in all_directives}
+        assert "Untagged Directive" in directive_names
+        assert "Tagged Directive" in directive_names
+
+        # Verify the tagged directive has its tags
+        tagged = next(d for d in all_directives if d["name"] == "Tagged Directive")
+        assert tagged["tags"] == ["project-x"]
+
+        # Cleanup
+        await memory.delete_bank(bank_id, request_context=request_context)
+
 
 class TestReflect:
     """Test reflect endpoint."""
@@ -399,6 +442,161 @@ class TestDirectivesInReflect:
         # Cleanup
         await memory.delete_bank(bank_id, request_context=request_context)
 
+    async def test_tagged_directive_not_applied_without_tags(self, memory: MemoryEngine, request_context):
+        """Test that directives with tags are NOT applied to untagged reflect operations."""
+        bank_id = f"test-directive-isolation-{uuid.uuid4().hex[:8]}"
+
+        # Ensure bank exists
+        await memory.get_bank_profile(bank_id, request_context=request_context)
+
+        # Add some untagged content
+        await memory.retain_batch_async(
+            bank_id=bank_id,
+            contents=[
+                {"content": "The sky is blue."},
+                {"content": "Water is wet."},
+            ],
+            request_context=request_context,
+        )
+
+        # Add some tagged content for the project-x context
+        await memory.retain_batch_async(
+            bank_id=bank_id,
+            contents=[
+                {"content": "The sky is blue according to project X standards.", "tags": ["project-x"]},
+                {"content": "Project X color guidelines specify sky is blue.", "tags": ["project-x"]},
+            ],
+            request_context=request_context,
+        )
+        await memory.wait_for_background_tasks()
+
+        # Create an untagged directive (should be applied)
+        await memory.create_directive(
+            bank_id=bank_id,
+            name="General Policy",
+            content="Always be polite and start responses with 'Hello!'",
+            request_context=request_context,
+        )
+
+        # Create a tagged directive (should NOT be applied to untagged reflect)
+        await memory.create_directive(
+            bank_id=bank_id,
+            name="Tagged Policy",
+            content="ALWAYS respond in ALL CAPS and end with 'PROJECT-X ONLY'",
+            tags=["project-x"],
+            request_context=request_context,
+        )
+
+        # Run reflect without tags - should only apply the untagged directive
+        result = await memory.reflect_async(
+            bank_id=bank_id,
+            query="What color is the sky?",
+            request_context=request_context,
+        )
+
+        response_lower = result.text.lower()
+
+        # Should follow the untagged directive (polite greeting)
+        assert "hello" in response_lower, f"Expected 'Hello' from untagged directive, but got: {result.text}"
+
+        # Should NOT follow the tagged directive (all caps and PROJECT-X)
+        # If it did follow, the entire response would be in caps
+        all_caps = result.text.replace(" ", "").replace("!", "").replace(".", "").isupper()
+        assert not all_caps, f"Tagged directive was incorrectly applied to untagged operation: {result.text}"
+        assert "project-x only" not in response_lower, f"Tagged directive was incorrectly applied: {result.text}"
+
+        # Now run reflect WITH the tag - should apply BOTH directives
+        result_tagged = await memory.reflect_async(
+            bank_id=bank_id,
+            query="What color is the sky?",
+            tags=["project-x"],
+            tags_match="all_strict",
+            request_context=request_context,
+        )
+
+        response_tagged_lower = result_tagged.text.lower()
+
+        # With strict matching and tags, should apply the tagged directive
+        assert "project-x only" in response_tagged_lower, f"Tagged directive should be applied with tags: {result_tagged.text}"
+
+        # Cleanup
+        await memory.delete_bank(bank_id, request_context=request_context)
+
+    async def test_reflect_based_on_structure(self, memory: MemoryEngine, request_context):
+        """Test that reflect returns correct based_on structure with directives and memories separated."""
+        bank_id = f"test-reflect-based-on-{uuid.uuid4().hex[:8]}"
+
+        # Ensure bank exists
+        await memory.get_bank_profile(bank_id, request_context=request_context)
+
+        # Add some memories
+        await memory.retain_batch_async(
+            bank_id=bank_id,
+            contents=[
+                {"content": "Alice works at Google as a software engineer."},
+                {"content": "Bob is a product manager at Microsoft."},
+                {"content": "The team meets every Monday at 9am."},
+            ],
+            request_context=request_context,
+        )
+        await memory.wait_for_background_tasks()
+
+        # Create a directive
+        directive = await memory.create_directive(
+            bank_id=bank_id,
+            name="Professional Tone",
+            content="Always maintain a professional and formal tone in responses.",
+            request_context=request_context,
+        )
+        directive_id = directive["id"]
+
+        # Run reflect which returns the core result
+        result = await memory.reflect_async(
+            bank_id=bank_id,
+            query="Who works at Google?",
+            request_context=request_context,
+        )
+
+        # Verify based_on structure exists
+        assert result.based_on is not None
+
+        # Verify directives key exists and contains our directive
+        assert "directives" in result.based_on
+        directives_list = result.based_on.get("directives", [])
+
+        # Verify directives are dicts with id, name, content (not MemoryFact objects)
+        assert len(directives_list) > 0, "Should have at least one directive"
+        directive_found = False
+        for d in directives_list:
+            assert isinstance(d, dict), f"Directive should be dict, got {type(d)}"
+            assert "id" in d, "Directive dict should have 'id'"
+            assert "name" in d, "Directive dict should have 'name'"
+            assert "content" in d, "Directive dict should have 'content'"
+            # Check if this is our directive
+            if d["id"] == directive_id:
+                directive_found = True
+                assert d["name"] == "Professional Tone"
+                assert "professional" in d["content"].lower()
+
+        assert directive_found, f"Our directive {directive_id} should be in based_on.directives"
+
+        # Verify memories (world/experience) are separate from directives
+        has_memories = "world" in result.based_on or "experience" in result.based_on
+        assert has_memories, "Should have world or experience memories"
+
+        # Verify that if mental-models key exists, it's separate from directives
+        if "mental-models" in result.based_on:
+            mental_models = result.based_on.get("mental-models", [])
+            # Verify mental models are MemoryFact objects, not dicts like directives
+            for mm in mental_models:
+                assert hasattr(mm, "fact_type"), "Mental model should be MemoryFact with fact_type"
+                assert mm.fact_type == "mental-models"
+                assert hasattr(mm, "context")
+                assert "mental model" in mm.context.lower()
+
+        # Cleanup
+        await memory.delete_bank(bank_id, request_context=request_context)
+
 
 class TestDirectivesPromptInjection:
     """Test that directives are properly injected into the system prompt."""
@@ -451,3 +649,198 @@ class TestDirectivesPromptInjection:
         directives_pos = prompt.find("## DIRECTIVES")
         critical_rules_pos = prompt.find("## CRITICAL RULES")
         assert directives_pos < critical_rules_pos
+
+
+class TestMentalModelRefreshTagSecurity:
+    """Test that mental model refresh respects tag-based security boundaries."""
+
+    async def test_refresh_with_tags_only_accesses_same_tagged_models(
+        self, memory: MemoryEngine, request_context
+    ):
+        """Test that refreshing a mental model with tags can only access other models with the same tags.
+
+        This is a security test to ensure that mental models with tags (e.g., user:alice)
+        cannot access mental models from other scopes (e.g., user:bob or no tags) during refresh.
+        """
+        bank_id = f"test-refresh-tags-{uuid.uuid4().hex[:8]}"
+
+        # Ensure bank exists
+        await memory.get_bank_profile(bank_id, request_context=request_context)
+
+        # Add some facts with different tags
+        await memory.retain_batch_async(
+            bank_id=bank_id,
+            contents=[
+                {"content": "Alice works on the frontend React project. Alice's favorite color is blue.", "tags": ["user:alice"]},
+                {"content": "Alice prefers working in the morning. Alice drinks coffee every day.", "tags": ["user:alice"]},
+                {"content": "Bob works on the backend API services. Bob's favorite language is Python.", "tags": ["user:bob"]},
+                {"content": "Bob prefers working at night. Bob drinks tea every day.", "tags": ["user:bob"]},
+                {"content": "The company has 100 employees and is growing fast.", "tags": []},  # No tags
+            ],
+            request_context=request_context,
+        )
+
+        # Wait for background processing
+        await memory.wait_for_background_tasks()
+
+        # Create mental model for user:alice with sensitive data
+        mm_alice = await memory.create_mental_model(
+            bank_id=bank_id,
+            name="Alice's Work Profile",
+            source_query="What does Alice work on?",
+            content="Alice is a frontend engineer specializing in React",
+            tags=["user:alice"],
+            request_context=request_context,
+        )
+
+        # Create mental model for user:bob with sensitive data
+        mm_bob = await memory.create_mental_model(
+            bank_id=bank_id,
+            name="Bob's Work Profile",
+            source_query="What does Bob work on?",
+            content="Bob is a backend engineer specializing in Python",
+            tags=["user:bob"],
+            request_context=request_context,
+        )
+
+        # Create mental model with no tags (should not be accessible from tagged models)
+        mm_untagged = await memory.create_mental_model(
+            bank_id=bank_id,
+            name="Company Info",
+            source_query="What is the company info?",
+            content="The company has 100 employees",
+            request_context=request_context,
+        )
+
+        # Create a mental model for user:alice that will be refreshed
+        mm_alice_refresh = await memory.create_mental_model(
+            bank_id=bank_id,
+            name="Alice's Summary",
+            source_query="What are all the facts about work and preferences?",  # Broad query that should match all facts
+            content="Initial content",
+            tags=["user:alice"],
+            request_context=request_context,
+        )
+
+        # Refresh Alice's mental model
+        refreshed = await memory.refresh_mental_model(
+            bank_id=bank_id,
+            mental_model_id=mm_alice_refresh["id"],
+            request_context=request_context,
+        )
+
+        # SECURITY CHECK: The refreshed content should ONLY include information from
+        # memories/models tagged with user:alice, NOT from user:bob or untagged
+        refreshed_content = refreshed["content"].lower()
+
+        # Should include Alice's content (either from facts or mental models)
+        assert "alice" in refreshed_content, \
+            "Refreshed model should access memories/models with matching tags (user:alice)"
+
+        # MUST NOT include Bob's content (security violation)
+        assert "bob" not in refreshed_content and "python" not in refreshed_content and "tea" not in refreshed_content, \
+            f"SECURITY VIOLATION: Refreshed model accessed memories/models with different tags (user:bob). Content: {refreshed_content}"
+
+        # MUST NOT include untagged content (security violation)
+        assert "100 employees" not in refreshed_content and "growing fast" not in refreshed_content, \
+            f"SECURITY VIOLATION: Refreshed model accessed untagged memories/models. Content: {refreshed_content}"
+
+        # Cleanup
+        await memory.delete_bank(bank_id, request_context=request_context)
+
+    async def test_consolidation_only_refreshes_matching_tagged_models(
+        self, memory: MemoryEngine, request_context
+    ):
+        """Test that consolidation only triggers refresh for mental models with matching tags.
+
+        This is a security test to ensure that when tagged memories are consolidated,
+        only mental models with overlapping tags get refreshed, not all mental models.
+        """
+        bank_id = f"test-consolidation-refresh-{uuid.uuid4().hex[:8]}"
+
+        # Ensure bank exists
+        await memory.get_bank_profile(bank_id, request_context=request_context)
+
+        # Create mental models with different tags, all with refresh_after_consolidation=true
+        mm_alice = await memory.create_mental_model(
+            bank_id=bank_id,
+            name="Alice's Model",
+            source_query="What about Alice?",
+            content="Initial Alice content",
+            tags=["user:alice"],
+            trigger={"refresh_after_consolidation": True},
+            request_context=request_context,
+        )
+
+        mm_bob = await memory.create_mental_model(
+            bank_id=bank_id,
+            name="Bob's Model",
+            source_query="What about Bob?",
+            content="Initial Bob content",
+            tags=["user:bob"],
+            trigger={"refresh_after_consolidation": True},
+            request_context=request_context,
+        )
+
+        mm_untagged = await memory.create_mental_model(
+            bank_id=bank_id,
+            name="Untagged Model",
+            source_query="What about general stuff?",
+            content="Initial untagged content",
+            trigger={"refresh_after_consolidation": True},
+            request_context=request_context,
+        )
+
+        # Record initial last_refreshed_at timestamps
+        alice_initial = mm_alice["last_refreshed_at"]
+        bob_initial = mm_bob["last_refreshed_at"]
+        untagged_initial = mm_untagged["last_refreshed_at"]
+
+        # Add memories with user:alice tags
+        await memory.retain_batch_async(
+            bank_id=bank_id,
+            contents=[
+                {"content": "Alice likes React", "tags": ["user:alice"]},
+                {"content": "Alice drinks coffee", "tags": ["user:alice"]},
+            ],
+            request_context=request_context,
+        )
+
+        # Trigger consolidation manually (this should only refresh Alice's mental model)
+        from hindsight_api.engine.consolidation.consolidator import run_consolidation_job
+
+        result = await run_consolidation_job(
+            memory_engine=memory,
+            bank_id=bank_id,
+            request_context=request_context,
+        )
+
+        # Wait for background refresh tasks to complete
+        await memory.wait_for_background_tasks()
+
+        # Check that mental models were refreshed appropriately
+        mm_alice_after = await memory.get_mental_model(
+            bank_id, mm_alice["id"], request_context=request_context
+        )
+        mm_bob_after = await memory.get_mental_model(
+            bank_id, mm_bob["id"], request_context=request_context
+        )
+        mm_untagged_after = await memory.get_mental_model(
+            bank_id, mm_untagged["id"], request_context=request_context
+        )
+
+        # SECURITY CHECK: Only Alice's mental model and untagged model should be refreshed
+        # Alice's model should be refreshed (tags match)
+        assert mm_alice_after["last_refreshed_at"] != alice_initial or mm_alice_after["content"] != mm_alice["content"], \
+            "Alice's mental model should be refreshed when user:alice memories are consolidated"
+
+        # Bob's model should NOT be refreshed (tags don't match)
+        assert mm_bob_after["last_refreshed_at"] == bob_initial, \
+            "SECURITY VIOLATION: Bob's mental model was refreshed even though user:bob memories were not consolidated"
+
+        # Untagged model should be refreshed (untagged models are always refreshed)
+        assert mm_untagged_after["last_refreshed_at"] != untagged_initial or mm_untagged_after["content"] != mm_untagged["content"], \
+            "Untagged mental model should be refreshed after any consolidation"
+
+        # Cleanup
+        await memory.delete_bank(bank_id, request_context=request_context)

hindsight-api/tests/test_reflections.py

@@ -175,6 +175,45 @@ class TestMentalModelsCRUD:
         # Cleanup
         await memory.delete_bank(bank_id, request_context=request_context)
 
+    @pytest.mark.asyncio
+    async def test_create_mental_model_with_custom_id(self, memory: MemoryEngine, request_context):
+        """Test creating a mental model with a custom ID."""
+        bank_id = f"test-mental-model-custom-id-{uuid.uuid4().hex[:8]}"
+
+        # Create the bank first
+        await memory.get_bank_profile(bank_id=bank_id, request_context=request_context)
+
+        # Create a mental model with a custom ID
+        custom_id = "team-communication-preferences"
+        mental_model = await memory.create_mental_model(
+            bank_id=bank_id,
+            mental_model_id=custom_id,
+            name="Team Communication Preferences",
+            source_query="How does the team prefer to communicate?",
+            content="The team prefers async communication via Slack",
+            tags=["team", "communication"],
+            request_context=request_context,
+        )
+
+        # Verify the custom ID was used
+        assert mental_model["id"] == custom_id
+        assert mental_model["name"] == "Team Communication Preferences"
+        assert mental_model["tags"] == ["team", "communication"]
+
+        # Verify we can retrieve it with the custom ID
+        fetched = await memory.get_mental_model(
+            bank_id=bank_id,
+            mental_model_id=custom_id,
+            request_context=request_context,
+        )
+
+        assert fetched is not None
+        assert fetched["id"] == custom_id
+        assert fetched["name"] == "Team Communication Preferences"
+
+        # Cleanup
+        await memory.delete_bank(bank_id, request_context=request_context)
+
 
 class TestObservationsAPI:
     """Test observations API endpoints.

hindsight-api/tests/test_retain.py

@@ -2193,3 +2193,65 @@ If the text contains both Italian and English content, extract ONLY the Italian
 
         # Clear cache again to restore original config
         clear_config_cache()
+
+
+@pytest.mark.asyncio
+async def test_retain_batch_with_per_item_tags_on_document(memory, request_context):
+    """
+    Test that per-item tags are correctly stored on documents.
+
+    This test verifies the fix for a bug where per-item tags in content dictionaries
+    were not being merged and passed to document tracking, causing tags to be lost
+    even though they were correctly sent through the API.
+
+    Without the fix, this test would fail because:
+    - Tags are correctly passed in the content dict
+    - Tags are correctly stored on memory_units (facts)
+    - BUT tags were NOT stored on the document record itself
+    """
+    bank_id = f"test_doc_tags_{datetime.now(timezone.utc).timestamp()}"
+    document_id = "app-state-testuser"
+
+    try:
+        # Retain content with per-item tags (simulating the TasteAI use case)
+        contents = [
+            {
+                "content": '{"username":"testuser","meals":[],"preferences":{"nickname":"testuser"}}',
+                "document_id": document_id,
+                "tags": ["user:testuser", "app-type:taste-ai"],
+            }
+        ]
+
+        result = await memory.retain_batch_async(
+            bank_id=bank_id,
+            contents=contents,
+            request_context=request_context,
+        )
+
+        assert len(result) > 0, "Should have retained content"
+        print(f"\n=== Retained content with tags ===")
+
+        # Retrieve the document
+        doc = await memory.get_document(
+            document_id=document_id,
+            bank_id=bank_id,
+            request_context=request_context,
+        )
+
+        assert doc is not None, "Document should exist"
+        assert "tags" in doc, "Document should have tags field"
+
+        # This is the critical assertion - tags should be stored on the document
+        doc_tags = doc["tags"] or []
+        print(f"Document tags: {doc_tags}")
+
+        assert "user:testuser" in doc_tags, \
+            f"Document should have 'user:testuser' tag, but got: {doc_tags}"
+        assert "app-type:taste-ai" in doc_tags, \
+            f"Document should have 'app-type:taste-ai' tag, but got: {doc_tags}"
+
+        print("✓ Per-item tags correctly stored on document")
+
+    finally:
+        await memory.delete_bank(bank_id, request_context=request_context)
+        print(f"\n=== Cleaned up bank: {bank_id} ===")

hindsight-cli/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "hindsight-cli"
-version = "0.4.7"
+version = "0.4.9"
 edition = "2021"
 authors = ["Hindsight Team"]
 description = "A beautiful CLI for Hindsight - semantic memory system"

hindsight-cli/src/commands/mental_model.rs

@@ -98,6 +98,7 @@ pub fn create(
     bank_id: &str,
     name: &str,
     source_query: &str,
+    id: Option<&str>,
     verbose: bool,
     output_format: OutputFormat,
 ) -> Result<()> {
@@ -108,6 +109,7 @@ pub fn create(
     };
 
     let request = types::CreateMentalModelRequest {
+        id: id.map(|s| s.to_string()),
         name: name.to_string(),
         source_query: source_query.to_string(),
         max_tokens: 2048,

hindsight-cli/src/main.rs

@@ -596,6 +596,10 @@ enum MentalModelCommands {
 
         /// Source query to generate the mental model from
         source_query: String,
+
+        /// Optional custom ID for the mental model (alphanumeric lowercase with hyphens)
+        #[arg(long)]
+        id: Option<String>,
     },
 
     /// Update a mental model
@@ -863,8 +867,8 @@ fn run() -> Result<()> {
             MentalModelCommands::Get { bank_id, mental_model_id } => {
                 commands::mental_model::get(&client, &bank_id, &mental_model_id, verbose, output_format)
             }
-            MentalModelCommands::Create { bank_id, name, source_query } => {
-                commands::mental_model::create(&client, &bank_id, &name, &source_query, verbose, output_format)
+            MentalModelCommands::Create { bank_id, name, source_query, id } => {
+                commands::mental_model::create(&client, &bank_id, &name, &source_query, id.as_deref(), verbose, output_format)
             }
             MentalModelCommands::Update { bank_id, mental_model_id, name } => {
                 commands::mental_model::update(&client, &bank_id, &mental_model_id, name, verbose, output_format)

hindsight-clients/python/hindsight_client_api/__init__.py

@@ -7,7 +7,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/api/banks_api.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/api/directives_api.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/api/documents_api.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/api/entities_api.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/api/memory_api.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/api/mental_models_api.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/api/monitoring_api.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/api/operations_api.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/api_client.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/configuration.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.
@@ -489,7 +489,7 @@ class Configuration:
         return "Python SDK Debug Report:\n"\
                "OS: {env}\n"\
                "Python Version: {pyversion}\n"\
-               "Version of the API: 0.4.7\n"\
+               "Version of the API: 0.4.9\n"\
                "SDK Package Version: 0.0.7".\
                format(env=sys.platform, pyversion=sys.version)
 

hindsight-clients/python/hindsight_client_api/exceptions.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/__init__.py

@@ -6,7 +6,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/add_background_request.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/async_operation_submit_response.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/background_response.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/bank_list_item.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/bank_list_response.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/bank_profile_response.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/bank_stats_response.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/budget.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/cancel_operation_response.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/chunk_data.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/chunk_include_options.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/chunk_response.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/consolidation_response.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/create_bank_request.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/create_directive_request.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/create_mental_model_request.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.
@@ -28,12 +28,13 @@ class CreateMentalModelRequest(BaseModel):
     """
     Request model for creating a mental model.
     """ # noqa: E501
+    id: Optional[StrictStr] = None
     name: StrictStr = Field(description="Human-readable name for the mental model")
     source_query: StrictStr = Field(description="The query to run to generate content")
     tags: Optional[List[StrictStr]] = Field(default=None, description="Tags for scoped visibility")
     max_tokens: Optional[Annotated[int, Field(le=8192, strict=True, ge=256)]] = Field(default=2048, description="Maximum tokens for generated content")
     trigger: Optional[MentalModelTrigger] = Field(default=None, description="Trigger settings")
-    __properties: ClassVar[List[str]] = ["name", "source_query", "tags", "max_tokens", "trigger"]
+    __properties: ClassVar[List[str]] = ["id", "name", "source_query", "tags", "max_tokens", "trigger"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -77,6 +78,11 @@ class CreateMentalModelRequest(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of trigger
         if self.trigger:
             _dict['trigger'] = self.trigger.to_dict()
+        # set to None if id (nullable) is None
+        # and model_fields_set contains the field
+        if self.id is None and "id" in self.model_fields_set:
+            _dict['id'] = None
+
         return _dict
 
     @classmethod
@@ -89,6 +95,7 @@ class CreateMentalModelRequest(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
+            "id": obj.get("id"),
             "name": obj.get("name"),
             "source_query": obj.get("source_query"),
             "tags": obj.get("tags"),

hindsight-clients/python/hindsight_client_api/models/create_mental_model_response.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.
@@ -18,7 +18,7 @@ import re  # noqa: F401
 import json
 
 from pydantic import BaseModel, ConfigDict, Field, StrictStr
-from typing import Any, ClassVar, Dict, List
+from typing import Any, ClassVar, Dict, List, Optional
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -26,8 +26,9 @@ class CreateMentalModelResponse(BaseModel):
     """
     Response model for mental model creation.
     """ # noqa: E501
-    operation_id: StrictStr = Field(description="Operation ID to track progress")
-    __properties: ClassVar[List[str]] = ["operation_id"]
+    mental_model_id: Optional[StrictStr] = None
+    operation_id: StrictStr = Field(description="Operation ID to track refresh progress")
+    __properties: ClassVar[List[str]] = ["mental_model_id", "operation_id"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -68,6 +69,11 @@ class CreateMentalModelResponse(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
+        # set to None if mental_model_id (nullable) is None
+        # and model_fields_set contains the field
+        if self.mental_model_id is None and "mental_model_id" in self.model_fields_set:
+            _dict['mental_model_id'] = None
+
         return _dict
 
     @classmethod
@@ -80,6 +86,7 @@ class CreateMentalModelResponse(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
+            "mental_model_id": obj.get("mental_model_id"),
             "operation_id": obj.get("operation_id")
         })
         return _obj

hindsight-clients/python/hindsight_client_api/models/delete_document_response.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/delete_response.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/directive_list_response.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/directive_response.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/disposition_traits.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/document_response.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/entity_detail_response.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/entity_include_options.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/entity_input.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/entity_list_item.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/entity_list_response.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/entity_observation_response.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/entity_state_response.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/features_info.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/graph_data_response.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/http_validation_error.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/include_options.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/list_documents_response.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/list_memory_units_response.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/list_tags_response.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/memory_item.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/mental_model_list_response.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/mental_model_response.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/mental_model_trigger.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/operation_response.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/operation_status_response.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/operations_list_response.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/recall_request.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/recall_response.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/recall_result.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/reflect_based_on.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/reflect_directive.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/reflect_fact.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/reflect_include_options.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/reflect_llm_call.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/reflect_mental_model.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/reflect_request.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/reflect_response.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/reflect_tool_call.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/reflect_trace.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/retain_request.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/retain_response.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/tag_item.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.

hindsight-clients/python/hindsight_client_api/models/token_usage.py

@@ -5,7 +5,7 @@
 
     HTTP API for Hindsight
 
-    The version of the OpenAPI document: 0.4.7
+    The version of the OpenAPI document: 0.4.9
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 
     Do not edit the class manually.