@agent-native/core 0.217.0 → 0.219.0

package/dist/a2a/server.d.ts

@@ -50,7 +50,7 @@ export declare function verifyA2AToken(token: string, event?: any, audienceOptio
     allowAnthropicManagedContinuation?: boolean;
     requireAudience?: boolean;
 }): Promise<A2ATokenPayload>;
-export type A2ATokenFailureCause = "malformed" | "secret-missing" | "audience-unresolvable" | "audience" | "issuer" | "expired" | "signature" | "invalid-claims" | "mcp-credential" | "missing-subject" | "org-binding" | "org-lookup-failed" | "undetermined";
+export type A2ATokenFailureCause = "malformed" | "secret-missing" | "audience-unresolvable" | "audience" | "issuer" | "expired" | "signature" | "algorithm" | "invalid-claims" | "mcp-credential" | "missing-subject" | "org-binding" | "org-lookup-failed" | "undetermined";
 /**
  * Names why a token that `verifyA2AToken` resolved no identity for was
  * refused. `verifyA2AToken` collapses a wrong audience, a wrong secret and an

package/dist/a2a/server.js

@@ -21,6 +21,7 @@ import { hasConfiguredA2ASecret, isA2AProductionRuntime, } from "./auth-policy.j
 import { handleJsonRpcH3, processA2ATaskFromQueue } from "./handlers.js";
 import { A2A_ORG_MEMBER_DELEGATION_TYPE, organizationPrincipalClaims, verifyA2AOrganizationIdentity, } from "./organization-identity.js";
 import { claimA2AApproval, a2aTaskLeaseThreadId, getA2AApprovalForOwner, settleA2AApproval, } from "./task-store.js";
+const A2A_TOKEN_ALGORITHMS = ["HS256"];
 let _warnedUnauthA2A = false;
 function warnA2AUnauthOnce() {
     if (_warnedUnauthA2A)
@@ -196,6 +197,8 @@ async function checkAgainstSecret(token, secret, options) {
     }
     catch (error) {
         const { code, claim } = error;
+        if (code === "ERR_JOSE_ALG_NOT_ALLOWED")
+            return { cause: "algorithm" };
         if (code === "ERR_JWT_EXPIRED")
             return { cause: "expired" };
         if (code === "ERR_JWS_SIGNATURE_VERIFICATION_FAILED") {
@@ -243,7 +246,7 @@ export async function diagnoseA2ATokenFailure(token, event) {
         return "malformed";
     }
     const secret = readDeployCredentialEnv("A2A_SECRET")?.trim();
-    const options = {};
+    const options = { algorithms: A2A_TOKEN_ALGORITHMS };
     if (typeof claims.aud !== "undefined") {
         const audience = expectedJwtAudience(event);
         if (!audience)
@@ -331,7 +334,9 @@ async function verifyA2ATokenInternal(token, event, audienceOptions) {
     if (audienceOptions?.requireAudience && !hasAudience) {
         return { payload: { email: null, orgDomain: null } };
     }
-    const verifyOptions = {};
+    const verifyOptions = {
+        algorithms: A2A_TOKEN_ALGORITHMS,
+    };
     if (hasAudience) {
         // Fail closed: the token was minted for a specific audience, but this
         // receiver can't derive its own expected audience (no APP_URL/URL and no
@@ -424,10 +429,7 @@ async function verifyA2ATokenInternal(token, event, audienceOptions) {
     }
     if (!organization)
         return { payload: { email: null, orgDomain: null } };
-    const orgVerifyOptions = unverifiedPayload?.typ === A2A_ORG_MEMBER_DELEGATION_TYPE
-        ? { ...verifyOptions, algorithms: ["HS256"] }
-        : verifyOptions;
-    const payload = await verifyJwtWithSecret(token, organization.secret, orgVerifyOptions);
+    const payload = await verifyJwtWithSecret(token, organization.secret, verifyOptions);
     if (!payload)
         return { payload: { email: null, orgDomain: null } };
     const claims = organizationPrincipalClaims(payload, organization);

package/dist/agent/run-manager.js

@@ -1205,6 +1205,9 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
     };
     let lastAbortCheck = Date.now() - 3000;
     let consecutiveAbortCheckFailures = 0;
+    let completionInProgress = false;
+    let ownTerminalStatusEstablished = false;
+    let terminalStatusWrite = null;
     const checkSqlAbort = () => {
         const now = Date.now();
         if (now - lastAbortCheck < 3000)
@@ -1216,9 +1219,16 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
                 abortInMemoryRun(run, state.reason ?? "user");
                 return;
             }
-            if (!abort.signal.aborted) {
+            if (!abort.signal.aborted && !ownTerminalStatusEstablished) {
                 const status = await getRunStatus(runId);
                 if (status !== null && status !== "running") {
+                    const pendingStatusWrite = terminalStatusWrite;
+                    if (pendingStatusWrite)
+                        await pendingStatusWrite;
+                }
+                if (status !== null &&
+                    status !== "running" &&
+                    !ownTerminalStatusEstablished) {
                     abortInMemoryRun(run, "displaced");
                 }
             }
@@ -1249,7 +1259,6 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
     };
     let consecutiveHeartbeatFailures = 0;
     let heartbeatInFlight = false;
-    let completionInProgress = false;
     const heartbeatTimer = setInterval(() => {
         if (!heartbeatInFlight) {
             heartbeatInFlight = true;
@@ -1748,11 +1757,26 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
         const persistTerminalStatus = () => Object.keys(terminalStatusOptions).length === 0
             ? updateRunStatusIfRunning(runId, persistedStatus)
             : updateRunStatusIfRunning(runId, persistedStatus, terminalStatusOptions);
-        const reconcileTerminalRun = () => threadProjectionPending
+        const persistOwnTerminalState = async (persist) => {
+            const write = withWorkerFence(persist);
+            terminalStatusWrite = write;
+            try {
+                const established = await write;
+                if (established)
+                    ownTerminalStatusEstablished = true;
+                return established;
+            }
+            finally {
+                if (terminalStatusWrite === write)
+                    terminalStatusWrite = null;
+            }
+        };
+        const persistOwnTerminalStatus = () => persistOwnTerminalState(persistTerminalStatus);
+        const reconcileTerminalRun = () => persistOwnTerminalState(() => threadProjectionPending
             ? reconcileTerminalRunFromEvents(runId, {
                 threadProjectionPending: true,
             })
-            : reconcileTerminalRunFromEvents(runId);
+            : reconcileTerminalRunFromEvents(runId));
         const reportTerminalStatusPersistenceError = (error) => {
             captureError(error, {
                 route: "/_agent-native/agent-chat",
@@ -1795,9 +1819,10 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
                 else {
                     try {
                         await insertRunPromise;
-                        continuationStatusPersistedBeforeEvent = await withWorkerFence(persistTerminalStatus);
+                        continuationStatusPersistedBeforeEvent =
+                            await persistOwnTerminalStatus();
                         if (!continuationStatusPersistedBeforeEvent) {
-                            await withWorkerFence(reconcileTerminalRun);
+                            await reconcileTerminalRun();
                             const persistedRun = await getRunById(runId);
                             continuationStatusPersistedBeforeEvent =
                                 persistedRun?.status === "truncated" &&
@@ -1875,7 +1900,7 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
                         : await withWorkerFence(persistAtomicAbort);
                     terminalPersistenceEstablished = aborted
                         ? true
-                        : await withWorkerFence(reconcileTerminalRun);
+                        : await reconcileTerminalRun();
                 }
                 catch (error) {
                     terminalPersistenceEstablished = false;
@@ -1893,7 +1918,7 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
                     (!terminalPersistenceError || eventPersistenceError)) {
                     let statusUpdated = false;
                     try {
-                        statusUpdated = await withWorkerFence(persistTerminalStatus);
+                        statusUpdated = await persistOwnTerminalStatus();
                     }
                     catch (error) {
                         reportTerminalStatusPersistenceError(error);
@@ -1905,8 +1930,7 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
                         terminalPersistenceEstablished = !terminalPersistenceError;
                     }
                     else {
-                        terminalPersistenceEstablished =
-                            await withWorkerFence(reconcileTerminalRun);
+                        terminalPersistenceEstablished = await reconcileTerminalRun();
                     }
                 }
             }
@@ -1957,7 +1981,7 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
         if (terminalPersistenceError) {
             const reconciled = eventPersistenceError
                 ? false
-                : await withWorkerFence(reconcileTerminalRun);
+                : await reconcileTerminalRun();
             if (!reconciled)
                 throw terminalPersistenceError;
             terminalPersistenceEstablished = true;

package/dist/client/agent-chat/index.d.ts

@@ -19,7 +19,7 @@ export { AGENT_NATIVE_MCP_APP_HOST_MESSAGE_TYPES, getMcpAppHostContext, initiali
 export { buildDynamicAgentSuggestions, dedupeSuggestions, mergeAgentSuggestions, normalizeAgentDynamicSuggestionsConfig, useAgentDynamicSuggestions, useAgentDynamicSuggestionsResult, type AgentDynamicSuggestionContext, type AgentDynamicSuggestionsConfig, type AgentDynamicSuggestionsOption, } from "../dynamic-suggestions.js";
 export { clearChatStorage } from "../chat/storage.js";
 export { isAssistantChatHistoryVersion, coerceAssistantChatHistoryDate, type AssistantChatHistoryDate, type AssistantChatHistoryVersion, } from "../chat/assistant-chat-history-version.js";
-export { ChatThreadListConfigError, useChatThreadList, type UseChatThreadListOptions, type UseChatThreadListResult, } from "../use-chat-thread-list.js";
+export { ChatThreadListConfigError, useChatThreadList, type UseChatThreadListOptions, type UseChatThreadListResult, type ChatThreadListRefreshOutcome, } from "../use-chat-thread-list.js";
 export { ChatThreadListError, fetchChatThreadListPage, notifyChatThreadsUpdated, useChatThreads, type ChatThreadAccessBasis, type ChatThreadListPage, type ChatThreadListRow, type ChatThreadListPageRequest, type ChatThreadOwnership, type ChatThreadVisibility, type ChatThreadScope, type ChatThreadSnapshot, type ChatThreadSummary, type ChatThreadData, type ChatThreadShareLink, type ChatThreadShareState, type UseChatThreadsOptions, } from "../use-chat-threads.js";
 export { type AgentCallProgress, type ContentPart, } from "../sse-event-processor.js";
 export { useRunStuckDetection, useAbortRun, type RunStuckState, type UseRunStuckDetectionOptions, } from "../use-run-stuck-detection.js";

package/dist/client/route-warmup.js

@@ -4,8 +4,28 @@ import { ROUTE_WARMUP_PRELOAD_ATTRIBUTE } from "../shared/route-chunk-recovery-b
 import { mergeAgentNativeRouteWarmupConfig, } from "../shared/route-warmup-config.js";
 import { isServerRoutePath } from "./api-path.js";
 const PREFETCH_ATTR = "data-an-prefetch";
+// WebKit checks once, 3 seconds after the window's load event, for link
+// preloads nothing has used yet, and logs "was preloaded using link preload but
+// not used within a few seconds" for each one. Warmed route modules are for
+// later navigations, so their modulepreload links wait until that check has
+// run. Until then the module files are fetched into the HTTP cache instead:
+// built assets are immutable, so an early click still skips the network, and
+// WebKit only reports link preloads. Data warmup is a plain fetch and starts
+// right away.
+// A third-party script that never finishes can hold the load event back
+// indefinitely. The hold lasts as long, since preloads added before a late load
+// event would still be reported; the HTTP cache and intent preloads cover clicks
+// meanwhile.
+const MODULE_WARMUP_DELAY_AFTER_LOAD_MS = 4_000;
 const warmedDataRoutes = new Set();
 const warmedRouteAssets = new Set();
+const fetchedRouteAssets = new Set();
+// A later scan retries a failed fetch, at most twice and no sooner than 5
+// seconds after the last failure, so page updates during an outage don't set
+// the request rate.
+const ROUTE_ASSET_FETCH_ATTEMPTS = 3;
+const ROUTE_ASSET_RETRY_DELAY_MS = 5_000;
+const failedRouteAssetFetches = new Map();
 let cachedManifest;
 let cachedManifestRoutesSignature = "";
 let cachedManifestRouteTree = [];
@@ -305,6 +325,62 @@ function warmRouteAssetsForHref(href) {
         document.head.appendChild(link);
     }
 }
+function fetchRouteAssetsForHref(href) {
+    for (const assetUrl of routeAssetUrlsForHref(href)) {
+        if (warmedRouteAssets.has(assetUrl) || fetchedRouteAssets.has(assetUrl)) {
+            continue;
+        }
+        const failed = failedRouteAssetFetches.get(assetUrl);
+        if (failed &&
+            (failed.attempts >= ROUTE_ASSET_FETCH_ATTEMPTS ||
+                Date.now() < failed.retryAt)) {
+            continue;
+        }
+        fetchedRouteAssets.add(assetUrl);
+        const onFailure = () => {
+            fetchedRouteAssets.delete(assetUrl);
+            failedRouteAssetFetches.set(assetUrl, {
+                attempts: (failed?.attempts ?? 0) + 1,
+                retryAt: Date.now() + ROUTE_ASSET_RETRY_DELAY_MS,
+            });
+        };
+        window
+            .fetch(assetUrl, { credentials: "same-origin", priority: "low" })
+            .then((response) => {
+            if (response.ok) {
+                failedRouteAssetFetches.delete(assetUrl);
+                return response.arrayBuffer();
+            }
+            onFailure();
+        })
+            .catch(onFailure);
+    }
+}
+function msSinceLoadEventEnd() {
+    const [entry] = performance.getEntriesByType?.("navigation") ?? [];
+    const loadEventEnd = entry
+        ?.loadEventEnd;
+    return loadEventEnd ? Math.max(0, performance.now() - loadEventEnd) : 0;
+}
+function afterUnusedPreloadCheck(callback) {
+    let timer;
+    const startTimer = () => {
+        if (timer !== undefined)
+            window.clearTimeout(timer);
+        timer = window.setTimeout(callback, Math.max(0, MODULE_WARMUP_DELAY_AFTER_LOAD_MS - msSinceLoadEventEnd()));
+    };
+    if (document.readyState === "complete") {
+        startTimer();
+    }
+    else {
+        window.addEventListener("load", startTimer, { once: true });
+    }
+    return () => {
+        window.removeEventListener("load", startTimer);
+        if (timer !== undefined)
+            window.clearTimeout(timer);
+    };
+}
 function linkWarmupMode(link, strategy) {
     const explicit = link.getAttribute(PREFETCH_ATTR)?.trim().toLowerCase();
     if (explicit === "none" || explicit === "off" || explicit === "false") {
@@ -353,6 +429,8 @@ function resetRouteWarmupCachesForTests() {
     cachedManifestRouteTree = [];
     warmedDataRoutes.clear();
     warmedRouteAssets.clear();
+    fetchedRouteAssets.clear();
+    failedRouteAssetFetches.clear();
 }
 export function AgentNativeRouteWarmup({ config, }) {
     useEffect(() => {
@@ -376,6 +454,8 @@ export function AgentNativeRouteWarmup({ config, }) {
         const dataRetryAttempts = new Map();
         const retryTimers = new Set();
         const observedLinks = new WeakSet();
+        const heldModuleHrefs = new Set();
+        let modulesHeld = warmModules;
         let active = 0;
         let stopped = false;
         let scheduleTimer;
@@ -435,9 +515,14 @@ export function AgentNativeRouteWarmup({ config, }) {
                 });
             }
         };
-        function warmHref(href) {
-            if (warmModules)
+        function warmHref(href, fromIntent = false) {
+            if (modulesHeld && !fromIntent) {
+                heldModuleHrefs.add(href);
+                fetchRouteAssetsForHref(href);
+            }
+            else if (warmModules) {
                 warmRouteAssetsForHref(href);
+            }
             if (!warmData)
                 return;
             for (const dataUrl of dataRouteUrlsForHref(href)) {
@@ -512,8 +597,20 @@ export function AgentNativeRouteWarmup({ config, }) {
             const mode = linkWarmupMode(link, resolved.strategy);
             if (mode === "none")
                 return;
-            warmHref(link.href);
+            // Hover, touch and focus usually come just before a click, so they
+            // preload right away even during the hold: the click uses the preload
+            // before WebKit's check, and an early click doesn't wait for the module
+            // to compile.
+            warmHref(link.href, true);
         };
+        const cancelModuleHold = warmModules
+            ? afterUnusedPreloadCheck(() => {
+                modulesHeld = false;
+                for (const href of heldModuleHrefs)
+                    warmRouteAssetsForHref(href);
+                heldModuleHrefs.clear();
+            })
+            : undefined;
         schedule();
         const observer = new MutationObserver(schedule);
         observer.observe(document.documentElement, {
@@ -533,6 +630,7 @@ export function AgentNativeRouteWarmup({ config, }) {
         document.addEventListener("focusin", warmFromIntent, true);
         return () => {
             stopped = true;
+            cancelModuleHold?.();
             if (scheduleTimer !== undefined)
                 window.clearTimeout(scheduleTimer);
             for (const timer of retryTimers)

package/dist/client/use-chat-thread-list.d.ts

@@ -16,6 +16,7 @@ export interface UseChatThreadListOptions {
     refreshOnThreadUpdates?: boolean;
     apiUrl?: string;
 }
+export type ChatThreadListRefreshOutcome = "success" | "error" | "superseded" | "disabled";
 export interface UseChatThreadListResult {
     threads: ChatThreadListRow[];
     /** True until the first page of the current list settles. */
@@ -27,6 +28,8 @@ export interface UseChatThreadListResult {
     hasMore: boolean;
     loadMore: () => Promise<void>;
     refresh: () => Promise<void>;
+    /** Reports whether this invocation applied the complete refreshed window. */
+    refreshWithResult: () => Promise<ChatThreadListRefreshOutcome>;
 }
 /** `pageSize` is not an integer between 1 and the server's page cap. */
 export declare class ChatThreadListConfigError extends Error {

package/dist/client/use-chat-thread-list.js

@@ -116,7 +116,7 @@ export function useChatThreadList(options) {
     // rows and offset already on screen untouched.
     const replace = useCallback(async (window) => {
         if (!session.active)
-            return;
+            return "superseded";
         const requestId = ++session.requestId;
         const isCurrent = () => session.active && requestId === session.requestId;
         session.inFlight = "replace";
@@ -131,7 +131,7 @@ export function useChatThreadList(options) {
                     limit: Math.min(CHAT_THREADS_MAX_PAGE_SIZE, window - consumed),
                 });
                 if (!isCurrent())
-                    return;
+                    return "superseded";
                 for (const thread of page.threads) {
                     if (!rows.has(thread.id))
                         rows.set(thread.id, thread);
@@ -142,11 +142,13 @@ export function useChatThreadList(options) {
             session.nextOffset = consumed;
             session.hasMore = more;
             update({ threads: [...rows.values()], hasMore: more, error: null });
+            return "success";
         }
         catch (failure) {
             if (!isCurrent())
-                return;
+                return "superseded";
             update({ error: asError(failure) });
+            return "error";
         }
         finally {
             if (isCurrent()) {
@@ -155,13 +157,18 @@ export function useChatThreadList(options) {
             }
         }
     }, [request, session, update]);
-    const refresh = useCallback(async () => {
+    const refreshWithResult = useCallback(async () => {
+        if (!session.active)
+            return "superseded";
         if (!enabled)
-            return;
+            return "disabled";
         // Reload every row already on screen so a mutation does not collapse a
         // list the person has paged through.
-        await replace(Math.max(pageSize, session.nextOffset));
+        return replace(Math.max(pageSize, session.nextOffset));
     }, [enabled, pageSize, replace, session]);
+    const refresh = useCallback(async () => {
+        await refreshWithResult();
+    }, [refreshWithResult]);
     const loadMore = useCallback(async () => {
         if (!session.active || session.inFlight || !session.hasMore)
             return;
@@ -216,5 +223,14 @@ export function useChatThreadList(options) {
         return () => window.removeEventListener(CHAT_THREADS_UPDATED_EVENT, onUpdated);
     }, [enabled, refresh, refreshOnThreadUpdates]);
     const { threads, loading, loadingMore, error, hasMore } = state;
-    return { threads, loading, loadingMore, error, hasMore, loadMore, refresh };
+    return {
+        threads,
+        loading,
+        loadingMore,
+        error,
+        hasMore,
+        loadMore,
+        refresh,
+        refreshWithResult,
+    };
 }

package/dist/collab/struct-routes.d.ts

@@ -1,6 +1,6 @@
 export declare const postCollabJson: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    error: string;
     ok?: undefined;
+    error: string;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/file-upload/actions/upload-image.d.ts

@@ -42,8 +42,8 @@ declare const _default: import("../../action.js").ActionDefinition<{
     url: string;
     id: string;
     provider: string;
-    configured?: undefined;
     error?: undefined;
+    configured?: undefined;
 } | {
     url?: undefined;
     id?: undefined;

package/dist/notifications/routes.d.ts

@@ -1,13 +1,13 @@
 export declare function createNotificationsHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<"" | import("./types.js").Notification[] | {
     count: number;
     updated?: undefined;
-    ok?: undefined;
     error?: undefined;
+    ok?: undefined;
 } | {
     count?: undefined;
     updated: number;
-    ok?: undefined;
     error?: undefined;
+    ok?: undefined;
 } | {
     count?: undefined;
     updated?: undefined;
@@ -16,6 +16,6 @@ export declare function createNotificationsHandler(): import("h3").EventHandlerW
 } | {
     count?: undefined;
     updated?: undefined;
-    ok: boolean;
     error?: undefined;
+    ok: boolean;
 }>>;

package/dist/observability/routes.d.ts

@@ -33,27 +33,27 @@ export declare function createObservabilityHandler(): import("h3").EventHandlerW
     summary?: undefined;
     spans?: undefined;
 } | {
+    error?: undefined;
     ok?: undefined;
     message?: undefined;
     summary: import("./types.js").TraceSummary;
     spans: import("./types.js").TraceSpan[];
-    error?: undefined;
 } | {
+    error?: undefined;
     ok?: undefined;
     message?: undefined;
     summary?: undefined;
     spans?: undefined;
     traceMissing: true;
     id: string;
-    error?: undefined;
 } | {
+    error?: undefined;
     ok?: undefined;
     message?: undefined;
     summary?: undefined;
     spans?: undefined;
     traceMissing?: undefined;
     id: string;
-    error?: undefined;
 } | {
     ok?: undefined;
     message?: undefined;
@@ -61,9 +61,9 @@ export declare function createObservabilityHandler(): import("h3").EventHandlerW
     spans?: undefined;
     error: any;
 } | {
+    error?: undefined;
     message?: undefined;
     summary?: undefined;
     spans?: undefined;
     ok: boolean;
-    error?: undefined;
 }>>;

package/dist/progress/routes.d.ts

@@ -2,6 +2,6 @@ export declare function createProgressHandler(): import("h3").EventHandlerWithFe
     error: string;
     ok?: undefined;
 } | {
-    ok: boolean;
     error?: undefined;
+    ok: boolean;
 }>>;

package/dist/server/agent-engine-default-model-route.d.ts

@@ -8,8 +8,8 @@ export declare const AGENT_ENGINE_API_KEY_ACTION_NAME = "agent-engine-api-key";
  * resolveEngine's credential detection.
  */
 export declare function createAgentEngineDisconnectHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    error: string;
     ok?: undefined;
+    error: string;
     scope?: undefined;
 } | {
     ok: boolean;

package/dist/server/agent-engine-ollama-models-route.d.ts

@@ -1,9 +1,9 @@
 export declare function createAgentEngineOllamaModelsHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
     error: string;
-    models?: undefined;
     ok?: undefined;
+    models?: undefined;
 } | {
+    error?: undefined;
     ok: boolean;
     models: string[];
-    error?: undefined;
 }>>;

package/dist/server/core-routes-plugin.d.ts

@@ -588,8 +588,8 @@ export declare function createPublicRemoteAgentsHandler(discover?: PublicAgentDi
     error: string;
     agents?: undefined;
 } | {
-    agents: Omit<import("./agent-discovery.js").DiscoveredAgent, "auth" | "kind">[];
     error?: undefined;
+    agents: Omit<import("./agent-discovery.js").DiscoveredAgent, "auth" | "kind">[];
 }>>;
 export declare function getBuilderConnectErrorDisposition(error: unknown, connectAttemptId: string | null): "correlated" | "legacy" | null;
 export declare function getBuilderConnectErrorKey(ownerEmail: string, connectAttemptId?: string | null): string;

package/dist/templates/builder-code-starter/template-layer.json

@@ -9,6 +9,7 @@
     "app/components/layout/AgentInspector.test.tsx",
     "app/components/layout/AgentInspector.tsx",
     "app/components/layout/Header.tsx",
+    "app/components/layout/Sidebar.spec.tsx",
     "app/components/layout/Sidebar.tsx",
     "app/i18n",
     "app/i18n-data.ts",