@agent-native/core 0.130.2 → 0.131.3

package/corpus/core/src/browser-context/index.ts

@@ -0,0 +1,392 @@
+import { z } from "zod";
+
+export const BROWSER_CONTEXT_V1_SCHEMA = "browser-context.v1" as const;
+
+export const BROWSER_CONTEXT_V1_LIMITS = {
+  totalBytes: 96 * 1024,
+  projections: 3,
+  readableTextChars: 64 * 1024,
+  readableBlocks: 500,
+  readableLinks: 250,
+  designElements: 300,
+  designStylesPerElement: 80,
+  designTokens: 300,
+  controlNodes: 2_000,
+  controlChildrenPerNode: 200,
+  controlPropertiesPerNode: 40,
+  screenshots: 4,
+} as const;
+
+const nonBlankString = (max: number) =>
+  z
+    .string()
+    .min(1)
+    .max(max)
+    .refine((value) => value.trim().length > 0, "Value must not be blank.");
+
+const isoTimestampSchema = z.iso.datetime({ offset: true });
+
+const safeHttpUrlSchema = nonBlankString(16_384).refine((value) => {
+  try {
+    const url = new URL(value);
+    return (
+      (url.protocol === "http:" || url.protocol === "https:") &&
+      !url.username &&
+      !url.password
+    );
+  } catch {
+    return false;
+  }
+}, "Expected a credential-free HTTP(S) URL.");
+
+const exactHttpOriginSchema = nonBlankString(2_048).refine((value) => {
+  try {
+    const url = new URL(value);
+    return (
+      (url.protocol === "http:" || url.protocol === "https:") &&
+      url.origin === value &&
+      url.pathname === "/" &&
+      !url.search &&
+      !url.hash &&
+      !url.username &&
+      !url.password
+    );
+  } catch {
+    return false;
+  }
+}, "Expected an exact credential-free HTTP(S) origin.");
+
+const projectionStatusSchema = z.discriminatedUnion("state", [
+  z.object({ state: z.literal("complete") }).strict(),
+  z
+    .object({
+      state: z.literal("truncated"),
+      reason: z.enum([
+        "byte-limit",
+        "item-limit",
+        "source-limit",
+        "permission-limit",
+      ]),
+      omittedItems: z.number().int().nonnegative().optional(),
+      omittedBytes: z.number().int().nonnegative().optional(),
+      detail: nonBlankString(1_024).optional(),
+    })
+    .strict(),
+]);
+
+const rectangleSchema = z
+  .object({
+    x: z.number().finite(),
+    y: z.number().finite(),
+    width: z.number().finite().nonnegative().max(100_000),
+    height: z.number().finite().nonnegative().max(100_000),
+  })
+  .strict();
+
+const readableBlockSchema = z
+  .object({
+    role: z.enum([
+      "heading",
+      "paragraph",
+      "list-item",
+      "table-cell",
+      "code",
+      "quote",
+      "other",
+    ]),
+    text: nonBlankString(8_000),
+    level: z.number().int().min(1).max(6).optional(),
+  })
+  .strict();
+
+const readableLinkSchema = z
+  .object({
+    label: nonBlankString(1_024),
+    url: safeHttpUrlSchema,
+  })
+  .strict();
+
+export const browserReadableProjectionV1Schema = z
+  .object({
+    type: z.literal("readable"),
+    status: projectionStatusSchema,
+    text: z.string().max(BROWSER_CONTEXT_V1_LIMITS.readableTextChars),
+    selection: z.string().max(20_000).optional(),
+    blocks: z
+      .array(readableBlockSchema)
+      .max(BROWSER_CONTEXT_V1_LIMITS.readableBlocks)
+      .optional(),
+    links: z
+      .array(readableLinkSchema)
+      .max(BROWSER_CONTEXT_V1_LIMITS.readableLinks)
+      .optional(),
+  })
+  .strict();
+
+const styleMapSchema = z
+  .record(nonBlankString(120), z.string().max(4_096))
+  .superRefine((styles, context) => {
+    if (
+      Object.keys(styles).length >
+      BROWSER_CONTEXT_V1_LIMITS.designStylesPerElement
+    ) {
+      context.addIssue({
+        code: "custom",
+        message: `Computed styles cannot exceed ${BROWSER_CONTEXT_V1_LIMITS.designStylesPerElement} properties.`,
+      });
+    }
+  });
+
+const designElementSchema = z
+  .object({
+    id: nonBlankString(256),
+    tagName: nonBlankString(64),
+    selector: nonBlankString(2_048).optional(),
+    text: z.string().max(4_000).optional(),
+    bounds: rectangleSchema,
+    computedStyles: styleMapSchema.optional(),
+  })
+  .strict();
+
+const designTokenSchema = z
+  .object({
+    kind: z.enum([
+      "color",
+      "font",
+      "space",
+      "radius",
+      "shadow",
+      "motion",
+      "other",
+    ]),
+    name: nonBlankString(256).optional(),
+    value: nonBlankString(4_096),
+    occurrences: z.number().int().positive().max(1_000_000).optional(),
+  })
+  .strict();
+
+export const browserScreenshotReferenceV1Schema = z
+  .object({
+    id: nonBlankString(256).optional(),
+    url: nonBlankString(16_384)
+      .refine((value) => {
+        if (value.startsWith("/")) return !value.startsWith("//");
+        try {
+          const url = new URL(value);
+          return (
+            (url.protocol === "http:" || url.protocol === "https:") &&
+            !url.username &&
+            !url.password
+          );
+        } catch {
+          return false;
+        }
+      }, "Screenshot URL must be root-relative or credential-free HTTP(S).")
+      .optional(),
+    contentType: z.enum(["image/jpeg", "image/png", "image/webp"]),
+    sha256: z
+      .string()
+      .regex(/^[a-f0-9]{64}$/, "Expected a lowercase SHA-256 digest."),
+    byteSize: z
+      .number()
+      .int()
+      .positive()
+      .max(100 * 1024 * 1024),
+    width: z.number().int().positive().max(16_384),
+    height: z.number().int().positive().max(16_384),
+  })
+  .strict()
+  .refine(
+    (reference) => Boolean(reference.id || reference.url),
+    "Screenshot reference requires an id or URL.",
+  );
+
+export const browserDesignProjectionV1Schema = z
+  .object({
+    type: z.literal("design"),
+    status: projectionStatusSchema,
+    viewport: z
+      .object({
+        width: z.number().int().positive().max(100_000),
+        height: z.number().int().positive().max(100_000),
+        scrollX: z.number().finite(),
+        scrollY: z.number().finite(),
+      })
+      .strict(),
+    elements: z
+      .array(designElementSchema)
+      .max(BROWSER_CONTEXT_V1_LIMITS.designElements),
+    tokens: z
+      .array(designTokenSchema)
+      .max(BROWSER_CONTEXT_V1_LIMITS.designTokens)
+      .optional(),
+    screenshots: z
+      .array(browserScreenshotReferenceV1Schema)
+      .max(BROWSER_CONTEXT_V1_LIMITS.screenshots)
+      .optional(),
+  })
+  .strict();
+
+const accessibilityValueSchema = z.union([
+  z.string().max(4_096),
+  z.number().finite(),
+  z.boolean(),
+]);
+
+const controlNodeSchema = z
+  .object({
+    nodeId: nonBlankString(256),
+    backendNodeId: z.number().int().positive().optional(),
+    ignored: z.boolean().optional(),
+    role: accessibilityValueSchema.optional(),
+    name: accessibilityValueSchema.optional(),
+    value: accessibilityValueSchema.optional(),
+    description: accessibilityValueSchema.optional(),
+    childIds: z
+      .array(nonBlankString(256))
+      .max(BROWSER_CONTEXT_V1_LIMITS.controlChildrenPerNode)
+      .optional(),
+    properties: z
+      .array(
+        z
+          .object({
+            name: nonBlankString(256),
+            value: accessibilityValueSchema,
+          })
+          .strict(),
+      )
+      .max(BROWSER_CONTEXT_V1_LIMITS.controlPropertiesPerNode)
+      .optional(),
+  })
+  .strict();
+
+export const browserControlProjectionV1Schema = z
+  .object({
+    type: z.literal("control"),
+    status: projectionStatusSchema,
+    ephemeral: z.literal(true),
+    observationId: nonBlankString(256),
+    expiresAt: isoTimestampSchema,
+    tabId: z.number().int().nonnegative(),
+    origin: exactHttpOriginSchema,
+    nodes: z
+      .array(controlNodeSchema)
+      .max(BROWSER_CONTEXT_V1_LIMITS.controlNodes),
+  })
+  .strict()
+  .refine(
+    (projection) => Date.parse(projection.expiresAt) > Date.now(),
+    "Control observations must have a future expiry.",
+  );
+
+export const browserContextProjectionV1Schema = z.discriminatedUnion("type", [
+  browserReadableProjectionV1Schema,
+  browserDesignProjectionV1Schema,
+  browserControlProjectionV1Schema,
+]);
+
+const capturedOutcomeSchema = z
+  .object({
+    state: z.enum(["complete", "truncated"]),
+    projections: z
+      .array(browserContextProjectionV1Schema)
+      .min(1)
+      .max(BROWSER_CONTEXT_V1_LIMITS.projections),
+  })
+  .strict()
+  .superRefine((outcome, context) => {
+    const types = new Set(
+      outcome.projections.map((projection) => projection.type),
+    );
+    if (types.size !== outcome.projections.length) {
+      context.addIssue({
+        code: "custom",
+        message: "Browser context cannot contain duplicate projection types.",
+      });
+    }
+    const hasTruncatedProjection = outcome.projections.some(
+      (projection) => projection.status.state === "truncated",
+    );
+    if ((outcome.state === "truncated") !== hasTruncatedProjection) {
+      context.addIssue({
+        code: "custom",
+        message:
+          "Browser context outcome must be truncated exactly when a projection is truncated.",
+      });
+    }
+  });
+
+const failedOutcomeSchema = z
+  .object({
+    state: z.literal("failure"),
+    failure: z
+      .object({
+        code: nonBlankString(120),
+        message: nonBlankString(4_096),
+        retryable: z.boolean(),
+      })
+      .strict(),
+  })
+  .strict();
+
+export const browserContextV1Schema = z
+  .object({
+    schema: z.literal(BROWSER_CONTEXT_V1_SCHEMA),
+    captureId: nonBlankString(256),
+    capturedAt: isoTimestampSchema,
+    page: z
+      .object({
+        url: safeHttpUrlSchema,
+        origin: exactHttpOriginSchema,
+        title: z.string().max(2_048),
+      })
+      .strict(),
+    outcome: z.discriminatedUnion("state", [
+      capturedOutcomeSchema,
+      failedOutcomeSchema,
+    ]),
+  })
+  .strict()
+  .superRefine((contextValue, context) => {
+    if (new URL(contextValue.page.url).origin !== contextValue.page.origin) {
+      context.addIssue({
+        code: "custom",
+        path: ["page", "origin"],
+        message: "Page origin must match the captured page URL.",
+      });
+    }
+    const bytes = new TextEncoder().encode(
+      JSON.stringify(contextValue),
+    ).byteLength;
+    if (bytes > BROWSER_CONTEXT_V1_LIMITS.totalBytes) {
+      context.addIssue({
+        code: "custom",
+        message: `Browser context exceeds ${BROWSER_CONTEXT_V1_LIMITS.totalBytes} JSON bytes.`,
+      });
+    }
+  });
+
+export type BrowserReadableProjectionV1 = z.infer<
+  typeof browserReadableProjectionV1Schema
+>;
+export type BrowserDesignProjectionV1 = z.infer<
+  typeof browserDesignProjectionV1Schema
+>;
+export type BrowserControlProjectionV1 = z.infer<
+  typeof browserControlProjectionV1Schema
+>;
+export type BrowserScreenshotReferenceV1 = z.infer<
+  typeof browserScreenshotReferenceV1Schema
+>;
+export type BrowserContextProjectionV1 = z.infer<
+  typeof browserContextProjectionV1Schema
+>;
+export type BrowserContextV1 = z.infer<typeof browserContextV1Schema>;
+
+export function parseBrowserContextV1(value: unknown): BrowserContextV1 {
+  return browserContextV1Schema.parse(value);
+}
+
+export function safeParseBrowserContextV1(value: unknown) {
+  return browserContextV1Schema.safeParse(value);
+}

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

@@ -768,9 +768,10 @@ function AgentPanelInner({
   ...assistantChatProps
 }: AgentPanelProps) {
   const t = useT();
-  const feedbackEnabled = resolveFeedbackUrl() !== null;
   const navigate = useNavigate();
   const mounted = useClientOnly();
+  const feedbackEnabled =
+    resolveFeedbackUrl(undefined, mounted ? undefined : null) !== null;
   const keyPrefix = storageKey ? `:${storageKey}` : "";
   const execModeKey = `${EXEC_MODE_KEY}${keyPrefix}`;
   const panelModeKey = `agent-native-panel-mode${keyPrefix}`;

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

@@ -17,6 +17,10 @@ import { useOptionalLocale } from "./i18n.js";
 import { useSession } from "./use-session.js";
 import { cn } from "./utils.js";
 
+const FIRST_PARTY_FEEDBACK_URL =
+  "https://forms.agent-native.com/f/agent-native-feedback/_16ewV";
+const FIRST_PARTY_HOSTNAME = "agent-native.com";
+
 function isSyntheticAgentNativeAnonymousEmail(
   value: string | null | undefined,
 ): boolean {
@@ -231,7 +235,11 @@ export interface FeedbackButtonProps {
    */
   variant?: "sidebar" | "icon" | "outlined";
   label?: string;
-  /** Defaults to VITE_AGENT_NATIVE_FEEDBACK_URL. Missing, blank, or null hides the control. */
+  /**
+   * Defaults to VITE_AGENT_NATIVE_FEEDBACK_URL. First-party agent-native.com
+   * apps fall back to the Agent Native feedback form; other apps stay hidden.
+   * Pass null to explicitly hide the control.
+   */
   url?: string | null;
   className?: string;
   /** Which side the popover opens on. Defaults match the variant. */
@@ -281,14 +289,39 @@ function clientEnv(): Record<string, string | boolean | undefined> | undefined {
   return importMetaEnv ?? processEnv;
 }
 
-export function resolveFeedbackUrl(url?: string | null): string | null {
+function clientHostname(): string | undefined {
+  const location = (
+    globalThis as typeof globalThis & {
+      location?: { hostname?: string };
+    }
+  ).location;
+  return location?.hostname;
+}
+
+function isFirstPartyHostname(hostname: string | null | undefined): boolean {
+  const normalized = hostname?.trim().toLowerCase();
+  return (
+    normalized === FIRST_PARTY_HOSTNAME ||
+    normalized?.endsWith(`.${FIRST_PARTY_HOSTNAME}`) === true
+  );
+}
+
+export function resolveFeedbackUrl(
+  url?: string | null,
+  hostname: string | null | undefined = clientHostname(),
+): string | null {
   const value =
     url === undefined ? clientEnv()?.VITE_AGENT_NATIVE_FEEDBACK_URL : url;
-  return typeof value === "string" && value.trim() ? value.trim() : null;
+  if (typeof value === "string" && value.trim()) return value.trim();
+  if (url !== undefined) return null;
+  return isFirstPartyHostname(hostname) ? FIRST_PARTY_FEEDBACK_URL : null;
 }
 
 export function FeedbackButton(props: FeedbackButtonProps) {
-  const url = resolveFeedbackUrl(props.url);
+  const [mounted, setMounted] = useState(false);
+  useEffect(() => setMounted(true), []);
+
+  const url = resolveFeedbackUrl(props.url, mounted ? undefined : null);
   if (!url) return null;
   return <FeedbackPopoverButton {...props} url={url} />;
 }

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

@@ -23,6 +23,7 @@ import {
   parseSubmitChatMessage,
   removeAgentChatContextItem,
   reportAgentChatSubmitResult,
+  reportAgentChatSubmitTarget,
   setAgentChatContextItem,
   type AgentChatContextItem,
 } from "./agent-chat.js";
@@ -1616,6 +1617,7 @@ export function MultiTabAssistantChat({
         engine,
         effort,
         newTab,
+        reuseEmptyTab,
         background,
         submit,
         images,
@@ -1682,6 +1684,7 @@ export function MultiTabAssistantChat({
 
       const sendToTab = (threadId: string) => {
         if (isAgentChatSubmitCancelled(submitMessageId)) return;
+        reportAgentChatSubmitTarget(submitMessageId, threadId);
         if (modelOverride) {
           threadModelRef.current.set(threadId, modelOverride);
           bumpModelSelectionVersion();
@@ -1697,6 +1700,23 @@ export function MultiTabAssistantChat({
 
       if (newTab) {
         const previousTabId = activeThreadIdRef.current;
+        const previousChat = previousTabId
+          ? chatRefs.current.get(previousTabId)
+          : undefined;
+        // A blank active chat is already an isolated destination. Reuse it for
+        // foreground creation requests so the action does not leave a ghost tab.
+        if (
+          reuseEmptyTab &&
+          !background &&
+          previousTabId &&
+          previousChat &&
+          (newThreadIds.current.has(previousTabId) ||
+            isNewThread(previousTabId)) &&
+          previousChat.exportThreadSnapshot() === null
+        ) {
+          sendToTab(previousTabId);
+          return;
+        }
         createThread(requestedTabId)
           .then((newId) => {
             if (isAgentChatSubmitCancelled(submitMessageId)) return;
@@ -1752,6 +1772,7 @@ export function MultiTabAssistantChat({
     bumpModelSelectionVersion,
     clearContextInTab,
     createThread,
+    isNewThread,
     postMessageSubmissionsDisabled,
     props.execMode,
     removeContextInTab,

package/corpus/core/src/client/agent-chat.ts

@@ -91,6 +91,11 @@ export interface AgentChatMessage {
    * their own isolated thread rather than cluttering an existing conversation.
    */
   newTab?: boolean;
+  /**
+   * When true with newTab, reuses the active tab only when the receiver knows
+   * it is a new foreground chat with no messages.
+   */
+  reuseEmptyTab?: boolean;
   /**
    * When true with newTab, creates the tab in the background without
    * focusing it or opening the sidebar. The message runs silently.
@@ -231,6 +236,7 @@ const AGENT_PANEL_PREPARE_EVENT = "agent-panel:prepare";
  * {@link sendToAgentChatAndConfirm} instead of listening for this directly.
  */
 export const AGENT_CHAT_SUBMIT_RESULT_EVENT = "agentNative.chatSubmitResult";
+export const AGENT_CHAT_SUBMIT_TARGET_EVENT = "agentNative.chatSubmitTarget";
 
 export interface AgentChatSubmitResult {
   submitMessageId: string;
@@ -238,6 +244,24 @@ export interface AgentChatSubmitResult {
   reason?: string;
 }
 
+export interface AgentChatSubmitTarget {
+  submitMessageId: string;
+  tabId: string;
+}
+
+/** Report the actual tab selected by the receiving chat surface for a submit. */
+export function reportAgentChatSubmitTarget(
+  submitMessageId: string | undefined,
+  tabId: string,
+): void {
+  if (!submitMessageId || !tabId || typeof window === "undefined") return;
+  window.dispatchEvent(
+    new CustomEvent<AgentChatSubmitTarget>(AGENT_CHAT_SUBMIT_TARGET_EVENT, {
+      detail: { submitMessageId, tabId },
+    }),
+  );
+}
+
 /** Report a submit's definitive outcome so `sendToAgentChatAndConfirm` (or any
  * other correlated listener) can resolve. No-ops without a submitMessageId or
  * a window (SSR). */
@@ -295,7 +319,7 @@ export function generateTabId(): string {
 }
 
 /** Unique id for one submitted message, used to dedup live + replayed sends. */
-function generateSubmitMessageId(): string {
+export function generateAgentChatSubmitMessageId(): string {
   return `submit-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
 }
 
@@ -887,6 +911,7 @@ export interface ParsedSubmitChat {
   /** Raw effort hint; the receiver validates it against the model. */
   effort?: unknown;
   newTab?: boolean;
+  reuseEmptyTab?: boolean;
   background?: boolean;
   tabId?: string;
   images?: string[];
@@ -928,6 +953,8 @@ export function parseSubmitChatMessage(
     engine: nonEmptyString(raw.engine),
     effort: raw.effort,
     newTab: typeof raw.newTab === "boolean" ? raw.newTab : undefined,
+    reuseEmptyTab:
+      typeof raw.reuseEmptyTab === "boolean" ? raw.reuseEmptyTab : undefined,
     background:
       typeof raw.background === "boolean" ? raw.background : undefined,
     tabId: typeof raw.tabId === "string" ? raw.tabId : undefined,
@@ -989,7 +1016,8 @@ export function sendToAgentChat(opts: AgentChatMessage): string {
     return tabId;
   }
 
-  const submitMessageId = opts.submitMessageId ?? generateSubmitMessageId();
+  const submitMessageId =
+    opts.submitMessageId ?? generateAgentChatSubmitMessageId();
   const payload = {
     type: AGENT_CHAT_MESSAGE_TYPE,
     data: {
@@ -1123,7 +1151,7 @@ export function sendToAgentChatAndConfirm(
     });
   }
 
-  const submitMessageId = generateSubmitMessageId();
+  const submitMessageId = generateAgentChatSubmitMessageId();
   const timeoutMs = Math.max(
     0,
     options?.timeoutMs ?? DEFAULT_SUBMIT_CONFIRM_TIMEOUT_MS,