@agent-native/core 0.80.0 → 0.80.1

package/corpus/core/src/brand-kit/index.ts

@@ -3,7 +3,7 @@
  *
  * The shared, template-agnostic Brand Kit surface. A Brand Kit unifies what
  * `design` and `slides` previously copy-pasted as a "design system": design
- * tokens + brand assets + custom instructions, extractable from Figma, code,
+ * tokens + brand assets + custom instructions, extractable from code,
  * GitHub, a URL, or documents, and used to generate on-brand content.
  *
  * This module is pure (no `defineAction`, no DB, no template imports). Templates

package/corpus/core/src/cli/skills.ts

@@ -404,6 +404,10 @@ iframe-backed screens on the infinite canvas.
   iframe frame and URL metadata; change the copy's path/query for a new state.
 - Flow visualization is multiple URL states: \`/checkout?step=shipping\`,
   \`/checkout?step=payment\`, \`/checkout?step=done\`, etc.
+- When the user gives a named flow or numbered screen list, preserve that order
+  and create one screen per URL/path. Shorthand like
+  \`localhost:1234/onboarding/1\` means
+  \`http://localhost:1234/onboarding/1\`.
 
 ## Required Local Bridge
 
@@ -439,6 +443,20 @@ pnpm action add-localhost-screens '{
 }'
 \`\`\`
 
+For a numbered flow the user describes in chat, keep the labels and order:
+
+\`\`\`bash
+pnpm action add-localhost-screens '{
+  "designId": "<design-id>",
+  "connectionId": "<connection-id>",
+  "routes": [
+    { "url": "localhost:1234/onboarding/1", "title": "Screen 1" },
+    { "url": "localhost:1234/onboarding/2", "title": "Screen 2" },
+    { "url": "localhost:1234/onboarding/3", "title": "Screen 3" }
+  ]
+}'
+\`\`\`
+
 If no \`routes\` or \`paths\` are supplied, \`add-localhost-screens\` uses every
 route from the latest localhost manifest.
 

package/corpus/core/src/client/AgentPanel.tsx

@@ -1318,7 +1318,7 @@ function AgentPanelInner({
             data-agent-page-new-chat=""
             aria-label={t("agentPanel.newChat")}
             onClick={() => {
-              void addTab();
+              addTab();
             }}
             className="pointer-events-auto inline-flex h-8 items-center gap-1.5 rounded-md border border-border bg-background/95 px-2.5 text-xs font-medium text-foreground shadow-sm backdrop-blur transition-colors hover:bg-accent focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
           >

package/corpus/core/src/client/MultiTabAssistantChat.tsx

@@ -1625,7 +1625,7 @@ export function MultiTabAssistantChat({
               return next;
             });
             if (shouldRefreshThreads) {
-              void refreshThreads();
+              refreshThreads();
             }
           }
         }

package/corpus/core/src/client/extensions/portable-extension.ts

@@ -47,7 +47,7 @@ export interface AgentNativeExtensionStorageOptions {
 export interface AgentNativeExtensionStorageContext {
   extensionId: string;
   slotId?: string;
-  scope?: Exclude<AgentNativeExtensionStorageScope, "all"> | string;
+  scope?: Exclude<AgentNativeExtensionStorageScope, "all">;
   userId?: string;
   organizationId?: string;
   [key: string]: unknown;

package/corpus/core/src/code-agents/transcript-normalizer.ts

@@ -576,7 +576,7 @@ function joinAssistantChunks(previous: string, next: string): string {
   if (!next) return previous;
   if (/\s$/.test(previous) || /^\s/.test(next)) return `${previous}${next}`;
   if (/^[.,!?;:)\]}'"`]/.test(next)) return `${previous}${next}`;
-  if (/[(\[{'"`]$/.test(previous)) return `${previous}${next}`;
+  if (/[([{'"`]$/.test(previous)) return `${previous}${next}`;
   return `${previous} ${next}`;
 }
 

package/corpus/core/src/extensions/path.ts

@@ -19,10 +19,7 @@ export function extensionNameToSlug(
   return sliced || "extension";
 }
 
-export function extensionPath(
-  id: string,
-  name?: string | null | undefined,
-): string {
+export function extensionPath(id: string, name?: string | null): string {
   const encodedId = encodeURIComponent(id);
   if (name === undefined) return `/extensions/${encodedId}`;
   return `/extensions/${encodedId}/${extensionNameToSlug(name)}`;

package/corpus/core/src/integrations/a2a-continuation-processor.ts

@@ -528,7 +528,7 @@ function expandRelativeUrls(text: string, agentUrl: string): string {
   if (!text || !agentUrl) return text;
   const base = publicAgentBaseUrl(agentUrl);
   return text.replace(
-    /(^|[\s(\[<"'`])(\/[a-z0-9_-][a-z0-9_/?&=%#.,:-]*)/gi,
+    /(^|[\s([<"'`])(\/[a-z0-9_-][a-z0-9_/?&=%#.,:-]*)/gi,
     (_match, lead, path) => `${lead}${base}${path}`,
   );
 }

package/corpus/core/src/mcp/build-server.ts

@@ -1889,7 +1889,7 @@ async function isConnectTokenAllowed(
  */
 export async function verifyAuth(
   authHeader: string | undefined,
-  ownerEmailHeader?: string | undefined,
+  ownerEmailHeader?: string,
   options: { allowDevOpen?: boolean; resourceUrl?: string | string[] } = {},
 ): Promise<{
   authed: boolean;

package/corpus/core/src/org/handlers.ts

@@ -17,8 +17,8 @@ function extractInvitationId(event: H3Event): string | undefined {
   if (fromRouter) return fromRouter;
   const path = getRequestURL(event).pathname;
   const match =
-    path.match(/^\/([^\/]+)\/accept\/?$/) ??
-    path.match(/\/org\/invitations\/([^\/]+)\/accept\/?$/);
+    path.match(/^\/([^/]+)\/accept\/?$/) ??
+    path.match(/\/org\/invitations\/([^/]+)\/accept\/?$/);
   return match?.[1] ? decodeURIComponent(match[1]) : undefined;
 }
 
@@ -28,9 +28,9 @@ function extractMemberEmail(event: H3Event): string | undefined {
   if (fromRouter) return fromRouter;
   const path = getRequestURL(event).pathname;
   const match =
-    path.match(/^\/([^\/]+)\/role\/?$/) ??
-    path.match(/^\/([^\/]+)\/?$/) ??
-    path.match(/\/org\/members\/([^\/]+)(?:\/role)?\/?$/);
+    path.match(/^\/([^/]+)\/role\/?$/) ??
+    path.match(/^\/([^/]+)\/?$/) ??
+    path.match(/\/org\/members\/([^/]+)(?:\/role)?\/?$/);
   return match?.[1] ? decodeURIComponent(match[1]) : undefined;
 }
 const nanoid = (): string =>

package/corpus/core/src/org/plugin.ts

@@ -100,7 +100,7 @@ export function createOrgPlugin(): NitroPluginDef {
           return listMembersHandler(event);
         }
         // Tail is /:email/role
-        if (/^\/[^\/]+\/role\/?$/.test(tail)) {
+        if (/^\/[^/]+\/role\/?$/.test(tail)) {
           if (method !== "PUT") {
             setResponseStatus(event, 405);
             return { error: "Method not allowed" };
@@ -129,7 +129,7 @@ export function createOrgPlugin(): NitroPluginDef {
           return { error: "Method not allowed" };
         }
         // Tail is /:id/accept
-        if (/^\/[^\/]+\/accept\/?$/.test(tail)) {
+        if (/^\/[^/]+\/accept\/?$/.test(tail)) {
           if (method !== "POST") {
             setResponseStatus(event, 405);
             return { error: "Method not allowed" };

package/corpus/core/src/scripts/call-agent.ts

@@ -434,7 +434,7 @@ export function expandRelativeUrls(text: string, agentUrl: string): string {
   // Path must start at boundary (start, whitespace, or punctuation that isn't
   // ':' — to avoid mangling `https://example.com/foo` or markdown link bodies).
   return text.replace(
-    /(^|[\s(\[<"'`])(\/[a-z0-9_-][a-z0-9_/?&=%#.,:-]*)/gi,
+    /(^|[\s([<"'`])(\/[a-z0-9_-][a-z0-9_/?&=%#.,:-]*)/gi,
     (_match, lead, path) => `${lead}${base}${path}`,
   );
 }

package/corpus/core/src/scripts/db/safety.ts

@@ -171,7 +171,7 @@ const ACCESS_CONTROL_COLUMN_TOKENS = new Set([
 function normalizeIdentifier(value: string): string {
   return value
     .trim()
-    .replace(/^["'`\[]/, "")
+    .replace(/^["'`[]/, "")
     .replace(/["'`\]]$/, "")
     .toLowerCase();
 }

package/corpus/core/src/server/auth.ts

@@ -1855,6 +1855,9 @@ function createAuthGuardFn(): (
     // the gate below 401s anonymous /_agent-native/* requests before any DB
     // query, so the database would never get warmed.
     if (p === "/_agent-native/health") return;
+    if (getMethod(event) === "GET" && p.startsWith("/_agent-native/avatar/")) {
+      return;
+    }
     if (isPublicPath(normalizedUrl, publicPaths)) return;
     if (shouldBypassAuthForBuilderConnect(event, p)) return;
     if (isPublicWorkspacePageRequest(event, p, config)) {

package/corpus/core/src/server/builder-design-systems.ts

@@ -0,0 +1,308 @@
+import { FeatureNotConfiguredError } from "./credential-provider.js";
+import {
+  getBuilderProxyOrigin,
+  resolveBuilderCredentials,
+} from "./credential-provider.js";
+
+const DEFAULT_TIMEOUT_MS = 120_000;
+
+export interface BuilderDesignSystemIndexFile {
+  name: string;
+  data: Uint8Array;
+  mimeType?: string;
+}
+
+export interface BuilderDesignSystemIndexOptions {
+  projectName?: string;
+  description?: string;
+  githubRepoUrl?: string;
+  connectedProjectId?: string;
+  files?: BuilderDesignSystemIndexFile[];
+  selection?: Record<string, string[]>;
+  devToolsVersion?: string;
+}
+
+export interface BuilderDesignSystemIndexResult {
+  ok: true;
+  source: "builder";
+  projectId: string;
+  jobId: string;
+  designSystemId: string;
+  suggestedTitle: string | null;
+  builderUrl: string;
+  status: "in-progress";
+}
+
+interface BuilderDesignSystemCredentials {
+  privateKey: string;
+  publicKey: string;
+  userId: string | null;
+}
+
+interface UploadStartResponse {
+  uploads?: Array<{ idx: number; uploadUrl: string; uploadToken: string }>;
+}
+
+interface GenerateResponse {
+  projectId?: string;
+  jobId?: string;
+  designSystemId?: string;
+}
+
+function trimTrailingSlash(value: string): string {
+  return value.replace(/\/+$/, "");
+}
+
+export function getBuilderDesignSystemsBaseUrl(): string {
+  return (
+    process.env.BUILDER_DESIGN_SYSTEMS_BASE_URL ||
+    `${trimTrailingSlash(getBuilderProxyOrigin())}/design-systems/v1`
+  );
+}
+
+function getBuilderAppHost(): string {
+  return (
+    process.env.BUILDER_APP_HOST ||
+    process.env.BUILDER_PUBLIC_APP_HOST ||
+    "https://builder.io"
+  );
+}
+
+function makeBuilderDesignSystemUrl(
+  path: string,
+  credentials: BuilderDesignSystemCredentials,
+): URL {
+  const base = `${trimTrailingSlash(getBuilderDesignSystemsBaseUrl())}/`;
+  const url = new URL(path.replace(/^\/+/, ""), base);
+  url.searchParams.set("apiKey", credentials.publicKey);
+  if (credentials.userId) url.searchParams.set("userId", credentials.userId);
+  return url;
+}
+
+function makeBuilderHeaders(
+  credentials: BuilderDesignSystemCredentials,
+): Record<string, string> {
+  return {
+    Authorization: `Bearer ${credentials.privateKey}`,
+    "x-builder-api-key": credentials.publicKey,
+    ...(credentials.userId ? { "x-builder-user-id": credentials.userId } : {}),
+  };
+}
+
+async function resolveBuilderDesignSystemCredentials(): Promise<BuilderDesignSystemCredentials> {
+  const credentials = await resolveBuilderCredentials();
+  if (!credentials.privateKey || !credentials.publicKey) {
+    throw new FeatureNotConfiguredError({
+      requiredCredential: "BUILDER_PRIVATE_KEY",
+      message:
+        "Connect Builder.io before indexing a design system from Figma or code.",
+      builderConnectUrl: "/_agent-native/builder/connect",
+    });
+  }
+  return {
+    privateKey: credentials.privateKey,
+    publicKey: credentials.publicKey,
+    userId: credentials.userId ?? null,
+  };
+}
+
+function mimeTypeForFile(file: BuilderDesignSystemIndexFile): string {
+  if (file.mimeType?.trim()) return file.mimeType.trim();
+  const lower = file.name.toLowerCase();
+  if (lower.endsWith(".fig")) return "application/octet-stream";
+  if (lower.endsWith(".pdf")) return "application/pdf";
+  if (lower.endsWith(".md") || lower.endsWith(".markdown"))
+    return "text/markdown";
+  if (lower.endsWith(".json")) return "application/json";
+  if (lower.endsWith(".css")) return "text/css";
+  return "text/plain";
+}
+
+function makeBody(bytes: Uint8Array, mimeType: string): BodyInit {
+  return typeof Blob !== "undefined"
+    ? new Blob([bytes as unknown as BlobPart], { type: mimeType })
+    : (bytes as unknown as BodyInit);
+}
+
+async function fetchWithTimeout(
+  url: string | URL,
+  init: RequestInit,
+  timeoutMs = DEFAULT_TIMEOUT_MS,
+): Promise<Response> {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await fetch(url, { ...init, signal: controller.signal });
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+async function parseErrorBody(response: Response): Promise<string> {
+  const text = await response.text().catch(() => "");
+  if (!text) return response.statusText || `HTTP ${response.status}`;
+  try {
+    const json = JSON.parse(text) as { error?: unknown };
+    if (typeof json.error === "string") return json.error;
+    if (json.error && typeof json.error === "object") {
+      return JSON.stringify(json.error).slice(0, 500);
+    }
+  } catch {}
+  return text.replace(/\s+/g, " ").trim().slice(0, 500);
+}
+
+async function assertOk(response: Response, label: string): Promise<void> {
+  if (response.ok) return;
+  throw new Error(
+    `${label} (${response.status}): ${await parseErrorBody(response)}`,
+  );
+}
+
+async function uploadToResumableUrl(
+  slot: { uploadUrl: string },
+  file: BuilderDesignSystemIndexFile,
+): Promise<void> {
+  const mimeType = mimeTypeForFile(file);
+  const bytes = file.data;
+  const start = await fetchWithTimeout(slot.uploadUrl, {
+    method: "POST",
+    headers: {
+      "x-goog-resumable": "start",
+      "x-goog-content-length-range": `0,${bytes.byteLength}`,
+      "Content-Type": mimeType,
+    },
+  });
+  await assertOk(start, "Builder design-system upload session failed");
+  const sessionUrl = start.headers.get("Location");
+  if (!sessionUrl) {
+    throw new Error("Builder design-system upload session returned no URL.");
+  }
+
+  const response = await fetchWithTimeout(sessionUrl, {
+    method: "PUT",
+    headers: {
+      "Content-Range": `bytes 0-${bytes.byteLength - 1}/${bytes.byteLength}`,
+      "Content-Type": mimeType,
+    },
+    body: makeBody(bytes, mimeType),
+  });
+  await assertOk(response, "Builder design-system file upload failed");
+}
+
+function nonEmptyFiles(
+  files: BuilderDesignSystemIndexFile[] | undefined,
+): BuilderDesignSystemIndexFile[] {
+  return (files ?? []).filter((file) => file.data.byteLength > 0);
+}
+
+export function builderDesignSystemUrl(designSystemId?: string | null): string {
+  const host = trimTrailingSlash(getBuilderAppHost());
+  return designSystemId
+    ? `${host}/app/design-system-intelligence/${encodeURIComponent(
+        designSystemId,
+      )}`
+    : `${host}/app/design-system-intelligence`;
+}
+
+export async function startBuilderDesignSystemIndex(
+  options: BuilderDesignSystemIndexOptions,
+): Promise<BuilderDesignSystemIndexResult> {
+  const files = nonEmptyFiles(options.files);
+  const description = options.description?.trim();
+  if (description) {
+    files.unshift({
+      name: "additional-context.txt",
+      data: new TextEncoder().encode(description),
+      mimeType: "text/plain",
+    });
+  }
+  if (
+    files.length === 0 &&
+    !options.githubRepoUrl &&
+    !options.connectedProjectId
+  ) {
+    throw new Error(
+      "Provide at least one .fig/code/text file or a GitHub repository URL to index with Builder.",
+    );
+  }
+
+  const credentials = await resolveBuilderDesignSystemCredentials();
+  let uploadTokens: string[] = [];
+  if (files.length > 0) {
+    const uploadStart = await fetchWithTimeout(
+      makeBuilderDesignSystemUrl("upload/start", credentials),
+      {
+        method: "POST",
+        headers: {
+          ...makeBuilderHeaders(credentials),
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+          attachments: files.map((file) => ({
+            name: file.name,
+            mimetype: mimeTypeForFile(file),
+            declaredSize: file.data.byteLength,
+          })),
+        }),
+      },
+    );
+    await assertOk(uploadStart, "Builder design-system upload start failed");
+    const uploadJson = (await uploadStart.json()) as UploadStartResponse;
+    const slots = [...(uploadJson.uploads ?? [])].sort((a, b) => a.idx - b.idx);
+    if (slots.length !== files.length) {
+      throw new Error("Builder did not return upload slots for all files.");
+    }
+    for (let i = 0; i < slots.length; i++) {
+      if (slots[i].idx !== i) {
+        throw new Error(`Builder upload slot mismatch: expected ${i}.`);
+      }
+      await uploadToResumableUrl(slots[i], files[i]);
+    }
+    uploadTokens = slots.map((slot) => slot.uploadToken);
+  }
+
+  const generate = await fetchWithTimeout(
+    makeBuilderDesignSystemUrl("generate", credentials),
+    {
+      method: "POST",
+      headers: {
+        ...makeBuilderHeaders(credentials),
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        uploads: uploadTokens,
+        ...(options.projectName?.trim()
+          ? { projectName: options.projectName.trim() }
+          : {}),
+        ...(options.githubRepoUrl?.trim()
+          ? { githubRepoUrl: options.githubRepoUrl.trim() }
+          : {}),
+        ...(options.connectedProjectId?.trim()
+          ? { connectedProjectId: options.connectedProjectId.trim() }
+          : {}),
+        ...(options.selection ? { selection: options.selection } : {}),
+        ...(options.devToolsVersion?.trim()
+          ? { devToolsVersion: options.devToolsVersion.trim() }
+          : {}),
+      }),
+    },
+  );
+  await assertOk(generate, "Builder design-system indexing failed");
+  const generated = (await generate.json()) as GenerateResponse;
+  if (!generated.projectId || !generated.jobId || !generated.designSystemId) {
+    throw new Error(
+      "Builder design-system indexing returned an incomplete response.",
+    );
+  }
+
+  return {
+    ok: true,
+    source: "builder",
+    projectId: generated.projectId,
+    jobId: generated.jobId,
+    designSystemId: generated.designSystemId,
+    suggestedTitle: options.projectName?.trim() || null,
+    builderUrl: builderDesignSystemUrl(generated.designSystemId),
+    status: "in-progress",
+  };
+}

package/corpus/core/src/server/core-routes-plugin.ts

@@ -383,6 +383,31 @@ function parseBuilderCallbackBoolean(
 // inlines them in the DOM. Mirrors SAFE_DATA_IMAGE in sanitize-html.ts.
 export const AVATAR_RASTER_MIME = /^data:image\/(png|jpe?g|gif|webp);/i;
 
+export function resolveAvatarEmailParam(
+  pathname: string,
+  appBasePath = "",
+): string {
+  const base = appBasePath.replace(/\/+$/, "");
+  const avatarPaths = Array.from(
+    new Set([`${base}/_agent-native/avatar/`, "/_agent-native/avatar/"]),
+  );
+
+  for (const avatarPath of avatarPaths) {
+    const avatarIndex = pathname.indexOf(avatarPath);
+    if (avatarIndex >= 0) {
+      return pathname
+        .slice(avatarIndex + avatarPath.length)
+        .replace(/^\/+/, "")
+        .split("/")[0];
+    }
+  }
+
+  const firstSegment = pathname.replace(/^\/+/, "").split("/")[0] ?? "";
+  if (!firstSegment || firstSegment === "_agent-native") return "";
+  if (base && firstSegment === base.replace(/^\/+/, "")) return "";
+  return firstSegment;
+}
+
 async function detectUsageEngineName(
   event: H3Event,
   userEmail: string | undefined,
@@ -3010,9 +3035,10 @@ export function createCoreRoutesPlugin(
         `${P}/avatar`,
         defineEventHandler(async (event: H3Event) => {
           const method = getMethod(event);
-          const emailParam = (event.url?.pathname || "")
-            .replace(/^\/+/, "")
-            .split("/")[0];
+          const emailParam = resolveAvatarEmailParam(
+            event.url?.pathname || "",
+            getConfiguredAppBasePath(),
+          );
 
           if (method === "GET") {
             if (!emailParam) {

package/corpus/core/src/server/index.ts

@@ -386,6 +386,14 @@ export {
   deleteBuilderCredentials,
   resolveSecret,
 } from "./credential-provider.js";
+export {
+  builderDesignSystemUrl,
+  getBuilderDesignSystemsBaseUrl,
+  startBuilderDesignSystemIndex,
+  type BuilderDesignSystemIndexFile,
+  type BuilderDesignSystemIndexOptions,
+  type BuilderDesignSystemIndexResult,
+} from "./builder-design-systems.js";
 export {
   getBuilderBranchProjectId,
   isBuilderBranchingEnabled,

package/corpus/core/src/styles/agent-native.css

@@ -162,6 +162,17 @@
     box-shadow 260ms cubic-bezier(0.32, 0.72, 0, 1);
 }
 
+.agent-layout-main-surface::before,
+.agent-sidebar-main-surface::before {
+  content: "";
+  position: absolute;
+  inset: 0;
+  z-index: 20;
+  pointer-events: none;
+  border-radius: inherit;
+  box-shadow: var(--agent-native-raised-outline);
+}
+
 .agent-layout-shell
   :where(.agent-layout-main-surface, .agent-sidebar-main-surface)
   > :first-child
@@ -213,23 +224,19 @@
   .agent-layout-shell > .agent-sidebar-shell > .agent-sidebar-main-surface {
     border-start-start-radius: var(--agent-native-raised-radius);
     border-end-start-radius: var(--agent-native-raised-radius);
-    box-shadow:
-      var(--agent-native-raised-outline), var(--agent-native-raised-shadow-left);
+    box-shadow: var(--agent-native-raised-shadow-left);
   }
 
   .agent-sidebar-main-surface[data-agent-sidebar-main-state="open"][data-agent-sidebar-main-position="right"] {
     border-start-end-radius: var(--agent-native-raised-radius);
     border-end-end-radius: var(--agent-native-raised-radius);
-    box-shadow:
-      var(--agent-native-raised-outline),
-      var(--agent-native-raised-shadow-right);
+    box-shadow: var(--agent-native-raised-shadow-right);
   }
 
   .agent-sidebar-main-surface[data-agent-sidebar-main-state="open"][data-agent-sidebar-main-position="left"] {
     border-start-start-radius: var(--agent-native-raised-radius);
     border-end-start-radius: var(--agent-native-raised-radius);
-    box-shadow:
-      var(--agent-native-raised-outline), var(--agent-native-raised-shadow-left);
+    box-shadow: var(--agent-native-raised-shadow-left);
   }
 }
 

package/corpus/core/src/usage/store.ts

@@ -112,12 +112,12 @@ const PRICING: Array<{ match: RegExp; pricing: ModelPricing }> = [
   // ── Google Gemini ───────────────────────────────────────────────────────────
   // Gemini 3 Pro / 3.1 Pro: ~$1.25/$10 per MTok (approximate; verify on billing)
   {
-    match: /gemini-3[\.\-]1-pro/i,
+    match: /gemini-3[.\-]1-pro/i,
     pricing: { input: 125, output: 1000, cacheRead: 31, cacheWrite: 0 },
   },
   // Gemini 3.5 Flash / 3 Flash: ~$0.15/$0.60 per MTok
   {
-    match: /gemini-3[\.\-][0-9]+-flash/i,
+    match: /gemini-3[.\-][0-9]+-flash/i,
     pricing: { input: 15, output: 60, cacheRead: 4, cacheWrite: 0 },
   },
   // Gemini 2.5 Pro/Flash (catch-all for older 2.5)