Skip to content

:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.

feat(replay-vision): send every gemini call through the ai gateway (#125401)

Tue Haulund4550c13315f6
diff --git a/ee/settings.py b/ee/settings.py
index 29d49dba60df..5c4d467e411e 100644
--- a/ee/settings.py
+++ b/ee/settings.py
@@ -104,8 +104,6 @@ LLM_GATEWAY_API_KEY = get_from_env("LLM_GATEWAY_PERSONAL_API_KEY", DEV_API_KEY i
INKEEP_API_KEY = get_from_env("INKEEP_API_KEY", "")
MISTRAL_API_KEY = get_from_env("MISTRAL_API_KEY", "")
GEMINI_API_KEY = get_from_env("GEMINI_API_KEY", "")
-# Dedicated key for Replay Vision (own GCP project for cost/quota isolation); falls back to GEMINI_API_KEY
-REPLAY_VISION_GEMINI_API_KEY = get_from_env("REPLAY_VISION_GEMINI_API_KEY", "")
PPLX_API_KEY = get_from_env("PPLX_API_KEY", "")
AZURE_INFERENCE_ENDPOINT = get_from_env("AZURE_INFERENCE_ENDPOINT", "", type_cast=str)
AZURE_INFERENCE_CREDENTIAL = get_from_env("AZURE_INFERENCE_CREDENTIAL", "", type_cast=str)
diff --git a/products/replay_vision/README.md b/products/replay_vision/README.md
index a6e151bb1fad..0ce34830bdc5 100644
--- a/products/replay_vision/README.md
+++ b/products/replay_vision/README.md
@@ -66,6 +66,7 @@ The `experiment` scanner type is the way agents (Max, MCP, the `scanning-experim
- `backend/queries/` — ClickHouse candidate selection (watermark + settle window + eligibility + sampling), the backfill's bounded descending walk and its exact count, and volume estimates.
- `backend/temporal/` — the apply workflow and its activities, per-scanner sweep, per-backfill tick, schedule reconciler (+ observation and backfill-schedule reapers), estimate refresher, vision alerts, and the Gemini file cleanup sweep.
- `backend/quota.py` + `backend/billing.py` — credit accounting: the per-model price table, the receipt ledger, the quota snapshot the meter reads, and the per-org credit-limit override described below.
+- `backend/gemini_client.py` — every Gemini call goes through the Go AI gateway (`AI_GATEWAY_URL` and `AI_GATEWAY_API_KEY`). There is no direct route to Google, so local development needs a running gateway (`bin/start-ai-gateway`, credential from `bin/setup-gateway-e2e`).
- `backend/enqueue_claims.py` — atomic slot claims that keep on-demand scans inside the in-flight caps.
- `backend/embeddings.py` — the embedding identity shared by the write and search sides.
- `backend/search.py` + `backend/search_rerank.py` — observation search: embedding rank, access-scoped hydration, and the decision-model rerank of the head.
diff --git a/products/replay_vision/backend/gemini_client.py b/products/replay_vision/backend/gemini_client.py
index 4a163cb9c54c..35d6d357e0a4 100644
--- a/products/replay_vision/backend/gemini_client.py
+++ b/products/replay_vision/backend/gemini_client.py
@@ -1,70 +1,51 @@
-"""Replay Vision's Gemini client: the AI gateway when enabled for the team, else Google directly with our key."""
+"""Replay Vision's Gemini client. Every call goes through the AI gateway; there is no direct route to Google."""
from collections.abc import Mapping
from typing import Any
-from django.conf import settings
-
from google.genai import (
Client as RawGenAIClient,
errors,
types,
)
-from posthoganalytics.ai.gemini import genai
-from posthog.llm.gateway_client import (
- ai_gateway_headers,
- build_gemini_client,
- resolve_ai_gateway_config,
- team_distinct_id,
-)
-from posthog.models import Team
-from posthog.ph_client import feature_enabled_or_false
+from posthog.llm.gateway_client import GatewayNotConfiguredError, ai_gateway_headers, build_gemini_client
AI_PRODUCT = "replay_vision"
-GATEWAY_FLAG = "replay-vision-ai-gateway"
-def gemini_api_key() -> str:
- """Replay Vision's dedicated key (own GCP project), falling back to the shared key where unset."""
- return settings.REPLAY_VISION_GEMINI_API_KEY or settings.GEMINI_API_KEY
+def replay_gemini_client(*, properties: Mapping[str, Any] | None = None) -> "ReplayGemini":
+ base_properties = dict(properties or {})
+ client = _gateway_client(properties=_gateway_labels(base_properties), privacy_mode=True)
+ return ReplayGemini(client, _AsyncGatewayModels(client.aio.models, base_properties))
-async def replay_gemini_client(team_id: int, *, properties: Mapping[str, Any] | None = None) -> "ReplayGemini":
- base_properties = dict(properties or {})
- if await _gateway_enabled(team_id) and (
- client := build_gemini_client(
- ai_product=AI_PRODUCT, properties=_gateway_labels(base_properties), privacy_mode=True
- )
- ):
- return ReplayGemini(client, _AsyncGatewayModels(client.aio.models, base_properties))
- # Privacy mode keeps recording content out of the internal project, where it can't be deleted with the recording.
- direct = genai.AsyncClient(api_key=gemini_api_key(), posthog_privacy_mode=True, posthog_properties=base_properties)
- return ReplayGemini(RawGenAIClient(api_key=gemini_api_key()), direct.models)
-
-
-async def _gateway_enabled(team_id: int) -> bool:
- # Cleanup and the sweep delete files with the direct key, so gateway mode also needs Replay Vision's own key.
- if not settings.REPLAY_VISION_GEMINI_API_KEY or resolve_ai_gateway_config() is None:
- return False
- organization_id = str(await Team.objects.values_list("organization_id", flat=True).aget(id=team_id))
- # Local evaluation only, so a flag outage leaves a scan's many calls direct and fast; conditions must use the
- # org or project id.
- return feature_enabled_or_false(
- GATEWAY_FLAG,
- team_distinct_id(team_id),
- groups={"organization": organization_id, "project": str(team_id)},
- group_properties={"organization": {"id": organization_id}, "project": {"id": str(team_id)}},
- only_evaluate_locally=True,
- send_feature_flag_events=False,
+def gemini_text_models(*, timeout_ms: int) -> "_SyncGatewayModels":
+ """Sync `models` for text-only calls; takes the analytics wrapper's `posthog_*` kwargs as gateway headers."""
+ return _SyncGatewayModels(_gateway_client(privacy_mode=True, timeout_ms=timeout_ms))
+
+
+def gemini_files_client() -> RawGenAIClient:
+ """Deletes uploaded files, which carry no content, so it needs no privacy mode or labels."""
+ return _gateway_client()
+
+
+def _gateway_client(
+ *, properties: Mapping[str, str] | None = None, privacy_mode: bool = False, timeout_ms: int | None = None
+) -> RawGenAIClient:
+ # Privacy mode keeps customer content out of the internal project, where it could not be deleted on request.
+ client = build_gemini_client(
+ ai_product=AI_PRODUCT, properties=properties, privacy_mode=privacy_mode, timeout_ms=timeout_ms
)
+ if client is None:
+ raise GatewayNotConfiguredError("AI_GATEWAY_URL and AI_GATEWAY_API_KEY must be configured")
+ return client
class ReplayGemini:
- """One client for both routes: `models` takes the analytics wrapper's `posthog_*` kwargs; `raw` serves files and
- caches."""
+ """`models` takes the analytics wrapper's `posthog_*` kwargs; `raw` serves files and caches."""
- def __init__(self, raw: RawGenAIClient, models: Any) -> None:
+ def __init__(self, raw: RawGenAIClient, models: "_AsyncGatewayModels") -> None:
self.raw = raw
self.models = models
@@ -74,35 +55,58 @@ class ReplayGemini:
await self.raw.aio.aclose()
+def _gateway_config(
+ config: types.GenerateContentConfig | None,
+ posthog_distinct_id: str | None,
+ posthog_trace_id: str | None,
+ posthog_properties: Mapping[str, Any] | None,
+ base_properties: Mapping[str, Any] | None = None,
+) -> types.GenerateContentConfig | None:
+ """Turn the analytics wrapper's `posthog_*` kwargs into gateway headers."""
+ # The client's default headers carry the product, privacy mode and base labels; a call adds its own.
+ labels = (
+ _gateway_labels({**(base_properties or {}), **posthog_properties, "ai_product": AI_PRODUCT})
+ if posthog_properties
+ else None
+ )
+ headers = ai_gateway_headers(trace_id=posthog_trace_id, properties=labels, distinct_id=posthog_distinct_id) or {}
+ # The gateway sets `$ai_span_name` only from this header; it strips `$` keys from the properties.
+ if posthog_properties and (span_name := posthog_properties.get("$ai_span_name")):
+ headers["X-PostHog-Span-Name"] = str(span_name)
+ return _with_headers(config, headers)
+
+
+class _SyncGatewayModels:
+ """Buffered, unlike the async path: text calls finish far inside the gateway's 290s cut."""
+
+ def __init__(self, client: RawGenAIClient) -> None:
+ # Holds the client, not just `models`: a collected client closes the transport `models` sends on.
+ self._client = client
+
+ def generate_content(
+ self,
+ *,
+ model: str,
+ contents: Any,
+ config: types.GenerateContentConfig | None = None,
+ posthog_distinct_id: str | None = None,
+ posthog_trace_id: str | None = None,
+ posthog_properties: Mapping[str, Any] | None = None,
+ ) -> types.GenerateContentResponse:
+ return self._client.models.generate_content(
+ model=model,
+ contents=contents,
+ config=_gateway_config(config, posthog_distinct_id, posthog_trace_id, posthog_properties),
+ )
+
+
class _AsyncGatewayModels:
- """Takes the analytics wrapper's `posthog_*` kwargs as gateway headers; groups have none, so they drop. Streams
- every call: the gateway cuts a buffered call at 290s and long scans run past that."""
+ """Streams every call: the gateway cuts a buffered call at 290s and long scans run past that."""
def __init__(self, models: Any, base_properties: Mapping[str, Any]) -> None:
self._models = models
self._base_properties = base_properties
- def _config(
- self,
- config: types.GenerateContentConfig | None,
- posthog_distinct_id: str | None,
- posthog_trace_id: str | None,
- posthog_properties: Mapping[str, Any] | None,
- ) -> types.GenerateContentConfig | None:
- # The client's default headers carry the product, privacy mode and base labels; a call adds its own.
- labels = (
- _gateway_labels({**self._base_properties, **posthog_properties, "ai_product": AI_PRODUCT})
- if posthog_properties
- else None
- )
- headers = (
- ai_gateway_headers(trace_id=posthog_trace_id, properties=labels, distinct_id=posthog_distinct_id) or {}
- )
- # The gateway sets `$ai_span_name` only from this header; it strips `$` keys from the properties.
- if posthog_properties and (span_name := posthog_properties.get("$ai_span_name")):
- headers["X-PostHog-Span-Name"] = str(span_name)
- return _with_headers(config, headers)
-
async def generate_content(
self,
*,
@@ -112,13 +116,13 @@ class _AsyncGatewayModels:
posthog_distinct_id: str | None = None,
posthog_trace_id: str | None = None,
posthog_properties: Mapping[str, Any] | None = None,
- posthog_privacy_mode: bool | None = None,
- posthog_groups: Mapping[str, Any] | None = None,
) -> types.GenerateContentResponse:
stream = await self._models.generate_content_stream(
model=model,
contents=contents,
- config=self._config(config, posthog_distinct_id, posthog_trace_id, posthog_properties),
+ config=_gateway_config(
+ config, posthog_distinct_id, posthog_trace_id, posthog_properties, self._base_properties
+ ),
)
chunks = [chunk async for chunk in stream]
return assemble_stream(chunks)
diff --git a/products/replay_vision/backend/learned_rules.py b/products/replay_vision/backend/learned_rules.py
index 4475109a582b..d03064db85f9 100644
--- a/products/replay_vision/backend/learned_rules.py
+++ b/products/replay_vision/backend/learned_rules.py
@@ -20,7 +20,6 @@ from django.utils import timezone
import structlog
import posthoganalytics
from google.genai.types import GenerateContentConfig
-from posthoganalytics.ai.gemini import genai
from pydantic import BaseModel, Field
from posthog.dataclasses import frozen
@@ -29,7 +28,7 @@ from posthog.models.team import Team
from posthog.models.team.extensions import get_or_create_team_extension
from products.replay_vision.backend.distinct_ids import replay_vision_distinct_id
-from products.replay_vision.backend.gemini_client import gemini_api_key
+from products.replay_vision.backend.gemini_client import gemini_text_models
from products.replay_vision.backend.models.replay_observation import ObservationStatus, ReplayObservation
from products.replay_vision.backend.models.replay_observation_label import ReplayObservationLabel
from products.replay_vision.backend.models.replay_scanner import ReplayScanner, ScannerOrigin
@@ -754,15 +753,8 @@ def _build_user_content(
def _generate(*, user_content: str, team_id: int, trace_id: str) -> _LlmRules:
- api_key = gemini_api_key()
try:
- client = genai.Client(
- api_key=api_key,
- # Privacy mode keeps customer content out of the internal project, where it could not be deleted on request.
- posthog_privacy_mode=True,
- posthog_client=posthoganalytics.default_client,
- http_options={"timeout": _MODEL_CALL_TIMEOUT_MS},
- )
+ models = gemini_text_models(timeout_ms=_MODEL_CALL_TIMEOUT_MS)
except Exception as e:
raise LearnedRulesError("model client unavailable") from e
config = GenerateContentConfig(
@@ -771,14 +763,13 @@ def _generate(*, user_content: str, team_id: int, trace_id: str) -> _LlmRules:
response_json_schema=_LlmRules.model_json_schema(),
)
try:
- response = client.models.generate_content(
+ response = models.generate_content(
model=_RULES_MODEL,
contents=user_content,
config=config,
posthog_distinct_id=f"team:{team_id}",
posthog_trace_id=trace_id,
posthog_properties={"ai_product": "replay_vision", "feature": "learned_rules", "team_id": team_id},
- posthog_groups={"project": str(team_id)},
)
except Exception as e:
logger.exception("replay_vision.learned_rules.generate_failed", team_id=team_id)
diff --git a/products/replay_vision/backend/prompt_questions.py b/products/replay_vision/backend/prompt_questions.py
index 181c21bb3cff..3453f970e8b7 100644
--- a/products/replay_vision/backend/prompt_questions.py
+++ b/products/replay_vision/backend/prompt_questions.py
@@ -8,14 +8,11 @@ prompt or scale can tell the question no longer describes it.
import uuid
-from django.conf import settings
from django.core.cache import cache
from django.utils import timezone
import structlog
-import posthoganalytics
from google.genai.types import GenerateContentConfig
-from posthoganalytics.ai.gemini import genai
from pydantic import BaseModel, Field
from posthog.dataclasses import frozen
@@ -23,6 +20,7 @@ from posthog.dataclasses import frozen
from products.replay_vision.backend.built_in_scans import built_in_scan_for
from products.replay_vision.backend.consent import is_ai_data_processing_approved
from products.replay_vision.backend.distinct_ids import replay_vision_distinct_id
+from products.replay_vision.backend.gemini_client import gemini_text_models
from products.replay_vision.backend.models.replay_scanner import (
PromptValence,
ReplayScanner,
@@ -139,16 +137,9 @@ def _generate(
response_mime_type="application/json",
response_json_schema=_LlmQuestion.model_json_schema(),
)
- # Client setup is inside the guard too: a missing key must fall back, not fail the save.
+ # Client setup is inside the guard too: a missing gateway config must fall back, not fail the save.
try:
- client = genai.Client(
- api_key=settings.REPLAY_VISION_GEMINI_API_KEY or settings.GEMINI_API_KEY,
- # Privacy mode keeps customer content out of the internal project, where it could not be deleted on request.
- posthog_privacy_mode=True,
- posthog_client=posthoganalytics.default_client,
- http_options={"timeout": _MODEL_CALL_TIMEOUT_MS},
- )
- response = client.models.generate_content(
+ response = gemini_text_models(timeout_ms=_MODEL_CALL_TIMEOUT_MS).generate_content(
model=_QUESTION_MODEL,
contents=f"Scanner type: {scanner_type}{scale_line}\n\nInstructions:\n{prompt}"
+ (f"\n\nQuestion already written:\n{question}" if question else ""),
@@ -156,7 +147,6 @@ def _generate(
posthog_distinct_id=replay_vision_distinct_id(team_id),
posthog_trace_id=str(uuid.uuid4()),
posthog_properties={"ai_product": "replay_vision", "feature": "prompt_question", "team_id": team_id},
- posthog_groups={"project": str(team_id)},
)
return _LlmQuestion.model_validate_json(response.text or "")
except Exception:
diff --git a/products/replay_vision/backend/scanner_draft.py b/products/replay_vision/backend/scanner_draft.py
index 0778ca1350a6..08101eb52ab9 100644
--- a/products/replay_vision/backend/scanner_draft.py
+++ b/products/replay_vision/backend/scanner_draft.py
@@ -27,9 +27,7 @@ from django.db import connections
from django.db.models import Q
import structlog
-import posthoganalytics
from google.genai.types import FinishReason, GenerateContentConfig, GenerateContentResponse, ThinkingConfig
-from posthoganalytics.ai.gemini import genai
from pydantic import BaseModel, Field
from posthog.schema import RecordingsQuery
@@ -50,6 +48,7 @@ from posthog.scopes import APIScopeObject
from products.access_control.backend.facade.user_access_control import UserAccessControl
from products.experiments.backend.facade.replay import targetable_experiments
from products.replay_vision.backend.billing import observation_credits_for_model
+from products.replay_vision.backend.gemini_client import gemini_text_models
from products.replay_vision.backend.models.replay_scanner import (
ReplayScanner,
SamplingMode,
@@ -1534,18 +1533,11 @@ def _generate(
distinct_id: str,
thinking_budget: int | None = None,
) -> _LlmDraft:
- api_key = settings.REPLAY_VISION_GEMINI_API_KEY or settings.GEMINI_API_KEY
# Runs inline on the interactive request path, so a hung provider call must time out.
try:
- client = genai.Client(
- api_key=api_key,
- # Privacy mode keeps customer content out of the internal project, where it could not be deleted on request.
- posthog_privacy_mode=True,
- posthog_client=posthoganalytics.default_client,
- http_options={"timeout": _MODEL_CALL_TIMEOUT_MS},
- )
+ models = gemini_text_models(timeout_ms=_MODEL_CALL_TIMEOUT_MS)
except Exception as e:
- # A missing or malformed API key raises at construction. Wrap it so the API returns
+ # A missing gateway config raises at construction. Wrap it so the API returns
# the friendly 503 instead of a 500.
raise DraftError("model_client_unavailable") from e
config = GenerateContentConfig(
@@ -1557,7 +1549,7 @@ def _generate(
)
def call_model() -> GenerateContentResponse:
- return client.models.generate_content(
+ return models.generate_content(
model=_DRAFT_MODEL,
contents=user_content,
config=config,
@@ -1570,7 +1562,6 @@ def _generate(
"team_id": team_id,
"thinking_budget": thinking_budget,
},
- posthog_groups={"project": str(team_id)},
)
started = time.monotonic()
diff --git a/products/replay_vision/backend/temporal/activities/call_scanner_provider.py b/products/replay_vision/backend/temporal/activities/call_scanner_provider.py
index ffb709104232..0e3a230d26e7 100644
--- a/products/replay_vision/backend/temporal/activities/call_scanner_provider.py
+++ b/products/replay_vision/backend/temporal/activities/call_scanner_provider.py
@@ -641,7 +641,7 @@ async def _run_mission(
)
steps.append(step)
- gemini = await replay_gemini_client(team_id, properties=properties)
+ gemini = replay_gemini_client(properties=properties)
run = functools.partial(
_run_steps,
client=gemini,
@@ -871,7 +871,6 @@ async def _run_step(
posthog_distinct_id=replay_vision_distinct_id(team_id),
posthog_trace_id=trace_id,
posthog_properties={"$ai_span_name": step.name},
- posthog_groups={"project": str(team_id)},
)
last_error: str | None = None
diff --git a/products/replay_vision/backend/temporal/activities/cleanup_gemini_file.py b/products/replay_vision/backend/temporal/activities/cleanup_gemini_file.py
index 57e9490c5e95..0afb3372265c 100644
--- a/products/replay_vision/backend/temporal/activities/cleanup_gemini_file.py
+++ b/products/replay_vision/backend/temporal/activities/cleanup_gemini_file.py
@@ -1,9 +1,8 @@
"""Best-effort cleanup of a Gemini file uploaded by `upload_video_to_gemini_activity`."""
-from google.genai import Client as RawGenAIClient
from temporalio import activity
-from products.replay_vision.backend.gemini_client import gemini_api_key
+from products.replay_vision.backend.gemini_client import gemini_files_client
from products.replay_vision.backend.temporal.decorators import track_activity
from products.replay_vision.backend.temporal.gemini_cleanup_sweep.tracking import delete_and_untrack
from products.replay_vision.backend.temporal.types import CleanupGeminiFileInputs
@@ -13,5 +12,5 @@ from products.replay_vision.backend.temporal.types import CleanupGeminiFileInput
@track_activity()
async def cleanup_gemini_file_activity(inputs: CleanupGeminiFileInputs) -> None:
"""Best-effort delete of the uploaded Gemini file; the cleanup sweep retries on transient failure via the tracking key."""
- raw_client = RawGenAIClient(api_key=gemini_api_key())
+ raw_client = gemini_files_client()
await delete_and_untrack(raw_client, inputs.gemini_file_name, log_source="replay_vision.cleanup_gemini_file")
diff --git a/products/replay_vision/backend/temporal/activities/upload_video_to_gemini.py b/products/replay_vision/backend/temporal/activities/upload_video_to_gemini.py
index 9e4506b2ae66..51f9cb783a83 100644
--- a/products/replay_vision/backend/temporal/activities/upload_video_to_gemini.py
+++ b/products/replay_vision/backend/temporal/activities/upload_video_to_gemini.py
@@ -87,7 +87,7 @@ async def _upload_video(inputs: UploadVideoToGeminiInputs) -> UploadedVideo:
f"ExportedAsset {inputs.asset_id} produced empty video bytes", kind=FailureKind.INTERNAL_ERROR
)
- gemini = await replay_gemini_client(asset.team_id)
+ gemini = replay_gemini_client()
try:
return await _store_video(gemini.raw, video_bytes, asset.export_format, workflow_id)
finally:
diff --git a/products/replay_vision/backend/temporal/gemini_cleanup_sweep/activities.py b/products/replay_vision/backend/temporal/gemini_cleanup_sweep/activities.py
index 0cc85b0dd7da..de59d382eb01 100644
--- a/products/replay_vision/backend/temporal/gemini_cleanup_sweep/activities.py
+++ b/products/replay_vision/backend/temporal/gemini_cleanup_sweep/activities.py
@@ -1,9 +1,7 @@
import asyncio
from datetime import UTC, datetime
-from itertools import islice
import structlog
-from google.genai import Client as RawGenAIClient
from temporalio import activity
from temporalio.client import Client, WorkflowExecutionStatus
from temporalio.service import RPCError, RPCStatusCode
@@ -11,14 +9,12 @@ from temporalio.service import RPCError, RPCStatusCode
from posthog.temporal.common.client import async_connect
from posthog.temporal.common.heartbeat import Heartbeater
-from products.replay_vision.backend.gemini_client import gemini_api_key
+from products.replay_vision.backend.gemini_client import gemini_files_client
from products.replay_vision.backend.temporal.decorators import track_activity
from products.replay_vision.backend.temporal.gemini_cleanup_sweep.constants import (
DELETE_CONCURRENCY,
DESCRIBE_CONCURRENCY,
MAX_FILES_PER_SWEEP,
- MAX_STORAGE_LIST_FILES,
- STORAGE_LIST_PAGE_SIZE,
SWEEP_MIN_AGE,
)
from products.replay_vision.backend.temporal.gemini_cleanup_sweep.tracking import (
@@ -29,7 +25,6 @@ from products.replay_vision.backend.temporal.gemini_cleanup_sweep.tracking impor
from products.replay_vision.backend.temporal.gemini_cleanup_sweep.types import (
CleanupSweepInputs,
CleanupSweepResult,
- GeminiStorageUsage,
TrackedFile,
)
from products.replay_vision.backend.temporal.metrics import push_gemini_cleanup_gauges, record_gemini_cleanup_files
@@ -82,7 +77,7 @@ async def sweep_gemini_files_activity(inputs: CleanupSweepInputs) -> CleanupSwee
async def _sweep_gemini_files(inputs: CleanupSweepInputs) -> CleanupSweepResult:
- raw_client = RawGenAIClient(api_key=gemini_api_key())
+ raw_client = gemini_files_client()
temporal = await async_connect()
cutoff = datetime.now(UTC) - SWEEP_MIN_AGE
@@ -144,11 +139,10 @@ async def _sweep_gemini_files(inputs: CleanupSweepInputs) -> CleanupSweepResult:
deleted = sum(1 for r in delete_results if r)
delete_failed = sum(1 for r in delete_results if not r)
- storage = await _measure_storage(raw_client)
- result = base_result.model_copy(update={"deleted": deleted, "delete_failed": delete_failed, "storage": storage})
+ result = base_result.model_copy(update={"deleted": deleted, "delete_failed": delete_failed})
for name in _FILE_RESULTS:
record_gemini_cleanup_files(name, getattr(result, name))
- await asyncio.to_thread(push_gemini_cleanup_gauges, total_tracked, storage)
+ await asyncio.to_thread(push_gemini_cleanup_gauges, total_tracked)
logger.info(
"replay_vision.cleanup_sweep.cycle_complete",
scanned=result.scanned,
@@ -159,46 +153,6 @@ async def _sweep_gemini_files(inputs: CleanupSweepInputs) -> CleanupSweepResult:
skipped_temporal_error=result.skipped_temporal_error,
delete_failed=result.delete_failed,
hit_max_files_cap=result.hit_max_files_cap,
- storage=storage.model_dump() if storage else None,
signals_type="cleanup-sweep",
)
return result
-
-
-def _list_storage(raw_client: RawGenAIClient) -> GeminiStorageUsage:
- now = datetime.now(UTC)
- files = 0
- total_bytes = 0
- oldest_created_at = now
- for file in islice(raw_client.files.list(config={"page_size": STORAGE_LIST_PAGE_SIZE}), MAX_STORAGE_LIST_FILES):
- files += 1
- total_bytes += file.size_bytes or 0
- if file.create_time and file.create_time < oldest_created_at:
- oldest_created_at = file.create_time
- return GeminiStorageUsage(
- files=files,
- total_bytes=total_bytes,
- oldest_age_seconds=(now - oldest_created_at).total_seconds(),
- truncated=files == MAX_STORAGE_LIST_FILES,
- )
-
-
-async def _measure_storage(raw_client: RawGenAIClient) -> GeminiStorageUsage | None:
- """Lists every file in the Gemini project, which is what counts against its storage quota.
-
- The Redis index only knows files whose tracking write succeeded, so this listing also sees the files
- the sweep can never reach. A failed listing returns None and never fails the sweep.
- """
- try:
- storage = await asyncio.to_thread(_list_storage, raw_client)
- except Exception:
- logger.exception("replay_vision.cleanup_sweep.storage_list_failed", signals_type="cleanup-sweep")
- return None
- activity.heartbeat({"phase": "storage_listed", "files": storage.files})
- if storage.truncated:
- logger.warning(
- "replay_vision.cleanup_sweep.storage_list_truncated",
- max_files=MAX_STORAGE_LIST_FILES,
- signals_type="cleanup-sweep",
- )
- return storage
diff --git a/products/replay_vision/backend/temporal/gemini_cleanup_sweep/constants.py b/products/replay_vision/backend/temporal/gemini_cleanup_sweep/constants.py
index 0d0a3d5b083c..0eeaa51bff1e 100644
--- a/products/replay_vision/backend/temporal/gemini_cleanup_sweep/constants.py
+++ b/products/replay_vision/backend/temporal/gemini_cleanup_sweep/constants.py
@@ -19,10 +19,6 @@ SWEEP_MIN_AGE = timedelta(seconds=60)
MAX_FILES_PER_SWEEP = 1500
MGET_BATCH_SIZE = 200
-# The Files API caps a page at 100 files. The cap bounds a listing when files leak and pile up.
-STORAGE_LIST_PAGE_SIZE = 100
-MAX_STORAGE_LIST_FILES = 5000
-
DESCRIBE_CONCURRENCY = 20
DELETE_CONCURRENCY = 10
diff --git a/products/replay_vision/backend/temporal/gemini_cleanup_sweep/tracking.py b/products/replay_vision/backend/temporal/gemini_cleanup_sweep/tracking.py
index b3a874de5896..2658534de2e0 100644
--- a/products/replay_vision/backend/temporal/gemini_cleanup_sweep/tracking.py
+++ b/products/replay_vision/backend/temporal/gemini_cleanup_sweep/tracking.py
@@ -17,6 +17,7 @@ if TYPE_CHECKING:
from posthog.redis import get_async_client
+from products.replay_vision.backend.temporal.gemini import is_gateway_refusal
from products.replay_vision.backend.temporal.gemini_cleanup_sweep.constants import (
MGET_BATCH_SIZE,
REDIS_INDEX_KEY,
@@ -32,7 +33,8 @@ def is_gemini_file_gone(error: Exception) -> bool:
"""Whether a Gemini delete failure means the file no longer exists. Gemini reports missing
files as 403 PERMISSION_DENIED ("...or it may not exist"), not just 404 — callers should
untrack on either instead of retrying a doomed delete."""
- return isinstance(error, APIError) and error.code in (403, 404)
+ # The gateway's own 403/404 (bad key, missing route) says nothing about the file, so it keeps the key for retry.
+ return isinstance(error, APIError) and error.code in (403, 404) and not is_gateway_refusal(error)
async def delete_and_untrack(
diff --git a/products/replay_vision/backend/temporal/gemini_cleanup_sweep/types.py b/products/replay_vision/backend/temporal/gemini_cleanup_sweep/types.py
index 99f2f2c73768..568b04d9b095 100644
--- a/products/replay_vision/backend/temporal/gemini_cleanup_sweep/types.py
+++ b/products/replay_vision/backend/temporal/gemini_cleanup_sweep/types.py
@@ -7,13 +7,6 @@ class CleanupSweepInputs(BaseModel, frozen=True):
pass
-class GeminiStorageUsage(BaseModel, frozen=True):
- files: int
- total_bytes: int
- oldest_age_seconds: float
- truncated: bool
-
-
class CleanupSweepResult(BaseModel, frozen=True):
scanned: int = 0
deleted: int = 0
@@ -23,7 +16,6 @@ class CleanupSweepResult(BaseModel, frozen=True):
skipped_invalid_value: int = 0
delete_failed: int = 0
hit_max_files_cap: bool = False
- storage: GeminiStorageUsage | None = None
class TrackedFile(BaseModel, frozen=True):
diff --git a/products/replay_vision/backend/temporal/metrics.py b/products/replay_vision/backend/temporal/metrics.py
index b5ac60f44a4c..cc627eb2dfad 100644
--- a/products/replay_vision/backend/temporal/metrics.py
+++ b/products/replay_vision/backend/temporal/metrics.py
@@ -9,16 +9,12 @@ is swallowed so telemetry can never fail an activity.
"""
import time
-from typing import TYPE_CHECKING
from prometheus_client import Counter, Gauge, Histogram
from posthog.metrics import pushed_metrics_registry
from posthog.otel_metrics import OtelInstrumentFactory
-if TYPE_CHECKING:
- from products.replay_vision.backend.temporal.gemini_cleanup_sweep.types import GeminiStorageUsage
-
_otel = OtelInstrumentFactory("replay-vision")
REPLAY_VISION_OBSERVATIONS = Counter(
@@ -378,31 +374,13 @@ def record_gemini_cleanup_files(result: str, count: int) -> None:
# Prometheus metrics, so these gauges have no OTLP twin.
-def push_gemini_cleanup_gauges(tracked_files: int, storage: "GeminiStorageUsage | None") -> None:
- """Each push replaces the job's previous gauges, so a failed listing leaves a gap in the storage series."""
+def push_gemini_cleanup_gauges(tracked_files: int) -> None:
with pushed_metrics_registry("replay_vision_gemini_cleanup_sweep") as registry:
Gauge(
"replay_vision_gemini_cleanup_backlog",
"Tracked Gemini files awaiting cleanup (a growing backlog means the sweep is losing)",
registry=registry,
).set(tracked_files)
- if storage is not None:
- Gauge(
- "replay_vision_gemini_storage_files",
- "Files in the Gemini project from a full Files API listing, including files the Redis index "
- "lost; a flat line at the listing cap means the real count is higher",
- registry=registry,
- ).set(storage.files)
- Gauge(
- "replay_vision_gemini_storage_bytes",
- "Bytes the listed Gemini files hold against the project's Files API storage quota",
- registry=registry,
- ).set(storage.total_bytes)
- Gauge(
- "replay_vision_gemini_oldest_file_age_seconds",
- "Age of the oldest listed Gemini file; a file older than any scan's run time is one cleanup missed",
- registry=registry,
- ).set(storage.oldest_age_seconds)
Gauge(
"replay_vision_gemini_cleanup_last_run_timestamp_seconds",
"Unix time the Gemini cleanup sweep last finished",
diff --git a/products/replay_vision/backend/temporal/pii_check.py b/products/replay_vision/backend/temporal/pii_check.py
index e7cd07ec4837..d92c897751c1 100644
--- a/products/replay_vision/backend/temporal/pii_check.py
+++ b/products/replay_vision/backend/temporal/pii_check.py
@@ -173,7 +173,7 @@ def contains_pii(*, team_id: int, text: dict[str, str], trace_id: str) -> bool |
async def rewrite_without_pii(*, team_id: int, question: str, text: dict[str, str], trace_id: str) -> dict[str, str]:
"""Rewrite the answer's text fields without the personal data; fields the rewrite drops keep their old text."""
properties = {"ai_product": AI_PRODUCT, "feature": "pii_rewrite", "team_id": team_id}
- client = await replay_gemini_client(team_id, properties=properties)
+ client = replay_gemini_client(properties=properties)
try:
response = await client.models.generate_content(
model=_REWRITE_MODEL,
@@ -184,7 +184,6 @@ async def rewrite_without_pii(*, team_id: int, question: str, text: dict[str, st
posthog_distinct_id=replay_vision_distinct_id(team_id),
posthog_trace_id=trace_id,
posthog_properties={"$ai_span_name": "pii_rewrite"},
- posthog_groups={"project": str(team_id)},
)
finally:
await client.aclose()
diff --git a/products/replay_vision/backend/tests/conftest.py b/products/replay_vision/backend/tests/conftest.py
index e4e13a072c46..90be24f36686 100644
--- a/products/replay_vision/backend/tests/conftest.py
+++ b/products/replay_vision/backend/tests/conftest.py
@@ -37,6 +37,6 @@ def activity_environment():
def _no_prompt_question_model_call():
"""Every scanner save condenses its prompt with a model call. Tests fall back to the prompt's first line
unless they patch the client themselves."""
- with patch("products.replay_vision.backend.prompt_questions.genai.Client") as client:
- client.return_value.models.generate_content.side_effect = RuntimeError("no model calls in tests")
+ with patch("products.replay_vision.backend.prompt_questions.gemini_text_models") as client:
+ client.return_value.generate_content.side_effect = RuntimeError("no model calls in tests")
yield client
diff --git a/products/replay_vision/backend/tests/test_call_scanner_provider.py b/products/replay_vision/backend/tests/test_call_scanner_provider.py
index af32c8378208..172f7d828519 100644
--- a/products/replay_vision/backend/tests/test_call_scanner_provider.py
+++ b/products/replay_vision/backend/tests/test_call_scanner_provider.py
@@ -128,7 +128,7 @@ async def test_the_mission_runs_generate_and_caches_on_one_client_and_closes_it(
attempts = AsyncMock(side_effect=RuntimeError("mission failed") if fails == "mission" else None, return_value={})
module = "products.replay_vision.backend.temporal.activities.call_scanner_provider"
with (
- patch(f"{module}.replay_gemini_client", new=AsyncMock(return_value=gemini)),
+ patch(f"{module}.replay_gemini_client", MagicMock(return_value=gemini)),
patch(f"{module}._maybe_create_video_cache", new=create_cache),
patch(f"{module}._run_mission_attempts", new=attempts),
patch(f"{module}.build_events_index", return_value={}),
@@ -163,7 +163,7 @@ async def test_the_mission_deletes_its_cache_before_closing_the_client() -> None
gemini.aclose = AsyncMock(side_effect=lambda: order.append("aclose"))
module = "products.replay_vision.backend.temporal.activities.call_scanner_provider"
with (
- patch(f"{module}.replay_gemini_client", new=AsyncMock(return_value=gemini)),
+ patch(f"{module}.replay_gemini_client", MagicMock(return_value=gemini)),
patch(f"{module}._run_mission_attempts", new=AsyncMock(return_value={})),
patch(f"{module}.build_events_index", return_value={}),
):
@@ -194,7 +194,7 @@ async def test_scanner_generations_include_team_attribution() -> None:
with (
patch(
"products.replay_vision.backend.temporal.activities.call_scanner_provider.replay_gemini_client",
- new=AsyncMock(return_value=_gemini()),
+ MagicMock(return_value=_gemini()),
) as client_factory,
patch(
"products.replay_vision.backend.temporal.activities.call_scanner_provider._maybe_create_video_cache",
@@ -454,7 +454,7 @@ async def test_signal_timestamps_use_recording_duration(
)
module = "products.replay_vision.backend.temporal.activities.call_scanner_provider"
with (
- patch(f"{module}.replay_gemini_client", new=AsyncMock(return_value=_gemini(client.models))),
+ patch(f"{module}.replay_gemini_client", MagicMock(return_value=_gemini(client.models))),
patch(f"{module}.build_events_index", return_value={}),
patch(f"{module}._maybe_create_video_cache", new=AsyncMock(return_value=None)),
):
diff --git a/products/replay_vision/backend/tests/test_gemini_cleanup_activities.py b/products/replay_vision/backend/tests/test_gemini_cleanup_activities.py
index 0a638dc9b2b6..06759c71c143 100644
--- a/products/replay_vision/backend/tests/test_gemini_cleanup_activities.py
+++ b/products/replay_vision/backend/tests/test_gemini_cleanup_activities.py
@@ -6,7 +6,6 @@ from dataclasses import dataclass
import pytest
from unittest.mock import AsyncMock, patch
-from google.genai import types
from google.genai.errors import APIError
from prometheus_client import CollectorRegistry
from temporalio.client import WorkflowExecutionStatus
@@ -20,11 +19,7 @@ from products.replay_vision.backend.temporal.gemini_cleanup_sweep.constants impo
REDIS_KEY_TTL,
SWEEP_MIN_AGE,
)
-from products.replay_vision.backend.temporal.gemini_cleanup_sweep.types import (
- CleanupSweepInputs,
- CleanupSweepResult,
- GeminiStorageUsage,
-)
+from products.replay_vision.backend.temporal.gemini_cleanup_sweep.types import CleanupSweepInputs, CleanupSweepResult
_PUSHED_REGISTRY = "products.replay_vision.backend.temporal.metrics.pushed_metrics_registry"
_NOW = dt.datetime(2026, 6, 12, 12, 0, 0, tzinfo=dt.UTC)
@@ -65,13 +60,6 @@ class _StubFiles:
def __init__(self) -> None:
self.deleted: list[str] = []
self.delete_raises_for: dict[str, BaseException] = {}
- self.listed: list[types.File] = []
- self.list_raises: BaseException | None = None
-
- def list(self, *, config: dict) -> list[types.File]:
- if self.list_raises is not None:
- raise self.list_raises
- return self.listed
def delete(self, *, name: str) -> None:
if name in self.delete_raises_for:
@@ -108,7 +96,7 @@ async def _track(client, *, file_name: str, workflow_id: str, age: dt.timedelta)
def _patch_clients(raw_client: _StubRawClient, temporal: _StubTemporal):
return (
patch(
- "products.replay_vision.backend.temporal.gemini_cleanup_sweep.activities.RawGenAIClient",
+ "products.replay_vision.backend.temporal.gemini_cleanup_sweep.activities.gemini_files_client",
return_value=raw_client,
),
patch(
@@ -132,9 +120,7 @@ async def test_no_keys_returns_zeros(activity_environment, fixed_now, gemini_red
p1, p2 = _patch_clients(raw, tmp)
with p1, p2:
result = await activity_environment.run(sweep_gemini_files_activity, CleanupSweepInputs())
- assert result == CleanupSweepResult(
- storage=GeminiStorageUsage(files=0, total_bytes=0, oldest_age_seconds=0.0, truncated=False)
- )
+ assert result == CleanupSweepResult()
assert raw.files.deleted == []
@@ -353,36 +339,12 @@ async def test_mixed_cycle_aggregates_correctly(activity_environment, fixed_now,
@pytest.mark.asyncio
-async def test_reports_storage_from_the_full_gemini_listing(activity_environment, fixed_now, gemini_redis):
- raw, tmp = _StubRawClient(), _StubTemporal({})
- raw.files.listed = [
- types.File(name="files/tracked", size_bytes=300, create_time=_NOW - dt.timedelta(minutes=5)),
- types.File(name="files/untracked", size_bytes=700, create_time=_NOW - dt.timedelta(hours=30)),
- types.File(name="files/no-metadata"),
- ]
- p1, p2 = _patch_clients(raw, tmp)
- pushed = CollectorRegistry()
- with p1, p2, patch(_PUSHED_REGISTRY, lambda _job: nullcontext(pushed)):
- result = await activity_environment.run(sweep_gemini_files_activity, CleanupSweepInputs())
- assert result.storage == GeminiStorageUsage(
- files=3, total_bytes=1000, oldest_age_seconds=30 * 3600, truncated=False
- )
- assert pushed.get_sample_value("replay_vision_gemini_storage_bytes") == 1000
- assert pushed.get_sample_value("replay_vision_gemini_cleanup_backlog") == 0
-
-
-async def test_storage_listing_failure_still_deletes_and_drops_storage_gauges(
- activity_environment, fixed_now, gemini_redis
-):
+async def test_pushes_the_backlog_seen_before_deleting(activity_environment, fixed_now, gemini_redis):
await _track(gemini_redis, file_name="files/old", workflow_id="wf-1", age=SWEEP_MIN_AGE * 10)
raw, tmp = _StubRawClient(), _StubTemporal({"wf-1": _Outcome(status=WorkflowExecutionStatus.COMPLETED)})
- raw.files.list_raises = RuntimeError("simulated")
p1, p2 = _patch_clients(raw, tmp)
pushed = CollectorRegistry()
with p1, p2, patch(_PUSHED_REGISTRY, lambda _job: nullcontext(pushed)):
result = await activity_environment.run(sweep_gemini_files_activity, CleanupSweepInputs())
assert result.deleted == 1
- assert result.storage is None
assert pushed.get_sample_value("replay_vision_gemini_cleanup_backlog") == 1
- assert pushed.get_sample_value("replay_vision_gemini_storage_bytes") is None
diff --git a/products/replay_vision/backend/tests/test_gemini_cleanup_workflow.py b/products/replay_vision/backend/tests/test_gemini_cleanup_workflow.py
index fef79a015da2..3307a0427ed1 100644
--- a/products/replay_vision/backend/tests/test_gemini_cleanup_workflow.py
+++ b/products/replay_vision/backend/tests/test_gemini_cleanup_workflow.py
@@ -8,11 +8,7 @@ from temporalio.testing import WorkflowEnvironment
from temporalio.worker import Worker
from products.replay_vision.backend.temporal.gemini_cleanup_sweep.constants import WORKFLOW_NAME
-from products.replay_vision.backend.temporal.gemini_cleanup_sweep.types import (
- CleanupSweepInputs,
- CleanupSweepResult,
- GeminiStorageUsage,
-)
+from products.replay_vision.backend.temporal.gemini_cleanup_sweep.types import CleanupSweepInputs, CleanupSweepResult
from products.replay_vision.backend.temporal.gemini_cleanup_sweep.workflow import ReplayVisionGeminiCleanupSweepWorkflow
@@ -29,7 +25,6 @@ async def test_workflow_returns_activity_result_as_dict():
skipped_invalid_value=2,
delete_failed=1,
hit_max_files_cap=True,
- storage=GeminiStorageUsage(files=7, total_bytes=2048, oldest_age_seconds=60.0, truncated=False),
)
task_queue = str(uuid.uuid4())
@@ -57,5 +52,4 @@ async def test_workflow_returns_activity_result_as_dict():
"skipped_invalid_value": 2,
"delete_failed": 1,
"hit_max_files_cap": True,
- "storage": {"files": 7, "total_bytes": 2048, "oldest_age_seconds": 60.0, "truncated": False},
}
diff --git a/products/replay_vision/backend/tests/test_gemini_client.py b/products/replay_vision/backend/tests/test_gemini_client.py
index 2f57957bb88d..f40fe152186c 100644
--- a/products/replay_vision/backend/tests/test_gemini_client.py
+++ b/products/replay_vision/backend/tests/test_gemini_client.py
@@ -1,10 +1,11 @@
+import gc
import json
import asyncio
from collections.abc import Callable
from typing import Any
import pytest
-from unittest.mock import AsyncMock, MagicMock, patch
+from unittest.mock import AsyncMock, patch
from django.test import override_settings
@@ -17,11 +18,13 @@ from google.genai import (
from posthog.llm.gateway_client import AIGatewayHostError
from products.replay_vision.backend.gemini_client import (
- GATEWAY_FLAG,
+ GatewayNotConfiguredError,
ReplayGemini,
_AsyncGatewayModels,
_with_headers,
assemble_stream,
+ gemini_files_client,
+ gemini_text_models,
replay_gemini_client,
)
from products.replay_vision.backend.temporal import pii_check
@@ -29,29 +32,8 @@ from products.replay_vision.backend.temporal.activities.upload_video_to_gemini i
from products.replay_vision.backend.temporal.errors import FailureKind
from products.replay_vision.backend.temporal.gemini import classify_gemini_error
-_GATEWAY = {
- "AI_GATEWAY_URL": "https://ai-gateway.example/v1",
- "AI_GATEWAY_API_KEY": "phs_gateway",
- "REPLAY_VISION_GEMINI_API_KEY": "replay-vision-google-key",
-}
+_GATEWAY = {"AI_GATEWAY_URL": "https://ai-gateway.example/v1", "AI_GATEWAY_API_KEY": "phs_gateway"}
_OK = {"candidates": [{"content": {"role": "model", "parts": [{"text": "ok"}]}, "finishReason": "STOP"}]}
-_FLAG = "products.replay_vision.backend.gemini_client.feature_enabled_or_false"
-
-
-_ORG = "0190e1a2-0000-7000-8000-000000000042"
-
-
[email protected](autouse=True)
-def flag_on() -> Any:
- with patch(_FLAG, return_value=True) as flag:
- yield flag
-
-
[email protected](autouse=True)
-def team_org() -> Any:
- with patch("products.replay_vision.backend.gemini_client.Team") as team:
- team.objects.values_list.return_value.aget = AsyncMock(return_value=_ORG)
- yield team
def _sse(*chunks: dict[str, Any]) -> bytes:
@@ -64,17 +46,13 @@ def _ok(request: httpx.Request) -> httpx.Response:
return httpx.Response(200, json=_OK)
-async def _agateway_client(properties: dict[str, Any] | None = None) -> ReplayGemini:
+def _gateway_client(properties: dict[str, Any] | None = None) -> ReplayGemini:
with override_settings(**_GATEWAY):
- client = await replay_gemini_client(42, properties=properties)
+ client = replay_gemini_client(properties=properties)
assert isinstance(client.models, _AsyncGatewayModels)
return client
-def _gateway_client(properties: dict[str, Any] | None = None) -> ReplayGemini:
- return asyncio.run(_agateway_client(properties))
-
-
def _wired_gateway_client(
properties: dict[str, Any], respond: Callable[[httpx.Request], httpx.Response] = _ok
) -> tuple[ReplayGemini, list[httpx.Request]]:
@@ -98,47 +76,22 @@ def _wire(client: ReplayGemini, respond: Callable[[httpx.Request], httpx.Respons
class TestReplayGeminiClient:
- def test_flag_off_stays_direct(self, flag_on: MagicMock) -> None:
- flag_on.return_value = False
- with (
- override_settings(**_GATEWAY),
- patch("products.replay_vision.backend.gemini_client.build_gemini_client") as build,
- ):
- client = asyncio.run(replay_gemini_client(42))
- build.assert_not_called()
- assert client.raw._api_client.api_key == "replay-vision-google-key"
- assert not isinstance(client.models, _AsyncGatewayModels)
-
- def test_direct_mode_captures_with_privacy_mode_and_the_callers_properties(self, flag_on: MagicMock) -> None:
- flag_on.return_value = False
+ @pytest.mark.parametrize(
+ "build",
+ [
+ lambda: replay_gemini_client(),
+ lambda: gemini_text_models(timeout_ms=1000),
+ gemini_files_client,
+ ],
+ )
+ def test_an_unconfigured_gateway_fails_instead_of_calling_google(self, build: Callable[[], Any]) -> None:
with (
- override_settings(**_GATEWAY),
- patch("products.replay_vision.backend.gemini_client.genai.AsyncClient") as direct_client,
+ override_settings(AI_GATEWAY_URL="", AI_GATEWAY_API_KEY=""),
+ patch("posthog.llm.gateway_client.genai.Client") as sdk_client,
+ pytest.raises(GatewayNotConfiguredError),
):
- client = asyncio.run(replay_gemini_client(42, properties={"feature": "scanner"}))
- direct_client.assert_called_once_with(
- api_key="replay-vision-google-key", posthog_privacy_mode=True, posthog_properties={"feature": "scanner"}
- )
- assert client.models is direct_client.return_value.models
-
- def test_gateway_mode_needs_the_direct_key_cleanup_deletes_with(self) -> None:
- settings = {**_GATEWAY, "REPLAY_VISION_GEMINI_API_KEY": "", "GEMINI_API_KEY": "shared-key"}
- with override_settings(**settings):
- client = asyncio.run(replay_gemini_client(42))
- assert client.raw._api_client.api_key == "shared-key"
- assert not isinstance(client.models, _AsyncGatewayModels)
-
- def test_flag_is_evaluated_locally_per_org_without_events(self, flag_on: MagicMock, team_org: MagicMock) -> None:
- _gateway_client()
- team_org.objects.values_list.return_value.aget.assert_awaited_once_with(id=42)
- flag_on.assert_called_once_with(
- GATEWAY_FLAG,
- "team-42",
- groups={"organization": _ORG, "project": "42"},
- group_properties={"organization": {"id": _ORG}, "project": {"id": "42"}},
- only_evaluate_locally=True,
- send_feature_flag_events=False,
- )
+ build()
+ sdk_client.assert_not_called()
def test_per_call_capture_kwargs_become_request_headers(self) -> None:
client, seen = _wired_gateway_client({"feature": "scanner", "team_id": 42})
@@ -151,7 +104,6 @@ class TestReplayGeminiClient:
posthog_distinct_id="user-1",
posthog_trace_id="trace-1",
posthog_properties={"$ai_span_name": "core", "feature": "override"},
- posthog_groups={"project": "42"},
)
)
@@ -228,11 +180,10 @@ class TestReplayGeminiClient:
assert merged.http_options.headers == {"a": "1", "b": "2"}
-def test_pii_rewrite_uses_the_gateway_when_configured() -> None:
+def test_pii_rewrite_uses_the_gateway() -> None:
with (
override_settings(**_GATEWAY),
patch("posthog.llm.gateway_client.genai.Client") as gateway_client,
- patch("products.replay_vision.backend.gemini_client.genai.AsyncClient") as direct_client,
):
sdk = gateway_client.return_value
sdk.aio.models.generate_content_stream = AsyncMock(side_effect=RuntimeError("stop"))
@@ -240,7 +191,6 @@ def test_pii_rewrite_uses_the_gateway_when_configured() -> None:
with pytest.raises(RuntimeError):
asyncio.run(pii_check.rewrite_without_pii(team_id=1, question="q", text={"a": "b"}, trace_id="t"))
- direct_client.assert_not_called()
request_headers = sdk.aio.models.generate_content_stream.call_args.kwargs["config"].http_options.headers
assert json.loads(request_headers["X-PostHog-Properties"])["feature"] == "pii_rewrite"
assert request_headers["X-PostHog-Span-Name"] == "pii_rewrite"
@@ -248,6 +198,44 @@ def test_pii_rewrite_uses_the_gateway_when_configured() -> None:
sdk.aio.aclose.assert_awaited_once()
+def test_text_models_send_the_timeout_and_capture_headers() -> None:
+ with override_settings(**_GATEWAY), patch("posthog.llm.gateway_client.genai.Client") as gateway_client:
+ gemini_text_models(timeout_ms=1000).generate_content(
+ model="m",
+ contents="c",
+ posthog_trace_id="t",
+ posthog_properties={"feature": "prompt_question", "team_id": 42},
+ )
+
+ assert gateway_client.call_args.kwargs["http_options"].timeout == 1000
+ headers = gateway_client.return_value.models.generate_content.call_args.kwargs["config"].http_options.headers
+ assert headers["X-PostHog-Trace-Id"] == "t"
+ assert json.loads(headers["X-PostHog-Properties"]) == {
+ "feature": "prompt_question",
+ "team_id": "42",
+ "ai_product": "replay_vision",
+ }
+
+
+def test_text_models_keep_their_client_open_between_calls() -> None:
+ with override_settings(**_GATEWAY):
+ models = gemini_text_models(timeout_ms=1000)
+ gc.collect()
+ seen: list[httpx.Request] = []
+
+ def respond(request: httpx.Request) -> httpx.Response:
+ seen.append(request)
+ return _ok(request)
+
+ http_client = models._client._api_client._httpx_client
+ assert http_client is not None
+ http_client._transport = httpx.MockTransport(respond)
+
+ assert models.generate_content(model="gemini-test", contents="hi").text == "ok"
+ assert models.generate_content(model="gemini-test", contents="again").text == "ok"
+ assert len(seen) == 2
+
+
def _chunk(*parts: types.Part, finish: types.FinishReason | None = None) -> types.GenerateContentResponse:
return types.GenerateContentResponse(
candidates=[types.Candidate(content=types.Content(role="model", parts=list(parts)), finish_reason=finish)]
diff --git a/products/replay_vision/backend/tests/test_prompt_questions.py b/products/replay_vision/backend/tests/test_prompt_questions.py
index c35990d3240f..e14b668a483d 100644
--- a/products/replay_vision/backend/tests/test_prompt_questions.py
+++ b/products/replay_vision/backend/tests/test_prompt_questions.py
@@ -40,8 +40,8 @@ LONG_FIRST_LINE = "Look at " + "the checkout flow and " * 20
def _model_says(client: MagicMock, question: str, valence: str = "bad") -> None:
- client.return_value.models.generate_content.side_effect = None
- client.return_value.models.generate_content.return_value = MagicMock(
+ client.return_value.generate_content.side_effect = None
+ client.return_value.generate_content.return_value = MagicMock(
text=json.dumps({"question": question, "valence": valence})
)
@@ -54,7 +54,7 @@ class TestPromptQuestions(APIBaseTest):
estimate = patch("products.replay_vision.backend.api.scanners.refresh_scanner_estimate")
estimate.start()
self.addCleanup(estimate.stop)
- client = patch("products.replay_vision.backend.prompt_questions.genai.Client")
+ client = patch("products.replay_vision.backend.prompt_questions.gemini_text_models")
self.client_mock = client.start()
self.addCleanup(client.stop)
_model_says(self.client_mock, "Did the user struggle at checkout?")
@@ -131,7 +131,7 @@ class TestPromptQuestions(APIBaseTest):
expected_valence: str,
) -> None:
if reply is None:
- self.client_mock.return_value.models.generate_content.side_effect = RuntimeError("provider down")
+ self.client_mock.return_value.generate_content.side_effect = RuntimeError("provider down")
elif reply == "setup-fails":
self.client_mock.side_effect = ValueError("missing API key")
else:
@@ -145,7 +145,7 @@ class TestPromptQuestions(APIBaseTest):
assert (question.valence or "") == expected_valence
assert question.source == prompt_fingerprint(prompt)
if not consent:
- self.client_mock.return_value.models.generate_content.assert_not_called()
+ self.client_mock.return_value.generate_content.assert_not_called()
def test_team_over_its_hourly_budget_falls_back_without_a_model_call(self) -> None:
cache.set(_budget_key(self.team.id), MAX_MODEL_CALLS_PER_TEAM_PER_HOUR, timeout=3600)
@@ -154,7 +154,7 @@ class TestPromptQuestions(APIBaseTest):
question = condense_prompt(team_id=self.team.id, scanner_type="monitor", scanner_config={"prompt": PROMPT})
assert question.question == "Did the user struggle to complete checkout?"
- self.client_mock.return_value.models.generate_content.assert_not_called()
+ self.client_mock.return_value.generate_content.assert_not_called()
@parameterized.expand(
[
@@ -195,10 +195,10 @@ class TestPromptQuestions(APIBaseTest):
assert scanner.prompt_question == "Did the user struggle at checkout?"
assert scanner.prompt_question_source == prompt_fingerprint(PROMPT)
- calls = self.client_mock.return_value.models.generate_content.call_count
+ calls = self.client_mock.return_value.generate_content.call_count
renamed = self.client.patch(f"{self.scanners_url}{scanner.id}/", data={"name": "renamed"}, format="json")
assert renamed.status_code == 200, renamed.json()
- assert self.client_mock.return_value.models.generate_content.call_count == calls
+ assert self.client_mock.return_value.generate_content.call_count == calls
_model_says(self.client_mock, "Did the user abandon their cart?")
edited = self.client.patch(
@@ -278,13 +278,13 @@ class TestPromptQuestions(APIBaseTest):
dry = backfill_prompt_questions(team_id=self.team.id, dry_run=True)
assert (dry.checked, dry.written) == (4, 3)
assert ReplayScanner.objects.get(pk=stale.pk).prompt_question == ""
- self.client_mock.return_value.models.generate_content.reset_mock()
+ self.client_mock.return_value.generate_content.reset_mock()
result = backfill_prompt_questions(team_id=self.team.id)
assert result.written == 3
# The copy shares the stale scanner's call; the unjudged scanner sends its kept question.
- calls = self.client_mock.return_value.models.generate_content.call_args_list
+ calls = self.client_mock.return_value.generate_content.call_args_list
assert ["Judged before valence?" in call.kwargs["contents"] for call in calls] == [False, True]
assert ReplayScanner.objects.get(pk=copy.pk).prompt_question == "Did the user struggle at checkout?"
stale.refresh_from_db()
@@ -308,7 +308,7 @@ class TestPromptQuestions(APIBaseTest):
backfill_prompt_questions()
- assert self.client_mock.return_value.models.generate_content.call_count == 2
+ assert self.client_mock.return_value.generate_content.call_count == 2
def test_backfill_retries_the_model_for_each_scanner_after_a_failed_call(self) -> None:
unjudged = self._scanner(name="unjudged")
@@ -317,7 +317,7 @@ class TestPromptQuestions(APIBaseTest):
prompt_question="Judged before valence?", prompt_question_source=prompt_fingerprint(PROMPT)
)
reply = MagicMock(text=json.dumps({"question": "Did the user struggle at checkout?", "valence": "bad"}))
- self.client_mock.return_value.models.generate_content.side_effect = [RuntimeError("provider down"), reply]
+ self.client_mock.return_value.generate_content.side_effect = [RuntimeError("provider down"), reply]
result = backfill_prompt_questions(team_id=self.team.id)
@@ -328,7 +328,7 @@ class TestPromptQuestions(APIBaseTest):
assert (retried.prompt_question, retried.prompt_valence) == ("Judged before valence?", "bad")
def test_inline_scanners_only_ever_get_a_built_in_question(self) -> None:
- self.client_mock.return_value.models.generate_content.reset_mock()
+ self.client_mock.return_value.generate_content.reset_mock()
summarize = create_inline_scanner(
team=self.team,
key="summarize-button",
@@ -351,4 +351,4 @@ class TestPromptQuestions(APIBaseTest):
assert result.written == 1
assert ReplayScanner.all_origins.get(pk=summarize.pk).prompt_question == SUMMARY.question
assert ReplayScanner.all_origins.get(pk=custom.pk).prompt_question == ""
- self.client_mock.return_value.models.generate_content.assert_not_called()
+ self.client_mock.return_value.generate_content.assert_not_called()
diff --git a/products/replay_vision/backend/tests/test_scanner_draft.py b/products/replay_vision/backend/tests/test_scanner_draft.py
index a8c7161cf0c8..fe461f4b6d4c 100644
--- a/products/replay_vision/backend/tests/test_scanner_draft.py
+++ b/products/replay_vision/backend/tests/test_scanner_draft.py
@@ -343,12 +343,12 @@ class TestDraftGrounding(_VisionAPITestCase):
class TestGenerate:
def _mock_client(self, mock_client_cls: MagicMock, side_effect: list) -> MagicMock:
- generate = mock_client_cls.return_value.models.generate_content
+ generate = mock_client_cls.return_value.generate_content
generate.side_effect = side_effect
return generate
@parameterized.expand([("quick_blip", 0.5, 2), ("slow_timeout", 60.0, 1)])
- @patch("products.replay_vision.backend.scanner_draft.genai.Client")
+ @patch("products.replay_vision.backend.scanner_draft.gemini_text_models")
def test_retries_only_a_quick_failure(self, _name, failure_seconds, expected_calls, mock_client_cls):
response = MagicMock(text=_draft().model_dump_json())
generate = self._mock_client(mock_client_cls, [RuntimeError("blip"), response])
@@ -362,7 +362,7 @@ class TestGenerate:
assert generate.call_count == expected_calls
- @patch("products.replay_vision.backend.scanner_draft.genai.Client")
+ @patch("products.replay_vision.backend.scanner_draft.gemini_text_models")
def test_gives_up_after_the_second_failure(self, mock_client_cls):
generate = self._mock_client(mock_client_cls, [RuntimeError("blip"), RuntimeError("blip")])
@@ -371,7 +371,7 @@ class TestGenerate:
assert generate.call_count == 2
- @patch("products.replay_vision.backend.scanner_draft.genai.Client")
+ @patch("products.replay_vision.backend.scanner_draft.gemini_text_models")
def test_caps_output_tokens(self, mock_client_cls):
response = MagicMock(text=_draft().model_dump_json())
generate = self._mock_client(mock_client_cls, [response])
@@ -381,7 +381,7 @@ class TestGenerate:
assert generate.call_args.kwargs["config"].max_output_tokens == _MAX_OUTPUT_TOKENS
assert generate.call_args.kwargs["config"].thinking_config is None
- @patch("products.replay_vision.backend.scanner_draft.genai.Client")
+ @patch("products.replay_vision.backend.scanner_draft.gemini_text_models")
def test_a_thinking_budget_reaches_the_model_config(self, mock_client_cls):
response = MagicMock(text=_draft().model_dump_json())
generate = self._mock_client(mock_client_cls, [response])
@@ -390,7 +390,7 @@ class TestGenerate:
assert generate.call_args.kwargs["config"].thinking_config.thinking_budget == 512
- @patch("products.replay_vision.backend.scanner_draft.genai.Client")
+ @patch("products.replay_vision.backend.scanner_draft.gemini_text_models")
def test_output_cut_off_by_the_token_budget_is_its_own_failure(self, mock_client_cls):
# Thinking shares the output budget, so a truncated draft is our cap's fault, not a bad
# model response — the two used to be indistinguishable as "invalid_response".
@@ -611,7 +611,7 @@ class TestDraftScannerEndpoint(_VisionAPITestCase):
assert "model down" not in resp.content.decode()
@patch(
- "products.replay_vision.backend.scanner_draft.genai.Client",
+ "products.replay_vision.backend.scanner_draft.gemini_text_models",
side_effect=ValueError("Missing key inputs argument!"),
)
def test_client_construction_failure_is_a_clean_503(self, _mock):
diff --git a/products/replay_vision/backend/tests/test_temporal.py b/products/replay_vision/backend/tests/test_temporal.py
index a104d62730b4..8a82e581774f 100644
--- a/products/replay_vision/backend/tests/test_temporal.py
+++ b/products/replay_vision/backend/tests/test_temporal.py
@@ -1033,7 +1033,7 @@ class TestEgressConsentRecheck:
team = await sync_to_async(self._team_without_consent)()
# The activity derives the team from the asset row (no team_id in the payload), so it must exist.
asset = await ExportedAsset.objects.acreate(team=team, export_format="video/mp4")
- with patch("products.replay_vision.backend.gemini_client.RawGenAIClient") as mock_client:
+ with patch("products.replay_vision.backend.gemini_client.build_gemini_client") as mock_client:
with pytest.raises(ConsentWithdrawnError) as exc_info:
await ActivityEnvironment().run(
upload_video_to_gemini_activity,
@@ -2719,7 +2719,7 @@ class TestCleanupGeminiFileActivity:
await gemini_redis.zadd(_GEMINI_REDIS_INDEX_KEY, {"files/rv-ok": 0.0})
fake_client = MagicMock()
with patch(
- "products.replay_vision.backend.temporal.activities.cleanup_gemini_file.RawGenAIClient",
+ "products.replay_vision.backend.temporal.activities.cleanup_gemini_file.gemini_files_client",
return_value=fake_client,
):
await cleanup_gemini_file_activity(CleanupGeminiFileInputs(gemini_file_name="files/rv-ok"))
@@ -2734,7 +2734,7 @@ class TestCleanupGeminiFileActivity:
fake_client = MagicMock()
fake_client.files.delete.side_effect = RuntimeError("gemini down")
with patch(
- "products.replay_vision.backend.temporal.activities.cleanup_gemini_file.RawGenAIClient",
+ "products.replay_vision.backend.temporal.activities.cleanup_gemini_file.gemini_files_client",
return_value=fake_client,
):
await cleanup_gemini_file_activity(CleanupGeminiFileInputs(gemini_file_name="files/rv-transient"))
@@ -2751,13 +2751,29 @@ class TestCleanupGeminiFileActivity:
fake_client = MagicMock()
fake_client.files.delete.side_effect = APIError(code=code, response_json={})
with patch(
- "products.replay_vision.backend.temporal.activities.cleanup_gemini_file.RawGenAIClient",
+ "products.replay_vision.backend.temporal.activities.cleanup_gemini_file.gemini_files_client",
return_value=fake_client,
):
await cleanup_gemini_file_activity(CleanupGeminiFileInputs(gemini_file_name="files/rv-gone"))
assert await gemini_redis.exists(f"{_GEMINI_REDIS_KEY_PREFIX}files/rv-gone") == 0
assert await gemini_redis.zscore(_GEMINI_REDIS_INDEX_KEY, "files/rv-gone") is None
+ @pytest.mark.parametrize("code", [403, 404])
+ @pytest.mark.asyncio
+ async def test_keeps_tracking_when_the_gateway_refuses_the_delete(self, gemini_redis, code: int) -> None:
+ await gemini_redis.set(f"{_GEMINI_REDIS_KEY_PREFIX}files/rv-refused", "{}")
+ await gemini_redis.zadd(_GEMINI_REDIS_INDEX_KEY, {"files/rv-refused": 0.0})
+ fake_client = MagicMock()
+ fake_client.files.delete.side_effect = APIError(
+ code=code, response_json={"error": {"code": code, "details": [{"domain": "posthog.com"}]}}
+ )
+ with patch(
+ "products.replay_vision.backend.temporal.activities.cleanup_gemini_file.gemini_files_client",
+ return_value=fake_client,
+ ):
+ await cleanup_gemini_file_activity(CleanupGeminiFileInputs(gemini_file_name="files/rv-refused"))
+ assert await gemini_redis.exists(f"{_GEMINI_REDIS_KEY_PREFIX}files/rv-refused") == 1
+
def _build_inputs(**overrides: Any) -> ApplyScannerInputs:
defaults: dict[str, Any] = {
@@ -3718,10 +3734,7 @@ class TestUploadedFileNotActive:
state=types.FileState.FAILED,
error=types.FileStatus(code=code, message="the provider quoted 'wf-secret-name' back at us"),
)
- with (
- patch("products.replay_vision.backend.gemini_client.RawGenAIClient") as mock_client,
- patch("products.replay_vision.backend.gemini_client.genai.AsyncClient"),
- ):
+ with patch("products.replay_vision.backend.gemini_client.build_gemini_client") as mock_client:
mock_client.return_value.files.upload.return_value = failed_file
mock_client.return_value.aio.aclose = AsyncMock()
with patch(
@@ -3748,7 +3761,7 @@ class TestUploadThroughTheGateway:
return Team.objects.create(organization=org, name="gateway-upload-team")
@pytest.mark.asyncio
- async def test_the_upload_runs_on_the_teams_client_and_closes_it(self) -> None:
+ async def test_the_upload_runs_on_the_gateway_client_and_closes_it(self) -> None:
team = await sync_to_async(self._team)()
asset = await ExportedAsset.objects.acreate(team=team, export_format="video/mp4", content=b"mp4-bytes")
uri = "https://generativelanguage.googleapis.com/v1beta/files/abc"
@@ -3760,7 +3773,7 @@ class TestUploadThroughTheGateway:
)
module = "products.replay_vision.backend.temporal.activities.upload_video_to_gemini"
with (
- patch(f"{module}.replay_gemini_client", new=AsyncMock(return_value=gemini)) as factory,
+ patch(f"{module}.replay_gemini_client", return_value=gemini),
patch(f"{module}.track_uploaded_file", AsyncMock()),
patch(f"{module}.asyncio.sleep", AsyncMock()),
):
@@ -3768,7 +3781,6 @@ class TestUploadThroughTheGateway:
upload_video_to_gemini_activity, UploadVideoToGeminiInputs(asset_id=asset.id)
)
- factory.assert_awaited_once_with(team.id)
upload = gemini.raw.files.upload.call_args.kwargs
assert "http_options" not in upload and upload["config"].http_options is None
assert upload["config"].mime_type == "video/mp4"
@@ -3776,35 +3788,6 @@ class TestUploadThroughTheGateway:
assert (uploaded.file_uri, uploaded.gemini_file_name) == (uri, "files/abc")
gemini.aclose.assert_awaited_once()
- @pytest.mark.asyncio
- async def test_flag_off_uploads_direct_with_the_gateway_configured(self) -> None:
- team = await sync_to_async(self._team)()
- asset = await ExportedAsset.objects.acreate(team=team, export_format="video/mp4", content=b"mp4-bytes")
- module = "products.replay_vision.backend.temporal.activities.upload_video_to_gemini"
- gateway_settings = {
- "AI_GATEWAY_URL": "https://ai-gateway.example/v1",
- "AI_GATEWAY_API_KEY": "phs_gateway",
- "REPLAY_VISION_GEMINI_API_KEY": "replay-vision-google-key",
- }
- with (
- override_settings(**gateway_settings),
- patch("products.replay_vision.backend.gemini_client.feature_enabled_or_false", return_value=False),
- patch("products.replay_vision.backend.gemini_client.build_gemini_client") as build,
- patch("products.replay_vision.backend.gemini_client.RawGenAIClient") as raw_client,
- patch(f"{module}.track_uploaded_file", AsyncMock()),
- ):
- raw_client.return_value.aio.aclose = AsyncMock()
- raw_client.return_value.files.upload.return_value = types.File(
- name="files/abc", state=types.FileState.ACTIVE, uri="https://g/files/abc"
- )
- uploaded = await ActivityEnvironment().run(
- upload_video_to_gemini_activity, UploadVideoToGeminiInputs(asset_id=asset.id)
- )
-
- raw_client.assert_called_once_with(api_key="replay-vision-google-key")
- build.assert_not_called()
- assert uploaded.gemini_file_name == "files/abc"
-
class TestGeminiErrorRedaction:
"""`error_reason` is shown to the user verbatim, and a Gemini error body can quote request content
diff --git a/products/replay_vision/backend/tests/test_watch_semantics.py b/products/replay_vision/backend/tests/test_watch_semantics.py
index 34cb838c2d3e..6e98ce8aa49d 100644
--- a/products/replay_vision/backend/tests/test_watch_semantics.py
+++ b/products/replay_vision/backend/tests/test_watch_semantics.py
@@ -353,7 +353,7 @@ class TestAssignSemantics(BaseTest):
client = MagicMock(aclose=AsyncMock())
client.models.generate_content = AsyncMock(side_effect=[RuntimeError("model unavailable"), response])
with (
- patch(f"{_THEMES}.replay_gemini_client", AsyncMock(return_value=client)),
+ patch(f"{_THEMES}.replay_gemini_client", MagicMock(return_value=client)),
patch(f"{_THEMES}.is_ai_data_processing_approved", return_value=True),
):
with self.assertRaises(RuntimeError):
@@ -381,7 +381,7 @@ class TestAssignSemantics(BaseTest):
client = MagicMock(aclose=AsyncMock())
client.models.generate_content = AsyncMock(side_effect=doubled_then_failed)
with (
- patch(f"{_THEMES}.replay_gemini_client", AsyncMock(return_value=client)),
+ patch(f"{_THEMES}.replay_gemini_client", MagicMock(return_value=client)),
patch(f"{_THEMES}.is_ai_data_processing_approved", return_value=True),
self.assertRaises(RuntimeError),
):
diff --git a/products/replay_vision/backend/watch_themes.py b/products/replay_vision/backend/watch_themes.py
index a2af67333375..314bc14bf1f3 100644
--- a/products/replay_vision/backend/watch_themes.py
+++ b/products/replay_vision/backend/watch_themes.py
@@ -276,9 +276,7 @@ async def name_theme(team_id: int, theme_id: uuid.UUID, now: datetime) -> str |
scanner, samples = context
prompt = (scanner.scanner_config or {}).get("prompt") if isinstance(scanner.scanner_config, dict) else None
try:
- client = await replay_gemini_client(
- team_id, properties={"ai_product": AI_PRODUCT, "feature": "name_search_theme"}
- )
+ client = replay_gemini_client(properties={"ai_product": AI_PRODUCT, "feature": "name_search_theme"})
try:
response = await client.models.generate_content(
model=_THEME_MODEL,
@@ -295,7 +293,6 @@ async def name_theme(team_id: int, theme_id: uuid.UUID, now: datetime) -> str |
posthog_distinct_id=replay_vision_distinct_id(team_id),
posthog_trace_id=str(uuid.uuid4()),
posthog_properties={"$ai_span_name": "name_search_theme", "team_id": team_id},
- posthog_groups={"project": str(team_id)},
)
finally:
await client.aclose()