@agent-native/core 0.86.0 → 0.87.0

package/corpus/templates/clips/desktop/src-tauri/src/shortcuts.rs

@@ -28,6 +28,7 @@ fn numpad_enter_shortcut() -> Shortcut {
 
 static CUSTOM_VOICE_SHORTCUT: OnceLock<Mutex<Option<Shortcut>>> = OnceLock::new();
 static CUSTOM_POPOVER_SHORTCUT: OnceLock<Mutex<Option<Shortcut>>> = OnceLock::new();
+static CUSTOM_RECORD_SHORTCUT: OnceLock<Mutex<Option<Shortcut>>> = OnceLock::new();
 static FN_TAP_ENABLED: AtomicBool = AtomicBool::new(false);
 static FN_TAP_INSTALL_STARTED: AtomicBool = AtomicBool::new(false);
 static POPOVER_DISMISS_SHORTCUT_ACTIVE: AtomicBool = AtomicBool::new(false);
@@ -41,6 +42,10 @@ fn custom_popover_shortcut() -> &'static Mutex<Option<Shortcut>> {
     CUSTOM_POPOVER_SHORTCUT.get_or_init(|| Mutex::new(None))
 }
 
+fn custom_record_shortcut() -> &'static Mutex<Option<Shortcut>> {
+    CUSTOM_RECORD_SHORTCUT.get_or_init(|| Mutex::new(None))
+}
+
 fn current_custom_voice_shortcut() -> Option<Shortcut> {
     custom_voice_shortcut().lock().ok().and_then(|g| *g)
 }
@@ -49,6 +54,10 @@ fn current_custom_popover_shortcut() -> Option<Shortcut> {
     custom_popover_shortcut().lock().ok().and_then(|g| *g)
 }
 
+fn current_custom_record_shortcut() -> Option<Shortcut> {
+    custom_record_shortcut().lock().ok().and_then(|g| *g)
+}
+
 fn parse_optional_shortcut(value: Option<String>) -> Result<Option<Shortcut>, String> {
     let Some(value) = value else {
         return Ok(None);
@@ -109,21 +118,39 @@ pub async fn set_custom_shortcuts(
     app: AppHandle,
     voice: Option<String>,
     popover: Option<String>,
+    record: Option<String>,
 ) -> Result<(), String> {
     let voice = parse_optional_shortcut(voice)?;
     let popover = parse_optional_shortcut(popover)?;
-    if voice.is_some() && voice == popover {
-        return Err("Voice dictation and Open Clips need different shortcuts.".to_string());
+    let record = parse_optional_shortcut(record)?;
+    if (voice.is_some() && voice == popover)
+        || (voice.is_some() && voice == record)
+        || (popover.is_some() && popover == record)
+    {
+        return Err(
+            "Voice dictation, Open Clips, and Start/stop recording need different shortcuts."
+                .to_string(),
+        );
     }
     let gs = app.global_shortcut();
 
     let prev_voice = swap_custom_shortcut(gs, custom_voice_shortcut(), voice, "voice")?;
-    if let Err(err) = swap_custom_shortcut(gs, custom_popover_shortcut(), popover, "Clips") {
-        // Popover registration failed after voice already mutated — roll the
-        // voice slot back to its previous value so callers see all-or-nothing
-        // behaviour. If the rollback itself fails we surface only the
-        // original popover error to the user; the local state always
-        // reflects whatever actually got registered.
+    let prev_popover = match swap_custom_shortcut(gs, custom_popover_shortcut(), popover, "Clips") {
+        Ok(prev_popover) => prev_popover,
+        Err(err) => {
+            // Popover registration failed after voice already mutated — roll
+            // the voice slot back to its previous value so callers see
+            // all-or-nothing behaviour. If the rollback itself fails we
+            // surface only the original popover error to the user; local
+            // state always reflects whatever actually got registered.
+            let _ = swap_custom_shortcut(gs, custom_voice_shortcut(), prev_voice, "voice");
+            return Err(err);
+        }
+    };
+    if let Err(err) = swap_custom_shortcut(gs, custom_record_shortcut(), record, "recording") {
+        // Recording registration failed after earlier slots already mutated —
+        // roll them back so callers see all-or-nothing behaviour.
+        let _ = swap_custom_shortcut(gs, custom_popover_shortcut(), prev_popover, "Clips");
         let _ = swap_custom_shortcut(gs, custom_voice_shortcut(), prev_voice, "voice");
         return Err(err);
     }
@@ -273,6 +300,9 @@ pub fn build_shortcut_plugin() -> tauri_plugin_global_shortcut::Builder<tauri::W
         let is_custom_popover = current_custom_popover_shortcut()
             .map(|custom| custom == *shortcut)
             .unwrap_or(false);
+        let is_custom_record = current_custom_record_shortcut()
+            .map(|custom| custom == *shortcut)
+            .unwrap_or(false);
         let is_escape = shortcut.matches(Modifiers::empty(), Code::Escape);
         let is_enter = shortcut.matches(Modifiers::empty(), Code::Enter);
         let is_numpad_enter = shortcut.matches(Modifiers::empty(), Code::NumpadEnter);
@@ -347,6 +377,15 @@ pub fn build_shortcut_plugin() -> tauri_plugin_global_shortcut::Builder<tauri::W
         if event.state() != tauri_plugin_global_shortcut::ShortcutState::Pressed {
             return;
         }
+        if is_custom_record {
+            wake_popover_for_recording_shortcut(app);
+            let app = app.clone();
+            thread::spawn(move || {
+                thread::sleep(Duration::from_millis(80));
+                let _ = app.emit("clips:record-shortcut", ());
+            });
+            return;
+        }
         if is_cmd || is_ctrl || is_custom_popover {
             // Loom-style: if a recording is already active, the
             // global shortcut stops it rather than re-opening the
@@ -361,6 +400,19 @@ pub fn build_shortcut_plugin() -> tauri_plugin_global_shortcut::Builder<tauri::W
     })
 }
 
+fn wake_popover_for_recording_shortcut(app: &tauri::AppHandle) {
+    let Some(window) = app.get_webview_window("popover") else {
+        return;
+    };
+    if window.is_visible().unwrap_or(false) {
+        return;
+    }
+    let _ = window.set_position(PhysicalPosition::new(2_i32, 2_i32));
+    let _ = window.set_size(tauri::Size::Physical(PhysicalSize::new(2_u32, 2_u32)));
+    show_without_activation(&window);
+    let _ = app.emit("clips:popover-visible", false);
+}
+
 fn emit_voice_shortcut(
     app: &tauri::AppHandle,
     event: &'static str,

package/corpus/templates/clips/package.json

@@ -20,6 +20,7 @@
   },
   "dependencies": {
     "@agent-native/core": "workspace:*",
+    "@agent-native/toolkit": "workspace:*",
     "@ffmpeg/ffmpeg": "^0.12.15",
     "@ffmpeg/util": "^0.12.2",
     "@fontsource-variable/inter": "^5.2.8",

package/corpus/templates/clips/server/lib/public-agent-context.ts

@@ -2,16 +2,17 @@ import { appStateGet } from "@agent-native/core/application-state";
 import { ssrfSafeFetch } from "@agent-native/core/extensions/url-safety";
 import {
   getSession,
-  signShortLivedToken,
-  verifyShortLivedToken,
+  signScopedAgentAccessToken,
+  verifyScopedAgentAccessToken,
 } from "@agent-native/core/server";
 import { asc, eq } from "drizzle-orm";
 import { getRequestURL, setResponseHeader, type H3Event } from "h3";
 
 import {
-  agentAccessTokenResourceId,
   buildAgentApiUrls,
   buildRecommendedFrames,
+  CLIP_AGENT_ACCESS_TOKEN_PREFIX,
+  CLIPS_AGENT_ACCESS_PARAM,
   CLIP_AGENT_CONTEXT_VERSION,
   toAgentTranscriptSegments,
 } from "../../shared/agent-context.js";
@@ -54,8 +55,8 @@ export type PublicAgentAccessResult =
   | { ok: false; failure: PublicAgentFailure };
 
 const DEFAULT_MAX_AGENT_FRAME_MEDIA_BYTES = 200 * 1024 * 1024;
-export const CLIPS_AGENT_ACCESS_PARAM = "agent_access";
 export const CLIPS_AGENT_ACCESS_TTL_SECONDS = 2 * 60 * 60;
+export { CLIPS_AGENT_ACCESS_PARAM };
 
 function sameOwnerEmail(
   a: string | null | undefined,
@@ -212,10 +213,10 @@ export async function loadPublicAgentAccess(
   );
   const suppliedToken = options.token ?? "";
   const tokenAccess = suppliedToken
-    ? verifyShortLivedToken(
-        suppliedToken,
-        agentAccessTokenResourceId(recording.id),
-      )
+    ? verifyScopedAgentAccessToken(suppliedToken, {
+        resourceKind: CLIP_AGENT_ACCESS_TOKEN_PREFIX,
+        resourceId: recording.id,
+      })
     : null;
   const tokenAllowsAgentAccess = Boolean(tokenAccess?.ok);
 
@@ -252,8 +253,10 @@ export async function loadPublicAgentAccess(
     recording.visibility === "public" &&
     viewerIsOwner
   ) {
-    apiToken = signShortLivedToken({
-      resourceId: agentAccessTokenResourceId(recording.id),
+    apiToken = signScopedAgentAccessToken({
+      resourceKind: CLIP_AGENT_ACCESS_TOKEN_PREFIX,
+      resourceId: recording.id,
+      ttlSeconds: CLIPS_AGENT_ACCESS_TTL_SECONDS,
     });
   }
 
@@ -267,8 +270,10 @@ export async function loadPublicAgentAccess(
       verifySharePassword(suppliedPassword, recording.password)
     ) {
       allowed = true;
-      apiToken = signShortLivedToken({
-        resourceId: agentAccessTokenResourceId(recording.id),
+      apiToken = signScopedAgentAccessToken({
+        resourceKind: CLIP_AGENT_ACCESS_TOKEN_PREFIX,
+        resourceId: recording.id,
+        ttlSeconds: CLIPS_AGENT_ACCESS_TTL_SECONDS,
       });
     }
 

package/corpus/templates/clips/server/lib/recording-media-cleanup.ts

@@ -0,0 +1,110 @@
+import { resolveBuilderCredentials } from "@agent-native/core/server";
+
+import { deleteS3ObjectByUrl } from "./s3-upload-provider.js";
+
+interface RecordingMediaUrls {
+  id?: string;
+  videoUrl?: string | null;
+  thumbnailUrl?: string | null;
+  animatedThumbnailUrl?: string | null;
+}
+
+export interface RecordingMediaCleanupResult {
+  attempted: number;
+  deleted: number;
+  skipped: number;
+  errors: Array<{ url: string; error: string }>;
+}
+
+interface RecordingMediaCleanupOptions {
+  protectedUrls?: Iterable<string>;
+}
+
+export function recordingMediaUrls(recording: RecordingMediaUrls): string[] {
+  const urls = [
+    recording.videoUrl,
+    recording.thumbnailUrl,
+    recording.animatedThumbnailUrl,
+  ];
+  return [...new Set(urls.filter((url): url is string => Boolean(url)))];
+}
+
+function builderAssetUrl(url: string): string | null {
+  try {
+    const parsed = new URL(url);
+    if (parsed.hostname !== "cdn.builder.io") return null;
+    parsed.search = "";
+    parsed.hash = "";
+    return parsed.toString();
+  } catch {
+    return null;
+  }
+}
+
+async function deleteBuilderAssetByUrl(url: string): Promise<boolean> {
+  const assetUrl = builderAssetUrl(url);
+  if (!assetUrl) return false;
+
+  const credentials = await resolveBuilderCredentials();
+  if (!credentials.privateKey || !credentials.publicKey) return false;
+
+  const deleteUrl = new URL("/api/v1/assets/by-url", "https://cdn.builder.io");
+  deleteUrl.searchParams.set("url", assetUrl);
+  deleteUrl.searchParams.set("apiKey", credentials.publicKey);
+
+  const res = await fetch(deleteUrl.toString(), {
+    method: "DELETE",
+    headers: {
+      Authorization: `Bearer ${credentials.privateKey}`,
+    },
+  });
+
+  if (res.ok) return true;
+  if (res.status === 404) return false;
+
+  const text = await res.text().catch(() => "");
+  throw new Error(
+    `Builder.io asset delete failed (${res.status}): ${text || res.statusText}`,
+  );
+}
+
+export async function deleteRecordingMediaObjects(
+  recording: RecordingMediaUrls,
+  options: RecordingMediaCleanupOptions = {},
+): Promise<RecordingMediaCleanupResult> {
+  const result: RecordingMediaCleanupResult = {
+    attempted: 0,
+    deleted: 0,
+    skipped: 0,
+    errors: [],
+  };
+  const protectedUrls = new Set(options.protectedUrls ?? []);
+
+  for (const url of recordingMediaUrls(recording)) {
+    result.attempted += 1;
+    if (protectedUrls.has(url)) {
+      result.skipped += 1;
+      continue;
+    }
+    try {
+      if (
+        (await deleteS3ObjectByUrl(url)) ||
+        (await deleteBuilderAssetByUrl(url))
+      ) {
+        result.deleted += 1;
+      } else {
+        result.skipped += 1;
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      result.errors.push({ url, error: message });
+      console.warn("[clips] failed to delete recording media object", {
+        recordingId: recording.id,
+        url,
+        error: message,
+      });
+    }
+  }
+
+  return result;
+}

package/corpus/templates/clips/server/lib/s3-upload-provider.ts

@@ -227,6 +227,132 @@ async function putObject(
     : `${cfg.endpoint}/${cfg.bucket}/${key}`;
 }
 
+function withTrailingSlash(value: string): string {
+  return value.endsWith("/") ? value : `${value}/`;
+}
+
+function decodeUrlPathSegment(value: string): string | null {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return null;
+  }
+}
+
+function keyFromUrlPrefix(rawUrl: URL, rawBase: string): string | null {
+  const base = new URL(withTrailingSlash(rawBase));
+  if (rawUrl.origin !== base.origin) return null;
+  const basePath = withTrailingSlash(base.pathname);
+  if (!rawUrl.pathname.startsWith(basePath)) return null;
+  const encodedKey = rawUrl.pathname.slice(basePath.length);
+  if (!encodedKey) return null;
+  return decodeUrlPathSegment(encodedKey);
+}
+
+function objectKeyFromUrl(cfg: S3Config, rawUrl: string): string | null {
+  let url: URL;
+  try {
+    url = new URL(rawUrl);
+  } catch {
+    return null;
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") return null;
+
+  if (cfg.publicBaseUrl) {
+    const key = keyFromUrlPrefix(url, cfg.publicBaseUrl);
+    if (key) return key;
+  }
+
+  const endpoint = new URL(withTrailingSlash(cfg.endpoint));
+  if (url.origin !== endpoint.origin) return null;
+  const endpointPath = withTrailingSlash(endpoint.pathname);
+  const bucketPath = `${endpointPath}${rfc3986(cfg.bucket)}/`;
+  if (!url.pathname.startsWith(bucketPath)) return null;
+  const encodedKey = url.pathname.slice(bucketPath.length);
+  if (!encodedKey) return null;
+  return decodeUrlPathSegment(encodedKey);
+}
+
+async function deleteObject(cfg: S3Config, key: string): Promise<void> {
+  const now = new Date();
+  const amzDate =
+    now
+      .toISOString()
+      .replace(/[:-]|\.\d{3}/g, "")
+      .slice(0, 15) + "Z";
+  const dateStamp = amzDate.slice(0, 8);
+  const credentialScope = `${dateStamp}/${cfg.region}/s3/aws4_request`;
+
+  const hostUrl = new URL(cfg.endpoint);
+  const host = hostUrl.host;
+  const canonicalUri = `/${cfg.bucket}/${key.split("/").map(rfc3986).join("/")}`;
+  const payloadHash = await sha256(new Uint8Array(0));
+
+  const headers: Record<string, string> = {
+    host,
+    "x-amz-content-sha256": payloadHash,
+    "x-amz-date": amzDate,
+  };
+
+  const signedHeaderKeys = Object.keys(headers).sort();
+  const signedHeaders = signedHeaderKeys.join(";");
+  const canonicalHeaders =
+    signedHeaderKeys.map((k) => `${k}:${headers[k]}`).join("\n") + "\n";
+
+  const canonicalRequest = [
+    "DELETE",
+    canonicalUri,
+    "",
+    canonicalHeaders,
+    signedHeaders,
+    payloadHash,
+  ].join("\n");
+
+  const crHash = await sha256(new TextEncoder().encode(canonicalRequest));
+  const stringToSign = [
+    "AWS4-HMAC-SHA256",
+    amzDate,
+    credentialScope,
+    crHash,
+  ].join("\n");
+
+  const signingKey = await deriveSigningKey(
+    cfg.secretAccessKey,
+    dateStamp,
+    cfg.region,
+  );
+  const signature = toHex(await hmac(signingKey, stringToSign));
+
+  const authorization =
+    `AWS4-HMAC-SHA256 Credential=${cfg.accessKeyId}/${credentialScope}, ` +
+    `SignedHeaders=${signedHeaders}, Signature=${signature}`;
+
+  const url = `${cfg.endpoint}${canonicalUri}`;
+  const res = await fetch(url, {
+    method: "DELETE",
+    headers: {
+      ...headers,
+      Authorization: authorization,
+    },
+  });
+
+  if (!res.ok && res.status !== 404) {
+    const text = await res.text().catch(() => "");
+    throw new Error(
+      `S3 DeleteObject failed (${res.status}): ${text || res.statusText}`,
+    );
+  }
+}
+
+export async function deleteS3ObjectByUrl(url: string): Promise<boolean> {
+  const cfg = await readS3Config();
+  if (!cfg) return false;
+  const key = objectKeyFromUrl(cfg, url);
+  if (!key) return false;
+  await deleteObject(cfg, key);
+  return true;
+}
+
 // ── Provider ──────────────────────────────────────────────────────────
 
 export const s3FileUploadProvider: FileUploadProvider = {

package/corpus/templates/clips/server/routes/api/public-recording.get.ts

@@ -13,7 +13,12 @@
  * the authenticated player route).
  */
 
-import { getSession, signShortLivedToken } from "@agent-native/core/server";
+import {
+  getSession,
+  signScopedAgentAccessToken,
+  signShortLivedToken,
+  verifyScopedAgentAccessToken,
+} from "@agent-native/core/server";
 import { asc, eq } from "drizzle-orm";
 import {
   defineEventHandler,
@@ -27,8 +32,8 @@ import {
 } from "h3";
 
 import {
-  agentAccessTokenResourceId,
   buildAgentApiUrls,
+  CLIP_AGENT_ACCESS_TOKEN_PREFIX,
 } from "../../../shared/agent-context.js";
 import {
   normalizeTranscriptSegments,
@@ -122,9 +127,20 @@ function addProtectedMediaTokenFallback(
 }
 
 export default defineEventHandler(async (event) => {
-  const q = getQuery(event) as { id?: string; password?: string };
+  const q = getQuery(event) as {
+    id?: string;
+    password?: string;
+    agent_access?: string;
+    t?: string;
+  };
   const recordingId = q.id;
   const password = typeof q.password === "string" ? q.password : "";
+  const suppliedAgentAccessToken =
+    typeof q.agent_access === "string"
+      ? q.agent_access
+      : typeof q.t === "string"
+        ? q.t
+        : "";
 
   if (!recordingId) {
     setResponseStatus(event, 400);
@@ -147,8 +163,18 @@ export default defineEventHandler(async (event) => {
   const viewerIsOwner = Boolean(
     session?.email && sameOwnerEmail(session.email, rec.ownerEmail),
   );
+  const tokenAllowsAgentAccess = suppliedAgentAccessToken
+    ? verifyScopedAgentAccessToken(suppliedAgentAccessToken, {
+        resourceKind: CLIP_AGENT_ACCESS_TOKEN_PREFIX,
+        resourceId: rec.id,
+      }).ok
+    : false;
 
-  if (rec.visibility !== "public" && !viewerIsOwner) {
+  if (
+    rec.visibility !== "public" &&
+    !viewerIsOwner &&
+    !tokenAllowsAgentAccess
+  ) {
     setResponseStatus(event, 404);
     return { error: "Not found" };
   }
@@ -165,11 +191,16 @@ export default defineEventHandler(async (event) => {
   // Password check
   let protectedMediaToken: string | null = null;
   if (rec.password && !viewerIsOwner) {
-    if (!password || !verifySharePassword(password, rec.password)) {
+    if (
+      !tokenAllowsAgentAccess &&
+      (!password || !verifySharePassword(password, rec.password))
+    ) {
       setResponseStatus(event, 401);
       return { error: "Password required", passwordRequired: true };
     }
     protectedMediaToken = setProtectedMediaAccessCookie(event, recordingId);
+  } else if (tokenAllowsAgentAccess && !viewerIsOwner) {
+    protectedMediaToken = setProtectedMediaAccessCookie(event, recordingId);
   }
 
   const [transcript] = await db
@@ -248,13 +279,18 @@ export default defineEventHandler(async (event) => {
   );
 
   const canExposeAgentContext =
-    rec.visibility === "public" && !rec.archivedAt && !rec.trashedAt;
+    (rec.visibility === "public" || tokenAllowsAgentAccess || viewerIsOwner) &&
+    !rec.archivedAt &&
+    !rec.trashedAt;
   const agentToken =
-    canExposeAgentContext && rec.password
-      ? signShortLivedToken({
-          resourceId: agentAccessTokenResourceId(recordingId),
-        })
-      : undefined;
+    canExposeAgentContext && tokenAllowsAgentAccess
+      ? suppliedAgentAccessToken
+      : canExposeAgentContext && rec.password
+        ? signScopedAgentAccessToken({
+            resourceKind: CLIP_AGENT_ACCESS_TOKEN_PREFIX,
+            resourceId: recordingId,
+          })
+        : undefined;
   const agentContextUrl = canExposeAgentContext
     ? buildAgentApiUrls(recordingId, {
         origin: getRequestURL(event).origin,

package/corpus/templates/clips/shared/agent-context.ts

@@ -1,3 +1,9 @@
+import {
+  AGENT_ACCESS_PARAM,
+  buildAgentAccessApiUrl,
+  scopedAgentAccessResourceId,
+} from "@agent-native/core/shared";
+
 import type { TranscriptSegment } from "./transcript-segments";
 
 export const CLIP_AGENT_CONTEXT_VERSION = 1;
@@ -5,9 +11,16 @@ export const AGENT_CONTEXT_ENDPOINT = "/api/agent-context.json";
 export const AGENT_TRANSCRIPT_ENDPOINT = "/api/agent-transcript.json";
 export const AGENT_FRAME_ENDPOINT = "/api/agent-frame.jpg";
 export const CLIP_AGENT_ACCESS_TOKEN_PREFIX = "clip-agent-context";
+export const CLIPS_AGENT_ACCESS_PARAM = AGENT_ACCESS_PARAM || "agent_access";
 
 export function agentAccessTokenResourceId(recordingId: string): string {
-  return `${CLIP_AGENT_ACCESS_TOKEN_PREFIX}:${recordingId}`;
+  if (typeof scopedAgentAccessResourceId !== "function") {
+    return `${CLIP_AGENT_ACCESS_TOKEN_PREFIX}:${recordingId}`;
+  }
+  return scopedAgentAccessResourceId(
+    CLIP_AGENT_ACCESS_TOKEN_PREFIX,
+    recordingId,
+  );
 }
 
 export interface AgentApiUrls {
@@ -37,20 +50,6 @@ export interface ChapterLike {
   title: string;
 }
 
-function trimSlashes(value: string): string {
-  return value.replace(/^\/+|\/+$/g, "");
-}
-
-function normalizeBasePath(basePath?: string): string {
-  const trimmed = trimSlashes(basePath ?? "");
-  return trimmed ? `/${trimmed}` : "";
-}
-
-function normalizeOrigin(origin?: string): string {
-  if (!origin) return "";
-  return origin.replace(/\/+$/g, "");
-}
-
 function endpointUrl({
   endpoint,
   recordingId,
@@ -66,12 +65,15 @@ function endpointUrl({
   token?: string | null;
   extraParams?: Array<[string, string]>;
 }): string {
-  const params = new URLSearchParams({ id: recordingId });
-  if (token) params.set("t", token);
-  for (const [key, value] of extraParams ?? []) {
-    params.set(key, value);
-  }
-  return `${normalizeOrigin(origin)}${normalizeBasePath(basePath)}${endpoint}?${params.toString()}`;
+  return buildAgentAccessApiUrl({
+    endpoint,
+    resourceId: recordingId,
+    origin,
+    basePath,
+    token,
+    tokenParam: AGENT_ACCESS_PARAM,
+    extraParams,
+  });
 }
 
 export function buildAgentApiUrls(

package/corpus/templates/content/app/blocks/contentBlockRegistry.tsx

@@ -10,14 +10,14 @@ import {
   type NestedBlock,
 } from "@agent-native/core/blocks";
 import { sendToAgentChat } from "@agent-native/core/client";
-import { useEffect, useRef, useState } from "react";
-
-import { uploadImageFile } from "@/components/editor/image-upload";
 import {
   Popover,
   PopoverContent,
   PopoverTrigger,
-} from "@/components/ui/popover";
+} from "@agent-native/toolkit/ui/popover";
+import { useEffect, useRef, useState } from "react";
+
+import { uploadImageFile } from "@/components/editor/image-upload";
 import { cn } from "@/lib/utils";
 
 import { builderDocsBlocks } from "./BuilderDocsBlocks";

package/corpus/templates/content/app/components/EmptyState.tsx

@@ -1,11 +1,11 @@
 import { useT } from "@agent-native/core/client";
+import { Button } from "@agent-native/toolkit/ui/button";
 import type { Document } from "@shared/api";
 import { IconFileText, IconPlus } from "@tabler/icons-react";
 import { useQueryClient } from "@tanstack/react-query";
 import { useNavigate } from "react-router";
 import { toast } from "sonner";
 
-import { Button } from "@/components/ui/button";
 import { useCreateDocument } from "@/hooks/use-documents";
 
 function nanoid(size = 12): string {

package/corpus/templates/content/app/components/ThemeToggle.tsx

@@ -1,14 +1,14 @@
 import { useT } from "@agent-native/core/client";
-import { IconDeviceDesktop, IconMoon, IconSun } from "@tabler/icons-react";
-import { useTheme } from "next-themes";
-import { useState, useEffect } from "react";
-
-import { Button } from "@/components/ui/button";
+import { Button } from "@agent-native/toolkit/ui/button";
 import {
   Tooltip,
   TooltipContent,
   TooltipTrigger,
-} from "@/components/ui/tooltip";
+} from "@agent-native/toolkit/ui/tooltip";
+import { IconDeviceDesktop, IconMoon, IconSun } from "@tabler/icons-react";
+import { useTheme } from "next-themes";
+import { useState, useEffect } from "react";
+
 import { cn } from "@/lib/utils";
 
 const themeOptions = [