@k2b/cloud 0.25.0 → 0.27.0

package/src/access/messages.ts

@@ -29,6 +29,21 @@ export const accessMessages = i18n.define({
       lastManager: ({ level }: { level: string }) =>
         `The last entry with “${level}” access can't be lowered or removed. Give another person or group “${level}” access first.`,
       lastManagerOption: ({ level }: { level: string }) => `Available once another person or group has “${level}” access`,
+      groupMembers: "Members",
+      groupMembersOf: ({ name }: { name: string }) => `Members of ${name}`,
+      groupMemberCount: ({ count }: { count: number }) =>
+        count === 0
+          ? "No one receives access through this group right now."
+          : count === 1
+            ? "1 person receives access through this group right now."
+            : `${count.toLocaleString("en")} people receive access through this group right now.`,
+      groupMembersLoading: "Loading members…",
+      groupMembersHidden: "Your account can't see who belongs to this group.",
+      groupMembersFailed: "Members couldn't be loaded.",
+      retry: "Try again",
+      showMoreMembers: ({ count }: { count: number }) => `Show ${count.toLocaleString("en")} more`,
+      directoryGroupHint:
+        "This group comes from the directory. Local accounts such as guests can't be members, so give them access directly.",
       read: "Read",
       readDescription: "Read this resource through the app API.",
       write: "Write",
@@ -92,6 +107,21 @@ export const accessMessages = i18n.define({
       lastManager: ({ level }) =>
         `Der letzte Eintrag mit Zugriff „${level}“ kann nicht herabgestuft oder entfernt werden. Gib zuerst einer anderen Person oder Gruppe Zugriff „${level}“.`,
       lastManagerOption: ({ level }) => `Möglich, sobald eine weitere Person oder Gruppe Zugriff „${level}“ hat`,
+      groupMembers: "Mitglieder",
+      groupMembersOf: ({ name }) => `Mitglieder von ${name}`,
+      groupMemberCount: ({ count }) =>
+        count === 0
+          ? "Über diese Gruppe erhält gerade niemand Zugriff."
+          : count === 1
+            ? "Über diese Gruppe erhält gerade 1 Person Zugriff."
+            : `Über diese Gruppe erhalten gerade ${count.toLocaleString("de")} Personen Zugriff.`,
+      groupMembersLoading: "Mitglieder werden geladen…",
+      groupMembersHidden: "Dein Konto kann nicht sehen, wer zu dieser Gruppe gehört.",
+      groupMembersFailed: "Die Mitglieder konnten nicht geladen werden.",
+      retry: "Erneut versuchen",
+      showMoreMembers: ({ count }) => `${count.toLocaleString("de")} weitere anzeigen`,
+      directoryGroupHint:
+        "Diese Gruppe stammt aus dem Verzeichnis. Lokale Konten wie Gäste können nicht Mitglied sein; gib ihnen direkt Zugriff.",
       read: "Lesen",
       readDescription: "Diese Ressource über die App-API lesen.",
       write: "Schreiben",

package/src/ai/admin.ts

@@ -1,5 +1,6 @@
 export { quotaAdminConfig, quotaReport } from "./quota-report";
 export { AiQuotaError, aiQuotas } from "./quotas";
+export { listAiRequestHeaderNames } from "./request-headers";
 /** Server-only AI administration and usage accounting. */
 
 export { type AiModelAccessDraft, type AiModelAccessMap, type AiModelAccessState, aiModelAccess } from "./model-access";

package/src/ai/approval-routes.ts

@@ -4,7 +4,7 @@ import { z } from "zod";
 import { listCapabilities } from "../_internal/registry";
 import { ErrorResponseSchema } from "../contracts";
 import type { CapabilityRegistryEntry } from "../contracts/registry";
-import { type AuthContext, auth, expectUserBackedActor, jsonResponse, rateLimit, requiresAuth, v } from "../server";
+import { type AuthContext, auth, expectUserBackedActor, getLocale, jsonResponse, rateLimit, requiresAuth, v } from "../server";
 import { type AiToolApprovalPreference, listAiToolApprovalPreferences, revokeAiToolApprovalPreference } from "./approvals";
 import { buildAiCapabilityCatalog } from "./capabilities";
 
@@ -70,7 +70,7 @@ export const createAiApprovalPreferenceRoutes = (dependencies: AiApprovalRouteDe
       describeRoute({
         tags: ["AI"],
         summary: "List remembered AI approvals",
-        description: "Lists AI tool approvals remembered for the current user.",
+        description: "Lists AI tool approvals remembered for the current user, with titles in the request locale.",
         ...requiresAuth,
         responses: {
           200: jsonResponse(AiApprovalPreferenceListSchema, "Remembered approvals"),
@@ -84,16 +84,16 @@ export const createAiApprovalPreferenceRoutes = (dependencies: AiApprovalRouteDe
           listPreferences(user.id),
           registry().catch(() => [] as CapabilityRegistryEntry[]),
         ]);
-        const catalogByName = new Map(buildAiCapabilityCatalog(capabilities).map((entry) => [entry.name, entry]));
+        const catalogByName = new Map(buildAiCapabilityCatalog(capabilities, getLocale(c)).map((entry) => [entry.name, entry]));
         const approvals: AiApprovalPreferenceView[] = preferences.map((preference) => {
           const capability = catalogByName.get(preference.toolName);
           return {
             ...preference,
-            title: capability?.title ?? fallbackTitle(preference.toolName),
+            title: capability?.display.title ?? fallbackTitle(preference.toolName),
             app: capability
               ? {
                   id: capability.appId,
-                  name: capability.appName,
+                  name: capability.display.appName,
                   icon: capability.app.appIcon,
                   ...(capability.app.appAccent ? { accent: capability.app.appAccent } : {}),
                 }

package/src/ai/browser-code-contracts.ts

@@ -23,7 +23,7 @@ export const CodeRunInput = z
     resourceId: id
       .optional()
       .describe(
-        "Optional data context for one-off code. Requires Manage; uses this resource database and shared files/KV without changing its source. Local storage stays temporary.",
+        "Optional data context for one-off code. Requires Manage; uses this resource database and shared files/KV without changing its source. Test runs use real shared and personal data; writes and capability effects keep normal permissions and approvals.",
       ),
     version: z
       .number()
@@ -71,7 +71,10 @@ export const CodeActionInput = z
       .positive()
       .optional()
       .describe("Exact draft revision returned by code_actions({draft:true}); Manage required. Supply this OR publishedVersion."),
-    input: z.json().describe("Action input matching the discovered inputSchema."),
+    input: z
+      .record(z.string(), z.json())
+      .default({})
+      .describe("Action input object matching the discovered inputSchema. Pass the object itself, never JSON text."),
   })
   .strict()
   .refine(
@@ -162,6 +165,15 @@ export const CodeSecretInput = z
   })
   .strict();
 
+/**
+ * A runtime call that did not complete: rejected input, timeout, lost run or host failure.
+ * Hosts return it as data because a client tool result carries no error flag; the managed
+ * server tools report it to the model as a tool error. A run snapshot whose code failed is a
+ * completed call and keeps its own `status` and `error`.
+ */
+export const CodeToolFailure = z.object({ failed: z.literal(true), error: z.string(), guidance: z.string().optional() });
+export type CodeToolFailure = z.infer<typeof CodeToolFailure>;
+
 // Internal bridge envelope. Each model-facing tool receives only its own flat schema.
 export const CodeRuntimeInput = z.discriminatedUnion("operation", [
   CodeRunInput.safeExtend({ operation: z.literal("run") }),

package/src/ai/browser.ts

@@ -1,4 +1,11 @@
-export { CODE_RUNTIME_TOOL_NAMES, CodeActionInput, CodeResourceId, CodeRuntimeInput, parseCodeToolInput } from "./browser-code-contracts";
+export {
+  CODE_RUNTIME_TOOL_NAMES,
+  CodeActionInput,
+  CodeResourceId,
+  CodeRuntimeInput,
+  CodeToolFailure,
+  parseCodeToolInput,
+} from "./browser-code-contracts";
 export { type AiTaskRequest, type AiTaskRequestInput, AiTaskRequestSchema } from "./task-contracts";
 export { type AiTodoPlan, parseAiTodoPlan } from "./todo-contracts";
 

package/src/ai/capabilities.ts

@@ -1,6 +1,7 @@
 import { createHash } from "node:crypto";
 import type { Tool, ToolContext, ToolResolver } from "@k2b/nessi";
 import { z } from "zod";
+import { resolveCapabilityOperationTitle } from "../_internal/capabilities";
 import { HELP_READ_MAX_CHARS, HELP_SEARCH_MAX_LIMIT, readHelpArticle } from "../_internal/help-catalog";
 import {
   type CapabilityActionManifest,
@@ -13,6 +14,7 @@ import {
 import type { CapabilityRegistryEntry } from "../contracts/registry";
 import type { RequestActor } from "../server";
 import { createHelpReader, type HelpReaderFactory } from "../services/help";
+import { resolveAppIdentityPresentation } from "../shared/app-presentation";
 import { recordRejectedAiCapability } from "./capability-execution";
 import { CODE_SOURCE_TOOLS } from "./code-source-contracts";
 import { createCodeSourceTool } from "./code-source-tools";
@@ -44,6 +46,12 @@ export type AiCapabilityAppCatalogItem = {
 export type AiCapabilityCatalogEntry = AiCapabilityCatalogItem & {
   app: CapabilityRegistryEntry;
   operation: CapabilityQueryManifest | CapabilityActionManifest;
+  /**
+   * What people see in tool rows and approvals, in the locale the catalog was built for. The model keeps
+   * the base `title`, `description`, and schemas: they are prompt text, and stable prompts do not change
+   * with the reader's language.
+   */
+  display: { appName: string; title: string };
 };
 
 export type AiToolKind = "builtin" | AiCapabilityKind;
@@ -64,6 +72,16 @@ type AiToolCatalogEntry = AiToolCatalogItem & {
 
 export type AiRememberableCapabilityApprovals = ReadonlyMap<string, string>;
 
+/**
+ * Why `load_tools` could not make a requested name callable:
+ * - `unknown`: no tool has this exact name;
+ * - `not_offered_in_turn`: the tool exists, but this turn's client or task does not provide it;
+ * - `not_allowed`: the conversation's fixed tool scope excludes it;
+ * - `app_offline`: the app operation is not in the live registry now.
+ */
+export const AI_TOOL_UNAVAILABLE_REASONS = ["unknown", "not_offered_in_turn", "not_allowed", "app_offline"] as const;
+export type AiToolUnavailableReason = (typeof AI_TOOL_UNAVAILABLE_REASONS)[number];
+
 const DEFAULT_SEARCH_LIMIT = 10;
 const DEFAULT_APP_LIST_LIMIT = 20;
 const MAX_APP_LIST_LIMIT = 25;
@@ -109,8 +127,11 @@ export const buildAiCapabilityAppCatalog = (apps: readonly CapabilityRegistryEnt
     });
 };
 
-/** Build one deterministic, immutable view of the current live registry. */
-export const buildAiCapabilityCatalog = (apps: CapabilityRegistryEntry[]): AiCapabilityCatalogEntry[] => {
+/**
+ * Build one deterministic, immutable view of the current live registry. `locale` selects the human
+ * presentation in `display`; model-facing fields always stay in the app's base presentation.
+ */
+export const buildAiCapabilityCatalog = (apps: CapabilityRegistryEntry[], locale?: string): AiCapabilityCatalogEntry[] => {
   const entries = [...apps]
     .sort(
       (left, right) =>
@@ -119,12 +140,18 @@ export const buildAiCapabilityCatalog = (apps: CapabilityRegistryEntry[]): AiCap
         left.appName.localeCompare(right.appName) ||
         left.endpoint.localeCompare(right.endpoint),
     )
-    .flatMap((app) => [
-      ...app.manifest.actions.map((operation) => ({ app, operation, kind: "action" as const })),
-      ...app.manifest.queries.map((operation) => ({ app, operation, kind: "query" as const })),
-    ])
+    .flatMap((app) => {
+      const appName = locale
+        ? resolveAppIdentityPresentation({ name: app.appName, description: app.appDescription, presentation: app.appPresentation }, locale)
+            .name
+        : app.appName;
+      return [
+        ...app.manifest.actions.map((operation) => ({ app, appName, operation, kind: "action" as const })),
+        ...app.manifest.queries.map((operation) => ({ app, appName, operation, kind: "query" as const })),
+      ];
+    })
     .map(
-      ({ app, operation, kind }): AiCapabilityCatalogEntry => ({
+      ({ app, appName, operation, kind }): AiCapabilityCatalogEntry => ({
         name: aiCapabilityId(app.appId, operation.localId),
         providerName: aiCapabilityToolName(app.appId, kind, operation.localId),
         appId: app.appId,
@@ -135,6 +162,12 @@ export const buildAiCapabilityCatalog = (apps: CapabilityRegistryEntry[]): AiCap
         description: operation.description,
         app,
         operation,
+        display: {
+          appName,
+          title: locale
+            ? resolveCapabilityOperationTitle(operation, kind === "action" ? "actions" : "queries", app.presentation, locale)
+            : operation.title,
+        },
       }),
     )
     .sort((left, right) => left.name.localeCompare(right.name));
@@ -344,15 +377,16 @@ export const createAiHelpTools = (help: HelpReaderFactory = createHelpReader, lo
   return [search, read];
 };
 
+/** `null` when the registry could not be read. */
 const resolveCapabilityRegistry = async (
   listRegistry: () => Promise<CapabilityRegistryEntry[]>,
   onError?: (error: unknown) => void,
-): Promise<CapabilityRegistryEntry[]> => {
+): Promise<CapabilityRegistryEntry[] | null> => {
   try {
     return await listRegistry();
   } catch (error) {
     onError?.(error);
-    return [];
+    return null;
   }
 };
 
@@ -430,6 +464,9 @@ const ToolCatalogItemSchema = z
 
 type ToolStateStore = Pick<AiConversationService, "loadTools">;
 
+/** `call` is the name to call the tool by; app operations get a provider-safe name. */
+const LoadedToolSchema = z.object({ name: z.string(), call: z.string() }).strict();
+
 export const createAiToolMetaTools = (input: {
   apps: readonly CapabilityRegistryEntry[];
   catalog: readonly AiToolCatalogEntry[];
@@ -438,6 +475,10 @@ export const createAiToolMetaTools = (input: {
   store: ToolStateStore;
   maxLoadedTools?: number;
   unavailableLoadedNames?: readonly string[];
+  /** False when this turn offers no app operations at all. */
+  appOperationsOffered?: boolean;
+  /** Why a requested name that is not in `catalog` cannot be loaded; defaults to `unknown`. */
+  unavailableReason?: (name: string) => AiToolUnavailableReason;
 }): AiRuntimeTool[] => {
   const apps = buildAiCapabilityAppCatalog(input.apps);
   const directoryEntries: string[] = [];
@@ -453,17 +494,17 @@ export const createAiToolMetaTools = (input: {
   const liveAppDirectory =
     directoryEntries.length > 0
       ? ` Live capability apps: ${directoryEntries.join(", ")}${hiddenAppCount > 0 ? `, and ${hiddenAppCount} more` : ""}.`
-      : " No live capability apps are visible in this provider turn; retry discovery later instead of claiming a permanent product limitation.";
+      : input.appOperationsOffered === false
+        ? " App operations are not offered in this turn."
+        : " No Cloud app publishes operations right now. Do not search for app operations again in this turn; tell the user which app is not reachable instead of claiming a permanent product limitation.";
   const unavailableLoadedNames = input.unavailableLoadedNames ?? [];
   const unavailableLoadedNotice =
     unavailableLoadedNames.length > 0
-      ? ` Previously loaded tools currently absent from the live catalog: ${unavailableLoadedNames
-          .slice(-MAX_UNAVAILABLE_LOADED_NAMES)
-          .join(", ")}${
+      ? ` Previously loaded tools that are not available now: ${unavailableLoadedNames.slice(-MAX_UNAVAILABLE_LOADED_NAMES).join(", ")}${
           unavailableLoadedNames.length > MAX_UNAVAILABLE_LOADED_NAMES
             ? `, and ${unavailableLoadedNames.length - MAX_UNAVAILABLE_LOADED_NAMES} more`
             : ""
-        }. Treat them as temporarily unavailable; do not infer a permanent product limitation or search repeatedly.`
+        }. Do not search for them again in this turn; continue without them or tell the user what is missing.`
       : "";
   const search = defineAiTool({
     name: "search_tools",
@@ -501,38 +542,52 @@ export const createAiToolMetaTools = (input: {
   const load = defineAiTool({
     name: "load_tools",
     description:
-      "Load stable capability ids such as mail.conversation.list, or exact built-in names returned by search_tools, as ordinary tools for the next model turn. Skills may name capability ids directly, so load them without searching first.",
+      "Load stable capability ids such as mail.conversation.list, or exact built-in names returned by search_tools, as ordinary tools for the next model turn. Skills may name capability ids directly, so load them without searching first. Call each loaded tool by the `call` name returned for it. `unavailable` gives a reason per name: unknown means no tool has this exact name, so look it up once with search_tools instead of guessing; not_offered_in_turn means this client or task does not provide the tool; not_allowed means this chat's fixed tool scope excludes it; app_offline means its app is not reachable now. For the last three, do not search or load the name again in this turn.",
     inputSchema: z.object({ names: z.array(z.string().trim().min(1)).min(1).max(25) }).strict(),
     outputSchema: z
       .object({
-        loaded: z.array(z.string()),
-        alreadyLoaded: z.array(z.string()),
-        missing: z.array(z.string()),
+        loaded: z.array(LoadedToolSchema),
+        alreadyLoaded: z.array(LoadedToolSchema),
+        unavailable: z.array(z.object({ name: z.string(), reason: z.enum(AI_TOOL_UNAVAILABLE_REASONS) }).strict()),
         evicted: z.array(z.string()),
         titles: z.record(z.string(), z.string()),
       })
       .strict(),
     approval: "never",
   }).server(async ({ names }) => {
-    const available = new Set(input.catalog.map((entry) => entry.name));
+    const catalogByName = new Map(input.catalog.map((entry) => [entry.name, entry]));
+    // A provider name the model saw in an earlier call loads its operation, too.
+    const byProviderName = new Map(input.catalog.flatMap((entry) => (entry.capability ? [[entry.capability.providerName, entry]] : [])));
     const requested = [...new Set(names)];
-    const eager = requested.filter((name) => input.eagerNames.has(name));
-    const valid = requested.filter((name) => available.has(name) && !input.eagerNames.has(name));
-    const missing = requested.filter((name) => !available.has(name));
+    const found = requested.flatMap((name) => {
+      const entry = catalogByName.get(name) ?? byProviderName.get(name);
+      return entry ? [entry.name] : [];
+    });
+    const eager = [...new Set(found.filter((name) => input.eagerNames.has(name)))];
+    const valid = [...new Set(found.filter((name) => !input.eagerNames.has(name)))];
+    const unavailable = requested
+      .filter((name) => !catalogByName.has(name) && !byProviderName.has(name))
+      .map((name) => ({ name, reason: input.unavailableReason?.(name) ?? ("unknown" as const) }));
     const updated = await input.store.loadTools({
       conversationId: input.conversationId,
       names: valid,
       maxLoadedTools: input.maxLoadedTools,
     });
+    const callable = (name: string) => ({ name, call: catalogByName.get(name)?.capability?.providerName ?? name });
     const alreadyLoaded = [...new Set([...eager, ...updated.alreadyLoaded])];
-    const catalogByName = new Map(input.catalog.map((entry) => [entry.name, entry]));
     const titles = Object.fromEntries(
       [...new Set([...updated.loaded, ...alreadyLoaded, ...updated.evicted])].flatMap((name) => {
         const entry = catalogByName.get(name);
         return entry ? [[name, entry.title]] : [];
       }),
     );
-    return { ...updated, alreadyLoaded, missing, titles };
+    return {
+      loaded: updated.loaded.map(callable),
+      alreadyLoaded: alreadyLoaded.map(callable),
+      unavailable,
+      evicted: updated.evicted,
+      titles,
+    };
   });
 
   return [search, load, listApps];
@@ -566,8 +621,7 @@ export const createLoadedAiCapabilityTools = (input: {
         if (!input.authorizeBackground && entry.kind === "action" && (entry.operation as CapabilityActionManifest).approval !== "none") {
           const review = (await input.review?.(entry, args, context)) ?? null;
           if (review && context.callId) input.onReview?.(context.callId, review);
-          const message =
-            review?.message ?? `${entry.appName}: ${entry.title}\nReview the validated arguments below before running this Action.`;
+          const message = review?.message ?? `${entry.display.appName}: ${entry.display.title}`;
           if (!(await context.requestApproval(message))) {
             if (input.actor.kind === "user") {
               await recordRejectedAiCapability({ entry, actor: input.actor, args }).catch(() => undefined);
@@ -635,6 +689,8 @@ export const createAiToolResolver =
     actor: RequestActor;
     staticTools: AiRuntimeTool[];
     allowedTools?: readonly string[] | null;
+    /** Built-in tools that exist but that this turn does not offer, such as client tools its client did not declare or tools outside `allowedTools`. */
+    unofferedTools?: readonly string[];
     runtimeContext?: Omit<AiToolPreparationContext, "actor" | "conversationId">;
     store: Pick<AiConversationService, "getLoadedTools" | "loadTools">;
     listRegistry?: () => Promise<CapabilityRegistryEntry[]>;
@@ -653,10 +709,11 @@ export const createAiToolResolver =
     }) => void;
   }): ToolResolver =>
   async (): Promise<Tool[]> => {
-    const [registry, persistedLoadedNames] = await Promise.all([
+    const [liveRegistry, persistedLoadedNames] = await Promise.all([
       input.listRegistry ? resolveCapabilityRegistry(input.listRegistry, input.onCapabilityRegistryError) : [],
       input.store.getLoadedTools({ conversationId: input.conversationId }),
     ]);
+    const registry = liveRegistry ?? [];
     const configuredLimit = Math.floor(input.maxLoadedTools ?? 0);
     const loadedNames = configuredLimit > 0 ? persistedLoadedNames.slice(-configuredLimit) : persistedLoadedNames;
     if (loadedNames.length !== persistedLoadedNames.length) {
@@ -667,18 +724,41 @@ export const createAiToolResolver =
       });
     }
     const allowed = input.allowedTools == null ? null : new Set(input.allowedTools);
-    const capabilityCatalog = buildAiCapabilityCatalog(registry).filter((entry) => !allowed || allowed.has(entry.name));
+    const fullCapabilityCatalog = buildAiCapabilityCatalog(registry, input.locale);
+    const capabilityCatalog = fullCapabilityCatalog.filter((entry) => !allowed || allowed.has(entry.name));
     const helpTools = input.help ? createAiHelpTools(input.help, input.locale) : [];
     const resourceTool =
       input.execute && (capabilityCatalog.length > 0 || input.staticTools.some((tool) => tool.def.name === "code_read"))
         ? createAiResourceReaderTool({ apps: registry, catalog: capabilityCatalog, execute: input.execute })
         : null;
-    const builtIns = [...input.staticTools, ...helpTools, ...(resourceTool ? [resourceTool] : [])].filter(
-      (tool) => !allowed || allowed.has(tool.def.name),
-    );
+    const allBuiltIns = [...input.staticTools, ...helpTools, ...(resourceTool ? [resourceTool] : [])];
+    const builtIns = allBuiltIns.filter((tool) => !allowed || allowed.has(tool.def.name));
     const catalog = buildAiToolCatalog(builtIns, capabilityCatalog);
     const catalogNames = new Set(catalog.map((entry) => entry.name));
     const unavailableLoadedNames = loadedNames.filter((name) => !catalogNames.has(name));
+    const outOfScope = new Set([
+      ...allBuiltIns.map((tool) => tool.def.name),
+      ...fullCapabilityCatalog.flatMap((entry) => [entry.name, entry.providerName]),
+      ...(input.unofferedTools ?? []),
+    ]);
+    const unoffered = new Set(input.unofferedTools);
+    // A model may name a loaded operation by the provider name it called it by; app IDs contain no dot.
+    const loadedByProviderName = new Map(
+      persistedLoadedNames.flatMap((id) => {
+        const dot = id.indexOf(".");
+        if (dot < 1) return [];
+        return (["query", "action"] as const).map((kind) => [aiCapabilityToolName(id.slice(0, dot), kind, id.slice(dot + 1)), id] as const);
+      }),
+    );
+    // App operation IDs always contain a dot; built-in names never do.
+    const unavailableReason = (requested: string): AiToolUnavailableReason => {
+      const name = loadedByProviderName.get(requested) ?? requested;
+      if (allowed && outOfScope.has(name) && !allowed.has(name)) return "not_allowed";
+      if (unoffered.has(name)) return "not_offered_in_turn";
+      if (!name.includes(".")) return "unknown";
+      if (!input.listRegistry) return "not_offered_in_turn";
+      return liveRegistry === null || persistedLoadedNames.includes(name) ? "app_offline" : "unknown";
+    };
     const eagerNames = new Set(builtIns.map((tool) => tool.def.name).filter((name) => !CLOUD_AI_DEFERRED_BUILTIN_TOOL_NAMES.has(name)));
     const activeBuiltIns = builtIns.filter((tool) => eagerNames.has(tool.def.name) || loadedNames.includes(tool.def.name));
     const runtimeTools = [
@@ -690,6 +770,8 @@ export const createAiToolResolver =
         store: input.store,
         maxLoadedTools: input.maxLoadedTools,
         unavailableLoadedNames,
+        appOperationsOffered: Boolean(input.listRegistry),
+        unavailableReason,
       }),
       ...activeBuiltIns,
       ...(input.execute
@@ -719,10 +801,10 @@ export const createAiToolResolver =
       presentations.set(entry.providerName, {
         kind: "capability",
         appId: entry.appId,
-        appName: entry.appName,
+        appName: entry.display.appName,
         appIcon: entry.app.appIcon,
         appAccent: entry.app.appAccent,
-        title: entry.title,
+        title: entry.display.title,
         capabilityKind: entry.kind,
       });
       // Rememberable scopes are resolved by the owning app for each concrete