@agent-native/core 0.164.12 → 0.164.17

package/corpus/templates/factory/server/triage/slack-client.ts

@@ -2,13 +2,18 @@ import { resolveConnectorSecret } from "../connectors/credentials.js";
 import {
   getChannelHistory as readChannelHistory,
   addEyesReaction as writeEyesReaction,
+  authTest as readAuthTest,
+  getEyesReaction as readEyesReaction,
   getThread as readThread,
   getTeamInfo as readTeamInfo,
   getUserInfo as readUserInfo,
   postThreadReply as writeThreadReply,
   type ChannelHistoryResult,
+  type SlackAuthTestResult,
+  type SlackMessage,
   type SlackPostMessageResult,
   type SlackReactionResult,
+  type SlackReactionState,
   type SlackTeamInfo,
   type SlackUserInfo,
   type SlackTokenResolver,
@@ -40,14 +45,38 @@ function createTokenResolver({
 
 export function createSlackReader(identity: SlackReaderIdentity) {
   const tokenResolver = createTokenResolver(identity);
+  const identities = new Map<Workspace, SlackAuthTestResult>();
+
+  async function getAgentNativeIdentity(
+    workspace: Workspace,
+  ): Promise<SlackAuthTestResult> {
+    const existing = identities.get(workspace);
+    if (existing) return existing;
+    const auth = await readAuthTest(workspace, tokenResolver);
+    const userName = auth.userName.trim().replace(/^@/, "").toLowerCase();
+    if (userName !== "agent-native") {
+      throw new Error(
+        `Slack credential authenticated as @${auth.userName}, not @agent-native.`,
+      );
+    }
+    identities.set(workspace, auth);
+    return auth;
+  }
+
+  async function verifyAgentNativeIdentity(
+    workspace: Workspace,
+  ): Promise<void> {
+    await getAgentNativeIdentity(workspace);
+  }
 
   return {
-    getChannelHistory(
+    async getChannelHistory(
       workspace: Workspace,
       channelId: string,
       limit?: number,
       cursor?: string,
     ): Promise<ChannelHistoryResult> {
+      await verifyAgentNativeIdentity(workspace);
       return readChannelHistory(
         workspace,
         channelId,
@@ -56,19 +85,25 @@ export function createSlackReader(identity: SlackReaderIdentity) {
         tokenResolver,
       );
     },
-    getTeamInfo(workspace: Workspace): Promise<SlackTeamInfo> {
+    async getTeamInfo(workspace: Workspace): Promise<SlackTeamInfo> {
+      await verifyAgentNativeIdentity(workspace);
       return readTeamInfo(workspace, tokenResolver);
     },
-    getUserInfo(workspace: Workspace, userId: string): Promise<SlackUserInfo> {
+    async getUserInfo(
+      workspace: Workspace,
+      userId: string,
+    ): Promise<SlackUserInfo> {
+      await verifyAgentNativeIdentity(workspace);
       return readUserInfo(workspace, userId, tokenResolver);
     },
-    getThread(
+    async getThread(
       workspace: Workspace,
       channelId: string,
       threadTs: string,
       limit?: number,
       cursor?: string,
     ): Promise<ThreadRepliesResult> {
+      await verifyAgentNativeIdentity(workspace);
       return readThread(
         workspace,
         channelId,
@@ -78,19 +113,21 @@ export function createSlackReader(identity: SlackReaderIdentity) {
         tokenResolver,
       );
     },
-    addEyesReaction(
+    async addEyesReaction(
       workspace: Workspace,
       channelId: string,
       timestamp: string,
     ): Promise<SlackReactionResult> {
+      await verifyAgentNativeIdentity(workspace);
       return writeEyesReaction(workspace, channelId, timestamp, tokenResolver);
     },
-    postThreadReply(
+    async postThreadReply(
       workspace: Workspace,
       channelId: string,
       threadTs: string,
       text: string,
     ): Promise<SlackPostMessageResult> {
+      await verifyAgentNativeIdentity(workspace);
       return writeThreadReply(
         workspace,
         channelId,
@@ -99,5 +136,41 @@ export function createSlackReader(identity: SlackReaderIdentity) {
         tokenResolver,
       );
     },
+    async getEyesReaction(
+      workspace: Workspace,
+      channelId: string,
+      timestamp: string,
+    ): Promise<SlackReactionState> {
+      await verifyAgentNativeIdentity(workspace);
+      return readEyesReaction(workspace, channelId, timestamp, tokenResolver);
+    },
+    async getCompleteThread(
+      workspace: Workspace,
+      channelId: string,
+      threadTs: string,
+    ): Promise<{ messages: SlackMessage[]; hasMore: boolean }> {
+      const messages: SlackMessage[] = [];
+      let cursor: string | undefined;
+      for (let page = 0; page < 100; page += 1) {
+        const result = await this.getThread(
+          workspace,
+          channelId,
+          threadTs,
+          100,
+          cursor,
+        );
+        messages.push(...result.messages);
+        if (!result.has_more) return { messages, hasMore: false };
+        if (!result.next_cursor) {
+          throw new Error(
+            "Slack thread pagination is incomplete because the provider omitted its next cursor.",
+          );
+        }
+        cursor = result.next_cursor;
+      }
+      return { messages, hasMore: true };
+    },
+    verifyAgentNativeIdentity,
+    getAgentNativeIdentity,
   };
 }

package/dist/app-config/auth.d.ts

@@ -0,0 +1,4 @@
+import { z } from "zod";
+export declare const authConfig: z.ZodObject<{
+    disableDesktopSsoFallbackInDevelopment: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;

package/dist/app-config/auth.js

@@ -0,0 +1,7 @@
+import { z } from "zod";
+export const authConfig = z.object({
+    disableDesktopSsoFallbackInDevelopment: z.boolean().default(false).meta({
+        env: "AGENT_NATIVE_DISABLE_DESKTOP_SSO_FALLBACK",
+        doc: "Disable the loopback Desktop SSO fallback in development so isolated acceptance runs can use their configured local identity. Ignored in production.",
+    }),
+});

package/dist/app-config/schema.d.ts

@@ -32,6 +32,9 @@ export declare const appConfigSchema: z.ZodObject<{
         packageName: z.ZodOptional<z.ZodString>;
         template: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
+    auth: z.ZodPrefault<z.ZodObject<{
+        disableDesktopSsoFallbackInDevelopment: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
     integrations: z.ZodPrefault<z.ZodObject<{
         allowUnverifiedWebhooks: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$strip>>;

package/dist/app-config/schema.js

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { a2aConfig } from "./a2a.js";
 import { agentConfig } from "./agent.js";
 import { appConfig } from "./app.js";
+import { authConfig } from "./auth.js";
 import { integrationsConfig } from "./integrations.js";
 import { privateBlobConfig } from "./private-blob.js";
 import { workspaceConfig } from "./workspace.js";
@@ -25,6 +26,7 @@ export const appConfigSchema = z.object({
     a2a: a2aConfig.prefault({}),
     agent: agentConfig.prefault({}),
     app: appConfig.prefault({}),
+    auth: authConfig.prefault({}),
     integrations: integrationsConfig.prefault({}),
     privateBlob: privateBlobConfig.prefault({}),
     workspace: workspaceConfig.prefault({}),

package/dist/cli/code-agent-executor.js

@@ -1226,8 +1226,13 @@ async function executeCodexCliRun(options) {
     const streamToolOutputToStdout = options.streamToolOutputToStdout ??
         process.env.AGENT_NATIVE_CODE_AGENT_STRUCTURED_STDOUT !== "1";
     const additionalSkillsRoot = process.env.AGENT_NATIVE_CODE_AGENT_SKILLS_ROOT?.trim();
+    // Desktop has already resolved and capability-scoped its MCP catalog before
+    // spawning the packaged runner. Reading persisted settings again here would
+    // both widen that boundary and require the app's native database binding in
+    // the standalone runner process.
+    const mcpConfig = process.env.MCP_SERVERS === undefined ? await buildMergedConfig() : null;
     const args = [
-        ...codexMcpConfigArgs(),
+        ...codexMcpConfigArgs(mcpConfig),
         "--ask-for-approval",
         "never",
         "--sandbox",

package/dist/cli/code-agent-mcp-config.d.ts

@@ -1,4 +1,4 @@
-import type { McpConfig } from "../mcp-client/config.js";
+import { type McpConfig } from "../mcp-client/config.js";
 /**
  * Keep a desktop coding run on the app registry's MCP servers. The normal
  * server-side manager merges persisted MCP settings for web requests, but a
@@ -18,4 +18,4 @@ export declare function mergeCodeAgentMcpConfig(config: McpConfig | null, enviro
  * coding session receives the workspace apps, not the user's global MCP
  * catalog.
  */
-export declare function codexMcpConfigArgs(environment?: NodeJS.ProcessEnv): string[];
+export declare function codexMcpConfigArgs(config?: McpConfig | null, environment?: NodeJS.ProcessEnv): string[];

package/dist/cli/code-agent-mcp-config.js

@@ -1,3 +1,4 @@
+import { resolveDesktopChildComputerMcpServer, } from "../mcp-client/config.js";
 const DESKTOP_MCP_ALLOWLIST_ENV = "AGENT_NATIVE_CODE_AGENT_MCP_SERVER_ALLOWLIST";
 function parseServerAllowlist(raw) {
     if (raw === undefined)
@@ -17,6 +18,9 @@ export function restrictCodeAgentMcpConfig(config, environment = process.env) {
     const allowlist = parseServerAllowlist(environment[DESKTOP_MCP_ALLOWLIST_ENV]);
     if (!allowlist || !config)
         return config;
+    const desktopServer = findDesktopChildComputerMcpServer(config, environment);
+    if (desktopServer)
+        allowlist.add(desktopServer.id);
     const servers = Object.fromEntries(Object.entries(config.servers).filter(([id]) => allowlist.has(id)));
     return { ...config, servers };
 }
@@ -59,6 +63,18 @@ function parseMcpServers(environment) {
         return [id, value];
     }));
 }
+function desktopChildComputerServerConfig(environment) {
+    return resolveDesktopChildComputerMcpServer({}, environment)?.config ?? null;
+}
+function findDesktopChildComputerMcpServer(config, environment) {
+    const expected = desktopChildComputerServerConfig(environment);
+    if (!expected || expected.type !== "http")
+        return null;
+    const match = Object.entries(config.servers).find(([, server]) => server.type === "http" &&
+        server.url === expected.url &&
+        server.headers?.Authorization === expected.headers?.Authorization);
+    return match ? { id: match[0], config: match[1] } : null;
+}
 /**
  * Add host-provided app/plugin servers to the normal merged config. The
  * filesystem and environment layers have different precedence rules, so the
@@ -66,14 +82,23 @@ function parseMcpServers(environment) {
  */
 export function mergeCodeAgentMcpConfig(config, environment = process.env) {
     const environmentServers = parseMcpServers(environment);
-    if (Object.keys(environmentServers).length === 0)
+    const servers = {
+        ...(config?.servers ?? {}),
+        ...environmentServers,
+    };
+    const existingDesktopServer = config
+        ? findDesktopChildComputerMcpServer(config, environment)
+        : null;
+    const desktopServer = existingDesktopServer
+        ? null
+        : resolveDesktopChildComputerMcpServer(servers, environment);
+    if (desktopServer)
+        servers[desktopServer.id] = desktopServer.config;
+    if (Object.keys(servers).length === 0)
         return config;
     return {
         ...(config ?? { servers: {} }),
-        servers: {
-            ...(config?.servers ?? {}),
-            ...environmentServers,
-        },
+        servers,
         source: config?.source
             ? `${config.source}+desktop-environment`
             : "env:MCP_SERVERS",
@@ -85,8 +110,8 @@ export function mergeCodeAgentMcpConfig(config, environment = process.env) {
  * coding session receives the workspace apps, not the user's global MCP
  * catalog.
  */
-export function codexMcpConfigArgs(environment = process.env) {
-    const servers = parseMcpServers(environment);
+export function codexMcpConfigArgs(config = null, environment = process.env) {
+    const servers = restrictCodeAgentMcpConfig(mergeCodeAgentMcpConfig(config, environment), environment)?.servers ?? {};
     if (Object.keys(servers).length === 0)
         return [];
     const args = [];
@@ -94,9 +119,9 @@ export function codexMcpConfigArgs(environment = process.env) {
         if (server.type !== "http" || !server.url)
             continue;
         const key = codexConfigKey(serverId);
-        args.push("-c", `mcp_servers.${tomlString(key)}.url=${tomlString(server.url)}`);
+        args.push("-c", `mcp_servers.${key}.url=${tomlString(server.url)}`);
         if (server.headers && Object.keys(server.headers).length > 0) {
-            args.push("-c", `mcp_servers.${tomlString(key)}.http_headers=${tomlInlineTable(server.headers)}`);
+            args.push("-c", `mcp_servers.${key}.http_headers=${tomlInlineTable(server.headers)}`);
         }
     }
     return args;

package/dist/client/MultiTabAssistantChat.js

@@ -515,7 +515,7 @@ export function MultiTabAssistantChat({ showTabBar = true, renderHeader, renderO
         threadUrlParamName,
         threadUrlSyncEnabled,
     ]);
-    const { threads, activeThreadId, isLoading, createThread, switchThread: switchThreadState, forkThread, saveThreadData, generateTitle, searchThreads, loadMoreThreads, refreshThreads, hasMoreThreads, isLoadingMoreThreads, threadsLoadError, isNewThread, pinThread, renameThread, } = useChatThreads(apiUrl, storageKey, scope, {
+    const { threads, activeThreadId, isLoading, createThread, switchThread: switchThreadState, forkThread, saveThreadData, generateTitle, searchThreads, loadMoreThreads, refreshThreads, hasMoreThreads, isLoadingMoreThreads, threadsLoadError, restoredThreadIdOnListFailure, isNewThread, pinThread, renameThread, } = useChatThreads(apiUrl, storageKey, scope, {
         restoreActiveThread,
         routeThreadId: threadUrlSyncEnabled
             ? urlThreadId
@@ -1017,7 +1017,34 @@ export function MultiTabAssistantChat({ showTabBar = true, renderHeader, renderO
     // optimistic id for a brand-new session); the activeThreadId effect above
     // adds it to openTabIds without spinning up a duplicate thread.
     const autoCreatingRef = useRef(false);
+    const restoreFailureReplacementInFlightRef = useRef(null);
     const lastTabReplacementInFlightRef = useRef(false);
+    useEffect(() => {
+        if (isLoading ||
+            !restoredThreadIdOnListFailure ||
+            activeThreadId !== restoredThreadIdOnListFailure ||
+            restoreFailureReplacementInFlightRef.current ===
+                restoredThreadIdOnListFailure) {
+            return;
+        }
+        restoreFailureReplacementInFlightRef.current =
+            restoredThreadIdOnListFailure;
+        void createThread().then((id) => {
+            if (!id) {
+                restoreFailureReplacementInFlightRef.current = null;
+                return;
+            }
+            newThreadIds.current.add(id);
+            setOpenTabIds([id]);
+            writeThreadUrl(null, { replace: true });
+        });
+    }, [
+        activeThreadId,
+        createThread,
+        isLoading,
+        restoredThreadIdOnListFailure,
+        writeThreadUrl,
+    ]);
     useEffect(() => {
         if (isLoading || autoCreatingRef.current)
             return;

package/dist/client/org/OrgSwitcher.js

@@ -7,6 +7,7 @@ import { setBrowserDemoModeEnabled } from "../../demo/browser-state.js";
 import { shouldOfferWorkspace } from "../../org/workspace-url.js";
 import { agentNativePath } from "../api-path.js";
 import { useT } from "../i18n.js";
+import { buildSignInReturnHref } from "../require-session.js";
 import { useDemoModeStatus } from "../use-demo-mode-status.js";
 import { notifySessionInvalidated, useSession } from "../use-session.js";
 import { useOrg, useSwitchOrg, useCreateOrg, useInviteMember, useAcceptInvitation, useJoinByDomain, } from "./hooks.js";
@@ -142,16 +143,19 @@ export function OrgSwitcher({ className, hideWhenSingle, reserveSpace, compact,
             return;
         setSigningOut(true);
         try {
-            await fetch(agentNativePath("/_agent-native/auth/logout"), {
+            const response = await fetch(agentNativePath("/_agent-native/auth/logout"), {
                 method: "POST",
                 credentials: "include",
             });
+            if (!response.ok) {
+                console.warn("Logout request returned an error before sign-in", response.status);
+            }
         }
-        catch {
-            /* fall through to reload — server may already have cleared the cookie */
+        catch (error) {
+            console.warn("Unable to complete logout request before sign-in", error);
         }
         notifySessionInvalidated();
-        window.location.reload();
+        window.location.replace(buildSignInReturnHref());
     };
     if (!org) {
         return reserveSpace && isLoading ? (_jsx(OrgSwitcherLoadingPlaceholder, { className: className })) : null;

package/dist/client/use-chat-threads.d.ts

@@ -96,6 +96,7 @@ export declare function useChatThreads(apiUrl?: string, storageKey?: string, sco
     hasMoreThreads: boolean;
     isLoadingMoreThreads: boolean;
     threadsLoadError: string | null;
+    restoredThreadIdOnListFailure: string | null;
     isNewThread: (id: string) => boolean;
 };
 export {};

package/dist/client/use-chat-threads.js

@@ -157,6 +157,7 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
     const [hasMoreThreads, setHasMoreThreads] = useState(false);
     const [isLoadingMoreThreads, setIsLoadingMoreThreads] = useState(false);
     const [threadsLoadError, setThreadsLoadError] = useState(null);
+    const [restoredThreadIdOnListFailure, setRestoredThreadIdOnListFailure] = useState(null);
     const nextThreadsOffsetRef = useRef(0);
     const latestFetchRequestRef = useRef(0);
     const threadsRef = useRef(threads);
@@ -483,12 +484,20 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
             const loadedThreads = await fetchThreads();
             const restoredId = activeThreadIdRef.current;
             if (loadedThreads === undefined) {
-                // Thread-list fetch failed. Do not reclassify a saved id as a new
-                // optimistic tab; AssistantChat should still get a chance to restore
-                // the specific saved thread via /threads/:id.
+                // Keep the saved id intact for retry/history, but tell the owning
+                // surface to replace the visible tab. A failed list request cannot
+                // prove that the saved thread is gone; it only proves that this mount
+                // cannot safely restore it.
+                if (restoredId &&
+                    autoCreate &&
+                    !routeControlsActiveThread &&
+                    !newlyCreatedRef.current.has(restoredId)) {
+                    setRestoredThreadIdOnListFailure(restoredId);
+                }
                 setIsLoading(false);
                 return;
             }
+            setRestoredThreadIdOnListFailure(null);
             // Exempts route-owned threads (the URL names what the user asked for) and
             // ids this client generated, which have never reached the server.
             const lookupRestored = Boolean(restoredId &&
@@ -1074,6 +1083,7 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
         hasMoreThreads,
         isLoadingMoreThreads,
         threadsLoadError,
+        restoredThreadIdOnListFailure,
         isNewThread,
     };
 }

package/dist/collab/awareness.d.ts

@@ -62,11 +62,11 @@ export declare const postAwareness: import("h3").EventHandlerWithFetch<import("h
     error: string;
     states?: undefined;
 } | {
-    error?: undefined;
     states: {
         clientId: number;
         state: string;
     }[];
+    error?: undefined;
 }>>;
 /**
  * GET /_agent-native/collab/:docId/users
@@ -77,9 +77,9 @@ export declare const getActiveUsers: import("h3").EventHandlerWithFetch<import("
     error: string;
     users?: undefined;
 } | {
-    error?: undefined;
     users: {
         clientId: number;
         lastSeen: number;
     }[];
+    error?: undefined;
 }>>;

package/dist/collab/routes.d.ts

@@ -26,8 +26,8 @@ export declare const getCollabState: import("h3").EventHandlerWithFetch<import("
  * Body: { update: string (base64), requestSource?: string }
  */
 export declare const postCollabUpdate: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    error: string;
     ok?: undefined;
+    error: string;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/mcp-client/config.d.ts

@@ -60,12 +60,23 @@ export interface McpConfig {
     /** Where the config was loaded from (workspace root path, app path, or "env") */
     source?: string;
 }
+export interface DesktopChildComputerMcpServer {
+    id: string;
+    config: McpHttpServerConfig;
+}
 /**
  * Load MCP configuration.
  *
  * @param startDir - Directory to start the upward search from (defaults to cwd)
  */
 export declare function loadMcpConfig(startDir?: string): McpConfig | null;
+/**
+ * The desktop process supplies this configuration only to a child it spawned
+ * for a specific Agent run. Raw MCP config cannot opt into this trust path:
+ * the explicit child gate, loopback URL, and strong per-run bearer are all
+ * required. Existing user servers always win on key collisions.
+ */
+export declare function resolveDesktopChildComputerMcpServer(existingServers: Record<string, McpServerConfig>, environment?: NodeJS.ProcessEnv): DesktopChildComputerMcpServer | null;
 /**
  * Auto-detect the claude-in-chrome MCP server if it's installed but no
  * config file exists. Gated by `AGENT_NATIVE_DISABLE_MCP_AUTODETECT`.

package/dist/mcp-client/config.js

@@ -96,39 +96,46 @@ export function loadMcpConfig(startDir) {
  * the explicit child gate, loopback URL, and strong per-run bearer are all
  * required. Existing user servers always win on key collisions.
  */
-function mergeDesktopChildComputerConfig(base) {
-    if (process.env.AGENT_NATIVE_DESKTOP_CHILD !== "1")
-        return base;
-    const url = process.env.AGENT_NATIVE_DESKTOP_COMPUTER_MCP_URL?.trim();
-    const token = process.env.AGENT_NATIVE_DESKTOP_COMPUTER_MCP_TOKEN?.trim();
+export function resolveDesktopChildComputerMcpServer(existingServers, environment = process.env) {
+    if (environment.AGENT_NATIVE_DESKTOP_CHILD !== "1")
+        return null;
+    const url = environment.AGENT_NATIVE_DESKTOP_COMPUTER_MCP_URL?.trim();
+    const token = environment.AGENT_NATIVE_DESKTOP_COMPUTER_MCP_TOKEN?.trim();
     if (!url || !token || !/^[A-Za-z0-9_-]{32,}$/.test(token))
-        return base;
-    try {
-        const parsed = new URL(url);
-        if (parsed.protocol !== "http:" ||
-            parsed.hostname !== "127.0.0.1" ||
-            parsed.pathname !== "/mcp" ||
-            parsed.username ||
-            parsed.password) {
-            return base;
-        }
-    }
-    catch {
-        return base;
+        return null;
+    if (!URL.canParse(url))
+        return null;
+    const parsed = new URL(url);
+    if (parsed.protocol !== "http:" ||
+        parsed.hostname !== "127.0.0.1" ||
+        parsed.pathname !== "/mcp" ||
+        parsed.username ||
+        parsed.password) {
+        return null;
     }
-    const servers = { ...(base?.servers ?? {}) };
     let serverId = DESKTOP_COMPUTER_SERVER_ID;
-    for (let suffix = 2; servers[serverId]; suffix += 1) {
+    for (let suffix = 2; existingServers[serverId]; suffix += 1) {
         serverId = `${DESKTOP_COMPUTER_SERVER_ID}-${suffix}`;
     }
-    servers[serverId] = {
-        type: "http",
-        url,
-        headers: { Authorization: `Bearer ${token}` },
-        description: "Authenticated computer control for this Agent Native desktop task",
+    return {
+        id: serverId,
+        config: {
+            type: "http",
+            url,
+            headers: { Authorization: `Bearer ${token}` },
+            description: "Authenticated computer control for this Agent Native desktop task",
+        },
     };
+}
+function mergeDesktopChildComputerConfig(base) {
+    const desktopServer = resolveDesktopChildComputerMcpServer(base?.servers ?? {});
+    if (!desktopServer)
+        return base;
     return {
-        servers,
+        servers: {
+            ...(base?.servers ?? {}),
+            [desktopServer.id]: desktopServer.config,
+        },
         source: base?.source ? `${base.source}+desktop-child` : "desktop-child",
     };
 }

package/dist/notifications/routes.d.ts

@@ -11,14 +11,14 @@
  *   DELETE /_agent-native/notifications/:id         — delete
  */
 export declare function createNotificationsHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<"" | import("./types.js").Notification[] | {
-    error?: undefined;
     count: number;
     updated?: undefined;
+    error?: undefined;
     ok?: undefined;
 } | {
-    error?: undefined;
     count?: undefined;
     updated: number;
+    error?: undefined;
     ok?: undefined;
 } | {
     count?: undefined;
@@ -26,8 +26,8 @@ export declare function createNotificationsHandler(): import("h3").EventHandlerW
     error: string;
     ok?: undefined;
 } | {
-    error?: undefined;
     count?: undefined;
     updated?: undefined;
+    error?: undefined;
     ok: boolean;
 }>>;

package/dist/observability/routes.d.ts

@@ -41,27 +41,27 @@ export declare function createObservabilityHandler(): import("h3").EventHandlerW
     thumbsUpRate: number;
     avgEvalScore: number;
 } | {
-    error?: undefined;
-    ok?: undefined;
     summary: import("./types.js").TraceSummary;
     spans: import("./types.js").TraceSpan[];
     id?: undefined;
-} | {
     error?: undefined;
     ok?: undefined;
+} | {
     summary?: undefined;
     spans?: undefined;
     id: string;
-} | {
+    error?: undefined;
     ok?: undefined;
+} | {
     summary?: undefined;
     spans?: undefined;
     id?: undefined;
     error: any;
+    ok?: undefined;
 } | {
-    error?: undefined;
     summary?: undefined;
     spans?: undefined;
     id?: undefined;
+    error?: undefined;
     ok: boolean;
 }>>;

package/dist/progress/routes.d.ts

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

package/dist/resources/handlers.d.ts

@@ -51,8 +51,8 @@ export declare function handleDeleteResource(event: any): Promise<{
     error: string;
     ok?: undefined;
 } | {
-    ok: boolean;
     error?: undefined;
+    ok: boolean;
 }>;
 /** POST /_agent-native/resources/upload — upload a file as a resource */
 export declare function handleUploadResource(event: any): Promise<import("./store.js").Resource | {
@@ -73,10 +73,10 @@ export declare function handleUploadResource(event: any): Promise<import("./stor
     runId: string | null;
     expiresAt: number | null;
     metadata: string | null;
+    error?: undefined;
     url: string;
     provider: string;
     storageSetupRequired?: undefined;
-    error?: undefined;
 } | {
     error: string;
     storageSetupRequired: boolean;