@k2b/cloud 0.43.0 → 0.44.0

package/src/account/profile-picture-messages.ts

@@ -0,0 +1,269 @@
+import { i18n } from "@k2b/stdlib";
+
+type OptionLabels = Record<string, Record<string, string>>;
+
+const optionLabel = (labels: OptionLabels, part: string, id: string): string => labels[part]?.[id] ?? id;
+
+const OPTIONS_EN = {
+  face: { round: "Round", oval: "Oval", square: "Square" },
+  skin: { s1: "Light", s2: "Light medium", s3: "Medium", s4: "Medium dark", s5: "Dark", s6: "Very dark" },
+  hair: {
+    none: "None",
+    short: "Short",
+    buzz: "Very short",
+    curly: "Curls",
+    afro: "Afro",
+    long: "Long",
+    bob: "Bob",
+    bun: "Bun",
+    locs: "Locs",
+  },
+  hairColor: {
+    black: "Black",
+    dark: "Dark brown",
+    brown: "Brown",
+    blond: "Blond",
+    red: "Red",
+    grey: "Grey",
+    white: "White",
+    blue: "Blue",
+    pink: "Pink",
+  },
+  eyes: { dots: "Dots", ovals: "Oval", happy: "Happy", wink: "Wink", calm: "Calm" },
+  brows: { none: "None", straight: "Straight", arched: "Arched", thick: "Strong", raised: "Raised" },
+  mouth: { smile: "Smile", grin: "Laugh", neutral: "Neutral", oh: "Surprised", smirk: "Smirk" },
+  beard: { none: "None", stubble: "Stubble", moustache: "Moustache", goatee: "Goatee", full: "Full beard" },
+  glasses: { none: "None", round: "Round", square: "Square", half: "Half rim", sun: "Sunglasses" },
+  head: { none: "None", beanie: "Beanie", cap: "Cap", hijab: "Headscarf", turban: "Turban", kippa: "Kippah", phones: "Headphones" },
+  extra: { none: "None", freckles: "Freckles", blush: "Cheeks", earrings: "Earrings", mole: "Beauty mark" },
+  bg: { sky: "Sky", mint: "Mint", sand: "Sand", rose: "Rose", lilac: "Lilac", stone: "Stone", peach: "Peach", teal: "Teal" },
+  robotHead: { square: "Square", round: "Round", capsule: "Capsule", tv: "Screen" },
+  antenna: { none: "None", ball: "Ball", double: "Double", dish: "Dish" },
+  robotEyes: { round: "Round", visor: "Visor", pixel: "Pixel", cyclops: "One eye", happy: "Happy" },
+  robotMouth: { grill: "Grille", smile: "Smile", led: "Lights", line: "Straight", none: "None" },
+  body: { plain: "Plain", panel: "Panel", light: "Light", buttons: "Buttons" },
+  color: {
+    steel: "Steel",
+    white: "White",
+    blue: "Blue",
+    teal: "Turquoise",
+    coral: "Coral",
+    yellow: "Yellow",
+    purple: "Purple",
+    graphite: "Graphite",
+  },
+} as const satisfies OptionLabels;
+
+const OPTIONS_DE = {
+  face: { round: "Rund", oval: "Oval", square: "Eckig" },
+  skin: { s1: "Hell", s2: "Hell-mittel", s3: "Mittel", s4: "Mittel-dunkel", s5: "Dunkel", s6: "Sehr dunkel" },
+  hair: {
+    none: "Ohne",
+    short: "Kurz",
+    buzz: "Sehr kurz",
+    curly: "Locken",
+    afro: "Afro",
+    long: "Lang",
+    bob: "Bob",
+    bun: "Dutt",
+    locs: "Locs",
+  },
+  hairColor: {
+    black: "Schwarz",
+    dark: "Dunkelbraun",
+    brown: "Braun",
+    blond: "Blond",
+    red: "Rot",
+    grey: "Grau",
+    white: "Weiß",
+    blue: "Blau",
+    pink: "Pink",
+  },
+  eyes: { dots: "Punkte", ovals: "Oval", happy: "Fröhlich", wink: "Zwinkern", calm: "Ruhig" },
+  brows: { none: "Ohne", straight: "Gerade", arched: "Bogen", thick: "Kräftig", raised: "Fragend" },
+  mouth: { smile: "Lächeln", grin: "Lachen", neutral: "Neutral", oh: "Staunen", smirk: "Schmunzeln" },
+  beard: { none: "Ohne", stubble: "Stoppeln", moustache: "Schnurrbart", goatee: "Kinnbart", full: "Vollbart" },
+  glasses: { none: "Ohne", round: "Rund", square: "Eckig", half: "Halbrand", sun: "Sonnenbrille" },
+  head: { none: "Ohne", beanie: "Mütze", cap: "Kappe", hijab: "Kopftuch", turban: "Turban", kippa: "Kippa", phones: "Kopfhörer" },
+  extra: { none: "Ohne", freckles: "Sommersprossen", blush: "Wangen", earrings: "Ohrringe", mole: "Muttermal" },
+  bg: { sky: "Himmel", mint: "Minze", sand: "Sand", rose: "Rose", lilac: "Flieder", stone: "Stein", peach: "Pfirsich", teal: "Petrol" },
+  robotHead: { square: "Eckig", round: "Rund", capsule: "Kapsel", tv: "Bildschirm" },
+  antenna: { none: "Ohne", ball: "Kugel", double: "Doppelt", dish: "Schüssel" },
+  robotEyes: { round: "Rund", visor: "Visier", pixel: "Pixel", cyclops: "Ein Auge", happy: "Fröhlich" },
+  robotMouth: { grill: "Gitter", smile: "Lächeln", led: "Lichter", line: "Gerade", none: "Ohne" },
+  body: { plain: "Schlicht", panel: "Klappe", light: "Licht", buttons: "Knöpfe" },
+  color: {
+    steel: "Stahl",
+    white: "Weiß",
+    blue: "Blau",
+    teal: "Türkis",
+    coral: "Koralle",
+    yellow: "Gelb",
+    purple: "Lila",
+    graphite: "Graphit",
+  },
+} as const satisfies OptionLabels;
+
+/** Words of the profile picture dialog; option names follow the shape set ids (`option({ part, id })`). */
+export const profilePictureMessages = i18n.define({
+  baseLocale: "en",
+  messages: {
+    en: {
+      title: "Change profile picture",
+      close: "Close",
+      ways: "Kind of profile picture",
+      photo: "Photo",
+      avatar: "Avatar",
+      robot: "Robot",
+      initials: "Initials",
+      active: "Active",
+      cancel: "Cancel",
+      save: "Save",
+      saving: "Saving",
+      retry: "Retry",
+      unsaved: "Not saved yet",
+      visiblePerson: "Visible to everyone signed in to this Cloud.",
+      visibleAgent: "Visible to everyone who can see this agent.",
+      saveFailed: "Not saved. The previous profile picture stays, your choice is still here.",
+      loading: "Loading profile picture",
+      loadFailed: "The profile picture could not be loaded.",
+      discardTitle: "Discard changes?",
+      discardBody: "Your changes are not saved. The previous profile picture stays.",
+      discardConfirm: "Discard",
+      discardCancel: "Keep editing",
+      preview: "Preview",
+      previewSizes: "Preview in Cloud's sizes",
+      previewDark: "Preview in the dark theme",
+      random: "Random",
+      undo: "Undo",
+      reset: "Reset",
+      parts: "Parts",
+      chosen: ({ name }: { name: string }) => `${name} chosen`,
+      randomized: "Random choice",
+      undone: "Undone",
+      resetDone: "Reset",
+      hairHidden: ({ cover }: { cover: string }) => `${cover} covers the hair. Your choice stays saved.`,
+      beardColour: "The beard has your hair colour.",
+      photoDrop: "Drop a photo here",
+      photoFormats: "PNG, JPEG, or WebP. Then you crop the picture.",
+      photoChoose: "Choose photo",
+      photoOther: "Other photo",
+      photoDelete: "Delete photo",
+      photoDeleted: "Photo deleted",
+      photoNew: "New photo, cropped. Save makes it your profile picture.",
+      photoActive: "Your photo is your profile picture.",
+      photoHidden: "Your photo is stored but not visible right now. Others see only the active profile picture.",
+      photoDeleteFailed: "The photo could not be deleted.",
+      photoTypeInvalid: "Choose a PNG, JPEG, or WebP image.",
+      photoTooLarge: "Choose an image smaller than 32 MB.",
+      photoEmpty: "This image is empty. Choose another one.",
+      photoUnsupported: "This browser cannot prepare the image. Try another browser.",
+      photoProcessFailed: "This image could not be prepared as a small picture. Try a simpler image.",
+      initialsInfo: "Cloud builds the initials from your name. They change when your name changes.",
+      // Parts
+      face: "Face",
+      faceShape: "Face shape",
+      skin: "Skin tone",
+      hair: "Hair",
+      hairstyle: "Hairstyle",
+      hairColor: "Hair colour",
+      eyes: "Eyes",
+      brows: "Brows",
+      eyebrows: "Eyebrows",
+      mouth: "Mouth",
+      beard: "Beard",
+      glasses: "Glasses",
+      head: "Head",
+      headwear: "Headwear",
+      extra: "Extras",
+      colour: "Colour",
+      backgroundAndClothes: "Background and clothes",
+      antenna: "Antenna",
+      body: "Body",
+      colours: "Colours",
+      casing: "Casing",
+      background: "Background",
+      option: ({ part, id }: { part: string; id: string }) => optionLabel(OPTIONS_EN, part, id),
+      hijabCover: "The headscarf",
+      turbanCover: "The turban",
+    },
+    de: {
+      title: "Profilbild ändern",
+      close: "Schließen",
+      ways: "Art des Profilbilds",
+      photo: "Foto",
+      avatar: "Avatar",
+      robot: "Roboter",
+      initials: "Initialen",
+      active: "Aktiv",
+      cancel: "Abbrechen",
+      save: "Speichern",
+      saving: "Wird gespeichert",
+      retry: "Erneut versuchen",
+      unsaved: "Noch nicht gespeichert",
+      visiblePerson: "Sichtbar für alle angemeldeten Personen dieser Cloud.",
+      visibleAgent: "Sichtbar für alle, die diesen Agenten sehen.",
+      saveFailed: "Nicht gespeichert. Das bisherige Profilbild bleibt, deine Auswahl ist noch da.",
+      loading: "Profilbild wird geladen",
+      loadFailed: "Das Profilbild konnte nicht geladen werden.",
+      discardTitle: "Änderungen verwerfen?",
+      discardBody: "Deine Änderungen sind nicht gespeichert. Das bisherige Profilbild bleibt.",
+      discardConfirm: "Verwerfen",
+      discardCancel: "Weiter bearbeiten",
+      preview: "Vorschau",
+      previewSizes: "Vorschau in den Größen von Cloud",
+      previewDark: "Vorschau im dunklen Design",
+      random: "Zufall",
+      undo: "Rückgängig",
+      reset: "Zurücksetzen",
+      parts: "Teile",
+      chosen: ({ name }: { name: string }) => `${name} gewählt`,
+      randomized: "Zufällige Auswahl",
+      undone: "Rückgängig gemacht",
+      resetDone: "Zurückgesetzt",
+      hairHidden: ({ cover }: { cover: string }) => `${cover} verdeckt die Haare. Deine Wahl bleibt gespeichert.`,
+      beardColour: "Der Bart hat deine Haarfarbe.",
+      photoDrop: "Foto hierher ziehen",
+      photoFormats: "PNG, JPEG oder WebP. Danach schneidest du den Ausschnitt zu.",
+      photoChoose: "Foto auswählen",
+      photoOther: "Anderes Foto",
+      photoDelete: "Foto löschen",
+      photoDeleted: "Foto gelöscht",
+      photoNew: "Neues Foto, zugeschnitten. Mit „Speichern“ wird es dein Profilbild.",
+      photoActive: "Dein Foto ist dein Profilbild.",
+      photoHidden: "Dein Foto ist gespeichert, aber gerade nicht sichtbar. Andere sehen nur das aktive Profilbild.",
+      photoDeleteFailed: "Das Foto konnte nicht gelöscht werden.",
+      photoTypeInvalid: "Wähle ein PNG-, JPEG- oder WebP-Bild.",
+      photoTooLarge: "Wähle ein Bild unter 32 MB.",
+      photoEmpty: "Dieses Bild ist leer. Wähle ein anderes.",
+      photoUnsupported: "Dieser Browser kann das Bild nicht vorbereiten. Versuche einen anderen Browser.",
+      photoProcessFailed: "Dieses Bild konnte nicht als kleines Bild vorbereitet werden. Versuche ein einfacheres Bild.",
+      initialsInfo: "Cloud bildet die Initialen aus deinem Namen. Sie ändern sich, wenn sich dein Name ändert.",
+      face: "Gesicht",
+      faceShape: "Gesichtsform",
+      skin: "Hautton",
+      hair: "Haare",
+      hairstyle: "Frisur",
+      hairColor: "Haarfarbe",
+      eyes: "Augen",
+      brows: "Brauen",
+      eyebrows: "Augenbrauen",
+      mouth: "Mund",
+      beard: "Bart",
+      glasses: "Brille",
+      head: "Kopf",
+      headwear: "Kopfbedeckung",
+      extra: "Extras",
+      colour: "Farbe",
+      backgroundAndClothes: "Hintergrund und Kleidung",
+      antenna: "Antenne",
+      body: "Körper",
+      colours: "Farben",
+      casing: "Gehäuse",
+      background: "Hintergrund",
+      option: ({ part, id }: { part: string; id: string }) => optionLabel(OPTIONS_DE, part, id),
+      hijabCover: "Das Kopftuch",
+      turbanCover: "Der Turban",
+    },
+  },
+});

package/src/account/ui.ts

@@ -1,3 +1,10 @@
 export { CloudAvatar, type CloudAvatarKind, type CloudAvatarProps, cloudAvatarImage, cloudAvatarSource } from "./Avatar";
 export { type AvatarUploadDialogOptions, openAvatarUploadDialog } from "./avatar-upload-dialog";
 export { default as EntitySearch, type EntitySearchPrincipal } from "./EntitySearch";
+export {
+  openProfilePictureDialog,
+  type ProfilePictureChange,
+  type ProfilePictureDialogOptions,
+  type ProfilePictureState,
+} from "./ProfilePictureDialog";
+export { profilePictureMessages } from "./profile-picture-messages";

package/src/ai/admin.ts

@@ -1,3 +1,6 @@
+export { aiModelCatalog } from "./model-catalog";
+export { type AiAdminOverview, readAiAdminOverview } from "./model-overview";
+export { aiModelUsage } from "./model-usage";
 export { quotaAdminConfig, quotaReport } from "./quota-report";
 export { AiQuotaError, aiQuotas } from "./quotas";
 export { listAiRequestHeaderNames } from "./request-headers";

package/src/ai/app-frame.ts

@@ -0,0 +1,12 @@
+// The chart, view and task contracts that an HTML app frame draws and checks. Its prelude is inlined in every app
+// document, so it imports this entry instead of `./browser`, whose schemas and skill parser (with YAML) it never uses.
+export {
+  type CloudAiChartTable,
+  cloudAiChartMarkKey,
+  cloudAiChartRenderOptions,
+  cloudAiChartRows,
+  cloudAiChartTooltip,
+} from "./chart-block";
+export { type CloudAiChartInput, type CloudAiFormat, type CloudAiNumberFormat, cloudAiAppChartSchema } from "./default-tool-contracts";
+export { type AiTaskRequestInput, AiTaskRequestSchema } from "./task-contracts";
+export { CloudAiViewSummarySchema } from "./view-block";

package/src/ai/application-tasks.ts

@@ -0,0 +1,101 @@
+import type { SQL } from "bun";
+import { env } from "../config/env";
+import type { AccessSubject } from "../server/services/access";
+import { WorkflowAiAdmissionError, type WorkflowAiScope, workflowAiHash, workflowAiModelHash } from "../workflows/ai/policy";
+import { submitWorkflowAiTask } from "../workflows/ai/runtime";
+import {
+  createWorkflowAiTask,
+  getWorkflowAiTask,
+  getWorkflowAiTaskByEffectKey,
+  releaseApplicationAiTaskByEffectKey,
+} from "../workflows/ai/store";
+import { type AiTaskRequestInput, assertAiTaskRequestSize } from "./task-contracts";
+import { resolveApplicationAiTaskModel } from "./task-model";
+
+export type ApplicationAiTaskInput = {
+  appId: string;
+  scopeId: string;
+  effectKey: string;
+  task: string;
+  request: AiTaskRequestInput;
+  source: WorkflowAiScope;
+  usageSubject?: AccessSubject;
+  signal: AbortSignal;
+};
+
+export type ApplicationAiTaskKey = Pick<ApplicationAiTaskInput, "appId" | "scopeId" | "effectKey" | "usageSubject">;
+
+const applicationEffectKey = (input: ApplicationAiTaskKey): string =>
+  `application:${workflowAiHash({ app: input.appId, scope: input.scopeId, subject: input.usageSubject ?? null, effect: input.effectKey })}`;
+
+/** Call in the transaction settling the application request, including discarded or failed requests. */
+export const releaseApplicationAiTask = (input: ApplicationAiTaskKey, db?: SQL): Promise<boolean> =>
+  releaseApplicationAiTaskByEffectKey({ appId: input.appId, scopeId: input.scopeId, effectKey: applicationEffectKey(input) }, db);
+
+export { deleteApplicationAiTasks, listUnreleasedApplicationAiTaskSources } from "../workflows/ai/store";
+
+const waitForTask = (signal: AbortSignal, delayMs = 250) =>
+  new Promise<void>((resolve, reject) => {
+    const abort = () => {
+      clearTimeout(timer);
+      reject(signal.reason);
+    };
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", abort);
+      resolve();
+    }, delayMs);
+    signal.addEventListener("abort", abort, { once: true });
+    if (signal.aborted) abort();
+  });
+
+/** One durable inference in the shared AI runtime, without creating a workflow. */
+export const runApplicationAiTask = async (input: ApplicationAiTaskInput) => {
+  input.signal.throwIfAborted();
+  assertAiTaskRequestSize(input.request);
+  const effectKey = applicationEffectKey(input);
+  let task = await getWorkflowAiTaskByEffectKey(effectKey);
+  if (!task) {
+    const resolved = await resolveApplicationAiTaskModel(input.usageSubject, input.request.model);
+    const admissionSignal = AbortSignal.any([input.signal, AbortSignal.timeout(env.WORKFLOW_AI_QUEUE_TIMEOUT_MS)]);
+    for (;;) {
+      input.signal.throwIfAborted();
+      if (admissionSignal.aborted) throw new WorkflowAiAdmissionError("WORKFLOW_AI_QUEUE_TIMEOUT");
+      try {
+        task = (
+          await createWorkflowAiTask({
+            owner: { appId: input.appId, scopeId: input.scopeId, usageSubject: input.usageSubject },
+            stepKey: input.task,
+            effectKey,
+            request: input.request,
+            modelId: resolved.profile.id,
+            modelRef: resolved.model,
+            modelConfigHash: workflowAiModelHash(resolved.profile),
+            scope: input.source,
+          })
+        ).task;
+        break;
+      } catch (error) {
+        if (!(error instanceof WorkflowAiAdmissionError) || !error.retryable) throw error;
+        await waitForTask(admissionSignal, 500).catch(() => {
+          input.signal.throwIfAborted();
+          throw new WorkflowAiAdmissionError("WORKFLOW_AI_QUEUE_TIMEOUT");
+        });
+      }
+    }
+  }
+
+  if (task.status === "queued") await submitWorkflowAiTask(task.id);
+  let current = task;
+  for (;;) {
+    input.signal.throwIfAborted();
+    if (current.status === "succeeded") return { output: current.output, usage: current.usage, input: current.request.input };
+    if (current.status === "failed" || current.status === "canceled")
+      throw Object.assign(new Error("Application AI task did not complete. Retry the operation or inspect AI availability."), {
+        code: current.errorCode ?? "WORKFLOW_AI_FAILED",
+      });
+    await waitForTask(input.signal);
+    const latest = await getWorkflowAiTask(task.id);
+    if (!latest) throw new WorkflowAiAdmissionError("WORKFLOW_AI_SOURCE_UNAVAILABLE");
+    current = latest;
+  }
+};

package/src/ai/assistant-models.ts

@@ -1,93 +1,155 @@
 import type { AccessSubject, RequestActor } from "../server";
+import {
+  AI_MODEL_CLASSES,
+  type AiModelRequest,
+  type AiModelUnavailableReason,
+  type AiPeopleModelIcon,
+  type AiPeopleModels,
+  aiProviderMark,
+} from "../shared/ai-models";
 import { aiModelAccess } from "./model-access";
+import { aiModelCatalog } from "./model-catalog";
 import { personalAiModelPolicy } from "./personal-agent";
-import { listAiModels, toPublicAiSettingsState } from "./settings";
+import { aiUserPrefs } from "./prefs";
+import { aiQuotas } from "./quotas";
+import { listAiModels, readAiSettingsState, resolveAiModelRef, selectAiModelProfile, toPublicAiSettingsState } from "./settings";
 import { type AiResolvedAudioModel, AiTranscriptionError, resolveAiAudioModel } from "./transcription";
-import type { AiChatTurnRunConfig, AiDataBoundary, AiModelPolicy, AiSettingsError } from "./types";
+import type { AiChatTurnRunConfig, AiDataBoundary, AiModelPolicy, AiSettingsState } from "./types";
 import { isAiSettingsError } from "./validate";
 
 export const aiChatAccessSubject = (actor: RequestActor | undefined): AccessSubject | null => {
   if (!actor) return null;
   if (actor.kind === "user") return { type: "user", userId: actor.user.id };
-  if (actor.delegatedUser) {
-    return { type: "user", userId: actor.delegatedUser.id, delegatedByServiceAccountId: actor.serviceAccount.id };
-  }
+  if (actor.delegatedUser) return { type: "user", userId: actor.delegatedUser.id, delegatedByServiceAccountId: actor.serviceAccount.id };
   return { type: "service_account", serviceAccountId: actor.serviceAccount.id };
 };
-
-/** Background chat deliveries also use default tools; only the explicit HTTP marker identifies interactive turns. */
 export const isAssistantChatTurn = (config: AiChatTurnRunConfig): boolean => config.assistantChat === true && !config.mandate;
-
-export const listAssistantAiModels = async (subject: AccessSubject | null, policy: AiModelPolicy = personalAiModelPolicy) =>
-  aiModelAccess.filterModels(await listAiModels(policy), subject);
-
-/** The one audio check behind the composer microphone, dictation, and offering and running transcribe_audio. */
+/** Server-side list for permission-aware execution and the developer API. */
+export const listAssistantAiModels = async (
+  subject: AccessSubject | null,
+  policy: AiModelPolicy = personalAiModelPolicy,
+  state?: AiSettingsState,
+) => aiModelAccess.filterModels(await listAiModels(policy, state), subject);
+export const peopleAiModels = async (
+  subject: AccessSubject | null,
+  policy: AiModelPolicy = personalAiModelPolicy,
+): Promise<AiPeopleModels> => {
+  const [state, providers, prefs, config] = await Promise.all([
+    readAiSettingsState(),
+    aiModelCatalog.providers(undefined, false),
+    subject?.type === "user" ? aiUserPrefs.get(subject.userId) : null,
+    aiQuotas.config(),
+  ]);
+  const allowed = await listAssistantAiModels(subject, policy, state);
+  const quotaByModel = new Map<string, Awaited<ReturnType<typeof aiQuotas.snapshot>>>();
+  const options: AiPeopleModels["options"] = [];
+  const unavailable = new Map<string, AiModelUnavailableReason>();
+  for (const profile of allowed) {
+    const provider = providers.find((provider) => provider.id === profile.providerId);
+    let reason: AiModelUnavailableReason | undefined =
+      provider?.status === "key_rejected"
+        ? { code: "key_rejected" }
+        : provider?.status === "unreachable"
+          ? { code: "provider_unreachable" }
+          : undefined;
+    if (!reason && subject) {
+      let snapshot = quotaByModel.get(profile.modelId);
+      if (!snapshot) {
+        snapshot = await aiQuotas.snapshot(subject, profile.modelId, undefined, undefined, { state, config });
+        quotaByModel.set(profile.modelId, snapshot);
+      }
+      const exhausted = snapshot.balances.find(
+        (balance) => !balance.bypassed && balance.limit !== null && (balance.unknown > 0 || balance.used >= balance.limit),
+      );
+      if (exhausted) reason = { code: "budget_exhausted", resetsAt: exhausted.resetsAt };
+    }
+    if (reason) unavailable.set(profile.id, reason);
+    if (!profile.showInPicker) continue;
+    const icon: AiPeopleModelIcon =
+      profile.icon.kind === "image"
+        ? { kind: "image", src: profile.icon.dataUrl }
+        : profile.icon.kind === "emoji"
+          ? profile.icon
+          : { kind: "mark", ...aiProviderMark(provider ?? { id: profile.providerId, label: "AI" }) };
+    options.push({
+      id: profile.id,
+      label: profile.label,
+      ...(profile.id !== profile.modelId ? { variantLabel: profile.variantLabel } : {}),
+      description: profile.description,
+      icon,
+      classes: AI_MODEL_CLASSES.filter((modelClass) =>
+        state.assignments.some((assignment) => assignment.slot === modelClass && assignment.variantId === profile.id),
+      ),
+      ...(reason ? { unavailable: reason } : {}),
+    });
+  }
+  const storedSelection = prefs?.selection;
+  const selection =
+    storedSelection && "id" in storedSelection && !state.profiles.some((profile) => profile.id === storedSelection.id)
+      ? null
+      : (storedSelection ?? null);
+  return {
+    status: "ok",
+    selection,
+    effectiveDefault: { class: "balanced" },
+    classes: AI_MODEL_CLASSES.flatMap((modelClass) => {
+      const id = state.assignments.find((assignment) => assignment.slot === modelClass)?.variantId;
+      return id
+        ? [
+            {
+              class: modelClass,
+              variantId: id,
+              ...(!allowed.some((model) => model.id === id)
+                ? { unavailable: { code: "access_revoked" } as const }
+                : unavailable.has(id)
+                  ? { unavailable: unavailable.get(id) }
+                  : {}),
+            },
+          ]
+        : [];
+    }),
+    options,
+  };
+};
 export const resolveAssistantAudioModel = async (
   subject: AccessSubject | null,
   allowedDataBoundaries?: AiDataBoundary[],
 ): Promise<AiResolvedAudioModel> => {
   const model = await resolveAiAudioModel({ allowedDataBoundaries });
   try {
-    await aiModelAccess.assertAllowed(model.profile.id, subject);
+    await aiModelAccess.assertAllowed(model.profile.modelId, subject);
   } catch (error) {
-    if (!isAiSettingsError(error) || error.aiError.code !== "model_access_denied") throw error;
-    throw Object.assign(
-      new AiTranscriptionError(
-        "transcription_access_denied",
-        "Audio transcription is not available to you: you do not have access to the audio model. An administrator can grant access in the AI settings.",
-      ),
-      { aiError: error.aiError },
-    );
+    if (!isAiSettingsError(error)) throw error;
+    throw Object.assign(new AiTranscriptionError("transcription_access_denied", "Audio transcription is not available to you."), {
+      aiError: error.aiError,
+    });
   }
   return model;
 };
-
 export const assistantAiSettingsState = async (subject: AccessSubject | null) => {
-  const [status, models, audioModelConfigured] = await Promise.all([
+  const [status, choices, audioModelConfigured] = await Promise.all([
     toPublicAiSettingsState(personalAiModelPolicy.allowedDataBoundaries),
-    listAssistantAiModels(subject),
-    (async () => {
-      try {
-        await resolveAssistantAudioModel(subject, personalAiModelPolicy.allowedDataBoundaries);
-        return true;
-      } catch {
-        return false;
-      }
-    })(),
+    peopleAiModels(subject),
+    resolveAssistantAudioModel(subject, personalAiModelPolicy.allowedDataBoundaries).then(
+      () => true,
+      () => false,
+    ),
   ]);
-  return {
-    ...status,
-    audioModelConfigured,
-    models,
-    defaultModelId: models.some((model) => model.id === status.defaultModelId) ? status.defaultModelId : (models[0]?.id ?? ""),
-  };
+  return { ...status, ...choices, audioModelConfigured };
 };
-
-/** Explicit and project selections never silently switch models. */
-export const selectAssistantAiModelId = async (
+/** Class fallback only considers empty assignments, and access is checked on the owning model. */
+export const selectAssistantAiModel = async (
   subject: AccessSubject | null,
-  requestedModelId?: string,
+  model?: AiModelRequest,
   policy: AiModelPolicy = personalAiModelPolicy,
-): Promise<string> => {
-  if (policy.kind === "locked") {
-    await aiModelAccess.assertAllowed(policy.modelId, subject);
-    return policy.modelId;
-  }
-  if (policy.kind === "platform-default") {
-    const status = await toPublicAiSettingsState();
-    await aiModelAccess.assertAllowed(status.defaultModelId, subject);
-    return status.defaultModelId;
-  }
-  if (requestedModelId) {
-    await aiModelAccess.assertAllowed(requestedModelId, subject);
-    return requestedModelId;
-  }
-  const [status, models] = await Promise.all([toPublicAiSettingsState(), listAssistantAiModels(subject, policy)]);
-  const preferred = policy.defaultModelId;
-  const model = models.find((candidate) => candidate.id === (preferred ?? status.defaultModelId)) ?? models[0];
-  if (!model) {
-    const message = "No AI model is available for your Assistant access. Contact an administrator.";
-    throw Object.assign(new Error(message), { aiError: { code: "model_access_denied", message } satisfies AiSettingsError });
-  }
-  return model.id;
+  providedState?: AiSettingsState,
+): Promise<AiModelRequest> => {
+  const state = providedState ?? (await readAiSettingsState());
+  const stored = !model && subject?.type === "user" ? (await aiUserPrefs.get(subject.userId)).selection : null;
+  const selection = stored && "id" in stored && !state.profiles.some((profile) => profile.id === stored.id) ? null : stored;
+  const requested = model ?? selection ?? { class: "balanced" };
+  const profile = selectAiModelProfile(state, policy, requested);
+  await aiModelAccess.assertAllowed(profile.modelId, subject);
+  resolveAiModelRef(state, requested);
+  return requested;
 };