@agent-native/core 0.126.0 → 0.127.3

package/corpus/core/src/client/settings/SecretsSection.tsx

@@ -9,6 +9,15 @@ import {
   Button as ToolkitButton,
   ButtonBase as ToolkitButtonBase,
 } from "@agent-native/toolkit/ui/button";
+import {
+  Command,
+  CommandEmpty,
+  CommandGroup,
+  CommandInput,
+  CommandItem,
+  CommandList,
+  CommandSeparator,
+} from "@agent-native/toolkit/ui/command";
 import {
   IconCheck,
   IconChevronRight,
@@ -23,13 +32,10 @@ import React, { useEffect, useMemo, useState, useCallback } from "react";
 
 import { agentNativePath } from "../api-path.js";
 import {
-  DropdownMenu,
-  DropdownMenuContent,
-  DropdownMenuItem,
-  DropdownMenuLabel,
-  DropdownMenuSeparator,
-  DropdownMenuTrigger,
-} from "../components/ui/dropdown-menu.js";
+  Popover,
+  PopoverContent,
+  PopoverTrigger,
+} from "../components/ui/popover.js";
 import {
   Tooltip,
   TooltipContent,
@@ -207,11 +213,13 @@ function KeysHeader({
   onSecret?: (key: string) => void;
   onCustomKey: () => void;
 }) {
+  const [open, setOpen] = useState(false);
+
   return (
     <div className="flex items-center justify-between gap-3">
       <p className="text-[11px] font-medium text-foreground">Keys</p>
-      <DropdownMenu>
-        <DropdownMenuTrigger asChild>
+      <Popover open={open} onOpenChange={setOpen}>
+        <PopoverTrigger asChild>
           <ToolkitButtonBase
             type="button"
             variant="outline"
@@ -220,34 +228,61 @@ function KeysHeader({
             <IconPlus size={11} />
             New
           </ToolkitButtonBase>
-        </DropdownMenuTrigger>
-        <DropdownMenuContent align="end" className="w-60">
-          {availableSecrets.length > 0 && (
-            <>
-              <DropdownMenuLabel>Choose a key</DropdownMenuLabel>
-              {availableSecrets.map((secret) => (
-                <DropdownMenuItem
-                  key={secret.key}
-                  onSelect={() => onSecret?.(secret.key)}
-                  className="flex items-center justify-between gap-3"
+        </PopoverTrigger>
+        <PopoverContent align="end" className="w-60 p-0">
+          <Command
+            // cmdk's default scorer matches loose subsequences, so "logo"
+            // also surfaces every "G-o-o-g-l-e ... " key.
+            filter={(value, search) =>
+              value.toLowerCase().includes(search.toLowerCase()) ? 1 : 0
+            }
+          >
+            {availableSecrets.length > 0 && (
+              <CommandInput placeholder="Search keys..." />
+            )}
+            <CommandList>
+              <CommandEmpty>No keys found.</CommandEmpty>
+              {availableSecrets.length > 0 && (
+                <>
+                  <CommandGroup heading="Choose a key">
+                    {availableSecrets.map((secret) => (
+                      <CommandItem
+                        key={secret.key}
+                        value={`${secret.label} ${secret.key}`}
+                        onSelect={() => {
+                          setOpen(false);
+                          onSecret?.(secret.key);
+                        }}
+                        className="flex items-center justify-between gap-3"
+                      >
+                        <span className="truncate">{secret.label}</span>
+                        {secret.required && (
+                          <span className="shrink-0 text-[9px] font-semibold uppercase tracking-wide text-amber-600 dark:text-amber-400">
+                            Required
+                          </span>
+                        )}
+                      </CommandItem>
+                    ))}
+                  </CommandGroup>
+                  <CommandSeparator />
+                </>
+              )}
+              <CommandGroup>
+                <CommandItem
+                  value="custom key"
+                  onSelect={() => {
+                    setOpen(false);
+                    onCustomKey();
+                  }}
                 >
-                  <span className="truncate">{secret.label}</span>
-                  {secret.required && (
-                    <span className="text-[9px] font-semibold uppercase tracking-wide text-amber-600 dark:text-amber-400">
-                      Required
-                    </span>
-                  )}
-                </DropdownMenuItem>
-              ))}
-              <DropdownMenuSeparator />
-            </>
-          )}
-          <DropdownMenuItem onSelect={onCustomKey}>
-            <IconPlus size={14} />
-            Custom
-          </DropdownMenuItem>
-        </DropdownMenuContent>
-      </DropdownMenu>
+                  <IconPlus size={14} />
+                  Custom
+                </CommandItem>
+              </CommandGroup>
+            </CommandList>
+          </Command>
+        </PopoverContent>
+      </Popover>
     </div>
   );
 }

package/corpus/core/src/client/use-chat-models.ts

@@ -200,7 +200,14 @@ export function useChatModels({
         .catch(() => null),
     ])
       .then(([enginesData, envKeys, builderStatus]) => {
-        if (!enginesData?.engines) return;
+        if (!enginesData?.engines) {
+          // Without a catalog the picker keeps an unvalidated DEFAULT_MODEL,
+          // which is indistinguishable from a real selection unless we say so.
+          console.warn(
+            "[agent-chat] no engine list; model picker is showing an unvalidated default",
+          );
+          return;
+        }
         const configuredKeys = new Set(
           (envKeys as Array<{ key: string; configured: boolean }>)
             .filter((k) => k.configured)
@@ -223,22 +230,45 @@ export function useChatModels({
         setDefaultModel(nextDefaultModel);
 
         const selection = selectionRef.current;
+
+        // Default only to a CONFIGURED group, and to nothing when there is
+        // none. `DEFAULT_MODEL` is a builder-gateway id that no group carries
+        // unless Builder is connected, and unconfigured groups are kept in the
+        // list for their connect affordance — so both `?? DEFAULT_MODEL` and
+        // `?? groups[0]` yield a selection the app cannot route, which the
+        // server silently replaces with its own default. An empty selection
+        // hides the picker instead of showing a model that will not be used.
+        const configuredGroups = groups.filter((g) => g.configured);
+        const resolveRoutableSelection = () => {
+          const group =
+            configuredGroups.find((g) => g.models.includes(nextDefaultModel)) ??
+            configuredGroups[0];
+          if (!group) return null;
+          const model =
+            group.models.find((m) => m === nextDefaultModel) ?? group.models[0];
+          if (!model) return null;
+          return {
+            model,
+            engine: group.engine,
+            effort: resolveReasoningEffortSelection(
+              model,
+              selection.selectedEffort,
+            ),
+          };
+        };
+
+        const applyFallback = (persist: boolean) => {
+          const next = resolveRoutableSelection();
+          setSelectedModel(next?.model ?? "");
+          setSelectedEngine(next?.engine ?? "");
+          if (next) {
+            setSelectedEffort(next.effort);
+            if (persist) writePersisted(storageKey, next);
+          }
+        };
+
         if (!hasExplicitSelectionRef.current) {
-          const defaultGroup =
-            groups.find((group) => group.models.includes(nextDefaultModel)) ??
-            groups[0];
-          const nextModel =
-            defaultGroup?.models.find((model) => model === nextDefaultModel) ??
-            defaultGroup?.models[0] ??
-            nextDefaultModel;
-          const nextEngine = defaultGroup?.engine ?? "";
-          const nextEffort = resolveReasoningEffortSelection(
-            nextModel,
-            selection.selectedEffort,
-          );
-          setSelectedModel(nextModel);
-          setSelectedEngine(nextEngine);
-          setSelectedEffort(nextEffort);
+          applyFallback(false);
           return;
         }
 
@@ -248,28 +278,15 @@ export function useChatModels({
             (!selection.selectedEngine ||
               group.engine === selection.selectedEngine),
         );
-        if (!selectedGroup) {
-          const defaultGroup =
-            groups.find((group) => group.models.includes(nextDefaultModel)) ??
-            groups[0];
-          const nextModel =
-            defaultGroup?.models.find((model) => model === nextDefaultModel) ??
-            defaultGroup?.models[0] ??
-            nextDefaultModel;
-          const nextEngine = defaultGroup?.engine ?? "";
-          const nextEffort = resolveReasoningEffortSelection(
-            nextModel,
-            selection.selectedEffort,
-          );
-          setSelectedModel(nextModel);
-          setSelectedEngine(nextEngine);
-          setSelectedEffort(nextEffort);
-          writePersisted(storageKey, {
-            model: nextModel,
-            engine: nextEngine,
-            effort: nextEffort,
-          });
+        if (selectedGroup) {
+          // Heal a selection stored without an engine (or with a stale one) so
+          // later submits carry the pair the catalog resolved.
+          if (selection.selectedEngine !== selectedGroup.engine) {
+            setSelectedEngine(selectedGroup.engine);
+          }
+          return;
         }
+        applyFallback(true);
       })
       .catch(() => {})
       .finally(() => setIsLoading(false));

package/corpus/core/src/localization/default-messages.ts

@@ -206,6 +206,7 @@ const messages = {
       otherAppsDescription: "Open other apps available to you.",
       availableCount: "{{count}} available",
       activeCount: "{{count}} active",
+      pendingCount: "{{count}} pending",
       hiddenCount: "{{count}} hidden",
       createApp: "Create app",
       templates: "Templates",
@@ -215,6 +216,16 @@ const messages = {
       show: "Show",
       hiddenApps: "Hidden apps",
       hiddenAppCount: "{{count}} hidden apps",
+      pendingApps: "Pending apps",
+      pendingAppsDescription:
+        "{{count}} pending apps are hidden by default. Show them only when you need to inspect work in progress.",
+      showPendingApps: "Show pending apps",
+      hidePendingApps: "Hide pending apps",
+      noActiveWorkspaceApps: "No active workspace apps yet",
+      noActiveWorkspaceAppsDescription:
+        "Pending apps are hidden by default. Expand Pending apps below to inspect them.",
+      appMetadataOwner: "Owner",
+      appMetadataTeams: "Teams",
       workspaceAppFallback: "Workspace App",
       workspaceAppDescription:
         "Open a deployed app or check the status of an app being created.",

package/corpus/core/src/mcp/ask-app-task-handle.ts

@@ -0,0 +1,183 @@
+import { createHmac } from "node:crypto";
+
+import { CompactEncrypt, compactDecrypt } from "jose";
+
+import { getAuthSecret } from "../server/better-auth-instance.js";
+
+const HANDLE_VERSION = 1;
+const HANDLE_TTL_SECONDS = 60 * 60;
+const INVALID_HANDLE_ERROR = "Invalid or expired ask_app task handle.";
+
+export interface AskAppTaskHandleRoute {
+  app: string;
+  origin: string;
+  routedVia: "local" | "a2a";
+  requestOrigin?: string;
+}
+
+interface AskAppTaskHandleClaims {
+  version: number;
+  issuerApp: string;
+  issuerAudience: string;
+  organization: string;
+  subject: string;
+  route: AskAppTaskHandleRoute;
+  taskId: string;
+  expiresAt: number;
+}
+
+function normalizedIdentity(value: string): string {
+  return value.trim().toLowerCase();
+}
+
+function normalizedAudience(value: string): string | null {
+  const url = validHttpUrl(value);
+  if (!url || url.search || url.hash) return null;
+  const pathname = url.pathname.replace(/\/+$/, "");
+  return `${url.origin}${pathname}`;
+}
+
+function rootSecrets(): string[] {
+  const a2a = process.env.A2A_SECRET?.trim();
+  const auth = getAuthSecret();
+  return [...new Set([a2a, auth].filter((value): value is string => !!value))];
+}
+
+function handleKey(rootSecret: string): Uint8Array {
+  return createHmac("sha256", rootSecret)
+    .update("agent-native:ask-app-task-handle:v1")
+    .digest();
+}
+
+function validHttpUrl(value: string): URL | null {
+  try {
+    const url = new URL(value);
+    if (!["http:", "https:"].includes(url.protocol)) return null;
+    if (url.username || url.password) return null;
+    return url;
+  } catch {
+    return null;
+  }
+}
+
+function validRoute(value: unknown): value is AskAppTaskHandleRoute {
+  if (!value || typeof value !== "object") return false;
+  const route = value as Partial<AskAppTaskHandleRoute>;
+  if (typeof route.app !== "string" || !route.app.trim()) return false;
+  if (route.routedVia !== "local" && route.routedVia !== "a2a") return false;
+  if (typeof route.origin !== "string") return false;
+  const endpoint = validHttpUrl(route.origin);
+  if (!endpoint) return false;
+  if (route.requestOrigin == null) return true;
+  if (typeof route.requestOrigin !== "string") return false;
+  const requestOrigin = validHttpUrl(route.requestOrigin);
+  return requestOrigin?.origin === endpoint.origin;
+}
+
+function invalidHandle(): Error {
+  return new Error(INVALID_HANDLE_ERROR);
+}
+
+export async function signAskAppTaskHandle(params: {
+  issuerApp: string;
+  issuerAudience: string;
+  organization: string;
+  subject: string;
+  route: AskAppTaskHandleRoute;
+  taskId: string;
+  expiresInSeconds?: number;
+}): Promise<string> {
+  const issuerApp = normalizedIdentity(params.issuerApp);
+  const issuerAudience = normalizedAudience(params.issuerAudience);
+  const organization = normalizedIdentity(params.organization);
+  const subject = normalizedIdentity(params.subject);
+  const taskId = params.taskId.trim();
+  if (
+    !issuerApp ||
+    !issuerAudience ||
+    !subject ||
+    !taskId ||
+    !validRoute(params.route)
+  ) {
+    throw invalidHandle();
+  }
+
+  const claims: AskAppTaskHandleClaims = {
+    version: HANDLE_VERSION,
+    issuerApp,
+    issuerAudience,
+    organization,
+    subject,
+    route: {
+      ...params.route,
+      app: normalizedIdentity(params.route.app),
+    },
+    taskId,
+    expiresAt:
+      Math.floor(Date.now() / 1000) +
+      (params.expiresInSeconds ?? HANDLE_TTL_SECONDS),
+  };
+  const payload = new TextEncoder().encode(JSON.stringify(claims));
+  return new CompactEncrypt(payload)
+    .setProtectedHeader({
+      alg: "dir",
+      enc: "A256GCM",
+      typ: "agent-native-ask-app-task-handle",
+    })
+    .encrypt(handleKey(rootSecrets()[0]));
+}
+
+export async function verifyAskAppTaskHandle(
+  handle: string,
+  expected: {
+    issuerApp: string;
+    issuerAudience: string;
+    organization: string;
+    subject: string;
+  },
+): Promise<{ route: AskAppTaskHandleRoute; taskId: string }> {
+  const issuerApp = normalizedIdentity(expected.issuerApp);
+  const issuerAudience = normalizedAudience(expected.issuerAudience);
+  const organization = normalizedIdentity(expected.organization);
+  const subject = normalizedIdentity(expected.subject);
+  if (!handle.trim() || !issuerApp || !issuerAudience || !subject) {
+    throw invalidHandle();
+  }
+
+  for (const rootSecret of rootSecrets()) {
+    try {
+      const { plaintext, protectedHeader } = await compactDecrypt(
+        handle,
+        handleKey(rootSecret),
+      );
+      if (
+        protectedHeader.alg !== "dir" ||
+        protectedHeader.enc !== "A256GCM" ||
+        protectedHeader.typ !== "agent-native-ask-app-task-handle"
+      ) {
+        continue;
+      }
+      const claims = JSON.parse(
+        new TextDecoder().decode(plaintext),
+      ) as Partial<AskAppTaskHandleClaims>;
+      if (
+        claims.version !== HANDLE_VERSION ||
+        claims.issuerApp !== issuerApp ||
+        claims.issuerAudience !== issuerAudience ||
+        claims.organization !== organization ||
+        claims.subject !== subject ||
+        typeof claims.taskId !== "string" ||
+        !claims.taskId ||
+        typeof claims.expiresAt !== "number" ||
+        claims.expiresAt <= Math.floor(Date.now() / 1000) ||
+        !validRoute(claims.route)
+      ) {
+        continue;
+      }
+      return { route: claims.route, taskId: claims.taskId };
+    } catch {
+      // All handle failures are deliberately indistinguishable to callers.
+    }
+  }
+  throw invalidHandle();
+}