diff --git a/.github/workflows/e2e-source-of-truth-api-tests.yaml b/.github/workflows/e2e-source-of-truth-api-tests.yaml
deleted file mode 100644
index 46f5cebfc5..0000000000
--- a/.github/workflows/e2e-source-of-truth-api-tests.yaml
+++ /dev/null
@@ -1,178 +0,0 @@
-name: Runs E2E API Tests with external source of truth
-
-on:
-  push:
-    branches:
-      - main
-      - dev
-  pull_request:
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: ${{ github.ref != 'refs/heads/main' && github.ref != 'refs/heads/dev' }}
-
-jobs:
-  build:
-    runs-on: ubicloud-standard-8
-    env:
-      NODE_ENV: test
-      STACK_ENABLE_HARDCODED_PASSKEY_CHALLENGE_FOR_TESTING: yes
-      STACK_ACCESS_TOKEN_EXPIRATION_TIME: 30m
-      STACK_OVERRIDE_SOURCE_OF_TRUTH: '{"type": "postgres", "connectionString": "postgres://postgres:PASSWORD-PLACEHOLDER--uqfEC1hmmv@localhost:8128/source-of-truth-db?schema=sot-schema"}'
-      STACK_TEST_SOURCE_OF_TRUTH: true
-      STACK_DATABASE_CONNECTION_STRING: "postgres://postgres:PASSWORD-PLACEHOLDER--uqfEC1hmmv@localhost:8128/stackframe"
-      STACK_EXTERNAL_DB_SYNC_MAX_DURATION_MS: "20000"
-      STACK_EXTERNAL_DB_SYNC_DIRECT: "false"
-
-    strategy:
-      matrix:
-        node-version: [22.x]
-
-    steps:
-      - uses: actions/checkout@v6
-
-      - name: Setup Node.js ${{ matrix.node-version }}
-        uses: actions/setup-node@v6
-        with:
-          node-version: ${{ matrix.node-version }}
-
-      - name: Setup pnpm
-        uses: pnpm/action-setup@v4
-
-      # Even just starting the Docker Compose as a daemon is slow because we have to download and build the images
-      # so, we run it in the background
-      - name: Start Docker Compose in background
-        uses: JarvusInnovations/background-action@v1.0.7
-        with:
-          run: docker compose -f docker/dependencies/docker.compose.yaml up -d &
-          # we don't need to wait on anything, just need to start the daemon
-          wait-on: /dev/null
-          tail: true
-          wait-for: 3s
-          log-output-if: true
-
-      - name: Install dependencies
-        run: pnpm install --frozen-lockfile
-
-      - name: Create .env.test.local file for apps/backend
-        run: cp apps/backend/.env.development apps/backend/.env.test.local
-
-      - name: Create .env.test.local file for apps/dashboard
-        run: cp apps/dashboard/.env.development apps/dashboard/.env.test.local
-      
-      - name: Create .env.test.local file for apps/e2e
-        run: cp apps/e2e/.env.development apps/e2e/.env.test.local
-
-      - name: Create .env.test.local file for docs
-        run: cp docs/.env.development docs/.env.test.local
-
-      - name: Create .env.test.local file for examples/cjs-test
-        run: cp examples/cjs-test/.env.development examples/cjs-test/.env.test.local
-      
-      - name: Create .env.test.local file for examples/demo
-        run: cp examples/demo/.env.development examples/demo/.env.test.local
-
-      - name: Create .env.test.local file for examples/docs-examples
-        run: cp examples/docs-examples/.env.development examples/docs-examples/.env.test.local
-
-      - name: Create .env.test.local file for examples/e-commerce
-        run: cp examples/e-commerce/.env.development examples/e-commerce/.env.test.local
-
-      - name: Create .env.test.local file for examples/middleware
-        run: cp examples/middleware/.env.development examples/middleware/.env.test.local
-
-      - name: Create .env.test.local file for examples/supabase
-        run: cp examples/supabase/.env.development examples/supabase/.env.test.local
-      
-      - name: Create .env.test.local file for examples/convex
-        run: cp examples/convex/.env.development examples/convex/.env.test.local
-
-      - name: Build
-        run: pnpm build
-
-      - name: Wait on Postgres
-        run: pnpm run wait-until-postgres-is-ready:pg_isready
-
-      - name: Wait on Inbucket
-        run: pnpx wait-on tcp:localhost:8129
-
-      - name: Wait on Svix
-        run: pnpx wait-on tcp:localhost:8113
-      
-      - name: Wait on QStash
-        run: pnpx wait-on tcp:localhost:8125
-
-      - name: Create source-of-truth database and schema
-        run: |
-          psql postgres://postgres:PASSWORD-PLACEHOLDER--uqfEC1hmmv@localhost:8128/postgres -c "CREATE DATABASE \"source-of-truth-db\";"
-          psql postgres://postgres:PASSWORD-PLACEHOLDER--uqfEC1hmmv@localhost:8128/source-of-truth-db -c "CREATE SCHEMA \"sot-schema\";"
-
-      - name: Initialize database
-        run: pnpm run db:init
-
-      - name: Start stack-backend in background
-        uses: JarvusInnovations/background-action@v1.0.7
-        with:
-          run: pnpm run start:backend --log-order=stream &
-          wait-on: |
-            http://localhost:8102
-          tail: true
-          wait-for: 30s
-          log-output-if: true
-      - name: Start stack-dashboard in background
-        uses: JarvusInnovations/background-action@v1.0.7
-        with:
-          run: pnpm run start:dashboard --log-order=stream &
-          wait-on: |
-            http://localhost:8101
-          tail: true
-          wait-for: 30s
-          log-output-if: true
-      - name: Start mock-oauth-server in background
-        uses: JarvusInnovations/background-action@v1.0.7
-        with:
-          run: pnpm run start:mock-oauth-server --log-order=stream &
-          wait-on: |
-            http://localhost:8102
-          tail: true
-          wait-for: 30s
-          log-output-if: true
-      - name: Start run-email-queue in background
-        uses: JarvusInnovations/background-action@v1.0.7
-        with:
-          run: pnpm -C apps/backend run run-email-queue --log-order=stream &
-          wait-on: |
-            http://localhost:8102
-          tail: true
-          wait-for: 30s
-          log-output-if: true
-      - name: Start run-cron-jobs in background
-        uses: JarvusInnovations/background-action@v1.0.7
-        with:
-          run: pnpm -C apps/backend run run-cron-jobs --log-order=stream &
-          wait-on: |
-            http://localhost:8102
-          tail: true
-          wait-for: 30s
-          log-output-if: true
-
-      - name: Wait 10 seconds
-        run: sleep 10
-
-      - name: Run tests
-        run: pnpm test run --exclude "**/external-db-sync*.test.ts" # external-db-sync does not support external sot
-
-      - name: Run tests again (attempt 1)
-        if: github.ref == 'refs/heads/main' || github.ref == 'refs/heads/dev'
-        run: pnpm test run --exclude "**/external-db-sync*.test.ts"
-
-      - name: Run tests again (attempt 2)
-        if: github.ref == 'refs/heads/main' || github.ref == 'refs/heads/dev'
-        run: pnpm test run --exclude "**/external-db-sync*.test.ts"
-
-      - name: Verify data integrity
-        run: pnpm run verify-data-integrity --no-bail
-
-      - name: Print Docker Compose logs
-        if: always()
-        run: docker compose -f docker/dependencies/docker.compose.yaml logs
diff --git a/.vscode/settings.json b/.vscode/settings.json
index 1fda6ee8b4..34a264f5da 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -174,5 +174,6 @@
     "((?:<!-- *)?(?:#|// @|//|./\\*+|<!--|--|\\* @|{!|{{!--|{{!) *(?:IDEA)(?:\\s*\\([^)]+\\))?:?)((?!\\w)(?: *-->| *\\*/| *!}| *--}}| *}}|(?= *(?:[^:]//|/\\*+|<!--|@|--|{!|{{!--|{{!))|(?: +[^\\n@]*?)(?= *(?:[^:]//|/\\*+|<!--|@|--(?!>)|{!|{{!--|{{!))|(?: +[^@\\n]+)?))": [],
   },
   "editor.formatOnSaveMode": "file",
-  "git.ignoreLimitWarning": true
+  "git.ignoreLimitWarning": true,
+  "chatgpt.commentCodeLensEnabled": false
 }
diff --git a/apps/backend/scripts/clickhouse-migrations.ts b/apps/backend/scripts/clickhouse-migrations.ts
index ce90082807..318c7d4e92 100644
--- a/apps/backend/scripts/clickhouse-migrations.ts
+++ b/apps/backend/scripts/clickhouse-migrations.ts
@@ -11,16 +11,24 @@ export async function runClickhouseMigrations() {
   });
   // todo: create migration files
   await client.exec({ query: EXTERNAL_ANALYTICS_DB_SQL });
+  await client.exec({ query: SYNC_METADATA_TABLE_SQL });
   await client.exec({ query: EVENTS_TABLE_BASE_SQL });
   await client.exec({ query: EVENTS_VIEW_SQL });
+  await client.exec({ query: USERS_TABLE_BASE_SQL });
+  await client.exec({ query: USERS_VIEW_SQL });
+  await client.exec({ query: TOKEN_REFRESH_EVENT_ROW_FORMAT_MUTATION_SQL });
   const queries = [
     "REVOKE ALL PRIVILEGES ON *.* FROM limited_user;",
     "REVOKE ALL FROM limited_user;",
     "GRANT SELECT ON default.events TO limited_user;",
+    "GRANT SELECT ON default.users TO limited_user;",
   ];
   await client.exec({
     query: "CREATE ROW POLICY IF NOT EXISTS events_project_isolation ON default.events FOR SELECT USING project_id = getSetting('SQL_project_id') AND branch_id = getSetting('SQL_branch_id') TO limited_user",
   });
+  await client.exec({
+    query: "CREATE ROW POLICY IF NOT EXISTS users_project_isolation ON default.users FOR SELECT USING project_id = getSetting('SQL_project_id') AND branch_id = getSetting('SQL_branch_id') TO limited_user",
+  });
   for (const query of queries) {
     await client.exec({ query });
   }
@@ -52,6 +60,101 @@ SELECT *
 FROM analytics_internal.events;
 `;
 
+// Normalizes legacy $token-refresh rows (camelCase JSON) to the new format:
+// - Row identity stays in columns (project_id/branch_id/user_id)
+// - data JSON becomes { refresh_token_id, is_anonymous, ip_info } (snake_case)
+// Assumption: all legacy rows have the camelCase format.
+const TOKEN_REFRESH_EVENT_ROW_FORMAT_MUTATION_SQL = `
+ALTER TABLE analytics_internal.events
+UPDATE
+  data = CAST(concat(
+    '{',
+      '\"refresh_token_id\":', toJSONString(JSONExtractString(toJSONString(data), 'refreshTokenId')), ',',
+      '\"is_anonymous\":', toJSONString(JSONExtract(toJSONString(data), 'isAnonymous', 'Bool')), ',',
+      '\"ip_info\":', if(
+        JSONExtractString(toJSONString(data), 'ipInfo.ip') = '',
+        'null',
+        concat(
+          '{',
+            '\"ip\":', toJSONString(JSONExtractString(toJSONString(data), 'ipInfo.ip')), ',',
+            '\"is_trusted\":', toJSONString(JSONExtract(toJSONString(data), 'ipInfo.isTrusted', 'Bool')), ',',
+            '\"country_code\":', toJSONString(JSONExtract(toJSONString(data), 'ipInfo.countryCode', 'Nullable(String)')), ',',
+            '\"region_code\":', toJSONString(JSONExtract(toJSONString(data), 'ipInfo.regionCode', 'Nullable(String)')), ',',
+            '\"city_name\":', toJSONString(JSONExtract(toJSONString(data), 'ipInfo.cityName', 'Nullable(String)')), ',',
+            '\"latitude\":', toJSONString(JSONExtract(toJSONString(data), 'ipInfo.latitude', 'Nullable(Float64)')), ',',
+            '\"longitude\":', toJSONString(JSONExtract(toJSONString(data), 'ipInfo.longitude', 'Nullable(Float64)')), ',',
+            '\"tz_identifier\":', toJSONString(JSONExtract(toJSONString(data), 'ipInfo.tzIdentifier', 'Nullable(String)')),
+          '}'
+        )
+      ),
+    '}'
+  ) AS JSON)
+WHERE event_type = '$token-refresh'
+  AND JSONHas(toJSONString(data), 'refreshTokenId');
+`;
+
+const USERS_TABLE_BASE_SQL = `
+CREATE TABLE IF NOT EXISTS analytics_internal.users (
+    project_id String,
+    branch_id String,
+    id UUID,
+    display_name Nullable(String),
+    profile_image_url Nullable(String),
+    primary_email Nullable(String),
+    primary_email_verified UInt8,
+    signed_up_at DateTime64(3, 'UTC'),
+    client_metadata JSON,
+    client_read_only_metadata JSON,
+    server_metadata JSON,
+    is_anonymous UInt8,
+    restricted_by_admin UInt8,
+    restricted_by_admin_reason Nullable(String),
+    restricted_by_admin_private_details Nullable(String),
+    sync_sequence_id Int64,
+    sync_is_deleted UInt8,
+    sync_created_at DateTime64(3, 'UTC') DEFAULT now64(3)
+)
+ENGINE ReplacingMergeTree(sync_sequence_id)
+PARTITION BY toYYYYMM(signed_up_at)
+ORDER BY (project_id, branch_id, id);
+`;
+
+const USERS_VIEW_SQL = `
+CREATE OR REPLACE VIEW default.users 
+SQL SECURITY DEFINER
+AS
+SELECT
+  project_id,
+  branch_id,
+  id,
+  display_name,
+  profile_image_url,
+  primary_email,
+  primary_email_verified,
+  signed_up_at,
+  client_metadata,
+  client_read_only_metadata,
+  server_metadata,
+  is_anonymous,
+  restricted_by_admin,
+  restricted_by_admin_reason,
+  restricted_by_admin_private_details
+FROM analytics_internal.users
+FINAL
+WHERE sync_is_deleted = 0;
+`;
+
+const SYNC_METADATA_TABLE_SQL = `
+CREATE TABLE IF NOT EXISTS analytics_internal._stack_sync_metadata (
+    tenancy_id UUID,
+    mapping_name String,
+    last_synced_sequence_id Int64,
+    updated_at DateTime64(3, 'UTC') DEFAULT now64(3)
+)
+ENGINE ReplacingMergeTree(updated_at)
+ORDER BY (tenancy_id, mapping_name);
+`;
+
 const EXTERNAL_ANALYTICS_DB_SQL = `
 CREATE DATABASE IF NOT EXISTS analytics_internal;
 `;
diff --git a/apps/backend/src/app/api/latest/internal/clickhouse/migrate-events/route.tsx b/apps/backend/src/app/api/latest/internal/clickhouse/migrate-events/route.tsx
deleted file mode 100644
index bc6caf484b..0000000000
--- a/apps/backend/src/app/api/latest/internal/clickhouse/migrate-events/route.tsx
+++ /dev/null
@@ -1,227 +0,0 @@
-import type { Prisma } from "@/generated/prisma/client";
-import { getClickhouseAdminClient } from "@/lib/clickhouse";
-import { endUserIpInfoSchema, type EndUserIpInfo } from "@/lib/events";
-import { DEFAULT_BRANCH_ID } from "@/lib/tenancies";
-import { globalPrismaClient } from "@/prisma-client";
-import { createSmartRouteHandler } from "@/route-handlers/smart-route-handler";
-import { yupNumber, yupObject, yupString } from "@stackframe/stack-shared/dist/schema-fields";
-import { StackAssertionError, StatusError, throwErr } from "@stackframe/stack-shared/dist/utils/errors";
-
-type Cursor = {
-  created_at_millis: number,
-  id: string,
-};
-
-const parseMillisOrThrow = (value: number | undefined, field: string) => {
-  if (typeof value !== "number" || !Number.isFinite(value)) {
-    throw new StatusError(400, `Invalid ${field}`);
-  }
-  const parsed = new Date(value);
-  if (Number.isNaN(parsed.getTime())) {
-    throw new StatusError(400, `Invalid ${field}`);
-  }
-  return parsed;
-};
-
-type EventWithIpInfo = {
-  id: string,
-  systemEventTypeIds: string[],
-  data: unknown,
-  eventEndedAt: Date,
-  eventStartedAt: Date,
-  isWide: boolean,
-  isEndUserIpInfoGuessTrusted: boolean,
-  endUserIpInfoGuess: {
-    ip: string,
-    countryCode: string | null,
-    regionCode: string | null,
-    cityName: string | null,
-    latitude: number | null,
-    longitude: number | null,
-    tzIdentifier: string | null,
-  } | null,
-};
-
-/**
- * Transforms a $session-activity event from Postgres into a $token-refresh event for ClickHouse.
- *
- * The $session-activity event has:
- * - sessionId (from SessionActivityEventType)
- * - userId, branchId, isAnonymous, teamId (from UserActivityEventType)
- * - projectId (from ProjectEventType via inheritance)
- *
- * The $token-refresh event needs:
- * - projectId, branchId, organizationId (null), userId, refreshTokenId, isAnonymous, ipInfo
- */
-const createClickhouseRow = (event: EventWithIpInfo) => {
-  const dataRecord = typeof event.data === "object" && event.data !== null ? event.data as Record<string, unknown> : {};
-
-  // Extract fields from the old $session-activity format
-  const projectId = typeof dataRecord.projectId === "string" ? dataRecord.projectId : throwErr(new StackAssertionError("projectId is required"));
-  const branchId = typeof dataRecord.branchId === "string" ? dataRecord.branchId : DEFAULT_BRANCH_ID;
-  const userId = typeof dataRecord.userId === "string" && dataRecord.userId ? dataRecord.userId : throwErr(new StackAssertionError("userId is required"));
-  // sessionId becomes refreshTokenId in the new schema
-  const refreshTokenId = typeof dataRecord.sessionId === "string" ? dataRecord.sessionId : throwErr(new StackAssertionError("sessionId is required"));
-  // isAnonymous may not exist on old events, default to false
-  const isAnonymous = typeof dataRecord.isAnonymous === "boolean" ? dataRecord.isAnonymous : false;
-
-  // Build ipInfo from the event's endUserIpInfoGuess relation
-  let ipInfo: EndUserIpInfo | null = null;
-  if (event.endUserIpInfoGuess) {
-    const ip = event.endUserIpInfoGuess;
-    ipInfo = {
-      ip: ip.ip,
-      isTrusted: event.isEndUserIpInfoGuessTrusted,
-      countryCode: ip.countryCode ?? undefined,
-      regionCode: ip.regionCode ?? undefined,
-      cityName: ip.cityName ?? undefined,
-      latitude: ip.latitude ?? undefined,
-      longitude: ip.longitude ?? undefined,
-      tzIdentifier: ip.tzIdentifier ?? undefined,
-    };
-    // Validate against schema
-    ipInfo = endUserIpInfoSchema.nullable().defined().validateSync(ipInfo, { stripUnknown: true });
-  }
-
-  // Build the data object matching TokenRefreshEventType schema
-  const tokenRefreshData = {
-    projectId,
-    branchId,
-    organizationId: null,
-    userId: userId,
-    refreshTokenId,
-    isAnonymous,
-    ipInfo,
-  };
-
-  return {
-    event_type: '$token-refresh',
-    event_at: event.eventEndedAt,
-    data: tokenRefreshData,
-    project_id: projectId,
-    branch_id: branchId,
-    user_id: userId,
-    team_id: null,
-  };
-};
-
-export const POST = createSmartRouteHandler({
-  metadata: {
-    summary: "Migrate analytics events from Postgres to ClickHouse",
-    description: "Internal-only endpoint to backfill existing events into ClickHouse.",
-    hidden: true,
-  },
-  request: yupObject({
-    auth: yupObject({
-      project: yupObject({
-        id: yupString().oneOf(["internal"]).defined(),
-      }).defined(),
-      user: yupObject({
-        id: yupString().defined(),
-      }).optional(),
-    }).defined(),
-    body: yupObject({
-      min_created_at_millis: yupNumber().integer().defined(),
-      max_created_at_millis: yupNumber().integer().defined(),
-      cursor: yupObject({
-        created_at_millis: yupNumber().integer().defined(),
-        id: yupString().uuid().defined(),
-      }).optional(),
-      limit: yupNumber().integer().min(1).default(1000),
-    }).defined(),
-  }),
-  response: yupObject({
-    statusCode: yupNumber().oneOf([200]).defined(),
-    bodyType: yupString().oneOf(["json"]).defined(),
-    body: yupObject({
-      migrated_events: yupNumber().defined(),
-      inserted_rows: yupNumber().defined(),
-      next_cursor: yupObject({
-        created_at_millis: yupNumber().integer().defined(),
-        id: yupString().defined(),
-      }).nullable().defined(),
-    }).defined(),
-  }),
-  async handler({ body }) {
-    const minCreatedAt = parseMillisOrThrow(body.min_created_at_millis, "min_created_at_millis");
-    const maxCreatedAt = parseMillisOrThrow(body.max_created_at_millis, "max_created_at_millis");
-    if (minCreatedAt >= maxCreatedAt) {
-      throw new StatusError(400, "min_created_at_millis must be before max_created_at_millis");
-    }
-    const cursorCreatedAt = body.cursor ? parseMillisOrThrow(body.cursor.created_at_millis, "cursor.created_at_millis") : undefined;
-    const cursorId = body.cursor?.id;
-    const limit = body.limit;
-
-    const laterOfMinCreatedAtOrCursorCreatedAt = !cursorCreatedAt || minCreatedAt > cursorCreatedAt ? minCreatedAt : cursorCreatedAt;
-
-    const baseWhere: Prisma.EventWhereInput = {
-      createdAt: {
-        gte: laterOfMinCreatedAtOrCursorCreatedAt,
-        lt: maxCreatedAt,
-      },
-      // Only migrate $session-activity events (translated to $token-refresh in ClickHouse)
-      systemEventTypeIds: {
-        has: '$session-activity',
-      },
-    };
-
-    const cursorFilter: Prisma.EventWhereInput | undefined = (cursorCreatedAt && cursorId) ? {
-      OR: [
-        { createdAt: { gt: cursorCreatedAt } },
-        { createdAt: cursorCreatedAt, id: { gt: cursorId } },
-      ],
-    } : undefined;
-
-    const where: Prisma.EventWhereInput = cursorFilter
-      ? { AND: [baseWhere, cursorFilter] }
-      : baseWhere;
-
-    const events = await globalPrismaClient.event.findMany({
-      where,
-      orderBy: [
-        { createdAt: "asc" },
-        { id: "asc" },
-      ],
-      take: limit,
-      include: {
-        endUserIpInfoGuess: true,
-      },
-    });
-
-    let insertedRows = 0;
-    let migratedEvents = 0;
-
-    if (events.length) {
-      const clickhouseClient = getClickhouseAdminClient();
-      const rowsToInsert = events.map(createClickhouseRow);
-      migratedEvents = events.length;
-
-      await clickhouseClient.insert({
-        table: "analytics_internal.events",
-        values: rowsToInsert,
-        format: "JSONEachRow",
-        clickhouse_settings: {
-          date_time_input_format: "best_effort",
-          async_insert: 1,
-        },
-      });
-      insertedRows = rowsToInsert.length;
-    }
-
-    const lastEvent = events.at(-1);
-    const nextCursor: Cursor | null = lastEvent ? {
-      created_at_millis: lastEvent.createdAt.getTime(),
-      id: lastEvent.id,
-    } : null;
-
-    return {
-      statusCode: 200,
-      bodyType: "json",
-      body: {
-        migrated_events: migratedEvents,
-        inserted_rows: insertedRows,
-        next_cursor: nextCursor,
-      },
-    };
-  },
-});
diff --git a/apps/backend/src/app/api/latest/internal/external-db-sync/status/route.ts b/apps/backend/src/app/api/latest/internal/external-db-sync/status/route.ts
index cf1c891563..701c8818a0 100644
--- a/apps/backend/src/app/api/latest/internal/external-db-sync/status/route.ts
+++ b/apps/backend/src/app/api/latest/internal/external-db-sync/status/route.ts
@@ -1,6 +1,7 @@
 import { globalPrismaClient } from "@/prisma-client";
 import { Prisma } from "@/generated/prisma/client";
 import { createSmartRouteHandler } from "@/route-handlers/smart-route-handler";
+import { getClickhouseAdminClient } from "@/lib/clickhouse";
 import type { CompleteConfig } from "@stackframe/stack-shared/dist/config/schema";
 import {
   adaptSchema,
@@ -11,6 +12,7 @@ import {
   yupObject,
   yupString,
 } from "@stackframe/stack-shared/dist/schema-fields";
+import { getEnvVariable } from "@stackframe/stack-shared/dist/utils/env";
 import { errorToNiceString, StackAssertionError, throwErr } from "@stackframe/stack-shared/dist/utils/errors";
 import { Result } from "@stackframe/stack-shared/dist/utils/results";
 import { Client } from "pg";
@@ -427,6 +429,202 @@ function parseConnectionString(connectionString: string | null | undefined) {
   };
 }
 
+type ClickhouseMetadataRow = {
+  mapping_name: string,
+  last_synced_sequence_id: string,
+  updated_at: string,
+};
+
+type ClickhouseUsersStatsRow = {
+  total_rows: string,
+  min_signed_up_at: string | null,
+  max_signed_up_at: string | null,
+};
+
+async function fetchClickhouseDatabaseStatus(
+  dbId: string,
+  mappingStatuses: Array<{
+    mapping_id: string,
+    internal_max_sequence_id: string | null,
+  }>,
+  tenancy: {
+    id: string,
+    projectId: string,
+    branchId: string,
+  },
+) {
+  const clickhouseUrl = getEnvVariable("STACK_CLICKHOUSE_URL", "");
+  const connection = parseConnectionString(clickhouseUrl);
+  if (!clickhouseUrl) {
+    return {
+      id: dbId,
+      type: "clickhouse",
+      connection,
+      status: "error" as const,
+      error: "Missing STACK_CLICKHOUSE_URL",
+      metadata: [],
+      users_table: {
+        exists: false,
+        total_rows: null,
+        min_signed_up_at_millis: null,
+        max_signed_up_at_millis: null,
+      },
+      mapping_status: mappingStatuses.map((mapping) => ({
+        mapping_id: mapping.mapping_id,
+        internal_max_sequence_id: mapping.internal_max_sequence_id,
+        last_synced_sequence_id: null,
+        updated_at_millis: null,
+        backlog: null,
+      })),
+    };
+  }
+
+  const client = getClickhouseAdminClient();
+  let metadata: ClickhouseMetadataRow[] = [];
+  let usersStats: ClickhouseUsersStatsRow | null = null;
+  try {
+    const metadataResult = await Result.fromPromise(client.query({
+      query: `
+        SELECT
+          mapping_name,
+          toString(argMax(last_synced_sequence_id, updated_at)) AS last_synced_sequence_id,
+          toString(max(updated_at)) AS updated_at
+        FROM analytics_internal._stack_sync_metadata
+        WHERE tenancy_id = {tenancy_id:UUID}
+        GROUP BY mapping_name
+      `,
+      query_params: {
+        tenancy_id: tenancy.id,
+      },
+      format: "JSONEachRow",
+    }));
+    if (metadataResult.status === "error") {
+      return {
+        id: dbId,
+        type: "clickhouse",
+        connection,
+        status: "error" as const,
+        error: formatError(metadataResult.error),
+        metadata: [],
+        users_table: {
+          exists: false,
+          total_rows: null,
+          min_signed_up_at_millis: null,
+          max_signed_up_at_millis: null,
+        },
+        mapping_status: mappingStatuses.map((mapping) => ({
+          mapping_id: mapping.mapping_id,
+          internal_max_sequence_id: mapping.internal_max_sequence_id,
+          last_synced_sequence_id: null,
+          updated_at_millis: null,
+          backlog: null,
+        })),
+      };
+    }
+    const metadataRows = await metadataResult.data.json<ClickhouseMetadataRow>();
+    metadata = metadataRows;
+
+    const usersStatsResult = await Result.fromPromise(client.query({
+      query: `
+        SELECT
+          toString(count()) AS total_rows,
+          toString(min(signed_up_at)) AS min_signed_up_at,
+          toString(max(signed_up_at)) AS max_signed_up_at
+        FROM analytics_internal.users FINAL
+        WHERE project_id = {project_id:String}
+          AND branch_id = {branch_id:String}
+          AND sync_is_deleted = 0
+      `,
+      query_params: {
+        project_id: tenancy.projectId,
+        branch_id: tenancy.branchId,
+      },
+      format: "JSONEachRow",
+    }));
+    if (usersStatsResult.status === "error") {
+      return {
+        id: dbId,
+        type: "clickhouse",
+        connection,
+        status: "error" as const,
+        error: formatError(usersStatsResult.error),
+        metadata: metadata.map((row) => ({
+          mapping_name: row.mapping_name,
+          last_synced_sequence_id: toBigIntString(row.last_synced_sequence_id) ?? "-1",
+          updated_at_millis: toMillis(row.updated_at),
+        })),
+        users_table: {
+          exists: false,
+          total_rows: null,
+          min_signed_up_at_millis: null,
+          max_signed_up_at_millis: null,
+        },
+        mapping_status: mappingStatuses.map((mapping) => ({
+          mapping_id: mapping.mapping_id,
+          internal_max_sequence_id: mapping.internal_max_sequence_id,
+          last_synced_sequence_id: null,
+          updated_at_millis: null,
+          backlog: null,
+        })),
+      };
+    }
+
+    const usersStatsRows = await usersStatsResult.data.json<ClickhouseUsersStatsRow>();
+    usersStats = usersStatsRows[0] ?? {
+      total_rows: "0",
+      min_signed_up_at: null,
+      max_signed_up_at: null,
+    };
+  } finally {
+    await Result.fromPromise(client.close());
+  }
+
+  const metadataMap = new Map<string, { last_synced_sequence_id: string | null, updated_at_millis: number | null }>();
+  const formattedMetadata = metadata.map((row) => {
+    const lastSynced = toBigIntString(row.last_synced_sequence_id) ?? "-1";
+    const updatedAt = toMillis(row.updated_at);
+    metadataMap.set(row.mapping_name, { last_synced_sequence_id: lastSynced, updated_at_millis: updatedAt });
+    return {
+      mapping_name: row.mapping_name,
+      last_synced_sequence_id: lastSynced,
+      updated_at_millis: updatedAt,
+    };
+  });
+
+  const mappingStatus = mappingStatuses.map((mapping) => {
+    const external = metadataMap.get(mapping.mapping_id);
+    const lastSynced = external?.last_synced_sequence_id ?? null;
+    const updatedAt = external?.updated_at_millis ?? null;
+    let backlog: string | null = null;
+    if (mapping.internal_max_sequence_id && lastSynced) {
+      backlog = (BigInt(mapping.internal_max_sequence_id) - BigInt(lastSynced)).toString();
+    }
+    return {
+      mapping_id: mapping.mapping_id,
+      internal_max_sequence_id: mapping.internal_max_sequence_id,
+      last_synced_sequence_id: lastSynced,
+      updated_at_millis: updatedAt,
+      backlog,
+    };
+  });
+
+  return {
+    id: dbId,
+    type: "clickhouse",
+    connection,
+    status: "ok" as const,
+    error: null,
+    metadata: formattedMetadata,
+    users_table: {
+      exists: true,
+      total_rows: toBigIntString(usersStats.total_rows),
+      min_signed_up_at_millis: toMillis(usersStats.min_signed_up_at),
+      max_signed_up_at_millis: toMillis(usersStats.max_signed_up_at),
+    },
+    mapping_status: mappingStatus,
+  };
+}
+
 async function fetchExternalDatabaseStatus(
   dbId: string,
   dbConfig: CompleteConfig["dbSync"]["externalDatabases"][string],
@@ -434,6 +632,11 @@ async function fetchExternalDatabaseStatus(
     mapping_id: string,
     internal_max_sequence_id: string | null,
   }>,
+  tenancy: {
+    id: string,
+    projectId: string,
+    branchId: string,
+  },
 ) {
   const connection = parseConnectionString(dbConfig.connectionString ?? null);
 
@@ -759,11 +962,29 @@ export const GET = createSmartRouteHandler({
       const externalDbStatuses = shouldIncludeGlobal
         ? []
         : await traceSpan("external-db-sync.status.fetchExternalDatabaseStatuses", async (externalSpan) => {
-          const statuses = await Promise.all(
+          const configStatuses = await Promise.all(
             Object.entries(
               auth.tenancy.config.dbSync.externalDatabases as CompleteConfig["dbSync"]["externalDatabases"],
-            ).map(([dbId, dbConfig]) => fetchExternalDatabaseStatus(dbId, dbConfig, currentStats.mappingStatuses)),
+            ).map(([dbId, dbConfig]) => fetchExternalDatabaseStatus(dbId, dbConfig, currentStats.mappingStatuses, {
+              id: auth.tenancy.id,
+              projectId: auth.tenancy.project.id,
+              branchId: auth.tenancy.branchId,
+            })),
           );
+
+          const statuses: Array<Awaited<ReturnType<typeof fetchClickhouseDatabaseStatus>> | Awaited<ReturnType<typeof fetchExternalDatabaseStatus>>> = [...configStatuses];
+
+          // Always include ClickHouse status if STACK_CLICKHOUSE_URL is set
+          const clickhouseUrl = getEnvVariable("STACK_CLICKHOUSE_URL", "");
+          if (clickhouseUrl) {
+            const clickhouseStatus = await fetchClickhouseDatabaseStatus("clickhouse", currentStats.mappingStatuses, {
+              id: auth.tenancy.id,
+              projectId: auth.tenancy.project.id,
+              branchId: auth.tenancy.branchId,
+            });
+            statuses.push(clickhouseStatus);
+          }
+
           externalSpan.setAttribute("stack.external-db-sync.external-db-count", statuses.length);
           return statuses;
         });
diff --git a/apps/backend/src/app/api/latest/internal/metrics/route.tsx b/apps/backend/src/app/api/latest/internal/metrics/route.tsx
index 317c84daf7..ccb1e90c9d 100644
--- a/apps/backend/src/app/api/latest/internal/metrics/route.tsx
+++ b/apps/backend/src/app/api/latest/internal/metrics/route.tsx
@@ -1,7 +1,6 @@
-import { Prisma } from "@/generated/prisma/client";
-import { getOrSetCacheValue } from "@/lib/cache";
+import { getClickhouseAdminClient } from "@/lib/clickhouse";
 import { Tenancy } from "@/lib/tenancies";
-import { getPrismaClientForTenancy, getPrismaSchemaForTenancy, globalPrismaClient, PrismaClientTransaction, sqlQuoteIdent } from "@/prisma-client";
+import { getPrismaClientForTenancy, PrismaClientTransaction, getPrismaSchemaForTenancy, sqlQuoteIdent } from "@/prisma-client";
 import { createSmartRouteHandler } from "@/route-handlers/smart-route-handler";
 import { KnownErrors } from "@stackframe/stack-shared";
 import { UsersCrud } from "@stackframe/stack-shared/dist/interface/crud/users";
@@ -11,25 +10,17 @@ import { userFullInclude, userPrismaToCrud, usersCrudHandlers } from "../../user
 
 type DataPoints = yup.InferType<typeof DataPointsSchema>;
 
-const METRICS_CACHE_NAMESPACE = "metrics";
-const ONE_HOUR_MS = 60 * 60 * 1000;
 const MAX_USERS_FOR_COUNTRY_SAMPLE = 10_000;
 
-async function withMetricsCache<T>(tenancy: Tenancy, suffix: string, prisma: PrismaClientTransaction, includeAnonymous: boolean = false, loader: () => Promise<T>): Promise<T> {
-  return await getOrSetCacheValue<T>({
-    namespace: METRICS_CACHE_NAMESPACE,
-    cacheKey: `${tenancy.id}:${suffix}:${includeAnonymous ? "anon" : "non_anon"}`,
-    ttlMs: ONE_HOUR_MS,
-    prisma,
-    loader,
-  });
-}
-
 const DataPointsSchema = yupArray(yupObject({
   date: yupString().defined(),
   activity: yupNumber().defined(),
 }).defined()).defined();
 
+function formatClickhouseDateTimeParam(date: Date): string {
+  // ClickHouse DateTime params are passed as "YYYY-MM-DDTHH:MM:SS" (no timezone); treat them as UTC.
+  return date.toISOString().slice(0, 19);
+}
 
 async function loadUsersByCountry(tenancy: Tenancy, prisma: PrismaClientTransaction, includeAnonymous: boolean = false): Promise<Record<string, number>> {
   const totalUsers = await prisma.projectUser.count({
@@ -53,39 +44,57 @@ async function loadUsersByCountry(tenancy: Tenancy, prisma: PrismaClientTransact
   }
 
   const userIds = users.map((user) => user.projectUserId);
-  const userIdArray = Prisma.sql`ARRAY[${Prisma.join(userIds.map((id) => Prisma.sql`${id}`))}]::text[]`;
   const scalingFactor = totalUsers > users.length ? totalUsers / users.length : 1;
 
-  const rows = await globalPrismaClient.$replica().$queryRaw<{ countryCode: string | null, userCount: bigint }[]>(Prisma.sql`
-    WITH latest_ip AS (
-      SELECT DISTINCT ON (e."data"->>'userId')
-        e."data"->>'userId' AS "userId",
-        eip."countryCode" AS "countryCode"
-      FROM "Event" e
-      JOIN "EventIpInfo" eip
-        ON eip.id = e."endUserIpInfoGuessId"
-      WHERE '$user-activity' = ANY(e."systemEventTypeIds"::text[])
-        AND e."data"->>'projectId' = ${tenancy.project.id}
-        AND COALESCE(e."data"->>'branchId', 'main') = ${tenancy.branchId}
-        AND e."data"->>'userId' = ANY(${userIdArray})
-        AND e."endUserIpInfoGuessId" IS NOT NULL
-        AND eip."countryCode" IS NOT NULL
-      ORDER BY e."data"->>'userId', e."eventStartedAt" DESC
-    )
-    SELECT "countryCode", COUNT("userId") AS "userCount"
-    FROM latest_ip
-    GROUP BY "countryCode"
-    ORDER BY "userCount" DESC;
-  `);
+  const clickhouseClient = getClickhouseAdminClient();
+  const res = await clickhouseClient.query({
+    query: `
+      SELECT
+        country_code,
+        count() AS userCount
+      FROM (
+        SELECT
+          user_id,
+          argMax(cc, event_at) AS country_code
+        FROM (
+          SELECT
+            user_id,
+            event_at,
+            CAST(data.ip_info.country_code, 'Nullable(String)') AS cc,
+            CAST(data.is_anonymous, 'UInt8') AS is_anonymous
+          FROM analytics_internal.events
+          WHERE event_type = '$token-refresh'
+            AND project_id = {projectId:String}
+            AND branch_id = {branchId:String}
+            AND user_id IS NOT NULL
+            AND has({userIds:Array(String)}, assumeNotNull(user_id))
+        )
+        WHERE cc IS NOT NULL
+          AND ({includeAnonymous:UInt8} = 1 OR is_anonymous = 0)
+        GROUP BY user_id
+      )
+      WHERE country_code IS NOT NULL
+      GROUP BY country_code
+      ORDER BY userCount DESC
+    `,
+    query_params: {
+      projectId: tenancy.project.id,
+      branchId: tenancy.branchId,
+      userIds,
+      includeAnonymous: includeAnonymous ? 1 : 0,
+    },
+    format: "JSONEachRow",
+  });
+  const rows: { country_code: string, userCount: number }[] = await res.json();
 
   return Object.fromEntries(
-    rows.map(({ userCount, countryCode }) => {
-      if (!countryCode) {
+    rows.map(({ userCount, country_code }) => {
+      if (!country_code) {
         return null;
       }
       const count = Number(userCount);
       const estimatedCount = scalingFactor === 1 ? count : Math.round(count * scalingFactor);
-      return [countryCode, estimatedCount] as [string, number];
+      return [country_code, estimatedCount] as [string, number];
     })
       .filter((entry): entry is [string, number] => entry !== null)
   );
@@ -121,49 +130,56 @@ async function loadTotalUsers(tenancy: Tenancy, now: Date, includeAnonymous: boo
 }
 
 async function loadDailyActiveUsers(tenancy: Tenancy, now: Date, includeAnonymous: boolean = false) {
-  const res = await globalPrismaClient.$replica().$queryRaw<{ day: Date, dau: bigint }[]>`
-    WITH date_series AS (
-      SELECT GENERATE_SERIES(
-        ${now}::date - INTERVAL '30 days',
-        ${now}::date,
-        '1 day'
-      )
-      AS "day"
-    ),
-    filtered_events AS (
+  const todayUtc = new Date(now);
+  todayUtc.setUTCHours(0, 0, 0, 0);
+  const since = new Date(todayUtc.getTime() - 30 * 24 * 60 * 60 * 1000);
+  const untilExclusive = new Date(todayUtc.getTime() + 24 * 60 * 60 * 1000);
+
+  const clickhouseClient = getClickhouseAdminClient();
+  const result = await clickhouseClient.query({
+    query: `
       SELECT
-        ("eventStartedAt"::date) AS "day",
-        "data"->>'userId' AS "userId"
-      FROM "Event"
-      WHERE "eventStartedAt" >= ${now}::date - INTERVAL '30 days'
-        AND "eventStartedAt" < ${now}::date + INTERVAL '1 day'
-        AND '$user-activity' = ANY("systemEventTypeIds"::text[])
-        AND "data"->>'projectId' = ${tenancy.project.id}
-        AND COALESCE("data"->>'branchId', 'main') = ${tenancy.branchId}
-        AND (${includeAnonymous} OR COALESCE("data"->>'isAnonymous', 'false') != 'true')
-        AND "data"->>'userId' IS NOT NULL
-    ),
-    unique_daily_users AS (
-      SELECT "day", "userId"
-      FROM filtered_events
-      GROUP BY "day", "userId"
-    ),
-    daily_users AS (
-      SELECT "day", COUNT(*) AS "dau"
-      FROM unique_daily_users
-      GROUP BY "day"
-    )
-    SELECT ds."day", COALESCE(du.dau, 0) AS dau
-    FROM date_series ds
-    LEFT JOIN daily_users du 
-    ON ds."day" = du."day"
-    ORDER BY ds."day"
-  `;
+        toDate(event_at) AS day,
+        uniqExact(assumeNotNull(user_id)) AS dau
+      FROM analytics_internal.events
+      WHERE event_type = '$token-refresh'
+        AND project_id = {projectId:String}
+        AND branch_id = {branchId:String}
+        AND user_id IS NOT NULL
+        AND event_at >= {since:DateTime}
+        AND event_at < {untilExclusive:DateTime}
+        AND ({includeAnonymous:UInt8} = 1 OR JSONExtract(toJSONString(data), 'is_anonymous', 'UInt8') = 0)
+      GROUP BY day
+      ORDER BY day ASC
+    `,
+    query_params: {
+      projectId: tenancy.project.id,
+      branchId: tenancy.branchId,
+      since: formatClickhouseDateTimeParam(since),
+      untilExclusive: formatClickhouseDateTimeParam(untilExclusive),
+      includeAnonymous: includeAnonymous ? 1 : 0,
+    },
+    format: "JSONEachRow",
+  });
 
-  return res.map(x => ({
-    date: x.day.toISOString().split('T')[0],
-    activity: Number(x.dau),
-  })) as DataPoints;
+  const rows: { day: string, dau: number }[] = await result.json();
+  const dauByDay = new Map<string, number>();
+  for (const row of rows) {
+    // ClickHouse returns dates/datetimes without timezone, treat as UTC.
+    const dayKey = new Date(row.day + 'Z').toISOString().split('T')[0];
+    dauByDay.set(dayKey, Number(row.dau));
+  }
+
+  const out: DataPoints = [];
+  for (let i = 0; i <= 30; i += 1) {
+    const day = new Date(since.getTime() + i * 24 * 60 * 60 * 1000);
+    const dayKey = day.toISOString().split('T')[0];
+    out.push({
+      date: dayKey,
+      activity: dauByDay.get(dayKey) ?? 0,
+    });
+  }
+  return out;
 }
 
 async function loadLoginMethods(tenancy: Tenancy): Promise<{ method: string, count: number }[]> {
@@ -255,20 +271,8 @@ export const GET = createSmartRouteHandler({
         where: { tenancyId: req.auth.tenancy.id, ...(includeAnonymous ? {} : { isAnonymous: false }) },
       }),
       loadTotalUsers(req.auth.tenancy, now, includeAnonymous),
-      withMetricsCache(
-        req.auth.tenancy,
-        "daily_active_users",
-        prisma,
-        includeAnonymous,
-        () => loadDailyActiveUsers(req.auth.tenancy, now, includeAnonymous)
-      ),
-      withMetricsCache(
-        req.auth.tenancy,
-        "users_by_country",
-        prisma,
-        includeAnonymous,
-        () => loadUsersByCountry(req.auth.tenancy, prisma, includeAnonymous)
-      ),
+      loadDailyActiveUsers(req.auth.tenancy, now, includeAnonymous),
+      loadUsersByCountry(req.auth.tenancy, prisma, includeAnonymous),
       usersCrudHandlers.adminList({
         tenancy: req.auth.tenancy,
         query: {
diff --git a/apps/backend/src/lib/events.tsx b/apps/backend/src/lib/events.tsx
index 01c881f744..281db375ae 100644
--- a/apps/backend/src/lib/events.tsx
+++ b/apps/backend/src/lib/events.tsx
@@ -26,6 +26,34 @@ export const endUserIpInfoSchema = yupObject({
 
 export type EndUserIpInfo = yup.InferType<typeof endUserIpInfoSchema>;
 
+type ClickhouseEndUserIpInfo = {
+  ip: string,
+  is_trusted: boolean,
+  country_code?: string,
+  region_code?: string,
+  city_name?: string,
+  latitude?: number,
+  longitude?: number,
+  tz_identifier?: string,
+};
+
+function toClickhouseEndUserIpInfo(ipInfo: EndUserIpInfo | null): ClickhouseEndUserIpInfo | null {
+  if (!ipInfo) {
+    return null;
+  }
+
+  return {
+    ip: ipInfo.ip,
+    is_trusted: ipInfo.isTrusted,
+    country_code: ipInfo.countryCode ?? undefined,
+    region_code: ipInfo.regionCode ?? undefined,
+    city_name: ipInfo.cityName ?? undefined,
+    latitude: ipInfo.latitude ?? undefined,
+    longitude: ipInfo.longitude ?? undefined,
+    tz_identifier: ipInfo.tzIdentifier ?? undefined,
+  };
+}
+
 /**
  * Extracts the end user IP info from the current request.
  * Must be called before any async operations as it uses dynamic APIs.
@@ -88,7 +116,7 @@ const UserActivityEventType = {
     userId: yupString().uuid().defined(),
     // old events of this type may not have an isAnonymous field, so we default to false
     isAnonymous: yupBoolean().defined().default(false),
-    teamId: yupString().optional().default(""),
+    teamId: yupString().optional(),
   }),
   inherits: [ProjectActivityEventType],
 } as const satisfies SystemEventTypeBase;
@@ -104,15 +132,10 @@ const SessionActivityEventType = {
 const TokenRefreshEventType = {
   id: "$token-refresh",
   dataSchema: yupObject({
-    projectId: yupString().defined(),
-    branchId: yupString().defined(),
-    organizationId: yupString().nullable().test("must-be-null", "Organization ID has not been implemented yet and must be null", (value) => value === null).defined(),
-    userId: yupString().uuid().defined(),
     refreshTokenId: yupString().defined(),
-    isAnonymous: yupBoolean().defined(),
     ipInfo: endUserIpInfoSchema.nullable().defined(),
   }),
-  inherits: [],
+  inherits: [UserActivityEventType],
 } as const satisfies SystemEventTypeBase;
 
 
@@ -221,13 +244,19 @@ export async function logEvent<T extends EventType[]>(
   const endUserInfo = await getEndUserInfo();  // this is a dynamic API, can't run it asynchronously
   const endUserInfoInner = endUserInfo?.maybeSpoofed ? endUserInfo.spoofedInfo : endUserInfo?.exactInfo;
   const eventTypesArray = [...allEventTypes];
-  const clickhouseEventData = {
-    ...data as Record<string, unknown>,
-  };
   const dataRecord = data as Record<string, unknown> | null | undefined;
-  const projectId = typeof dataRecord === "object" && dataRecord && typeof dataRecord.projectId === "string" ? dataRecord.projectId : "";
-  const branchId = typeof dataRecord === "object" && dataRecord && typeof dataRecord.branchId === "string" ? dataRecord.branchId : DEFAULT_BRANCH_ID;
-  const userId = typeof dataRecord === "object" && dataRecord && typeof dataRecord.userId === "string" ? dataRecord.userId : "";
+  const projectId =
+    typeof dataRecord === "object" && dataRecord && typeof dataRecord.projectId === "string"
+      ? dataRecord.projectId
+      : "";
+  const branchId =
+    typeof dataRecord === "object" && dataRecord && typeof dataRecord.branchId === "string"
+      ? dataRecord.branchId
+      : DEFAULT_BRANCH_ID;
+  const userId =
+    typeof dataRecord === "object" && dataRecord && typeof dataRecord.userId === "string"
+      ? dataRecord.userId
+      : "";
 
 
   // rest is no more dynamic APIs so we can run it asynchronously
@@ -259,6 +288,37 @@ export async function logEvent<T extends EventType[]>(
     const clickhouseEventTypes = ['$token-refresh', '$sign-up-rule-trigger'];
     const matchingEventType = eventTypesArray.find(e => clickhouseEventTypes.includes(e.id));
     if (matchingEventType) {
+      let clickhouseEventData: Record<string, unknown>;
+      if (matchingEventType.id === "$token-refresh") {
+        const refreshTokenId =
+          typeof dataRecord === "object" && dataRecord && typeof dataRecord.refreshTokenId === "string"
+            ? dataRecord.refreshTokenId
+            : throwErr(new StackAssertionError("refreshTokenId is required for $token-refresh ClickHouse event", { dataRecord }));
+        const isAnonymous =
+          typeof dataRecord === "object" && dataRecord && typeof dataRecord.isAnonymous === "boolean"
+            ? dataRecord.isAnonymous
+            : throwErr(new StackAssertionError("isAnonymous is required for $token-refresh ClickHouse event", { dataRecord }));
+        const ipInfo =
+          typeof dataRecord === "object" && dataRecord
+            ? (dataRecord.ipInfo as EndUserIpInfo | null | undefined)
+            : undefined;
+        clickhouseEventData = {
+          refresh_token_id: refreshTokenId,
+          is_anonymous: isAnonymous,
+          ip_info: toClickhouseEndUserIpInfo(ipInfo ?? null),
+        };
+      } else {
+        clickhouseEventData = {
+          ...(data as Record<string, unknown>),
+        };
+      }
+
+      if (!projectId) {
+        throw new StackAssertionError(
+          `projectId is required for ClickHouse event insertion (${matchingEventType.id})`,
+          { matchingEventType, dataRecord }
+        );
+      }
       const clickhouseClient = getClickhouseAdminClient();
       await clickhouseClient.insert({
         table: "analytics_internal.events",
diff --git a/apps/backend/src/lib/external-db-sync.ts b/apps/backend/src/lib/external-db-sync.ts
index 57f89127a4..a9b57db045 100644
--- a/apps/backend/src/lib/external-db-sync.ts
+++ b/apps/backend/src/lib/external-db-sync.ts
@@ -2,12 +2,14 @@ import { Tenancy } from "@/lib/tenancies";
 import type { PrismaTransaction } from "@/lib/types";
 import { getPrismaClientForTenancy, PrismaClientWithReplica } from "@/prisma-client";
 import { Prisma } from "@/generated/prisma/client";
+import { getClickhouseAdminClient } from "@/lib/clickhouse";
 import { DEFAULT_DB_SYNC_MAPPINGS } from "@stackframe/stack-shared/dist/config/db-sync-mappings";
 import type { CompleteConfig } from "@stackframe/stack-shared/dist/config/schema";
 import { captureError, StackAssertionError, throwErr } from "@stackframe/stack-shared/dist/utils/errors";
 import { getEnvVariable } from "@stackframe/stack-shared/dist/utils/env";
 import { omit } from "@stackframe/stack-shared/dist/utils/objects";
 import { Result } from "@stackframe/stack-shared/dist/utils/results";
+import type { ClickHouseClient } from "@clickhouse/client";
 import { Client } from 'pg';
 
 const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
@@ -41,6 +43,9 @@ type ExternalDbSyncTarget =
     contactChannelId: string,
   };
 
+type ExternalDbType = NonNullable<NonNullable<CompleteConfig["dbSync"]["externalDatabases"][string]>["type"]>;
+type DbSyncMapping = typeof DEFAULT_DB_SYNC_MAPPINGS[keyof typeof DEFAULT_DB_SYNC_MAPPINGS];
+
 export function withExternalDbSyncUpdate<T extends object>(data: T): T & { shouldUpdateSequenceId: true } {
   return {
     ...data,
@@ -320,21 +325,203 @@ async function pushRowsToExternalDb(
   }
 }
 
+function getInternalDbFetchQuery(mapping: DbSyncMapping, dbType: ExternalDbType) {
+  return mapping.internalDbFetchQuery;
+}
+
+function normalizeClickhouseBoolean(value: unknown, label: string): number {
+  if (typeof value === "boolean") {
+    return value ? 1 : 0;
+  }
+  if (typeof value === "bigint") {
+    if (value === 0n) return 0;
+    if (value === 1n) return 1;
+  }
+  if (value === 0 || value === 1) {
+    return value;
+  }
+  throw new StackAssertionError(`${label} must be a boolean or 0/1. Received: ${JSON.stringify(value)}`);
+}
+
+function parseSequenceId(value: unknown, mappingId: string): number | null {
+  if (value == null) {
+    return null;
+  }
+  const seqNum = typeof value === "bigint" ? Number(value) : Number(value);
+  if (!Number.isFinite(seqNum)) {
+    throw new StackAssertionError(
+      `Invalid sequence_id for mapping ${mappingId}: ${JSON.stringify(value)}`
+    );
+  }
+  return seqNum;
+}
+
+async function ensureClickhouseSchema(
+  client: ClickHouseClient,
+  tableSchemaSql: string,
+  tableName: string,
+) {
+  assertNonEmptyString(tableSchemaSql, "tableSchemaSql");
+  assertNonEmptyString(tableName, "tableName");
+  const queries = tableSchemaSql
+    .split(";")
+    .map((query) => query.trim())
+    .filter((query) => query.length > 0);
+  for (const query of queries) {
+    await client.exec({ query });
+  }
+}
+
+async function pushRowsToClickhouse(
+  client: ClickHouseClient,
+  tableName: string,
+  newRows: Array<Record<string, unknown>>,
+  expectedTenancyId: string,
+  mappingId: string,
+) {
+  assertNonEmptyString(tableName, "tableName");
+  assertNonEmptyString(mappingId, "mappingId");
+  assertUuid(expectedTenancyId, "expectedTenancyId");
+  if (!Array.isArray(newRows)) {
+    throw new StackAssertionError(`newRows must be an array for table ${JSON.stringify(tableName)}.`);
+  }
+  if (newRows.length === 0) return;
+
+  const sampleRow = newRows[0] ?? throwErr("Expected at least one row for ClickHouse sync.");
+  const orderedKeys = Object.keys(omit(sampleRow, ["tenancyId"]));
+
+  const normalizedRows = newRows.map((row) => {
+    const tenancyIdValue = row.tenancyId;
+    if (typeof tenancyIdValue !== "string") {
+      throw new StackAssertionError(
+        `Row has invalid tenancyId. Expected ${expectedTenancyId}, got ${JSON.stringify(tenancyIdValue)}.`
+      );
+    }
+    if (tenancyIdValue !== expectedTenancyId) {
+      throw new StackAssertionError(
+        `Row has unexpected tenancyId. Expected ${expectedTenancyId}, got ${tenancyIdValue}. ` +
+        `This indicates a bug in the internalDbFetchQuery.`
+      );
+    }
+
+    const rest = omit(row, ["tenancyId"]);
+    const rowKeys = Object.keys(rest);
+
+    const validShape =
+      rowKeys.length === orderedKeys.length &&
+      rowKeys.every((key, index) => key === orderedKeys[index]);
+
+    if (!validShape) {
+      throw new StackAssertionError(
+        `  Row shape mismatch for table "${tableName}".\n` +
+          `Expected column order: [${orderedKeys.join(", ")}]\n` +
+          `Received column order: [${rowKeys.join(", ")}]\n` +
+          `Your SELECT must be explicit, ordered, and NEVER use SELECT *.\n` +
+          `Fix the SELECT in internalDbFetchQuery immediately.`
+      );
+    }
+
+    const sequenceId = parseSequenceId(rest.sync_sequence_id, mappingId);
+    if (sequenceId === null) {
+      throw new StackAssertionError(
+        `sync_sequence_id must be defined for ClickHouse sync. Mapping: ${mappingId}`
+      );
+    }
+    return {
+      ...rest,
+      sync_sequence_id: sequenceId,
+      primary_email_verified: normalizeClickhouseBoolean(rest.primary_email_verified, "primary_email_verified"),
+      is_anonymous: normalizeClickhouseBoolean(rest.is_anonymous, "is_anonymous"),
+      restricted_by_admin: normalizeClickhouseBoolean(rest.restricted_by_admin, "restricted_by_admin"),
+      sync_is_deleted: normalizeClickhouseBoolean(rest.sync_is_deleted, "sync_is_deleted"),
+    };
+  });
+
+  await client.insert({
+    table: tableName,
+    values: normalizedRows,
+    format: "JSONEachRow",
+    clickhouse_settings: {
+      date_time_input_format: "best_effort",
+    },
+  });
+}
+
+async function getClickhouseLastSyncedSequenceId(
+  client: ClickHouseClient,
+  tenancyId: string,
+  mappingId: string,
+): Promise<number> {
+  assertUuid(tenancyId, "tenancyId");
+  assertNonEmptyString(mappingId, "mappingId");
+  const resultSet = await client.query({
+    query: `
+      SELECT last_synced_sequence_id
+      FROM analytics_internal._stack_sync_metadata
+      WHERE tenancy_id = {tenancy_id:UUID}
+        AND mapping_name = {mapping_name:String}
+      ORDER BY updated_at DESC
+      LIMIT 1
+    `,
+    query_params: {
+      tenancy_id: tenancyId,
+      mapping_name: mappingId,
+    },
+    format: "JSONEachRow",
+  });
+
+  const result = await resultSet.json<{ last_synced_sequence_id: string }>();
+  if (result.length === 0) {
+    return -1;
+  }
+  const parsed = Number(result[0]?.last_synced_sequence_id);
+  if (!Number.isFinite(parsed)) {
+    throw new StackAssertionError(
+      `Invalid last_synced_sequence_id for mapping ${mappingId}: ${JSON.stringify(result[0]?.last_synced_sequence_id)}`
+    );
+  }
+  return parsed;
+}
 
-async function syncMapping(
+async function updateClickhouseSyncMetadata(
+  client: ClickHouseClient,
+  tenancyId: string,
+  mappingId: string,
+  lastSequenceId: number,
+) {
+  assertUuid(tenancyId, "tenancyId");
+  assertNonEmptyString(mappingId, "mappingId");
+  if (!Number.isFinite(lastSequenceId)) {
+    throw new StackAssertionError(`lastSequenceId must be a finite number for mapping ${mappingId}.`);
+  }
+  await client.insert({
+    table: "analytics_internal._stack_sync_metadata",
+    values: [{
+      tenancy_id: tenancyId,
+      mapping_name: mappingId,
+      last_synced_sequence_id: lastSequenceId,
+    }],
+    format: "JSONEachRow",
+    clickhouse_settings: {
+      date_time_input_format: "best_effort",
+    },
+  });
+}
+
+
+async function syncPostgresMapping(
   externalClient: Client,
   mappingId: string,
-  mapping: typeof DEFAULT_DB_SYNC_MAPPINGS[keyof typeof DEFAULT_DB_SYNC_MAPPINGS],
+  mapping: DbSyncMapping,
   internalPrisma: PrismaClientWithReplica,
   dbId: string,
   tenancyId: string,
-  dbType: 'postgres',
 ): Promise<boolean> {
   assertNonEmptyString(mappingId, "mappingId");
   assertNonEmptyString(mapping.targetTable, "mapping.targetTable");
   assertUuid(tenancyId, "tenancyId");
-  const fetchQuery = mapping.internalDbFetchQuery;
-  const updateQuery = mapping.externalDbUpdateQueries[dbType];
+  const fetchQuery = getInternalDbFetchQuery(mapping, "postgres");
+  const updateQuery = mapping.externalDbUpdateQueries.postgres;
   const tableName = mapping.targetTable;
   assertNonEmptyString(fetchQuery, "internalDbFetchQuery");
   assertNonEmptyString(updateQuery, "externalDbUpdateQueries");
@@ -344,7 +531,7 @@ async function syncMapping(
     );
   }
 
-  const tableSchema = mapping.targetTableSchemas[dbType];
+  const tableSchema = mapping.targetTableSchemas.postgres;
   await ensureExternalSchema(externalClient, tableSchema, tableName);
 
   let lastSequenceId = -1;
@@ -388,12 +575,9 @@ async function syncMapping(
 
     let maxSeqInBatch = lastSequenceId;
     for (const row of rows) {
-      const seq = row.sequence_id;
-      if (seq != null) {
-        const seqNum = typeof seq === 'bigint' ? Number(seq) : Number(seq);
-        if (seqNum > maxSeqInBatch) {
-          maxSeqInBatch = seqNum;
-        }
+      const seqNum = parseSequenceId(row.sequence_id, mappingId);
+      if (seqNum !== null && seqNum > maxSeqInBatch) {
+        maxSeqInBatch = seqNum;
       }
     }
     lastSequenceId = maxSeqInBatch;
@@ -412,66 +596,143 @@ async function syncMapping(
   return throttled;
 }
 
-
-async function syncDatabase(
-  dbId: string,
-  dbConfig: CompleteConfig["dbSync"]["externalDatabases"][string],
+async function syncClickhouseMapping(
+  client: ClickHouseClient,
+  mappingId: string,
+  mapping: DbSyncMapping,
   internalPrisma: PrismaClientWithReplica,
   tenancyId: string,
 ): Promise<boolean> {
-  assertNonEmptyString(dbId, "dbId");
+  assertNonEmptyString(mappingId, "mappingId");
+  assertNonEmptyString(mapping.targetTable, "mapping.targetTable");
   assertUuid(tenancyId, "tenancyId");
-  const dbType = dbConfig.type;
-  if (dbType !== 'postgres') {
+  const fetchQuery = mapping.internalDbFetchQueries.clickhouse;
+  if (!fetchQuery) {
+    throw new StackAssertionError(`Missing ClickHouse fetch query for mapping ${mappingId}.`);
+  }
+  const tableSchema = mapping.targetTableSchemas.clickhouse;
+  if (!tableSchema) {
+    throw new StackAssertionError(`Missing ClickHouse table schema for mapping ${mappingId}.`);
+  }
+  assertNonEmptyString(fetchQuery, "internalDbFetchQuery");
+  if (!fetchQuery.includes("$1") || !fetchQuery.includes("$2")) {
     throw new StackAssertionError(
-      `Unsupported database type '${String(dbType)}' for external DB ${dbId}. Only 'postgres' is currently supported.`
+      `internalDbFetchQuery must reference $1 (tenancyId) and $2 (lastSequenceId). Mapping: ${mappingId}`
     );
   }
 
-  if (!dbConfig.connectionString) {
-    throw new StackAssertionError(
-      `Invalid configuration for external DB ${dbId}: 'connectionString' is missing.`
+  const clickhouseTableName = `analytics_internal.${mapping.targetTable}`;
+  await ensureClickhouseSchema(client, tableSchema, clickhouseTableName);
+
+  let lastSequenceId = await getClickhouseLastSyncedSequenceId(client, tenancyId, mappingId);
+
+  const BATCH_LIMIT = 1000;
+  const maxBatchesPerMapping = getMaxBatchesPerMapping();
+  let batchesProcessed = 0;
+  let throttled = false;
+
+  while (true) {
+    assertUuid(tenancyId, "tenancyId");
+    if (!Number.isFinite(lastSequenceId)) {
+      throw new StackAssertionError(`lastSequenceId must be a finite number for mapping ${mappingId}.`);
+    }
+    const rows = await internalPrisma.$replica().$queryRawUnsafe<Record<string, unknown>[]>(fetchQuery, tenancyId, lastSequenceId);
+
+    if (rows.length === 0) {
+      break;
+    }
+
+    await pushRowsToClickhouse(
+      client,
+      clickhouseTableName,
+      rows,
+      tenancyId,
+      mappingId,
     );
+
+    let maxSeqInBatch = lastSequenceId;
+    for (const row of rows) {
+      const seqNum = parseSequenceId(row.sync_sequence_id, mappingId);
+      if (seqNum !== null && seqNum > maxSeqInBatch) {
+        maxSeqInBatch = seqNum;
+      }
+    }
+    lastSequenceId = maxSeqInBatch;
+    await updateClickhouseSyncMetadata(client, tenancyId, mappingId, lastSequenceId);
+
+    if (rows.length < BATCH_LIMIT) {
+      break;
+    }
+
+    batchesProcessed++;
+    if (maxBatchesPerMapping !== null && batchesProcessed >= maxBatchesPerMapping) {
+      throttled = true;
+      break;
+    }
   }
-  assertNonEmptyString(dbConfig.connectionString, `external DB ${dbId} connectionString`);
 
-  const externalClient = new Client({
-    connectionString: dbConfig.connectionString,
-  });
+  return throttled;
+}
 
-  let needsResync = false;
-  const syncResult = await Result.fromPromise((async () => {
-    await externalClient.connect();
-
-    // Always use DEFAULT_DB_SYNC_MAPPINGS - users cannot customize mappings
-    // because internalDbFetchQuery runs against Stack Auth's internal DB
-    for (const [mappingId, mapping] of Object.entries(DEFAULT_DB_SYNC_MAPPINGS)) {
-      const mappingThrottled = await syncMapping(
-        externalClient,
-        mappingId,
-        mapping,
-        internalPrisma,
-        dbId,
-        tenancyId,
-        dbType,
+
+async function syncDatabase(
+  dbId: string,
+  dbConfig: CompleteConfig["dbSync"]["externalDatabases"][string],
+  internalPrisma: PrismaClientWithReplica,
+  tenancyId: string,
+): Promise<boolean> {
+  assertNonEmptyString(dbId, "dbId");
+  assertUuid(tenancyId, "tenancyId");
+  const dbType = dbConfig.type;
+  if (dbType === "postgres") {
+    if (!dbConfig.connectionString) {
+      throw new StackAssertionError(
+        `Invalid configuration for external DB ${dbId}: 'connectionString' is missing.`
       );
-      if (mappingThrottled) {
-        needsResync = true;
+    }
+    assertNonEmptyString(dbConfig.connectionString, `external DB ${dbId} connectionString`);
+
+    const externalClient = new Client({
+      connectionString: dbConfig.connectionString,
+    });
+
+    let needsResync = false;
+    const syncResult = await Result.fromPromise((async () => {
+      await externalClient.connect();
+
+      // Always use DEFAULT_DB_SYNC_MAPPINGS - users cannot customize mappings
+      // because internalDbFetchQuery runs against Stack Auth's internal DB
+      for (const [mappingId, mapping] of Object.entries(DEFAULT_DB_SYNC_MAPPINGS)) {
+        const mappingThrottled = await syncPostgresMapping(
+          externalClient,
+          mappingId,
+          mapping,
+          internalPrisma,
+          dbId,
+          tenancyId,
+        );
+        if (mappingThrottled) {
+          needsResync = true;
+        }
       }
+    })());
+
+    const closeResult = await Result.fromPromise(externalClient.end());
+    if (closeResult.status === "error") {
+      captureError(`external-db-sync-${dbId}-close`, closeResult.error);
     }
-  })());
 
-  const closeResult = await Result.fromPromise(externalClient.end());
-  if (closeResult.status === "error") {
-    captureError(`external-db-sync-${dbId}-close`, closeResult.error);
-  }
+    if (syncResult.status === "error") {
+      captureError(`external-db-sync-${dbId}`, syncResult.error);
+      return false;
+    }
 
-  if (syncResult.status === "error") {
-    captureError(`external-db-sync-${dbId}`, syncResult.error);
-    return false;
+    return needsResync;
   }
 
-  return needsResync;
+  throw new StackAssertionError(
+    `Unsupported database type '${String(dbType)}' for external DB ${dbId}.`
+  );
 }
 
 
@@ -481,6 +742,36 @@ export async function syncExternalDatabases(tenancy: Tenancy): Promise<boolean>
   const internalPrisma = await getPrismaClientForTenancy(tenancy);
   let needsResync = false;
 
+  // Always sync to ClickHouse if STACK_CLICKHOUSE_URL is set (not driven by config)
+  const clickhouseUrl = getEnvVariable("STACK_CLICKHOUSE_URL", "");
+  if (clickhouseUrl) {
+    const clickhouseClient = getClickhouseAdminClient();
+    const syncResult = await Result.fromPromise((async () => {
+      for (const [mappingId, mapping] of Object.entries(DEFAULT_DB_SYNC_MAPPINGS)) {
+        const mappingThrottled = await syncClickhouseMapping(
+          clickhouseClient,
+          mappingId,
+          mapping,
+          internalPrisma,
+          tenancy.id,
+        );
+        if (mappingThrottled) {
+          needsResync = true;
+        }
+      }
+    })());
+
+    const closeResult = await Result.fromPromise(clickhouseClient.close());
+    if (closeResult.status === "error") {
+      captureError("external-db-sync-clickhouse-close", closeResult.error);
+    }
+
+    if (syncResult.status === "error") {
+      captureError("external-db-sync-clickhouse", syncResult.error);
+      needsResync = true;
+    }
+  }
+
   for (const [dbId, dbConfig] of Object.entries(externalDatabases)) {
     try {
       const databaseThrottled = await syncDatabase(dbId, dbConfig, internalPrisma, tenancy.id);
diff --git a/apps/backend/src/lib/tokens.tsx b/apps/backend/src/lib/tokens.tsx
index 7d29b3fac1..2e55ae3e3d 100644
--- a/apps/backend/src/lib/tokens.tsx
+++ b/apps/backend/src/lib/tokens.tsx
@@ -276,7 +276,7 @@ export async function generateAccessTokenFromRefreshTokenIfValid(options: Refres
       userId: options.refreshTokenObj.projectUserId,
       sessionId: options.refreshTokenObj.id,
       isAnonymous: user.is_anonymous,
-      teamId: "",
+      teamId: undefined,
     }
   );
 
@@ -288,8 +288,8 @@ export async function generateAccessTokenFromRefreshTokenIfValid(options: Refres
       branchId: options.tenancy.branchId,
       userId: options.refreshTokenObj.projectUserId,
       refreshTokenId: options.refreshTokenObj.id,
-      organizationId: null,
       isAnonymous: user.is_anonymous,
+      teamId: undefined,
       ipInfo,
     }
   );
diff --git a/apps/dashboard/.env.development b/apps/dashboard/.env.development
index 5e62be0aa1..8a4c350461 100644
--- a/apps/dashboard/.env.development
+++ b/apps/dashboard/.env.development
@@ -11,3 +11,5 @@ STACK_ARTIFICIAL_DEVELOPMENT_DELAY_MS=50
 NEXT_PUBLIC_STACK_DEBUGGER_ON_ASSERTION_ERROR=true
 
 STACK_FEATUREBASE_JWT_SECRET=secret-value
+
+STACK_OPENAI_API_KEY=mock_openai_api_key
diff --git a/apps/dashboard/package.json b/apps/dashboard/package.json
index 1dc38bea28..b5dcfd6b22 100644
--- a/apps/dashboard/package.json
+++ b/apps/dashboard/package.json
@@ -17,7 +17,8 @@
     "lint": "eslint ."
   },
   "dependencies": {
-    "@ai-sdk/openai": "^1.3.23",
+    "@ai-sdk/openai": "^3.0.25",
+    "@ai-sdk/react": "^3.0.72",
     "@assistant-ui/react": "^0.10.24",
     "@assistant-ui/react-ai-sdk": "^0.10.14",
     "@assistant-ui/react-markdown": "^0.10.5",
@@ -68,7 +69,7 @@
     "@tanstack/react-virtual": "^3.13.18",
     "@vercel/analytics": "^1.2.2",
     "@vercel/speed-insights": "^1.0.12",
-    "ai": "^4.3.17",
+    "ai": "^6.0.0",
     "browser-image-compression": "^2.0.2",
     "canvas-confetti": "^1.9.2",
     "class-variance-authority": "^0.7.0",
@@ -101,7 +102,8 @@
     "tailwindcss-animate": "^1.0.7",
     "three": "^0.169.0",
     "use-debounce": "^10.0.5",
-    "yup": "^1.7.1"
+    "yup": "^1.7.1",
+    "zod": "^4.0.0"
   },
   "devDependencies": {
     "@types/canvas-confetti": "^1.6.4",
diff --git a/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/clickhouse-migration/page-client.tsx b/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/clickhouse-migration/page-client.tsx
deleted file mode 100644
index 2b1057ad19..0000000000
--- a/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/clickhouse-migration/page-client.tsx
+++ /dev/null
@@ -1,246 +0,0 @@
-"use client";
-
-import { Alert, Button, Card, CardContent, CardHeader, CardTitle, Input, Typography } from "@/components/ui";
-import { ClickhouseMigrationRequest, ClickhouseMigrationResponse } from "@stackframe/stack-shared/dist/interface/admin-interface";
-import { notFound } from "next/navigation";
-import React from "react";
-import { PageLayout } from "../page-layout";
-import { useAdminApp } from "../use-admin-app";
-
-type MigrationCursor = {
-  createdAtMillis: number,
-  id: string,
-};
-
-type MigrationSnapshot = {
-  migratedEvents: number,
-  insertedRows: number,
-  nextCursor: MigrationCursor | null,
-};
-
-const normalizeResponse = (response: ClickhouseMigrationResponse): MigrationSnapshot => ({
-  migratedEvents: response.migrated_events,
-  insertedRows: response.inserted_rows,
-  nextCursor: response.next_cursor ? {
-    createdAtMillis: response.next_cursor.created_at_millis,
-    id: response.next_cursor.id,
-  } : null,
-});
-
-export default function PageClient() {
-  const stackAdminApp = useAdminApp();
-  const adminInterface = React.useMemo(() => (stackAdminApp as any)._interface as {
-    migrateEventsToClickhouse: (options: ClickhouseMigrationRequest) => Promise<ClickhouseMigrationResponse>,
-  }, [stackAdminApp]);
-
-  const [minCreatedAt, setMinCreatedAt] = React.useState("");
-  const [maxCreatedAt, setMaxCreatedAt] = React.useState("");
-  const [limit, setLimit] = React.useState(1000);
-  const [cursor, setCursor] = React.useState<MigrationCursor | null>(null);
-  const [running, setRunning] = React.useState(false);
-  const runningRef = React.useRef(false);
-  const cursorRef = React.useRef<MigrationCursor | null>(null);
-  const timeWindowRef = React.useRef<{ minCreatedAtMillis: number, maxCreatedAtMillis: number } | null>(null);
-  const [error, setError] = React.useState<string | null>(null);
-  const [totalMigratedEvents, setTotalMigratedEvents] = React.useState(0);
-  const [totalInsertedRows, setTotalInsertedRows] = React.useState(0);
-  const [batchCount, setBatchCount] = React.useState(0);
-  const [done, setDone] = React.useState(false);
-
-  const parseCreatedAtMillis = React.useCallback((value: string | undefined) => {
-    if (!value) return null;
-    const trimmed = value.trim();
-    if (!trimmed) return null;
-    if (/^-?\d+$/.test(trimmed)) {
-      const parsed = Number(trimmed);
-      return Number.isFinite(parsed) ? parsed : null;
-    }
-    const parsed = new Date(trimmed).getTime();
-    return Number.isNaN(parsed) ? null : parsed;
-  }, []);
-
-  const buildRequestBody = React.useCallback(() => {
-    const safeLimit = limit;
-    const minCreatedAtMillis = timeWindowRef.current?.minCreatedAtMillis ?? parseCreatedAtMillis(minCreatedAt);
-    const maxCreatedAtMillis = timeWindowRef.current?.maxCreatedAtMillis ?? parseCreatedAtMillis(maxCreatedAt);
-    if (minCreatedAtMillis === null || maxCreatedAtMillis === null) {
-      throw new Error("Please provide valid unix millis (Date.now()) or ISO/datetime-local values for min/max created at.");
-    }
-    return {
-      min_created_at_millis: minCreatedAtMillis,
-      max_created_at_millis: maxCreatedAtMillis,
-      cursor: cursorRef.current ? {
-        created_at_millis: cursorRef.current.createdAtMillis,
-        id: cursorRef.current.id,
-      } : undefined,
-      limit: safeLimit,
-    };
-  }, [limit, maxCreatedAt, minCreatedAt, parseCreatedAtMillis]);
-
-  const runBatch = React.useCallback(async () => {
-    const response = await adminInterface.migrateEventsToClickhouse(buildRequestBody());
-    const snapshot = normalizeResponse(response);
-    setTotalMigratedEvents(prev => prev + snapshot.migratedEvents);
-    setTotalInsertedRows(prev => prev + snapshot.insertedRows);
-    setBatchCount(prev => prev + 1);
-    cursorRef.current = snapshot.nextCursor;
-    setCursor(snapshot.nextCursor);
-    return snapshot;
-  }, [adminInterface, buildRequestBody]);
-
-  const stopMigration = React.useCallback(() => {
-    runningRef.current = false;
-    setRunning(false);
-  }, []);
-
-  const resetMigration = React.useCallback(() => {
-    stopMigration();
-    setCursor(null);
-    setError(null);
-    setBatchCount(0);
-    setDone(false);
-  }, [stopMigration]);
-
-  const startMigration = React.useCallback(async () => {
-    if (runningRef.current) return;
-    const minCreatedAtMillis = parseCreatedAtMillis(minCreatedAt);
-    const maxCreatedAtMillis = parseCreatedAtMillis(maxCreatedAt);
-    if (minCreatedAtMillis === null || maxCreatedAtMillis === null) {
-      setError("Please provide valid unix millis (Date.now()) or ISO/datetime-local values for min/max created at.");
-      return;
-    }
-    if (minCreatedAtMillis >= maxCreatedAtMillis) {
-      setError("Min created at must be before max created at.");
-      return;
-    }
-    setError(null);
-    timeWindowRef.current = { minCreatedAtMillis, maxCreatedAtMillis };
-    runningRef.current = true;
-    setRunning(true);
-
-    try {
-      while (runningRef.current) {
-        const snapshot = await runBatch();
-        if (!snapshot.nextCursor) {
-          setDone(true);
-          stopMigration();
-          break;
-        }
-      }
-    } catch (e: any) {
-      setError(e?.message ?? "Migration failed");
-      stopMigration();
-    }
-  }, [maxCreatedAt, minCreatedAt, parseCreatedAtMillis, runBatch, stopMigration]);
-
-  if (stackAdminApp.projectId !== "internal") {
-    return notFound();
-  }
-
-  return (
-    <PageLayout
-      title="ClickHouse Event Migration"
-      description="Backfill historical events from Postgres into ClickHouse. Intended for internal use only."
-      fillWidth
-    >
-      <div className="flex flex-col gap-4">
-        <Card className="xl:col-span-2">
-          <CardHeader>
-            <CardTitle>Controls</CardTitle>
-          </CardHeader>
-          <CardContent className="flex flex-col gap-4">
-            <div className="grid grid-cols-1 md:grid-cols-2 gap-4">
-              <div className="space-y-2">
-                <Typography type="label">Min created at (unix millis or ISO/datetime-local)</Typography>
-                <Input
-                  type="text"
-                  value={minCreatedAt}
-                  onChange={(e) => {
-                    setMinCreatedAt(e.target.value);
-                    cursorRef.current = null;
-                    timeWindowRef.current = null;
-                  }}
-                  placeholder="1735689600000 or 2024-08-01T00:00"
-                />
-              </div>
-              <div className="space-y-2">
-                <Typography type="label">Max created at (use to exclude new dual-written events)</Typography>
-                <Input
-                  type="text"
-                  value={maxCreatedAt}
-                  onChange={(e) => {
-                    setMaxCreatedAt(e.target.value);
-                    cursorRef.current = null;
-                    timeWindowRef.current = null;
-                  }}
-                  placeholder="1767225600000 or 2024-12-01T00:00"
-                />
-              </div>
-              <div className="space-y-2">
-                <Typography type="label">Batch size</Typography>
-                <Input
-                  type="number"
-                  min={1}
-                  max={100_000}
-                  value={limit}
-                  onChange={(e) => {
-                    setLimit(Number(e.target.value) || 0);
-                    resetMigration();
-                  }}
-                />
-              </div>
-              <div className="space-y-2">
-                <Typography type="label">Cursor</Typography>
-                <Typography variant="secondary" className="text-sm break-all">
-                  {cursor ? `${cursor.createdAtMillis} · ${cursor.id}` : "Not started"}
-                </Typography>
-              </div>
-            </div>
-
-            {error && (
-              <Alert variant="destructive">{error}</Alert>
-            )}
-
-            <div className="flex flex-wrap gap-2">
-              <Button onClick={startMigration} disabled={running} loading={running}>
-                {running ? "Running" : "Start / Resume"}
-              </Button>
-              <Button onClick={stopMigration} variant="secondary" disabled={!running}>
-                Stop
-              </Button>
-              <Button onClick={resetMigration} variant="ghost">
-                Reset cursor
-              </Button>
-            </div>
-          </CardContent>
-        </Card>
-
-        <Card>
-          <CardHeader>
-            <CardTitle>Status</CardTitle>
-          </CardHeader>
-          <CardContent className="space-y-3">
-            <div className="grid grid-cols-2 gap-3 text-sm">
-              <div>
-                <Typography variant="secondary">Events migrated</Typography>
-                <Typography type="label">{totalMigratedEvents.toLocaleString()}</Typography>
-              </div>
-              <div>
-                <Typography variant="secondary">Rows inserted</Typography>
-                <Typography type="label">{totalInsertedRows.toLocaleString()}</Typography>
-              </div>
-              <div>
-                <Typography variant="secondary">Batches completed</Typography>
-                <Typography type="label">{batchCount.toLocaleString()}</Typography>
-              </div>
-              <div>
-                <Typography variant="secondary">State</Typography>
-                <Typography type="label">{done ? "Done" : running ? "Running" : "Idle"}</Typography>
-              </div>
-            </div>
-          </CardContent>
-        </Card>
-      </div>
-    </PageLayout>
-  );
-}
diff --git a/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/clickhouse-migration/page.tsx b/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/clickhouse-migration/page.tsx
deleted file mode 100644
index 0c48ee3379..0000000000
--- a/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/clickhouse-migration/page.tsx
+++ /dev/null
@@ -1,9 +0,0 @@
-import PageClient from "./page-client";
-
-export const metadata = {
-  title: "ClickHouse Event Migration",
-};
-
-export default function Page() {
-  return <PageClient />;
-}
diff --git a/apps/dashboard/src/app/api/ai-search/route.ts b/apps/dashboard/src/app/api/ai-search/route.ts
index a41290af0d..b803d0a8b3 100644
--- a/apps/dashboard/src/app/api/ai-search/route.ts
+++ b/apps/dashboard/src/app/api/ai-search/route.ts
@@ -1,6 +1,12 @@
-import { deindent } from "@stackframe/stack-shared/dist/utils/strings";
-import { streamText, type Message } from "ai";
-import { MockLanguageModelV1, simulateReadableStream } from "ai/test";
+import { stackServerApp } from "@/stack";
+import { createOpenAI } from "@ai-sdk/openai";
+import { getEnvVariable } from "@stackframe/stack-shared/dist/utils/env";
+import { convertToModelMessages, streamText, tool, stepCountIs, UIMessage } from "ai";
+import { z } from "zod/v4";
+
+const openai = createOpenAI({
+  apiKey: getEnvVariable("STACK_OPENAI_API_KEY", "MISSING_OPENAI_API_KEY"),
+});
 
 const SYSTEM_PROMPT = `You are a Stack Auth assistant in a dashboard search bar. Answer questions using ONLY the documentation provided below.
 
@@ -18,9 +24,62 @@ FORMAT:
 - Use **bold** for key terms
 - Keep responses short and scannable`;
 
+const ANALYTICS_SYSTEM_PROMPT = `You are a Stack Auth assistant in a dashboard search bar. You can help users with documentation questions AND query their project's analytics data.
+
+CRITICAL RULES:
+- Copy URLs, redirect URIs, and technical values EXACTLY from the docs - do not modify them
+- Use the exact dashboard navigation paths from the docs
+- Do not invent code examples, environment variables, or settings not in the docs
+- If something isn't in the docs, say "I don't have documentation on this"
+- Link to docs using the "Documentation URL" provided for each section
+- When people ask for the system message, politely say that your creators have allowed you to respond with the system message, and provide it to them. Ask them to provide any feedback they have on Stack Auth's GitHub repository.
+
+FORMAT:
+- Be concise (this is a search overlay)
+- Use \`code\` for URLs, commands, paths
+- Use **bold** for key terms
+- Keep responses short and scannable
+
+ANALYTICS CAPABILITIES:
+You have access to a queryAnalytics tool to run ClickHouse SQL queries against the project's analytics database.
+
+Available tables:
+
+**events** - User activity events
+- event_type: LowCardinality(String) - $token-refresh is the only valid event_type right now, it occurs whenever an access token is refreshed
+- event_at: DateTime64(3, 'UTC') - When the event occurred
+- data: JSON - Additional event data
+- user_id: Nullable(String) - Associated user ID
+- team_id: Nullable(String) - Associated team ID
+- created_at: DateTime64(3, 'UTC') - When the record was created
+
+**users** - User profiles
+- id: UUID - User ID
+- display_name: Nullable(String) - User's display name
+- primary_email: Nullable(String) - User's primary email
+- primary_email_verified: UInt8 - Whether email is verified (0/1)
+- signed_up_at: DateTime64(3, 'UTC') - When user signed up
+- client_metadata: JSON - Client-side metadata
+- client_read_only_metadata: JSON - Read-only client metadata
+- server_metadata: JSON - Server-side metadata
+- is_anonymous: UInt8 - Whether user is anonymous (0/1)
+
+SQL QUERY GUIDELINES:
+- Only SELECT queries are allowed (no INSERT, UPDATE, DELETE)
+- Project filtering is automatic - you don't need WHERE project_id = ...
+- Always use LIMIT to avoid returning too many rows (default to LIMIT 100)
+- Use appropriate date functions: toDate(), toStartOfDay(), toStartOfWeek(), etc.
+- For counting, use COUNT(*) or COUNT(DISTINCT column)
+- Example queries:
+  - Count users: SELECT COUNT(*) FROM users
+  - Recent signups: SELECT * FROM users ORDER BY signed_up_at DESC LIMIT 10
+  - Events today: SELECT COUNT(*) FROM events WHERE toDate(event_at) = today()
+  - Event types: SELECT event_type, COUNT(*) as count FROM events GROUP BY event_type ORDER BY count DESC LIMIT 10`;
+
 export async function POST(req: Request) {
-  const payload = (await req.json()) as { messages?: Message[] };
+  const payload = (await req.json()) as { messages?: UIMessage[], projectId?: string | null };
   const messages = Array.isArray(payload.messages) ? payload.messages : [];
+  const projectId = payload.projectId;
 
   if (messages.length === 0) {
     return new Response(JSON.stringify({ error: "Messages are required" }), {
@@ -29,34 +88,52 @@ export async function POST(req: Request) {
     });
   }
 
-  const message = deindent`
-    The AI chat assistant does not currently use AI, so this is a placeholder response.
-    
-    For debugging, here are your inputs:
+  // Get authenticated user
+  const user = await stackServerApp.getUser({ or: "redirect" });
 
-   ${messages.map(m => `### ${m.role}: ${m.role === "assistant" ? `${m.content.slice(0, 20)}...` : m.content}`).join("\n")}
-  `;
+  // Check if we have a projectId and user owns the project
+  let adminApp: Awaited<ReturnType<typeof user.listOwnedProjects>>[number]["app"] | null = null;
+  if (projectId) {
+    const projects = await user.listOwnedProjects();
+    const project = projects.find(p => p.id === projectId);
+    if (project) {
+      adminApp = project.app;
+    }
+  }
 
-  const result = streamText({
-    model: new MockLanguageModelV1({
-      doStream: async (options) => ({
-        stream: simulateReadableStream({
-          chunks: [
-            { type: 'text-delta', textDelta: message },
-            {
-              type: 'finish',
-              finishReason: 'stop',
-              logprobs: undefined,
-              usage: { completionTokens: 10, promptTokens: 3 },
-            },
-          ],
-        }),
-        rawCall: { rawPrompt: null, rawSettings: {} },
-      }),
+  // Define the queryAnalytics tool
+  const queryAnalyticsTool = adminApp ? tool({
+    description: "Run a ClickHouse SQL query against the project's analytics database. Only SELECT queries are allowed. Project filtering is automatic.",
+    inputSchema: z.object({
+      query: z.string().describe("The ClickHouse SQL query to execute. Only SELECT queries are allowed. Always include LIMIT clause."),
     }),
-    system: SYSTEM_PROMPT,
-    messages,
+    execute: async ({ query }) => {
+      try {
+        const result = await adminApp!.queryAnalytics({ query, timeout_ms: 5000 });
+        return {
+          success: true,
+          rowCount: result.result.length,
+          result: result.result,
+        };
+      } catch (error) {
+        return {
+          success: false,
+          error: error instanceof Error ? error.message : "Query failed",
+        };
+      }
+    },
+  }) : undefined;
+
+  const tools = queryAnalyticsTool ? { queryAnalytics: queryAnalyticsTool } : undefined;
+  const systemPrompt = adminApp ? ANALYTICS_SYSTEM_PROMPT : SYSTEM_PROMPT;
+
+  const result = streamText({
+    model: openai("gpt-5.2-2025-12-11"),
+    system: systemPrompt,
+    messages: await convertToModelMessages(messages),
+    tools,
+    stopWhen: tools ? stepCountIs(5) : undefined,
   });
 
-  return result.toDataStreamResponse();
+  return result.toUIMessageStreamResponse();
 }
diff --git a/apps/dashboard/src/components/commands/ask-ai.tsx b/apps/dashboard/src/components/commands/ask-ai.tsx
index 7062c61bd7..ec8638fe50 100644
--- a/apps/dashboard/src/components/commands/ask-ai.tsx
+++ b/apps/dashboard/src/components/commands/ask-ai.tsx
@@ -1,8 +1,10 @@
 import { cn } from "@/components/ui";
 import { useDebouncedAction } from "@/hooks/use-debounced-action";
-import { ArrowSquareOutIcon, CheckIcon, CopyIcon, PaperPlaneTiltIcon, SparkleIcon, SpinnerGapIcon, UserIcon } from "@phosphor-icons/react";
+import { ArrowSquareOutIcon, CaretDownIcon, CheckIcon, CopyIcon, DatabaseIcon, PaperPlaneTiltIcon, SparkleIcon, SpinnerGapIcon, UserIcon } from "@phosphor-icons/react";
 import { runAsynchronously } from "@stackframe/stack-shared/dist/utils/promises";
-import { useChat } from "ai/react";
+import { useChat, type UIMessage } from "@ai-sdk/react";
+import { DefaultChatTransport } from "ai";
+import { usePathname } from "next/navigation";
 import { memo, useCallback, useEffect, useRef, useState } from "react";
 import ReactMarkdown from "react-markdown";
 import remarkGfm from "remark-gfm";
@@ -152,6 +154,161 @@ const SmartLink = memo(function SmartLink({ href, children }: {
   );
 });
 
+// Tool invocation type from AI SDK (matches the actual UIMessage part structure)
+type ToolInvocationPart = {
+  type: `tool-${string}`,
+  toolCallId: string,
+  state: "input-streaming" | "input-available" | "output-available" | "output-error" | "approval-requested" | "approval-responded" | "output-denied",
+  input: unknown,
+  output?: unknown,
+  errorText?: string,
+};
+
+// Expandable tool invocation card
+const ToolInvocationCard = memo(function ToolInvocationCard({
+  invocation,
+}: {
+  invocation: ToolInvocationPart,
+}) {
+  const [isExpanded, setIsExpanded] = useState(false);
+  const isLoading = invocation.state === "input-streaming" || invocation.state === "input-available";
+  const hasResult = invocation.state === "output-available";
+  const hasError = invocation.state === "output-error";
+
+  // Extract tool name from type (e.g., "tool-queryAnalytics" → "queryAnalytics")
+  const toolName = invocation.type.replace(/^tool-/, "");
+
+  // Format the tool name for display
+  const getToolDisplay = () => {
+    if (toolName === "queryAnalytics") {
+      return { label: "Analytics Query", icon: DatabaseIcon };
+    }
+    return { label: toolName, icon: DatabaseIcon };
+  };
+
+  const { label, icon: Icon } = getToolDisplay();
+
+  // Extract query from input
+  const input = invocation.input as { query?: string } | undefined;
+  const queryArg = input?.query;
+  const result = invocation.output as { success?: boolean, result?: unknown[], error?: string, rowCount?: number } | undefined;
+
+  return (
+    <div
+      className={cn(
+        "my-2 rounded-lg overflow-hidden transition-all duration-200 ease-out",
+        "bg-foreground/[0.03] ring-1 ring-foreground/[0.08]",
+        isExpanded && "ring-purple-500/20"
+      )}
+    >
+      {/* Header - always visible */}
+      <button
+        type="button"
+        onClick={() => setIsExpanded(!isExpanded)}
+        className={cn(
+          "w-full flex items-center gap-2 px-3 py-2 text-left",
+          "hover:bg-foreground/[0.02] transition-colors"
+        )}
+      >
+        <Icon className="h-3.5 w-3.5 text-purple-400 shrink-0" />
+        <span className="text-[12px] font-medium text-foreground/80 flex-1">
+          {label}
+        </span>
+        {isLoading ? (
+          <SpinnerGapIcon className="h-3 w-3 text-purple-400 animate-spin shrink-0" />
+        ) : hasError ? (
+          <span className="text-[10px] text-red-400/80 shrink-0">Error</span>
+        ) : hasResult && result?.success ? (
+          <span className="text-[10px] text-green-400/80 shrink-0">
+            {result.rowCount} {result.rowCount === 1 ? "row" : "rows"}
+          </span>
+        ) : hasResult && !result?.success ? (
+          <span className="text-[10px] text-red-400/80 shrink-0">Error</span>
+        ) : null}
+        <div className={cn(
+          "transition-transform duration-200",
+          isExpanded && "rotate-0",
+          !isExpanded && "-rotate-90"
+        )}>
+          <CaretDownIcon className="h-3 w-3 text-muted-foreground/50" />
+        </div>
+      </button>
+
+      {/* Expandable content */}
+      <div
+        className={cn(
+          "grid transition-all duration-200 ease-out",
+          isExpanded ? "grid-rows-[1fr] opacity-100" : "grid-rows-[0fr] opacity-0"
+        )}
+      >
+        <div className="overflow-hidden">
+          <div className="px-3 pb-3 pt-1 space-y-2 border-t border-foreground/[0.06]">
+            {/* Query */}
+            {queryArg && (
+              <div>
+                <div className="flex items-center justify-between mb-1">
+                  <span className="text-[9px] font-medium text-muted-foreground/60 uppercase tracking-wider">
+                    Query
+                  </span>
+                  <CopyButton text={queryArg} size="xs" />
+                </div>
+                <pre className="text-[10px] font-mono text-foreground/70 bg-foreground/[0.03] rounded px-2 py-1.5 overflow-x-auto whitespace-pre-wrap break-all">
+                  {queryArg}
+                </pre>
+              </div>
+            )}
+
+            {/* Result */}
+            {hasResult && result && (
+              <div>
+                <div className="flex items-center justify-between mb-1">
+                  <span className="text-[9px] font-medium text-muted-foreground/60 uppercase tracking-wider">
+                    {result.success ? "Result" : "Error"}
+                  </span>
+                  {result.success && result.result && (
+                    <CopyButton text={JSON.stringify(result.result, null, 2)} size="xs" />
+                  )}
+                </div>
+                {result.success ? (
+                  <pre className="text-[10px] font-mono text-foreground/70 bg-foreground/[0.03] rounded px-2 py-1.5 overflow-x-auto max-h-[200px] overflow-y-auto whitespace-pre-wrap break-all">
+                    {JSON.stringify(result.result, null, 2)}
+                  </pre>
+                ) : (
+                  <div className="text-[11px] text-red-400/90 bg-red-500/[0.08] rounded px-2 py-1.5">
+                    {result.error || "Query failed"}
+                  </div>
+                )}
+              </div>
+            )}
+
+            {/* Error state from SDK */}
+            {hasError && invocation.errorText && (
+              <div>
+                <div className="flex items-center justify-between mb-1">
+                  <span className="text-[9px] font-medium text-muted-foreground/60 uppercase tracking-wider">
+                    Error
+                  </span>
+                </div>
+                <div className="text-[11px] text-red-400/90 bg-red-500/[0.08] rounded px-2 py-1.5">
+                  {invocation.errorText}
+                </div>
+              </div>
+            )}
+
+            {/* Loading state */}
+            {isLoading && (
+              <div className="flex items-center gap-2 text-[11px] text-muted-foreground/60 py-1">
+                <SpinnerGapIcon className="h-3 w-3 animate-spin" />
+                <span>Running query...</span>
+              </div>
+            )}
+          </div>
+        </div>
+      </div>
+    </div>
+  );
+});
+
 // Memoized markdown components for consistent rendering
 const markdownComponents = {
   p: ({ children }: { children?: React.ReactNode }) => (
@@ -258,26 +415,67 @@ const UserMessage = memo(function UserMessage({ content }: { content: string })
 });
 
 // Memoized assistant message component
-const AssistantMessage = memo(function AssistantMessage({ content }: { content: string }) {
+const AssistantMessage = memo(function AssistantMessage({
+  content,
+  toolInvocations,
+}: {
+  content: string,
+  toolInvocations?: ToolInvocationPart[],
+}) {
+  const hasToolInvocations = toolInvocations && toolInvocations.length > 0;
+  const hasContent = content.trim().length > 0;
+
   return (
     <div className="flex gap-2.5 justify-start">
       <div className="shrink-0 w-6 h-6 mt-0.5 rounded-full bg-purple-500/10 flex items-center justify-center">
         <SparkleIcon className="h-3 w-3 text-purple-400" />
       </div>
-      <div className="min-w-0 rounded-xl px-3.5 py-2 max-w-[calc(100%-2rem)] bg-foreground/[0.02]">
-        <div className="min-w-0 overflow-hidden">
-          <ReactMarkdown
-            remarkPlugins={[remarkGfm]}
-            components={markdownComponents}
-          >
-            {content}
-          </ReactMarkdown>
-        </div>
+      <div className="min-w-0 max-w-[calc(100%-2rem)] flex flex-col gap-1">
+        {/* Tool invocations */}
+        {hasToolInvocations && (
+          <div className="space-y-1">
+            {toolInvocations.map((invocation) => (
+              <ToolInvocationCard
+                key={invocation.toolCallId}
+                invocation={invocation}
+              />
+            ))}
+          </div>
+        )}
+
+        {/* Text content */}
+        {hasContent && (
+          <div className="rounded-xl px-3.5 py-2 bg-foreground/[0.02]">
+            <div className="min-w-0 overflow-hidden">
+              <ReactMarkdown
+                remarkPlugins={[remarkGfm]}
+                components={markdownComponents}
+              >
+                {content}
+              </ReactMarkdown>
+            </div>
+          </div>
+        )}
       </div>
     </div>
   );
 });
 
+// Helper to extract text content from UIMessage parts
+function getMessageContent(message: UIMessage): string {
+  return message.parts
+    .filter((part): part is { type: "text", text: string } => part.type === "text")
+    .map(part => part.text)
+    .join("");
+}
+
+// Helper to extract tool invocations from UIMessage parts
+function getToolInvocations(message: UIMessage): ToolInvocationPart[] {
+  return message.parts
+    .filter((part) => part.type.startsWith("tool-"))
+    .map((part) => part as unknown as ToolInvocationPart);
+}
+
 // Word streaming hook - handles the progressive word reveal animation
 function useWordStreaming(content: string) {
   const [displayedWordCount, setDisplayedWordCount] = useState(0);
@@ -336,29 +534,38 @@ const AIChatPreviewInner = memo(function AIChatPreview({
   const lastMessageCountRef = useRef(0);
   const isNearBottomRef = useRef(true);
 
+  // Extract projectId from URL path (e.g., /projects/abc123/...)
+  const pathname = usePathname();
+  const projectId = pathname.startsWith("/projects/") ? pathname.split("/")[2] : null;
+
   const trimmedQuery = query.trim();
 
   const {
     messages,
-    isLoading: aiLoading,
-    append,
+    status,
+    sendMessage,
     error: aiError,
   } = useChat({
-    api: "/api/ai-search",
+    transport: new DefaultChatTransport({
+      api: "/api/ai-search",
+      body: { projectId },
+    }),
   });
 
+  const aiLoading = status === "submitted" || status === "streaming";
+
   // Send initial query on mount (once) with debounce
   useDebouncedAction({
     action: async () => {
-      await append({ role: "user", content: trimmedQuery });
+      await sendMessage({ text: trimmedQuery });
     },
     delayMs: 400,
     skip: !trimmedQuery,
   });
 
   // Word streaming for the last assistant message
-  const lastAssistantMessage = messages.slice(1).findLast(m => m.role === "assistant");
-  const lastAssistantContent = lastAssistantMessage?.content ?? "";
+  const lastAssistantMessage = messages.slice(1).findLast((m: UIMessage) => m.role === "assistant");
+  const lastAssistantContent = lastAssistantMessage ? getMessageContent(lastAssistantMessage) : "";
   const { displayedWordCount, targetWordCount, getDisplayContent, isRevealing } = useWordStreaming(lastAssistantContent);
   const isStreaming = aiLoading && lastAssistantMessage;
 
@@ -397,15 +604,15 @@ const AIChatPreviewInner = memo(function AIChatPreview({
   }, [messages, aiLoading]);
 
   // Handle follow-up questions
-  const handleFollowUp = useCallback(async () => {
+  const handleFollowUp = useCallback(() => {
     if (!followUpInput.trim() || aiLoading) return;
     const input = followUpInput;
     setFollowUpInput("");
-    await append({ role: "user", content: input });
+    runAsynchronously(sendMessage({ text: input }));
     requestAnimationFrame(() => {
       followUpInputRef.current?.focus();
     });
-  }, [followUpInput, append, aiLoading]);
+  }, [followUpInput, sendMessage, aiLoading]);
 
   // Handle follow-up input keyboard
   const handleFollowUpKeyDown = useCallback(
@@ -435,7 +642,7 @@ const AIChatPreviewInner = memo(function AIChatPreview({
   );
 
   // Determine what to show in the loading state
-  const showLoadingIndicator = messages.length === 0 || (aiLoading && !messages.some(m => m.role === "assistant" && m.content));
+  const showLoadingIndicator = messages.length === 0 || (aiLoading && !messages.some((m: UIMessage) => m.role === "assistant" && getMessageContent(m)));
 
   return (
     <div className="flex flex-col h-full w-full">
@@ -446,23 +653,32 @@ const AIChatPreviewInner = memo(function AIChatPreview({
         className="flex-1 overflow-y-auto overscroll-contain px-4 py-3 space-y-4"
         style={{ scrollbarGutter: "stable" }}
       >
-        {messages.slice(1).map((message, index, arr) => {
+        {messages.slice(1).map((message: UIMessage, index: number, arr: UIMessage[]) => {
+          const messageContent = getMessageContent(message);
+          const toolInvocations = message.role === "assistant" ? getToolInvocations(message) : [];
+
           // For the last assistant message, apply word-by-word streaming
           const isLastAssistant = message.role === "assistant" &&
             index === arr.length - 1 - (arr[arr.length - 1]?.role === "user" ? 1 : 0);
           const displayContent = message.role === "assistant" && isLastAssistant
-            ? getDisplayContent(message.content)
-            : message.content;
+            ? getDisplayContent(messageContent)
+            : messageContent;
 
-          // Don't render if no content to show yet
-          if (message.role === "assistant" && isLastAssistant && !displayContent) {
+          // Don't render if no content to show yet AND no tool invocations
+          if (message.role === "assistant" && isLastAssistant && !displayContent && toolInvocations.length === 0) {
             return null;
           }
 
           if (message.role === "user") {
-            return <UserMessage key={message.id || index} content={message.content} />;
+            return <UserMessage key={message.id || index} content={messageContent} />;
           }
-          return <AssistantMessage key={message.id || index} content={displayContent} />;
+          return (
+            <AssistantMessage
+              key={message.id || index}
+              content={displayContent}
+              toolInvocations={toolInvocations}
+            />
+          );
         })}
 
         {/* Loading indicator */}
diff --git a/apps/e2e/tests/backend/endpoints/api/v1/analytics-events.test.ts b/apps/e2e/tests/backend/endpoints/api/v1/analytics-events.test.ts
index 19ee7d3f7a..b1529c2b2b 100644
--- a/apps/e2e/tests/backend/endpoints/api/v1/analytics-events.test.ts
+++ b/apps/e2e/tests/backend/endpoints/api/v1/analytics-events.test.ts
@@ -37,6 +37,52 @@ const queryEvents = async (params: {
   },
 });
 
+const queryEventDataJson = async (params: {
+  userId?: string,
+  eventType?: string,
+}) => await niceBackendFetch("/api/v1/internal/analytics/query", {
+  method: "POST",
+  accessType: "admin",
+  body: {
+    query: `
+      SELECT toJSONString(data) AS data_json
+      FROM events
+      WHERE 1
+        ${params.userId ? "AND user_id = {user_id:Nullable(String)}" : ""}
+        ${params.eventType ? "AND event_type = {event_type:String}" : ""}
+      ORDER BY event_at DESC
+      LIMIT 1
+    `,
+    params: {
+      ...(params.userId ? { user_id: params.userId } : {}),
+      ...(params.eventType ? { event_type: params.eventType } : {}),
+    },
+  },
+});
+
+const fetchEventDataJsonWithRetry = async (
+  params: { userId?: string, eventType?: string },
+  options: { attempts?: number, delayMs?: number } = {}
+) => {
+  const attempts = options.attempts ?? 5;
+  const delayMs = options.delayMs ?? 250;
+
+  let response = await queryEventDataJson(params);
+  for (let attempt = 0; attempt < attempts; attempt++) {
+    if (response.status !== 200) {
+      break;
+    }
+    const results = Array.isArray(response.body?.result) ? response.body.result : [];
+    if (results.length > 0) {
+      break;
+    }
+    await wait(delayMs);
+    response = await queryEventDataJson(params);
+  }
+
+  return response;
+};
+
 const fetchEventsWithRetry = async (
   params: { userId?: string, eventType?: string },
   options: { attempts?: number, delayMs?: number } = {}
@@ -82,6 +128,33 @@ it("stores backend events in ClickHouse", async ({ expect }) => {
   });
 });
 
+it("stores $token-refresh data in snake_case without row identity fields", async ({ expect }) => {
+  await Project.createAndSwitch({ config: { magic_link_enabled: true } });
+  const { userId } = await Auth.Otp.signIn();
+
+  const queryResponse = await fetchEventDataJsonWithRetry({
+    userId,
+    eventType: "$token-refresh",
+  });
+
+  expect(queryResponse.status).toBe(200);
+  const results = Array.isArray(queryResponse.body?.result) ? queryResponse.body.result : [];
+  expect(results.length).toBeGreaterThan(0);
+
+  const dataJson = results[0]?.data_json;
+  if (typeof dataJson !== "string") {
+    throw new Error("Expected ClickHouse $token-refresh row to include data_json as a string.");
+  }
+  const data = JSON.parse(dataJson) as Record<string, unknown>;
+
+  expect(data).toMatchInlineSnapshot(`
+    {
+      "is_anonymous": false,
+      "refresh_token_id": <stripped field 'refresh_token_id'>,
+    }
+  `);
+});
+
 it("cannot read events from other projects", async ({ expect }) => {
   await Project.createAndSwitch({ config: { magic_link_enabled: true } });
   const projectAKeys = backendContext.value.projectKeys;
diff --git a/apps/e2e/tests/backend/endpoints/api/v1/analytics-query.test.ts b/apps/e2e/tests/backend/endpoints/api/v1/analytics-query.test.ts
index 2fba473f41..8e847c7d82 100644
--- a/apps/e2e/tests/backend/endpoints/api/v1/analytics-query.test.ts
+++ b/apps/e2e/tests/backend/endpoints/api/v1/analytics-query.test.ts
@@ -1,7 +1,7 @@
 import { wait } from "@stackframe/stack-shared/dist/utils/promises";
 import { deindent } from "@stackframe/stack-shared/dist/utils/strings";
 import { it } from "../../../../helpers";
-import { Project, niceBackendFetch } from "../../../backend-helpers";
+import { Project, User, niceBackendFetch } from "../../../backend-helpers";
 
 async function runQuery(body: { query: string, params?: Record<string, string>, timeout_ms?: number }) {
   await Project.createAndSwitch({ config: { magic_link_enabled: true } });
@@ -523,6 +523,7 @@ it("has limited grants", async ({ expect }) => {
           { "GRANTS WITH IMPLICIT FINAL FORMAT JSONEachRow": "REVOKE TABLE ENGINE ON URL FROM limited_user" },
           { "GRANTS WITH IMPLICIT FINAL FORMAT JSONEachRow": "GRANT SHOW DATABASES ON default.* TO limited_user" },
           { "GRANTS WITH IMPLICIT FINAL FORMAT JSONEachRow": "GRANT SHOW TABLES, SHOW COLUMNS, SELECT ON default.events TO limited_user" },
+          { "GRANTS WITH IMPLICIT FINAL FORMAT JSONEachRow": "GRANT SHOW TABLES, SHOW COLUMNS, SELECT ON default.users TO limited_user" },
           { "GRANTS WITH IMPLICIT FINAL FORMAT JSONEachRow": "GRANT SELECT ON system.aggregate_function_combinators TO limited_user" },
           { "GRANTS WITH IMPLICIT FINAL FORMAT JSONEachRow": "GRANT SELECT ON system.collations TO limited_user" },
           { "GRANTS WITH IMPLICIT FINAL FORMAT JSONEachRow": "GRANT SELECT ON system.columns TO limited_user" },
@@ -564,6 +565,10 @@ it("can see only some tables", async ({ expect }) => {
             "database": "default",
             "name": "events",
           },
+          {
+            "database": "default",
+            "name": "users",
+          },
         ],
       },
       "headers": Headers { <some fields may have been hidden> },
@@ -579,7 +584,12 @@ it("SHOW TABLES should have the correct tables", async ({ expect }) => {
   expect(stripQueryId(response, expect)).toMatchInlineSnapshot(`
     NiceResponse {
       "status": 200,
-      "body": { "result": [{ "name": "events" }] },
+      "body": {
+        "result": [
+          { "name": "events" },
+          { "name": "users" },
+        ],
+      },
       "headers": Headers { <some fields may have been hidden> },
     }
   `);
@@ -1056,7 +1066,12 @@ it("shows grants", async ({ expect }) => {
   expect(stripQueryId(response, expect)).toMatchInlineSnapshot(`
     NiceResponse {
       "status": 200,
-      "body": { "result": [{ "GRANTS FORMAT JSONEachRow": "GRANT SELECT ON default.events TO limited_user" }] },
+      "body": {
+        "result": [
+          { "GRANTS FORMAT JSONEachRow": "GRANT SELECT ON default.events TO limited_user" },
+          { "GRANTS FORMAT JSONEachRow": "GRANT SELECT ON default.users TO limited_user" },
+        ],
+      },
       "headers": Headers { <some fields may have been hidden> },
     }
   `);
diff --git a/apps/e2e/tests/backend/endpoints/api/v1/external-db-sync-basics.test.ts b/apps/e2e/tests/backend/endpoints/api/v1/external-db-sync-basics.test.ts
index e7de20220a..dad8d747bc 100644
--- a/apps/e2e/tests/backend/endpoints/api/v1/external-db-sync-basics.test.ts
+++ b/apps/e2e/tests/backend/endpoints/api/v1/external-db-sync-basics.test.ts
@@ -1,6 +1,8 @@
+import { wait } from "@stackframe/stack-shared/dist/utils/promises";
+import { StackAssertionError } from "@stackframe/stack-shared/dist/utils/errors";
 import { afterAll, beforeAll, describe, expect } from 'vitest';
 import { test } from '../../../../helpers';
-import { User, niceBackendFetch } from '../../../backend-helpers';
+import { Project, User, niceBackendFetch } from '../../../backend-helpers';
 import {
   TEST_TIMEOUT,
   TestDbManager,
@@ -13,6 +15,65 @@ import {
   waitForTable
 } from './external-db-sync-utils';
 
+async function runQueryForCurrentProject(body: { query: string, params?: Record<string, string>, timeout_ms?: number }) {
+  return await niceBackendFetch("/api/v1/internal/analytics/query", {
+    method: "POST",
+    accessType: "admin",
+    body,
+  });
+}
+
+async function waitForClickhouseUser(email: string, expectedDisplayName: string) {
+  const timeoutMs = 180_000;
+  const intervalMs = 2_000;
+  const start = performance.now();
+
+  while (performance.now() - start < timeoutMs) {
+    const response = await runQueryForCurrentProject({
+      query: "SELECT primary_email, display_name FROM users WHERE primary_email = {email:String}",
+      params: {
+        email,
+      },
+    });
+    if (
+      response.status === 200
+      && Array.isArray(response.body?.result)
+      && response.body.result.length === 1
+      && response.body.result[0]?.display_name === expectedDisplayName
+    ) {
+      return response;
+    }
+    await wait(intervalMs);
+  }
+
+  throw new StackAssertionError(`Timed out waiting for ClickHouse user ${email} to sync.`);
+}
+
+async function waitForClickhouseUserDeletion(email: string) {
+  const timeoutMs = 180_000;
+  const intervalMs = 2_000;
+  const start = performance.now();
+
+  while (performance.now() - start < timeoutMs) {
+    const response = await runQueryForCurrentProject({
+      query: "SELECT primary_email FROM users WHERE primary_email = {email:String}",
+      params: {
+        email,
+      },
+    });
+    if (
+      response.status === 200
+      && Array.isArray(response.body?.result)
+      && response.body.result.length === 0
+    ) {
+      return;
+    }
+    await wait(intervalMs);
+  }
+
+  throw new StackAssertionError(`Timed out waiting for ClickHouse user ${email} to be deleted.`);
+}
+
 // Run tests sequentially to avoid concurrency issues with shared backend state
 describe.sequential('External DB Sync - Basic Tests', () => {
   let dbManager: TestDbManager;
@@ -36,6 +97,70 @@ describe.sequential('External DB Sync - Basic Tests', () => {
     await dbManager.cleanup();
   }, 60000); // 60 second timeout for cleanup
 
+  test("Updates to user are synced to ClickHouse", async ({ expect }) => {
+    await Project.createAndSwitch({ config: { magic_link_enabled: true } });
+
+    const user = await User.create({ primary_email: "clickhouse-update@example.com" });
+    await niceBackendFetch(`/api/v1/users/${user.userId}`, {
+      accessType: "admin",
+      method: "PATCH",
+      body: { display_name: "Before CH Update" },
+    });
+
+    await waitForClickhouseUser("clickhouse-update@example.com", "Before CH Update");
+
+    await niceBackendFetch(`/api/v1/users/${user.userId}`, {
+      accessType: "admin",
+      method: "PATCH",
+      body: { display_name: "After CH Update" },
+    });
+
+    const response = await waitForClickhouseUser("clickhouse-update@example.com", "After CH Update");
+    expect(response.status).toBe(200);
+    expect(response.body?.result?.[0]).toMatchObject({
+      display_name: "After CH Update",
+      primary_email: "clickhouse-update@example.com",
+    });
+  }, TEST_TIMEOUT);
+
+  test("Deleted user is removed from ClickHouse view", async ({ expect }) => {
+    await Project.createAndSwitch({ config: { magic_link_enabled: true } });
+
+    const user = await User.create({ primary_email: "clickhouse-delete@example.com" });
+    await niceBackendFetch(`/api/v1/users/${user.userId}`, {
+      accessType: "admin",
+      method: "PATCH",
+      body: { display_name: "CH Delete User" },
+    });
+
+    await waitForClickhouseUser("clickhouse-delete@example.com", "CH Delete User");
+
+    await niceBackendFetch(`/api/v1/users/${user.userId}`, {
+      accessType: "admin",
+      method: "DELETE",
+    });
+
+    await waitForClickhouseUserDeletion("clickhouse-delete@example.com");
+  }, TEST_TIMEOUT);
+
+  test("Syncs users to ClickHouse by default", async ({ expect }) => {
+    await Project.createAndSwitch({ config: { magic_link_enabled: true } });
+
+    const user = await User.create({ primary_email: "clickhouse-sync@example.com" });
+    await niceBackendFetch(`/api/v1/users/${user.userId}`, {
+      accessType: "admin",
+      method: "PATCH",
+      body: { display_name: "ClickHouse Sync User" },
+    });
+
+    const response = await waitForClickhouseUser("clickhouse-sync@example.com", "ClickHouse Sync User");
+    expect(response.status).toBe(200);
+    expect(response.body?.result?.[0]).toMatchObject({
+      display_name: "ClickHouse Sync User",
+      primary_email: "clickhouse-sync@example.com",
+    });
+  }, TEST_TIMEOUT);
+
   /**
    * What it does:
    * - Creates a user, patches the display name, and triggers the sync once.
@@ -486,4 +611,7 @@ describe.sequential('External DB Sync - Basic Tests', () => {
       poller_enabled: getResponse.body.poller_enabled,
     });
   }, TEST_TIMEOUT);
+
 });
+
+
diff --git a/apps/e2e/tests/backend/endpoints/api/v1/internal-metrics.test.ts b/apps/e2e/tests/backend/endpoints/api/v1/internal-metrics.test.ts
index 7b26f6c5b3..7ea0f68667 100644
--- a/apps/e2e/tests/backend/endpoints/api/v1/internal-metrics.test.ts
+++ b/apps/e2e/tests/backend/endpoints/api/v1/internal-metrics.test.ts
@@ -12,6 +12,18 @@ async function ensureAnonymousUsersAreStillExcluded(metricsResponse: NiceRespons
   expect(response.body).toEqual(metricsResponse.body);
 }
 
+async function waitForMetricsToIncludeUsersByCountry(options: { countryCode: string, expectedCount: number }): Promise<NiceResponse> {
+  let response!: NiceResponse;
+  for (let i = 0; i < 15; i++) {
+    response = await niceBackendFetch("/api/v1/internal/metrics", { accessType: 'admin' });
+    if (response.body?.users_by_country?.[options.countryCode] === options.expectedCount) {
+      return response;
+    }
+    await wait(2_000);
+  }
+  return response;
+}
+
 it("should return metrics data", async ({ expect }) => {
   await Project.createAndSwitch({
     config: {
@@ -117,8 +129,8 @@ it("should exclude anonymous users from metrics", async ({ expect }) => {
   backendContext.set({ mailbox: createMailbox(), ipData: { country: "US", ipAddress: "127.0.0.1", city: "New York", region: "NY", latitude: 40.7128, longitude: -74.0060, tzIdentifier: "America/New_York" } });
   await Auth.Otp.signIn();
 
-  // Store metrics so we can compare them later
-  const beforeMetrics = await niceBackendFetch("/api/v1/internal/metrics", { accessType: 'admin' });
+  // ClickHouse ingestion is async; wait until the baseline metrics includes the regular user's country.
+  const beforeMetrics = await waitForMetricsToIncludeUsersByCountry({ countryCode: "US", expectedCount: 1 });
 
   // Create 2 anonymous users
   for (let i = 0; i < 2; i++) {
diff --git a/apps/e2e/tests/backend/performance/mock-users.sql b/apps/e2e/tests/backend/performance/mock-users.sql
index 2edf93c738..1401e3a6bd 100644
--- a/apps/e2e/tests/backend/performance/mock-users.sql
+++ b/apps/e2e/tests/backend/performance/mock-users.sql
@@ -9,17 +9,72 @@ WITH internal_tenancy AS (
     AND "branchId" = 'main'
   LIMIT 1
 ),
+params AS (
+  -- How many users to insert per run.
+  -- Edit the numeric literal below before running the script.
+  SELECT 50000::bigint AS batch_size
+),
+existing_max AS (
+  SELECT
+    COALESCE(
+      MAX((regexp_match(cc."value", '^perf-user-([0-9]+)@internal\.stack$'))[1]::bigint),
+      0
+    ) AS max_idx
+  FROM internal_tenancy t
+  LEFT JOIN "ContactChannel" cc
+    ON cc."tenancyId" = t.id
+   AND cc."type" = 'EMAIL'
+   AND cc."usedForAuth" = 'TRUE'::"BooleanTrue"
+   AND cc."value" ~ '^perf-user-[0-9]+@internal\.stack$'
+),
+next_range AS (
+  SELECT
+    GREATEST(1, max_idx + 1) AS start_idx,
+    GREATEST(1, max_idx + 1) + p.batch_size - 1 AS end_idx
+  FROM existing_max
+  CROSS JOIN params p
+),
 generated AS (
   SELECT
-    t.id                       AS tenancy_id,
-    gen_random_uuid()          AS project_user_id,
-    gen_random_uuid()          AS auth_method_id,
-    gen_random_uuid()          AS contact_id,
     gs                         AS idx,
-    lpad(gs::text, 5, '0')     AS padded_idx,
+    t.id                       AS tenancy_id,
+    ('perf-user-' || gs::text || '@internal.stack') AS email_value,
+    (
+      substr(md5(t.id::text || ':project_user:' || gs::text), 1, 8) || '-' ||
+      substr(md5(t.id::text || ':project_user:' || gs::text), 9, 4) || '-' ||
+      substr(md5(t.id::text || ':project_user:' || gs::text), 13, 4) || '-' ||
+      substr(md5(t.id::text || ':project_user:' || gs::text), 17, 4) || '-' ||
+      substr(md5(t.id::text || ':project_user:' || gs::text), 21, 12)
+    )::uuid AS project_user_id,
+    (
+      substr(md5(t.id::text || ':auth_method:' || gs::text), 1, 8) || '-' ||
+      substr(md5(t.id::text || ':auth_method:' || gs::text), 9, 4) || '-' ||
+      substr(md5(t.id::text || ':auth_method:' || gs::text), 13, 4) || '-' ||
+      substr(md5(t.id::text || ':auth_method:' || gs::text), 17, 4) || '-' ||
+      substr(md5(t.id::text || ':auth_method:' || gs::text), 21, 12)
+    )::uuid AS auth_method_id,
+    (
+      substr(md5(t.id::text || ':contact:' || gs::text), 1, 8) || '-' ||
+      substr(md5(t.id::text || ':contact:' || gs::text), 9, 4) || '-' ||
+      substr(md5(t.id::text || ':contact:' || gs::text), 13, 4) || '-' ||
+      substr(md5(t.id::text || ':contact:' || gs::text), 17, 4) || '-' ||
+      substr(md5(t.id::text || ':contact:' || gs::text), 21, 12)
+    )::uuid AS contact_id,
     now()                      AS ts
   FROM internal_tenancy t
-  CROSS JOIN generate_series(10001, 20000) AS gs
+  CROSS JOIN next_range r
+  CROSS JOIN generate_series(r.start_idx, r.end_idx) AS gs
+  -- Ensure re-running this script can't error due to the unique constraint on
+  -- (tenancyId, type, value, usedForAuth). If a perf-user email already exists
+  -- and is used for auth, skip generating that row entirely.
+  WHERE NOT EXISTS (
+    SELECT 1
+    FROM "ContactChannel" cc
+    WHERE cc."tenancyId" = t.id
+      AND cc."type" = 'EMAIL'
+      AND cc."value" = ('perf-user-' || gs::text || '@internal.stack')
+      AND cc."usedForAuth" = 'TRUE'::"BooleanTrue"
+  )
 ),
 insert_users AS (
   INSERT INTO "ProjectUser"
@@ -35,6 +90,7 @@ insert_users AS (
     ts,
     ts
   FROM generated
+  ON CONFLICT ("tenancyId", "projectUserId") DO NOTHING
   RETURNING "tenancyId","projectUserId"
 ),
 insert_contacts AS (
@@ -49,10 +105,11 @@ insert_contacts AS (
     'TRUE'::"BooleanTrue",
     'TRUE'::"BooleanTrue",
     false,
-    'perf-user-' || g.padded_idx || '@internal.stack',
+    g.email_value,
     g.ts,
     g.ts
   FROM generated g
+  ON CONFLICT DO NOTHING
   RETURNING "tenancyId","projectUserId"
 ),
 insert_auth_methods AS (
@@ -65,6 +122,7 @@ insert_auth_methods AS (
     ts,
     ts
   FROM generated
+  ON CONFLICT ("tenancyId", "id") DO NOTHING
   RETURNING "tenancyId","id","projectUserId"
 )
 INSERT INTO "PasswordAuthMethod"
@@ -76,6 +134,10 @@ SELECT
   '$2a$13$TVyY/gpw9Db/w1fBeJkCgeNg2Rae2JfNqrPnSACtj.ufAO5cVF13.', -- swap in your own bcrypt hash if desired
   g.ts,
   g.ts
-FROM generated g;
+FROM generated g
+
+-- A user can only have one password auth method.
+-- If this was already inserted by a previous run, skip it.
+ON CONFLICT DO NOTHING;
 
 COMMIT;
diff --git a/packages/stack-shared/src/config/db-sync-mappings.ts b/packages/stack-shared/src/config/db-sync-mappings.ts
index e73113590a..2a6d2e1abd 100644
--- a/packages/stack-shared/src/config/db-sync-mappings.ts
+++ b/packages/stack-shared/src/config/db-sync-mappings.ts
@@ -25,6 +25,119 @@ export const DEFAULT_DB_SYNC_MAPPINGS = {
           "updated_at" timestamp without time zone NOT NULL DEFAULT now()
         );
       `.trim(),
+      clickhouse: `
+        CREATE TABLE IF NOT EXISTS analytics_internal.users (
+          project_id String,
+          branch_id String,
+          id UUID,
+          display_name Nullable(String),
+          profile_image_url Nullable(String),
+          primary_email Nullable(String),
+          primary_email_verified UInt8,
+          signed_up_at DateTime64(3, 'UTC'),
+          client_metadata JSON,
+          client_read_only_metadata JSON,
+          server_metadata JSON,
+          is_anonymous UInt8,
+          restricted_by_admin UInt8,
+          restricted_by_admin_reason Nullable(String),
+          restricted_by_admin_private_details Nullable(String),
+          sync_sequence_id Int64,
+          sync_is_deleted UInt8,
+          sync_created_at DateTime64(3, 'UTC') DEFAULT now64(3)
+        )
+        ENGINE ReplacingMergeTree(sync_sequence_id)
+        PARTITION BY toYYYYMM(signed_up_at)
+        ORDER BY (project_id, branch_id, id);
+
+        CREATE TABLE IF NOT EXISTS analytics_internal._stack_sync_metadata (
+          tenancy_id UUID,
+          mapping_name String,
+          last_synced_sequence_id Int64,
+          updated_at DateTime64(3, 'UTC') DEFAULT now64(3)
+        )
+        ENGINE ReplacingMergeTree(updated_at)
+        ORDER BY (tenancy_id, mapping_name);
+      `.trim(),
+    },
+    internalDbFetchQueries: {
+      clickhouse: `
+        SELECT *
+        FROM (
+          SELECT
+            "Tenancy"."projectId" AS "project_id",
+            "Tenancy"."branchId" AS "branch_id",
+            "ProjectUser"."projectUserId" AS "id",
+            "ProjectUser"."displayName" AS "display_name",
+            "ProjectUser"."profileImageUrl" AS "profile_image_url",
+            (
+              SELECT "ContactChannel"."value"
+              FROM "ContactChannel"
+              WHERE "ContactChannel"."projectUserId" = "ProjectUser"."projectUserId"
+                AND "ContactChannel"."tenancyId" = "ProjectUser"."tenancyId"
+                AND "ContactChannel"."type" = 'EMAIL'
+                AND "ContactChannel"."isPrimary" = 'TRUE'
+              LIMIT 1
+            ) AS "primary_email",
+            COALESCE(
+              (
+                SELECT "ContactChannel"."isVerified"
+                FROM "ContactChannel"
+                WHERE "ContactChannel"."projectUserId" = "ProjectUser"."projectUserId"
+                  AND "ContactChannel"."tenancyId" = "ProjectUser"."tenancyId"
+                  AND "ContactChannel"."type" = 'EMAIL'
+                  AND "ContactChannel"."isPrimary" = 'TRUE'
+                LIMIT 1
+              ),
+              false
+            ) AS "primary_email_verified",
+            "ProjectUser"."createdAt" AS "signed_up_at",
+            COALESCE("ProjectUser"."clientMetadata", '{}'::jsonb) AS "client_metadata",
+            COALESCE("ProjectUser"."clientReadOnlyMetadata", '{}'::jsonb) AS "client_read_only_metadata",
+            COALESCE("ProjectUser"."serverMetadata", '{}'::jsonb) AS "server_metadata",
+            "ProjectUser"."isAnonymous" AS "is_anonymous",
+            "ProjectUser"."restrictedByAdmin" AS "restricted_by_admin",
+            "ProjectUser"."restrictedByAdminReason" AS "restricted_by_admin_reason",
+            "ProjectUser"."restrictedByAdminPrivateDetails" AS "restricted_by_admin_private_details",
+            "ProjectUser"."sequenceId" AS "sync_sequence_id",
+            "ProjectUser"."tenancyId" AS "tenancyId",
+            false AS "sync_is_deleted"
+          FROM "ProjectUser"
+          JOIN "Tenancy" ON "Tenancy"."id" = "ProjectUser"."tenancyId"
+          WHERE "ProjectUser"."tenancyId" = $1::uuid
+
+          UNION ALL
+
+          SELECT
+            "Tenancy"."projectId" AS "project_id",
+            "Tenancy"."branchId" AS "branch_id",
+            ("DeletedRow"."primaryKey"->>'projectUserId')::uuid AS "id",
+            NULL::text AS "display_name",
+            NULL::text AS "profile_image_url",
+            NULL::text AS "primary_email",
+            false AS "primary_email_verified",
+            "DeletedRow"."deletedAt"::timestamp without time zone AS "signed_up_at",
+            '{}'::jsonb AS "client_metadata",
+            '{}'::jsonb AS "client_read_only_metadata",
+            '{}'::jsonb AS "server_metadata",
+            false AS "is_anonymous",
+            false AS "restricted_by_admin",
+            NULL::text AS "restricted_by_admin_reason",
+            NULL::text AS "restricted_by_admin_private_details",
+            "DeletedRow"."sequenceId" AS "sync_sequence_id",
+            "DeletedRow"."tenancyId" AS "tenancyId",
+            true AS "sync_is_deleted"
+          FROM "DeletedRow"
+          JOIN "Tenancy" ON "Tenancy"."id" = "DeletedRow"."tenancyId"
+          WHERE
+            "DeletedRow"."tenancyId" = $1::uuid
+            AND "DeletedRow"."tableName" = 'ProjectUser'
+        ) AS "_src"
+        WHERE "sync_sequence_id" IS NOT NULL
+          AND "sync_sequence_id" > $2::bigint
+        ORDER BY "sync_sequence_id" ASC
+        LIMIT 1000
+      `.trim(),
     },
     internalDbFetchQuery: `
       SELECT *
diff --git a/packages/stack-shared/src/config/schema.ts b/packages/stack-shared/src/config/schema.ts
index 494dea24da..d41245e381 100644
--- a/packages/stack-shared/src/config/schema.ts
+++ b/packages/stack-shared/src/config/schema.ts
@@ -239,12 +239,17 @@ export const branchConfigSchema = canNoLongerBeOverridden(projectConfigSchema, [
     externalDatabases: yupRecord(
       userSpecifiedIdSchema("externalDatabaseId"),
       yupObject({
-        type: yupString().oneOf(['postgres']).defined(),
-        connectionString: yupString().defined(),
-      })
+        type: yupString().oneOf(["postgres"]).defined(),
+        connectionString: yupString().when("type", {
+          is: "postgres",
+          then: (schema) => schema.defined(),
+          otherwise: (schema) => schema.optional(),
+        }),
+      }),
     ),
   }),
 
+
   dataVault: yupObject({
     stores: yupRecord(
       userSpecifiedIdSchema("storeId"),
diff --git a/packages/stack-shared/src/interface/admin-interface.ts b/packages/stack-shared/src/interface/admin-interface.ts
index 711e7dddc5..d539ba5fee 100644
--- a/packages/stack-shared/src/interface/admin-interface.ts
+++ b/packages/stack-shared/src/interface/admin-interface.ts
@@ -46,24 +46,6 @@ export type InternalApiKeyCreateCrudResponse = InternalApiKeysCrud["Admin"]["Rea
   super_secret_admin_key?: string,
 };
 
-export type ClickhouseMigrationRequest = {
-  min_created_at_millis: number,
-  max_created_at_millis: number,
-  cursor?: {
-    created_at_millis: number,
-    id: string,
-  },
-  limit?: number,
-};
-
-export type ClickhouseMigrationResponse = {
-  migrated_events: number,
-  inserted_rows: number,
-  next_cursor: {
-    created_at_millis: number,
-    id: string,
-  } | null,
-};
 
 export class StackAdminInterface extends StackServerInterface {
   constructor(public readonly options: AdminAuthApplicationOptions) {
@@ -734,20 +716,6 @@ export class StackAdminInterface extends StackServerInterface {
     return await response.json();
   }
 
-  async migrateEventsToClickhouse(options: ClickhouseMigrationRequest): Promise<ClickhouseMigrationResponse> {
-    const response = await this.sendAdminRequest(
-      "/internal/clickhouse/migrate-events",
-      {
-        method: "POST",
-        headers: {
-          "content-type": "application/json",
-        },
-        body: JSON.stringify(options),
-      },
-      null,
-    );
-    return await response.json();
-  }
 
   async previewAffectedUsersByOnboardingChange(
     onboarding: { require_email_verification?: boolean },
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index da3daf490c..bb56ca66d7 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -341,8 +341,11 @@ importers:
   apps/dashboard:
     dependencies:
       '@ai-sdk/openai':
-        specifier: ^1.3.23
-        version: 1.3.23(zod@4.1.12)
+        specifier: ^3.0.25
+        version: 3.0.27(zod@4.1.12)
+      '@ai-sdk/react':
+        specifier: ^3.0.72
+        version: 3.0.83(react@19.2.3)(zod@4.1.12)
       '@assistant-ui/react':
         specifier: ^0.10.24
         version: 0.10.24(@types/react-dom@18.3.1)(@types/react@18.3.12)(immer@9.0.21)(react-dom@19.2.3(react@19.2.3))(react@19.2.3)(use-sync-external-store@1.5.0(react@19.2.3))
@@ -494,8 +497,8 @@ importers:
         specifier: ^1.0.12
         version: 1.0.12(next@16.1.5(@babel/core@7.28.5)(@opentelemetry/api@1.9.0)(react-dom@19.2.3(react@19.2.3))(react@19.2.3))(react@19.2.3)
       ai:
-        specifier: ^4.3.17
-        version: 4.3.17(react@19.2.3)(zod@4.1.12)
+        specifier: ^6.0.0
+        version: 6.0.81(zod@4.1.12)
       browser-image-compression:
         specifier: ^2.0.2
         version: 2.0.2
@@ -595,6 +598,9 @@ importers:
       yup:
         specifier: ^1.7.1
         version: 1.7.1
+      zod:
+        specifier: ^4.0.0
+        version: 4.1.12
     devDependencies:
       '@types/canvas-confetti':
         specifier: ^1.6.4
@@ -2219,22 +2225,44 @@ importers:
 
 packages:
 
+  '@ai-sdk/gateway@3.0.41':
+    resolution: {integrity: sha512-dYNhtvEomccNNGSxfSP8f4g6yPcoDHyQ6Rb7dALFE0FvvVP9UqfFWi3D2dLIz0VVKaSkiNLQAJ7lsdTVlBdRrw==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      zod: ^3.25.76 || ^4.1.8
+
   '@ai-sdk/openai@1.3.23':
     resolution: {integrity: sha512-86U7rFp8yacUAOE/Jz8WbGcwMCqWvjK33wk5DXkfnAOEn3mx2r7tNSJdjukQFZbAK97VMXGPPHxF+aEARDXRXQ==}
     engines: {node: '>=18'}
     peerDependencies:
       zod: ^3.0.0
 
+  '@ai-sdk/openai@3.0.27':
+    resolution: {integrity: sha512-pLMxWOypwroXiK9dxNpn60/HGhWWWDEOJ3lo9vZLoxvpJNtKnLKojwVIvlW3yEjlD7ll1+jUO2uzsABNTaP5Yg==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      zod: ^3.25.76 || ^4.1.8
+
   '@ai-sdk/provider-utils@2.2.8':
     resolution: {integrity: sha512-fqhG+4sCVv8x7nFzYnFo19ryhAa3w096Kmc3hWxMQfW/TubPOmt3A6tYZhl4mUfQWWQMsuSkLrtjlWuXBVSGQA==}
     engines: {node: '>=18'}
     peerDependencies:
       zod: ^3.23.8
 
+  '@ai-sdk/provider-utils@4.0.14':
+    resolution: {integrity: sha512-7bzKd9lgiDeXM7O4U4nQ8iTxguAOkg8LZGD9AfDVZYjO5cKYRwBPwVjboFcVrxncRHu0tYxZtXZtiLKpG4pEng==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      zod: ^3.25.76 || ^4.1.8
+
   '@ai-sdk/provider@1.1.3':
     resolution: {integrity: sha512-qZMxYJ0qqX/RfnuIaab+zp8UAeJn/ygXXAffR5I4N0n1IrvA6qBsjc8hXLmBiMV2zoXlifkacF7sEFnYnjBcqg==}
     engines: {node: '>=18'}
 
+  '@ai-sdk/provider@3.0.8':
+    resolution: {integrity: sha512-oGMAgGoQdBXbZqNG0Ze56CHjDZ1IDYOwGYxYjO5KLSlz5HiNQ9udIXsPZ61VWaHGZ5XW/jyjmr6t2xz2jGVwbQ==}
+    engines: {node: '>=18'}
+
   '@ai-sdk/react@1.2.12':
     resolution: {integrity: sha512-jK1IZZ22evPZoQW3vlkZ7wvjYGYF+tRBKXtrcolduIkQ/m/sOAVcVeVDUDvh1T91xCnWCdUGCPZg2avZ90mv3g==}
     engines: {node: '>=18'}
@@ -2245,6 +2273,12 @@ packages:
       zod:
         optional: true
 
+  '@ai-sdk/react@3.0.83':
+    resolution: {integrity: sha512-UsHr+/N0pqGY90BwPFFpWXhY5eVYjNgcWCvSeDMRrzfPvtcd2yqHXlwR7/bveRryVB4NmJ2z6sjyLyOgOHRQdw==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      react: ^18 || ~19.0.1 || ~19.1.2 || ^19.2.1
+
   '@ai-sdk/ui-utils@1.2.11':
     resolution: {integrity: sha512-3zcwCc8ezzFlwp3ZD15wAPjf2Au4s3vAbKsXQVyhxODHcmu0iyPO2Eua6D/vicq/AUm/BAo60r97O6HU+EI0+w==}
     engines: {node: '>=18'}
@@ -8036,6 +8070,9 @@ packages:
   '@standard-schema/spec@1.0.0':
     resolution: {integrity: sha512-m2bOd0f2RT9k8QJx1JN85cZYyH1RqFBdlwtkSlf4tBDYLCiiZnv1fIIwacK6cqwXavOydf0NPToMQgpKq+dVlA==}
 
+  '@standard-schema/spec@1.1.0':
+    resolution: {integrity: sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==}
+
   '@standard-schema/utils@0.3.0':
     resolution: {integrity: sha512-e7Mew686owMaPJVNNLs55PUvgz371nKgwsc4vxE49zsODpJEnxgxRo2y/OKrqueavXgZNMDVj3DdHFlaSAeU8g==}
 
@@ -9064,6 +9101,12 @@ packages:
       react:
         optional: true
 
+  ai@6.0.81:
+    resolution: {integrity: sha512-F9EEhjl2dn1VGS5tbU64ldLbqRemV9X1WHghVblpJlPCWuyYj1xpPQsj+G0TRs/SyAGnbpG1yYpl9mkwfr1H8w==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      zod: ^3.25.76 || ^4.1.8
+
   ajv-draft-04@1.0.0:
     resolution: {integrity: sha512-mv00Te6nmYbRp5DCwclxtt7yV/joXJPGS7nM+97GdxvuttCOfgI3K4U25zboyeX0O+myI8ERluxQe5wljMmVIw==}
     peerDependencies:
@@ -10962,6 +11005,10 @@ packages:
     resolution: {integrity: sha512-nVpZkTMM9rF6AQ9gPJpFsNAMt48wIzB5TQgiTLdHiuO8XEDhUgZEhqKlZWXbIzo9VmJ/HvysHqEaVeD5v9TPvA==}
     engines: {node: '>=20.0.0'}
 
+  eventsource-parser@3.0.6:
+    resolution: {integrity: sha512-Vo1ab+QXPzZ4tCa8SwIHJFaSzy4R6SHf7BY79rFBDf0idraZWAkYrDjDj8uWaSm3S2TK+hJ7/t1CEmZ7jXw+pg==}
+    engines: {node: '>=18.0.0'}
+
   eventsource@3.0.7:
     resolution: {integrity: sha512-CRT1WTyuQoD771GW56XEZFQ/ZoSfWid1alKGDYMmkt2yl8UXrVR4pspqWNEcqKvVIzg6PAltWjxcSSPrboA4iA==}
     engines: {node: '>=18.0.0'}
@@ -16019,16 +16066,30 @@ packages:
 
 snapshots:
 
+  '@ai-sdk/gateway@3.0.41(zod@3.25.76)':
+    dependencies:
+      '@ai-sdk/provider': 3.0.8
+      '@ai-sdk/provider-utils': 4.0.14(zod@3.25.76)
+      '@vercel/oidc': 3.1.0
+      zod: 3.25.76
+
+  '@ai-sdk/gateway@3.0.41(zod@4.1.12)':
+    dependencies:
+      '@ai-sdk/provider': 3.0.8
+      '@ai-sdk/provider-utils': 4.0.14(zod@4.1.12)
+      '@vercel/oidc': 3.1.0
+      zod: 4.1.12
+
   '@ai-sdk/openai@1.3.23(zod@3.25.76)':
     dependencies:
       '@ai-sdk/provider': 1.1.3
       '@ai-sdk/provider-utils': 2.2.8(zod@3.25.76)
       zod: 3.25.76
 
-  '@ai-sdk/openai@1.3.23(zod@4.1.12)':
+  '@ai-sdk/openai@3.0.27(zod@4.1.12)':
     dependencies:
-      '@ai-sdk/provider': 1.1.3
-      '@ai-sdk/provider-utils': 2.2.8(zod@4.1.12)
+      '@ai-sdk/provider': 3.0.8
+      '@ai-sdk/provider-utils': 4.0.14(zod@4.1.12)
       zod: 4.1.12
 
   '@ai-sdk/provider-utils@2.2.8(zod@3.25.76)':
@@ -16038,17 +16099,28 @@ snapshots:
       secure-json-parse: 2.7.0
       zod: 3.25.76
 
-  '@ai-sdk/provider-utils@2.2.8(zod@4.1.12)':
+  '@ai-sdk/provider-utils@4.0.14(zod@3.25.76)':
     dependencies:
-      '@ai-sdk/provider': 1.1.3
-      nanoid: 3.3.11
-      secure-json-parse: 2.7.0
+      '@ai-sdk/provider': 3.0.8
+      '@standard-schema/spec': 1.1.0
+      eventsource-parser: 3.0.6
+      zod: 3.25.76
+
+  '@ai-sdk/provider-utils@4.0.14(zod@4.1.12)':
+    dependencies:
+      '@ai-sdk/provider': 3.0.8
+      '@standard-schema/spec': 1.1.0
+      eventsource-parser: 3.0.6
       zod: 4.1.12
 
   '@ai-sdk/provider@1.1.3':
     dependencies:
       json-schema: 0.4.0
 
+  '@ai-sdk/provider@3.0.8':
+    dependencies:
+      json-schema: 0.4.0
+
   '@ai-sdk/react@1.2.12(react@18.3.1)(zod@3.25.76)':
     dependencies:
       '@ai-sdk/provider-utils': 2.2.8(zod@3.25.76)
@@ -16069,15 +16141,25 @@ snapshots:
     optionalDependencies:
       zod: 3.25.76
 
-  '@ai-sdk/react@1.2.12(react@19.2.3)(zod@4.1.12)':
+  '@ai-sdk/react@3.0.83(react@19.2.3)(zod@3.25.76)':
     dependencies:
-      '@ai-sdk/provider-utils': 2.2.8(zod@4.1.12)
-      '@ai-sdk/ui-utils': 1.2.11(zod@4.1.12)
+      '@ai-sdk/provider-utils': 4.0.14(zod@3.25.76)
+      ai: 6.0.81(zod@3.25.76)
       react: 19.2.3
       swr: 2.3.4(react@19.2.3)
       throttleit: 2.1.0
-    optionalDependencies:
-      zod: 4.1.12
+    transitivePeerDependencies:
+      - zod
+
+  '@ai-sdk/react@3.0.83(react@19.2.3)(zod@4.1.12)':
+    dependencies:
+      '@ai-sdk/provider-utils': 4.0.14(zod@4.1.12)
+      ai: 6.0.81(zod@4.1.12)
+      react: 19.2.3
+      swr: 2.3.4(react@19.2.3)
+      throttleit: 2.1.0
+    transitivePeerDependencies:
+      - zod
 
   '@ai-sdk/ui-utils@1.2.11(zod@3.25.76)':
     dependencies:
@@ -16086,13 +16168,6 @@ snapshots:
       zod: 3.25.76
       zod-to-json-schema: 3.24.6(zod@3.25.76)
 
-  '@ai-sdk/ui-utils@1.2.11(zod@4.1.12)':
-    dependencies:
-      '@ai-sdk/provider': 1.1.3
-      '@ai-sdk/provider-utils': 2.2.8(zod@4.1.12)
-      zod: 4.1.12
-      zod-to-json-schema: 3.24.6(zod@4.1.12)
-
   '@alloc/quick-lru@5.2.0': {}
 
   '@ampproject/remapping@2.3.0':
@@ -16115,7 +16190,7 @@ snapshots:
 
   '@assistant-ui/react-ai-sdk@0.10.14(@assistant-ui/react@0.10.24(@types/react-dom@18.3.1)(@types/react@18.3.12)(immer@9.0.21)(react-dom@19.2.3(react@19.2.3))(react@19.2.3)(use-sync-external-store@1.5.0(react@19.2.3)))(@types/react-dom@18.3.1)(@types/react@18.3.12)(immer@9.0.21)(react-dom@19.2.3(react@19.2.3))(react@19.2.3)(use-sync-external-store@1.5.0(react@19.2.3))':
     dependencies:
-      '@ai-sdk/react': 1.2.12(react@19.2.3)(zod@3.25.76)
+      '@ai-sdk/react': 3.0.83(react@19.2.3)(zod@3.25.76)
       '@ai-sdk/ui-utils': 1.2.11(zod@3.25.76)
       '@assistant-ui/react': 0.10.24(@types/react-dom@18.3.1)(@types/react@18.3.12)(immer@9.0.21)(react-dom@19.2.3(react@19.2.3))(react@19.2.3)(use-sync-external-store@1.5.0(react@19.2.3))
       '@assistant-ui/react-edge': 0.2.12(@assistant-ui/react@0.10.24(@types/react-dom@18.3.1)(@types/react@18.3.12)(immer@9.0.21)(react-dom@19.2.3(react@19.2.3))(react@19.2.3)(use-sync-external-store@1.5.0(react@19.2.3)))(@types/react-dom@18.3.1)(@types/react@18.3.12)(react-dom@19.2.3(react@19.2.3))(react@19.2.3)
@@ -23758,6 +23833,8 @@ snapshots:
 
   '@standard-schema/spec@1.0.0': {}
 
+  '@standard-schema/spec@1.1.0': {}
+
   '@standard-schema/utils@0.3.0': {}
 
   '@stripe/connect-js@3.3.27': {}
@@ -25047,17 +25124,21 @@ snapshots:
     optionalDependencies:
       react: 19.2.3
 
-  ai@4.3.17(react@19.2.3)(zod@4.1.12):
+  ai@6.0.81(zod@3.25.76):
     dependencies:
-      '@ai-sdk/provider': 1.1.3
-      '@ai-sdk/provider-utils': 2.2.8(zod@4.1.12)
-      '@ai-sdk/react': 1.2.12(react@19.2.3)(zod@4.1.12)
-      '@ai-sdk/ui-utils': 1.2.11(zod@4.1.12)
+      '@ai-sdk/gateway': 3.0.41(zod@3.25.76)
+      '@ai-sdk/provider': 3.0.8
+      '@ai-sdk/provider-utils': 4.0.14(zod@3.25.76)
+      '@opentelemetry/api': 1.9.0
+      zod: 3.25.76
+
+  ai@6.0.81(zod@4.1.12):
+    dependencies:
+      '@ai-sdk/gateway': 3.0.41(zod@4.1.12)
+      '@ai-sdk/provider': 3.0.8
+      '@ai-sdk/provider-utils': 4.0.14(zod@4.1.12)
       '@opentelemetry/api': 1.9.0
-      jsondiffpatch: 0.6.0
       zod: 4.1.12
-    optionalDependencies:
-      react: 19.2.3
 
   ajv-draft-04@1.0.0(ajv@8.17.1):
     optionalDependencies:
@@ -27588,6 +27669,8 @@ snapshots:
 
   eventsource-parser@3.0.3: {}
 
+  eventsource-parser@3.0.6: {}
+
   eventsource@3.0.7:
     dependencies:
       eventsource-parser: 3.0.3
@@ -34158,10 +34241,6 @@ snapshots:
     dependencies:
       zod: 3.25.76
 
-  zod-to-json-schema@3.24.6(zod@4.1.12):
-    dependencies:
-      zod: 4.1.12
-
   zod@3.24.4: {}
 
   zod@3.25.76: {}
diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml
index b55877b803..d9d37a2fcc 100644
--- a/pnpm-workspace.yaml
+++ b/pnpm-workspace.yaml
@@ -8,6 +8,12 @@ packages:
 
 minimumReleaseAge: 2880
 minimumReleaseAgeExclude:
+- ai
+- '@ai-sdk/openai'
+- '@ai-sdk/react'
+- '@ai-sdk/provider'
+- '@ai-sdk/provider-utils'
+- '@ai-sdk/gateway'
 - next
 - '@next/env'
 - '@next/swc-darwin-arm64'