@agent-native/core 0.130.2 → 0.131.3

package/src/client/use-chat-threads.ts

@@ -78,33 +78,17 @@ const ACTIVE_THREAD_KEY = "agent-chat-active-thread";
 const THREADS_UPDATED_EVENT = "agent-chat:threads-updated";
 const THREADS_PAGE_SIZE = 50;
 
-const sharedThreadListRequests = new Map<
-  string,
-  Promise<ChatThreadSummary[] | undefined>
->();
-
-async function fetchSharedThreadListPage(
+async function fetchThreadListPage(
   apiUrl: string,
   offset: number,
 ): Promise<ChatThreadSummary[] | undefined> {
-  const requestKey = `${apiUrl}\n${offset}`;
-  const pending = sharedThreadListRequests.get(requestKey);
-  if (pending) return pending;
-
-  const request = fetch(
+  return fetch(
     offset > 0 ? `${apiUrl}/threads?offset=${offset}` : `${apiUrl}/threads`,
-  )
-    .then(async (res) => {
-      if (!res.ok) return undefined;
-      const data = await res.json();
-      const threads = (data.threads ?? []) as ChatThreadSummary[];
-      return threads;
-    })
-    .finally(() => {
-      sharedThreadListRequests.delete(requestKey);
-    });
-  sharedThreadListRequests.set(requestKey, request);
-  return request;
+  ).then(async (res) => {
+    if (!res.ok) return undefined;
+    const data = await res.json();
+    return (data.threads ?? []) as ChatThreadSummary[];
+  });
 }
 
 function emitThreadsUpdated() {
@@ -470,7 +454,7 @@ export function useChatThreads(
     async (options?: { append?: boolean }) => {
       try {
         const offset = options?.append ? nextThreadsOffsetRef.current : 0;
-        const loaded = await fetchSharedThreadListPage(apiUrl, offset);
+        const loaded = await fetchThreadListPage(apiUrl, offset);
         if (!loaded) {
           if (!options?.append) {
             setThreadsLoadError("Could not load chat history.");
@@ -598,7 +582,6 @@ export function useChatThreads(
     fetchedRef.current = true;
 
     (async () => {
-      setIsLoading(true);
       const loadedThreads = await fetchThreads();
       const savedId = activeThreadIdRef.current;
       if (loadedThreads === undefined) {

package/src/deploy/build.ts

@@ -33,6 +33,7 @@ import {
   isDurableBackgroundFlagEnabled,
 } from "../agent/durable-background.js";
 import {
+  INTEGRATION_RECOVERY_RUNTIME_MARKER,
   INTEGRATION_RETRY_SWEEP_PATH,
   INTEGRATION_RETRY_SWEEP_TOKEN_SUBJECT,
   isIntegrationDurableDispatchConfigured,
@@ -3003,6 +3004,7 @@ export function emitSingleTemplateNetlifyIntegrationRecoveryFunction(
 
 const SWEEP_PATH = ${JSON.stringify(INTEGRATION_RETRY_SWEEP_PATH)};
 const SWEEP_SUBJECT = ${JSON.stringify(INTEGRATION_RETRY_SWEEP_TOKEN_SUBJECT)};
+globalThis.${INTEGRATION_RECOVERY_RUNTIME_MARKER} = true;
 
 function enabled() {
   const raw = process.env.AGENT_INTEGRATION_DURABLE_DISPATCH;

package/src/deploy/workspace-deploy.ts

@@ -28,6 +28,7 @@ import {
   isDurableBackgroundFlagExplicitlyDisabled,
 } from "../agent/durable-background.js";
 import {
+  INTEGRATION_RECOVERY_RUNTIME_MARKER,
   INTEGRATION_RETRY_SWEEP_PATH,
   INTEGRATION_RETRY_SWEEP_TOKEN_SUBJECT,
   isIntegrationDurableDispatchConfigured,
@@ -916,6 +917,7 @@ function emitNetlifyIntegrationRecoveryFunction(
 const basePath = ${JSON.stringify(basePath)};
 const SWEEP_PATH = ${JSON.stringify(sweepPath)};
 const SWEEP_SUBJECT = ${JSON.stringify(INTEGRATION_RETRY_SWEEP_TOKEN_SUBJECT)};
+globalThis.${INTEGRATION_RECOVERY_RUNTIME_MARKER} = true;
 
 function setBasePathEnv() {
   const processRef = globalThis.process ??= { env: {} };

package/src/extensions/actions.ts

@@ -67,6 +67,10 @@ import {
 // the surrounding metadata and indentation while still bounding tool context.
 const GET_EXTENSION_MAX_RESULT_CHARS = 500_000;
 const GET_EXTENSION_HISTORY_MAX_RESULT_CHARS = 2_000_000;
+const LARGE_EXTENSION_INLINE_CONTENT_MAX_CHARS = 60_000;
+const EXTENSION_CONTENT_MATCH_LIMIT = 8;
+const DEFAULT_EXTENSION_CONTENT_CONTEXT_CHARS = 1_500;
+const MAX_EXTENSION_CONTENT_CONTEXT_CHARS = 4_000;
 
 export function createExtensionActionEntries(): Record<string, ActionEntry> {
   return {
@@ -153,7 +157,7 @@ export function createExtensionActionEntries(): Record<string, ActionEntry> {
     "get-extension": {
       tool: {
         description:
-          "Get one existing extension by id. Use this when <current-screen> or <current-url> contains extensionId for the current extension; do not call list-extensions just to rediscover that id. Defaults to including the full Alpine.js content once per run so you can make a targeted update-extension edit; repeated unchanged reads return compact metadata unless forceContent=true.",
+          "Get one existing extension by id. Use this when <current-screen> or <current-url> contains extensionId for the current extension; do not call list-extensions just to rediscover that id. Small extensions include their full Alpine.js content once per run. Large extensions return compact metadata first; pass contentQuery with a function, variable, section marker, or literal text to retrieve bounded source excerpts for a targeted update-extension edit. Repeated unchanged full reads return compact metadata unless forceContent=true.",
         parameters: {
           type: "object",
           properties: {
@@ -170,7 +174,17 @@ export function createExtensionActionEntries(): Record<string, ActionEntry> {
             forceContent: {
               type: "boolean",
               description:
-                "Return full content even if this run already read the same unchanged body. Use sparingly; prefer update-extension edits after the first read.",
+                "Return full content even when the extension is large or this run already read the same unchanged body. Use only for a broad rewrite; prefer contentQuery plus focused update-extension edits.",
+            },
+            contentQuery: {
+              type: "string",
+              description:
+                "Literal, case-insensitive source text to find. Returns bounded excerpts around up to 8 matches without loading the full extension.",
+            },
+            contentContextChars: {
+              type: "number",
+              description:
+                "Characters of context before and after each contentQuery match. Defaults to 1500 and is capped at 4000.",
             },
           },
           required: ["id"],
@@ -184,6 +198,10 @@ export function createExtensionActionEntries(): Record<string, ActionEntry> {
             ? true
             : coerceBoolean(args.includeContent);
         const forceContent = coerceBoolean(args?.forceContent);
+        const contentQuery = String(args?.contentQuery ?? "").trim();
+        const contentContextChars = normalizeExtensionContentContextChars(
+          args?.contentContextChars,
+        );
         const localExtension = await getLocalExtension(id);
         if (localExtension) {
           return {
@@ -193,6 +211,8 @@ export function createExtensionActionEntries(): Record<string, ActionEntry> {
               new Set(),
               includeContent,
               forceContent,
+              contentQuery,
+              contentContextChars,
             ),
           };
         }
@@ -206,6 +226,8 @@ export function createExtensionActionEntries(): Record<string, ActionEntry> {
             hiddenIds,
             includeContent,
             forceContent,
+            contentQuery,
+            contentContextChars,
           ),
         };
       },
@@ -1402,12 +1424,50 @@ async function summarizeExtensionForAgentRead(
   hiddenIds: Set<string>,
   includeContent: boolean,
   forceContent: boolean,
+  contentQuery: string,
+  contentContextChars: number,
 ) {
+  const fingerprint = contentFingerprint(row.content);
+
+  if (contentQuery) {
+    const summary = await summarizeExtension(row, hiddenIds, false);
+    return {
+      ...summary,
+      contentMatches: findExtensionContentMatches(
+        row.content,
+        contentQuery,
+        contentContextChars,
+      ),
+      contentOmitted: {
+        reason: "targeted-content-read",
+        contentHash: fingerprint,
+        contentLength: row.content.length,
+        next: 'Use the returned excerpts to call update-extension with operation="edit" and focused edits. Call get-extension again with a different contentQuery when another source area is needed.',
+      },
+    };
+  }
+
   if (!includeContent) {
     return summarizeExtension(row, hiddenIds, false);
   }
 
-  const fingerprint = contentFingerprint(row.content);
+  if (
+    !forceContent &&
+    row.content.length > LARGE_EXTENSION_INLINE_CONTENT_MAX_CHARS
+  ) {
+    const summary = await summarizeExtension(row, hiddenIds, false);
+    return {
+      ...summary,
+      contentOmitted: {
+        reason: "large-content-requires-targeted-read",
+        contentHash: fingerprint,
+        contentLength: row.content.length,
+        inlineContentLimit: LARGE_EXTENSION_INLINE_CONTENT_MAX_CHARS,
+        next: "Call get-extension again with contentQuery set to the relevant function, variable, section marker, or literal text. Use forceContent=true only for a broad rewrite that truly needs the entire body.",
+      },
+    };
+  }
+
   const runCtx = getRequestRunContext();
   const reads = runCtx ? (runCtx.extensionContentReads ??= {}) : undefined;
   const alreadySent = !forceContent && reads?.[row.id] === fingerprint;
@@ -1429,6 +1489,58 @@ async function summarizeExtensionForAgentRead(
   };
 }
 
+function normalizeExtensionContentContextChars(value: unknown): number {
+  const numeric = Number(value);
+  if (!Number.isFinite(numeric)) {
+    return DEFAULT_EXTENSION_CONTENT_CONTEXT_CHARS;
+  }
+  return Math.min(
+    MAX_EXTENSION_CONTENT_CONTEXT_CHARS,
+    Math.max(250, Math.floor(numeric)),
+  );
+}
+
+function findExtensionContentMatches(
+  content: string,
+  query: string,
+  contextChars: number,
+) {
+  const lowerContent = content.toLowerCase();
+  const lowerQuery = query.toLowerCase();
+  const matches: Array<{
+    matchStart: number;
+    matchEnd: number;
+    excerptStart: number;
+    excerptEnd: number;
+    excerpt: string;
+  }> = [];
+  let searchFrom = 0;
+
+  while (matches.length < EXTENSION_CONTENT_MATCH_LIMIT) {
+    const matchStart = lowerContent.indexOf(lowerQuery, searchFrom);
+    if (matchStart < 0) break;
+    const matchEnd = matchStart + query.length;
+    const excerptStart = Math.max(0, matchStart - contextChars);
+    const excerptEnd = Math.min(content.length, matchEnd + contextChars);
+    matches.push({
+      matchStart,
+      matchEnd,
+      excerptStart,
+      excerptEnd,
+      excerpt: content.slice(excerptStart, excerptEnd),
+    });
+    searchFrom = matchEnd;
+  }
+
+  return {
+    query,
+    matches,
+    hasMore:
+      matches.length === EXTENSION_CONTENT_MATCH_LIMIT &&
+      lowerContent.indexOf(lowerQuery, searchFrom) >= 0,
+  };
+}
+
 function compactExtensionHistoryDetail(
   detail: ExtensionHistoryDetail,
   includeContent: boolean,

package/src/extensions/fetch-tool.ts

@@ -189,6 +189,17 @@ export function createFetchToolEntry(
           required: ["url"],
         },
       },
+      planMode: {
+        effect: (args) => {
+          const method = String(args.method ?? "GET").toUpperCase();
+          if (method !== "GET" && method !== "HEAD") return "write";
+          return args.saveToFile == null ? "read" : "write";
+        },
+        allowedValues: { method: ["GET", "HEAD"] },
+        omittedProperties: ["saveToFile"],
+        description:
+          "Plan mode allows GET and HEAD requests that return their response without saving it.",
+      },
       run: async (args: Record<string, unknown>) => {
         const startTime = Date.now();
         const rawUrl = String(args.url ?? "");

package/src/extensions/routes.ts

@@ -63,7 +63,14 @@ import {
   isBlockedExtensionUrlWithDns,
 } from "./url-safety.js";
 
-export function createExtensionsHandler() {
+export interface ExtensionsHandlerOptions {
+  /** Allow authenticated callers to create extensions through the collection route. */
+  extensionTools?: boolean;
+}
+
+export function createExtensionsHandler(
+  options: ExtensionsHandlerOptions = {},
+) {
   return defineEventHandler(async (event: H3Event) => {
     const method = getMethod(event);
     const pathname = (event.url?.pathname || "")
@@ -95,6 +102,14 @@ export function createExtensionsHandler() {
 
     try {
       return await runWithRequestContext({ userEmail, orgId }, async () => {
+        if (
+          method === "POST" &&
+          parts.length === 0 &&
+          options.extensionTools !== true
+        ) {
+          setResponseStatus(event, 403);
+          return { error: "Extension creation is disabled for this app" };
+        }
         await ensureExtensionsTables();
         return dispatch(event, method, parts, userEmail);
       });

package/src/extensions/web-content.ts

@@ -61,6 +61,7 @@ export interface WebContentResult {
   siteName?: string;
   lang?: string;
   publishedTime?: string;
+  agentMetadata?: unknown[];
   content?: string;
   links?: WebContentLink[];
   matches?: WebContentMatch[];
@@ -77,6 +78,8 @@ const DEFAULT_MAX_MATCHES = 50;
 const MAX_MATCHES = 500;
 const DEFAULT_CONTEXT_CHARS = 160;
 const MAX_CONTEXT_CHARS = 1_000;
+const MAX_AGENT_METADATA_SCRIPTS = 10;
+const MAX_AGENT_METADATA_CHARS = 32_000;
 
 const turndown = new TurndownService({
   headingStyle: "atx",
@@ -260,6 +263,13 @@ export function formatWebContentResult(result: WebContentResult): string {
   ) {
     lines.push("", "Links:", formatLinks(result.links));
   }
+  if (result.agentMetadata?.length) {
+    lines.push(
+      "",
+      "Agent-readable metadata:",
+      JSON.stringify(result.agentMetadata, null, 2),
+    );
+  }
   if (result.matches?.length && result.mode !== "matches") {
     lines.push("", formatMatches(result));
   }
@@ -307,8 +317,11 @@ function extractHtml(
   siteName?: string;
   lang?: string;
   publishedTime?: string;
+  agentMetadata?: unknown[];
 } {
   const document = parseFullDocument(body);
+  const alternateLinks = collectAlternateLinks(document, url);
+  const agentMetadata = collectAgentMetadata(document);
   removeNonContentNodes(document);
   const pageTitle = textOrUndefined(document.title);
   const article =
@@ -335,16 +348,95 @@ function extractHtml(
     html: absoluteHtml,
     text: normalizeWhitespace(sourceText),
     markdown,
-    links: collectLinks(absoluteHtml, url),
+    links: mergeLinks(alternateLinks, collectLinks(absoluteHtml, url)),
     title: textOrUndefined(article?.title) ?? pageTitle,
     excerpt: textOrUndefined(article?.excerpt),
     byline: textOrUndefined(article?.byline),
     siteName: textOrUndefined(article?.siteName),
     lang: textOrUndefined(article?.lang),
     publishedTime: textOrUndefined(article?.publishedTime),
+    ...(agentMetadata.length ? { agentMetadata } : {}),
   };
 }
 
+function collectAgentMetadata(document: Document): unknown[] {
+  const metadata: unknown[] = [];
+  let totalChars = 0;
+  for (const script of [
+    ...document.querySelectorAll(
+      'script[type="application/agent-native+json"]',
+    ),
+  ]) {
+    if (metadata.length >= MAX_AGENT_METADATA_SCRIPTS) break;
+    const json = script.textContent?.trim() ?? "";
+    if (
+      !json ||
+      json.length > MAX_AGENT_METADATA_CHARS ||
+      totalChars + json.length > MAX_AGENT_METADATA_CHARS
+    ) {
+      continue;
+    }
+    try {
+      const parsed = JSON.parse(json);
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        continue;
+      }
+      metadata.push(parsed);
+      totalChars += json.length;
+    } catch {}
+  }
+  return metadata;
+}
+
+function collectAlternateLinks(
+  document: Document,
+  url: string,
+): WebContentLink[] {
+  const links: WebContentLink[] = [];
+  for (const element of [
+    ...document.querySelectorAll("a[href][rel], link[href][rel]"),
+  ]) {
+    const rel = element
+      .getAttribute("rel")
+      ?.toLowerCase()
+      .split(/\s+/)
+      .filter(Boolean);
+    if (!rel?.includes("alternate")) continue;
+
+    const href = element.getAttribute("href");
+    if (!href) continue;
+    let absolute: string;
+    try {
+      absolute = new URL(href, url).href;
+    } catch {
+      continue;
+    }
+
+    const type = element.getAttribute("type")?.trim();
+    const text = normalizeWhitespace(element.textContent || "");
+    links.push({
+      text: text || (type ? `Alternate ${type}` : "Alternate resource"),
+      url: absolute,
+    });
+  }
+  return links;
+}
+
+function mergeLinks(
+  preferred: WebContentLink[],
+  remaining: WebContentLink[],
+): WebContentLink[] {
+  const links: WebContentLink[] = [];
+  const seen = new Set<string>();
+  for (const link of [...preferred, ...remaining]) {
+    if (seen.has(link.url)) continue;
+    seen.add(link.url);
+    links.push(link);
+    if (links.length >= 200) break;
+  }
+  return links;
+}
+
 function htmlToPlainText(html: string): string {
   const document = parseFullDocument(html);
   removeNonContentNodes(document);
@@ -449,6 +541,9 @@ function metadataFromExtraction(
     ...(extracted.publishedTime
       ? { publishedTime: extracted.publishedTime }
       : {}),
+    ...(extracted.agentMetadata?.length
+      ? { agentMetadata: extracted.agentMetadata }
+      : {}),
   };
 }
 

package/src/integrations/computer-supervision.ts

@@ -10,6 +10,13 @@ const OPERATION_CLASSES = new Set<ComputerOperationClass>([
   "desktop.control",
 ]);
 const APPROVAL_SCOPES = new Set(["once", "run", "task"] as const);
+const OBSERVE_ACTIONS = new Map<ComputerOperationClass, Set<string>>([
+  [
+    "browser.observe",
+    new Set(["browser.read", "browser.observe", "browser.stop"]),
+  ],
+  ["desktop.observe", new Set(["desktop.observe", "desktop.stop"])],
+]);
 const MAX_ACTION_BYTES = 32_768;
 const MAX_LEASE_MS = 24 * 60 * 60_000;
 
@@ -85,7 +92,11 @@ export async function assertValidComputerCommandEnvelope(
   if (!isRecord(value.action)) {
     throw invalid("action must be an object");
   }
-  boundedString(value.action.type, "action.type", 120);
+  const actionType = boundedString(value.action.type, "action.type", 120);
+  assertActionMatchesOperationClass(
+    value.operationClass as ComputerOperationClass,
+    actionType,
+  );
   const actionJson = stableJson(value.action);
   if (new TextEncoder().encode(actionJson).byteLength > MAX_ACTION_BYTES) {
     throw invalid("Computer action exceeds the 32 KiB metadata limit");
@@ -197,6 +208,27 @@ function looksLikeLargeBase64(value: string): boolean {
   return value.length > 512 && /^[A-Za-z0-9+/]+={0,2}$/.test(value);
 }
 
+function assertActionMatchesOperationClass(
+  operationClass: ComputerOperationClass,
+  actionType: string,
+): void {
+  const [surface, mode] = operationClass.split(".");
+  if (!actionType.startsWith(`${surface}.`)) {
+    throw invalid(
+      `${actionType} cannot execute as a ${operationClass} operation`,
+    );
+  }
+  if (
+    mode === "observe" &&
+    !OBSERVE_ACTIONS.get(operationClass)?.has(actionType)
+  ) {
+    throw invalid(`${actionType} requires a ${surface}.control operation`);
+  }
+  if (mode === "control" && actionType.endsWith(".observe")) {
+    throw invalid(`${actionType} must use a ${surface}.observe operation`);
+  }
+}
+
 function isRecord(value: unknown): value is Record<string, any> {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }

package/src/integrations/index.ts

@@ -61,6 +61,7 @@ export {
 } from "./plugin.js";
 
 export {
+  createRemoteDevice,
   getRemoteComputerCapabilities,
   listRemoteDevicesForOwner,
   revokeRemoteDeviceForOwner,
@@ -69,8 +70,13 @@ export {
 export {
   claimNextComputerCommand,
   enqueueComputerCommand,
+  getRemoteCommand,
   listRemoteCommandsForOwner,
 } from "./remote-commands-store.js";
+export {
+  createRemoteBrowserActionEntries,
+  type CreateRemoteBrowserActionEntriesOptions,
+} from "./remote-browser-actions.js";
 export {
   assertValidComputerCommandEnvelope,
   computeComputerActionHash,

package/src/integrations/integration-durable-dispatch-config.ts

@@ -8,6 +8,16 @@ export const INTEGRATION_RETRY_SWEEP_PATH =
   "/_agent-native/integrations/retry-stuck-tasks";
 export const INTEGRATION_RETRY_SWEEP_TOKEN_SUBJECT =
   "integration-pending-tasks-sweep";
+export const INTEGRATION_RECOVERY_RUNTIME_MARKER =
+  "__AGENT_NATIVE_INTEGRATION_RECOVERY_RUNTIME__";
+
+export function isInIntegrationRecoveryRuntime(): boolean {
+  return (
+    (globalThis as Record<string, unknown>)[
+      INTEGRATION_RECOVERY_RUNTIME_MARKER
+    ] === true
+  );
+}
 
 export function isIntegrationDurableDispatchConfigured(): boolean {
   const value = process.env.AGENT_INTEGRATION_DURABLE_DISPATCH;

package/src/integrations/integration-durable-dispatch.ts

@@ -10,8 +10,10 @@ import {
   INTEGRATION_DURABLE_DISPATCH_ENV,
   INTEGRATION_DURABLE_DISPATCH_SCOPES_ENV,
   INTEGRATION_PROCESS_TASK_PATH,
+  INTEGRATION_RECOVERY_RUNTIME_MARKER,
   INTEGRATION_RETRY_SWEEP_PATH,
   INTEGRATION_RETRY_SWEEP_TOKEN_SUBJECT,
+  isInIntegrationRecoveryRuntime,
   isIntegrationDurableDispatchConfigured,
 } from "./integration-durable-dispatch-config.js";
 import { recordPendingTaskDispatchAttempt } from "./pending-tasks-store.js";
@@ -20,8 +22,10 @@ export {
   INTEGRATION_DURABLE_DISPATCH_ENV,
   INTEGRATION_DURABLE_DISPATCH_SCOPES_ENV,
   INTEGRATION_PROCESS_TASK_PATH,
+  INTEGRATION_RECOVERY_RUNTIME_MARKER,
   INTEGRATION_RETRY_SWEEP_PATH,
   INTEGRATION_RETRY_SWEEP_TOKEN_SUBJECT,
+  isInIntegrationRecoveryRuntime,
   isIntegrationDurableDispatchConfigured,
 };