@k2b/cloud 0.42.0 → 0.44.0

package/src/ai/quota-report.ts

@@ -4,18 +4,21 @@ import { recursiveGroupIdsSubquery } from "../services/accounts/group-sql";
 import { toPgTextArray } from "../services/postgres";
 import { hasBillableAiPricing } from "../shared/ai-costs";
 import { type AiQuotaReport, type AiQuotaReportQuery, AiQuotaReportQuerySchema } from "../shared/ai-quotas";
+import { aiPeopleAtLimit } from "./quota-limits";
 import { aiQuotas } from "./quotas";
 import { readAiSettingsState } from "./settings";
 
 /** Resolve display metadata only for administration, never on the inference path. */
 export async function quotaAdminConfig() {
   const config = await aiQuotas.config();
+  const limits = await aiPeopleAtLimit();
   const grants = await resolveDisplayNames(config.rules.flatMap((rule) => rule.grants));
   let offset = 0;
   return {
     ...config,
     rules: config.rules.map((rule) => ({
       ...rule,
+      peopleAtLimit: limits.find((limit) => limit.scope === rule.scope)?.people.length ?? 0,
       grants: rule.grants.map(() => {
         const grant = grants[offset++]!;
         return {
@@ -50,7 +53,7 @@ export async function quotaReport(input: Partial<AiQuotaReportQuery> = {}, now =
       page: 1,
       perPage: 25,
     };
-  const pricedModels = (await readAiSettingsState()).profiles.filter((p) => hasBillableAiPricing(p.pricing)).map((p) => p.id);
+  const pricedModels = (await readAiSettingsState()).profiles.filter((p) => hasBillableAiPricing(p.pricing)).map((p) => p.modelId);
   const bucket = query.range === "24h" ? "hour" : "day";
   const order = query.sort === "label" ? sql`label` : query.sort === "cost" ? sql`cost` : sql`last_used`;
   const direction = query.direction === "asc" ? sql`ASC` : sql`DESC`;
@@ -80,7 +83,7 @@ export async function quotaReport(input: Partial<AiQuotaReportQuery> = {}, now =
       FROM ai.inference_calls c WHERE c.kind='chat' AND c.started_at<=${now}
     ), periods AS MATERIALIZED (
       SELECT * FROM calls WHERE started_at>=${since} AND started_at<${until}
-        AND (${query.model}='' OR model_profile_id=${query.model})
+        AND (${query.model}='' OR model_id=${query.model})
     ), allowances AS MATERIALIZED (
       SELECT a.id,a.type,r.scope,
         CASE WHEN bool_or((g->>'limit') IS NULL) FILTER(WHERE g IS NOT NULL) THEN NULL ELSE COALESCE(max((g->>'limit')::float8),0) END AS amount,
@@ -95,7 +98,7 @@ export async function quotaReport(input: Partial<AiQuotaReportQuery> = {}, now =
     ), balances AS MATERIALIZED (
       SELECT a.*,COALESCE(sum(c.cost),0)::float8 AS used,count(c.id) FILTER(WHERE c.unknown)::int AS unknown
       FROM allowances a LEFT JOIN calls c ON c.identity_id=a.id AND c.identity_type=a.type
-        AND (a.scope='*' OR c.model_profile_id=a.scope) AND c.started_at>=a.starts
+        AND (a.scope='*' OR c.model_id=a.scope) AND c.started_at>=a.starts
         AND c.started_at>COALESCE((SELECT max(created_at) FROM ai.cost_resets z
           WHERE COALESCE(z.user_id,z.service_account_id)=a.id AND (z.user_id IS NOT NULL)=(a.type='user') AND z.scope=a.scope),'-infinity'::timestamptz)
       GROUP BY a.id,a.type,a.scope,a.amount,a.starts
@@ -111,7 +114,7 @@ export async function quotaReport(input: Partial<AiQuotaReportQuery> = {}, now =
       SELECT a.id,a.type,a.label,
         CASE WHEN NOT COALESCE((SELECT enabled FROM config),false) THEN 'disabled' ELSE COALESCE(s.status,'unlimited') END AS status,
         COALESCE(s.scopes,0) AS scopes,CASE WHEN s.status='unlimited' OR NOT COALESCE((SELECT enabled FROM config),false) THEN 0 ELSE COALESCE(s.exhausted,0) END AS exhausted,
-        (SELECT max(started_at) FROM calls c WHERE c.identity_id=a.id AND c.identity_type=a.type AND (${query.model}='' OR c.model_profile_id=${query.model})) AS last_used,
+        (SELECT max(started_at) FROM calls c WHERE c.identity_id=a.id AND c.identity_type=a.type AND (${query.model}='' OR c.model_id=${query.model})) AS last_used,
         sum(p.cost)::float8 AS cost,COALESCE(sum(p.input),0)::float8 AS input,COALESCE(sum(p.output),0)::float8 AS output,
         count(p.id)::int AS calls,count(p.id) FILTER(WHERE p.input IS NOT NULL AND p.output IS NOT NULL)::int AS measured,count(p.id) FILTER(WHERE p.estimated)::int AS estimated,count(p.id) FILTER(WHERE p.unknown)::int AS unknown
       FROM identities a LEFT JOIN states s ON s.id=a.id AND s.type=a.type

package/src/ai/quotas-migrate.ts

@@ -23,6 +23,7 @@ export async function migrateAiQuotas() {
       CHECK(cost IS NULL OR cost>=0), CHECK(reserved>=0),
       CHECK(input IS NULL OR input>=0), CHECK(output IS NULL OR output>=0)
     )`;
+    await db`ALTER TABLE ai.inference_calls ADD COLUMN IF NOT EXISTS credential_id UUID`;
     await db`ALTER TABLE ai.inference_calls ADD COLUMN IF NOT EXISTS estimated BOOLEAN NOT NULL DEFAULT false`;
     await db`ALTER TABLE ai.inference_calls ADD COLUMN IF NOT EXISTS error TEXT`;
     await db`ALTER TABLE ai.inference_calls ADD COLUMN IF NOT EXISTS cancelled BOOLEAN NOT NULL DEFAULT false`;

package/src/ai/quotas.ts

@@ -3,6 +3,7 @@ import { type AccessSubject, buildAccessPrincipalCondition } from "../server/ser
 import { hasBillableAiPricing } from "../shared/ai-costs";
 import { type AiQuotaConfig, AiQuotaConfigSchema, type AiQuotaIdentity, type AiQuotaSnapshot } from "../shared/ai-quotas";
 import { readAiSettingsState } from "./settings";
+import type { AiSettingsState } from "./types";
 
 export class AiQuotaError extends Error {
   constructor(
@@ -43,10 +44,18 @@ export const aiQuotas = {
       return { ...config, revision };
     });
   },
-  async snapshot(subject: AccessSubject, model?: string, now = new Date(), db: SQL = sql): Promise<AiQuotaSnapshot> {
-    const config = await aiQuotas.config(db);
+  async snapshot(
+    subject: AccessSubject,
+    model?: string,
+    now = new Date(),
+    db: SQL = sql,
+    context?: { state: AiSettingsState; config: AiQuotaConfig },
+  ): Promise<AiQuotaSnapshot> {
+    const config = context?.config ?? (await aiQuotas.config(db));
     const identity = ids(subject);
-    const pricedModels = new Set((await readAiSettingsState()).profiles.filter((p) => hasBillableAiPricing(p.pricing)).map((p) => p.id));
+    const pricedModels = new Set(
+      (context?.state ?? (await readAiSettingsState())).profiles.filter((p) => hasBillableAiPricing(p.pricing)).map((p) => p.modelId),
+    );
     const matches = buildAccessPrincipalCondition({
       subject,
       columns: {
@@ -76,7 +85,7 @@ export const aiQuotas = {
             (c.finished_at IS NOT NULL OR (c.lease_expires_at <= now() OR (c.turn_id IS NOT NULL AND NOT EXISTS(SELECT 1 FROM ai.turns t WHERE t.id=c.turn_id AND t.attempt=c.turn_attempt AND t.status='running' AND t.lease_expires_at>now())))))::int AS unknown
         FROM ai.inference_calls c
         WHERE c.kind='chat' AND c.user_id IS NOT DISTINCT FROM ${identity.user}::uuid AND c.service_account_id IS NOT DISTINCT FROM ${identity.service}::uuid
-          AND (${rule.scope}='*' OR c.model_profile_id=${rule.scope})
+          AND (${rule.scope}='*' OR c.model_id=${rule.scope})
           AND c.started_at>=${window.from} AND c.started_at<${window.until}
           AND c.started_at>COALESCE((SELECT max(r.created_at) FROM ai.cost_resets r
             WHERE r.user_id IS NOT DISTINCT FROM ${identity.user}::uuid AND r.service_account_id IS NOT DISTINCT FROM ${identity.service}::uuid AND r.scope=${rule.scope}),'-infinity'::timestamptz)`;
@@ -110,13 +119,15 @@ export const aiQuotas = {
       GROUP BY model_profile_id ORDER BY model_profile_id`;
     return { enabled: config.enabled, unit: config.unit ?? "EUR", balances, usage };
   },
-  async assertAllowed(subject: AccessSubject, model: string) {
+  async assertAllowed(subject: AccessSubject, variantId: string, providedState?: AiSettingsState) {
+    const state = providedState ?? (await readAiSettingsState());
+    const profile = state.profiles.find((profile) => profile.id === variantId);
+    if (!profile || !hasBillableAiPricing(profile.pricing)) return false;
+    const model = profile.modelId;
     // Fast default path: no additional identity/usage queries on unrestricted installations.
-    const pricing = (await readAiSettingsState()).profiles.find((profile) => profile.id === model)?.pricing;
-    if (!hasBillableAiPricing(pricing)) return false;
     const config = await aiQuotas.config();
     if (!config.enabled || !config.rules.some((r) => r.scope === "*" || r.scope === model)) return false;
-    const snapshot = await aiQuotas.snapshot(subject, model);
+    const snapshot = await aiQuotas.snapshot(subject, model, undefined, undefined, { state, config });
     for (const b of snapshot.balances) {
       if (b.bypassed || b.limit === null) continue;
       if (b.unknown)

package/src/ai/recent-resources.ts

@@ -26,6 +26,8 @@ import type { AiConversationService, AiRecentResource } from "./types";
 export const AiRecentResourceSchema: z.ZodType<AiRecentResource> = z
   .object({
     ref: CloudResourceRefSchema,
+    context: LinkedCloudResourceReferenceSchema.shape.context,
+    status: LinkedCloudResourceReferenceSchema.shape.status,
     title: LinkedCloudResourceReferenceSchema.shape.title.unwrap(),
     icon: LinkedCloudResourceReferenceSchema.shape.icon,
     href: LinkedCloudResourceReferenceSchema.shape.href,
@@ -183,6 +185,8 @@ export const listAiRecentResources = async (input: {
             ref,
             count,
             title: data.title,
+            context: ownRef?.context,
+            status: ownRef?.status,
             icon: ownRef?.icon ?? data.icon,
             href,
             preview: recentResourcePreview(ownRef?.preview ?? data.description),
@@ -229,6 +233,8 @@ export const listAiRecentResources = async (input: {
           ref,
           count,
           title: ownRef.title,
+          context: ownRef.context,
+          status: ownRef.status,
           icon: (ownRef.icon ?? type.icon ?? app.appIcon)?.slice(0, 120),
           href: ownRef.href,
           kind: type.title.slice(0, 120),

package/src/ai/request-headers.ts

@@ -1,117 +1,44 @@
 import { sql } from "bun";
-import { toPgTextArray } from "../services/postgres";
 import { decryptValue, encryptValue } from "../services/settings/crypto";
-import {
-  AI_REQUEST_HEADERS_PROVIDER_ERROR,
-  AiRequestHeadersSchema,
-  patchAiRequestHeaders,
-  providerSupportsRequestHeaders,
-} from "../shared/ai-request-options";
-import type { AiModelProfile } from "./types";
+import { AiRequestHeadersSchema, patchAiRequestHeaders } from "../shared/ai-request-options";
 
 type SqlClient = typeof sql;
-export type AiRequestHeaderPatch = { profileId: string; patch: unknown };
 
-const decryptHeaders = async (profileId: string, secret: string): Promise<Record<string, string>> => {
+const decryptHeaders = async (providerId: string, secret: string): Promise<Record<string, string>> => {
   try {
     const parsed = AiRequestHeadersSchema.safeParse(await decryptValue(secret));
     if (parsed.success && Object.values(parsed.data).every((value) => typeof value === "string"))
       return patchAiRequestHeaders({}, parsed.data);
   } catch {}
-  console.warn(`[ai] ignoring unreadable request headers for profile ${JSON.stringify(profileId)}`);
+  console.warn(`[ai] ignoring unreadable request headers for provider ${JSON.stringify(providerId)}`);
   return {};
 };
 
 /** Secrets stay server-side, in a separate encrypted row like provider API keys. */
-export const getAiRequestHeaders = async (profileId: string, db: SqlClient = sql): Promise<Record<string, string>> => {
-  const [row] = await db<{ secret: string }[]>`SELECT secret FROM ai.model_request_headers WHERE profile_id = ${profileId}`;
-  return row ? decryptHeaders(profileId, row.secret) : {};
+export const getAiRequestHeaders = async (providerId: string, db: SqlClient = sql): Promise<Record<string, string>> => {
+  const [row] = await db<{ secret: string }[]>`SELECT secret FROM ai.provider_request_headers WHERE provider_id = ${providerId}`;
+  return row ? decryptHeaders(providerId, row.secret) : {};
 };
 
-export const setAiRequestHeaders = async (profileId: string, headers: Record<string, string>, db: SqlClient = sql): Promise<void> => {
+export const setAiRequestHeaders = async (providerId: string, headers: Record<string, string>, db: SqlClient = sql): Promise<void> => {
   const normalized = patchAiRequestHeaders({}, headers);
   if (!Object.keys(normalized).length) {
-    await db`DELETE FROM ai.model_request_headers WHERE profile_id = ${profileId}`;
+    await db`DELETE FROM ai.provider_request_headers WHERE provider_id = ${providerId}`;
     return;
   }
   const encrypted = await encryptValue(normalized);
-  await db`INSERT INTO ai.model_request_headers (profile_id, secret) VALUES (${profileId}, ${encrypted})
-    ON CONFLICT (profile_id) DO UPDATE SET secret = EXCLUDED.secret, updated_at = now()`;
+  await db`INSERT INTO ai.provider_request_headers (provider_id, secret) VALUES (${providerId}, ${encrypted})
+    ON CONFLICT (provider_id) DO UPDATE SET secret = EXCLUDED.secret, updated_at = now()`;
 };
 
-/** Admin reads contain names only. Never serialize header values into profiles. */
+/** Admin reads contain names only. Never serialize header values into providers. */
 export const listAiRequestHeaderNames = async (db: SqlClient = sql): Promise<Record<string, string[]>> => {
-  const rows = await db<{ profile_id: string; secret: string }[]>`SELECT profile_id, secret FROM ai.model_request_headers`;
+  const rows = await db<{ provider_id: string; secret: string }[]>`SELECT provider_id, secret FROM ai.provider_request_headers`;
   const names: Record<string, string[]> = {};
   for (const row of rows)
-    Object.defineProperty(names, row.profile_id, {
-      value: Object.keys(await decryptHeaders(row.profile_id, row.secret)).sort(),
+    Object.defineProperty(names, row.provider_id, {
+      value: Object.keys(await decryptHeaders(row.provider_id, row.secret)).sort(),
       enumerable: true,
     });
   return names;
 };
-
-export const pruneAiRequestHeaders = async (keepProfileIds: readonly string[], db: SqlClient = sql): Promise<void> => {
-  if (!keepProfileIds.length) await db`DELETE FROM ai.model_request_headers`;
-  else await db`DELETE FROM ai.model_request_headers WHERE profile_id <> ALL(${toPgTextArray([...keepProfileIds])}::text[])`;
-};
-
-/** Follow credentials: changing provider discards stored secrets; omission preserves them on the same provider. */
-export const planAiProfileRequestHeaders = (input: {
-  currentProfiles: readonly AiModelProfile[];
-  nextProfiles: readonly AiModelProfile[];
-  existingNames: Record<string, string[]>;
-  submitted: readonly AiRequestHeaderPatch[];
-}): { keepHeaderProfileIds: string[]; patches: { profileId: string; patch: Record<string, string | null> }[]; error?: string } => {
-  const current = new Map(input.currentProfiles.map((profile) => [profile.id, profile]));
-  const keepHeaderProfileIds = input.nextProfiles
-    .filter(
-      (profile) =>
-        providerSupportsRequestHeaders(profile.provider) &&
-        current.get(profile.id)?.provider === profile.provider &&
-        !profile.capabilities.includes("transcription"),
-    )
-    .map((profile) => profile.id);
-  const patches: { profileId: string; patch: Record<string, string | null> }[] = [];
-  for (const submitted of input.submitted) {
-    const profile = input.nextProfiles.find((profile) => profile.id === submitted.profileId);
-    const parsed = AiRequestHeadersSchema.safeParse(submitted.patch);
-    if (!parsed.success)
-      return { keepHeaderProfileIds: [], patches: [], error: `requestHeaders: ${zodHeaderMessage(parsed.error.issues)}` };
-    if (!profile || !providerSupportsRequestHeaders(profile.provider))
-      return { keepHeaderProfileIds: [], patches: [], error: AI_REQUEST_HEADERS_PROVIDER_ERROR };
-    if (profile.capabilities.includes("transcription"))
-      return {
-        keepHeaderProfileIds: [],
-        patches: [],
-        error: "requestHeaders: Request settings are not supported on transcription profiles.",
-      };
-    const oldNames =
-      keepHeaderProfileIds.includes(profile.id) && Object.hasOwn(input.existingNames, profile.id) ? input.existingNames[profile.id]! : [];
-    try {
-      patchAiRequestHeaders(Object.fromEntries(oldNames.map((name) => [name, ""])), parsed.data);
-    } catch {
-      return {
-        keepHeaderProfileIds: [],
-        patches: [],
-        error: "requestHeaders: At most 32 extra headers are allowed after applying the patch.",
-      };
-    }
-    patches.push({ profileId: profile.id, patch: parsed.data });
-  }
-  return { keepHeaderProfileIds, patches };
-};
-
-const zodHeaderMessage = (issues: readonly { path: readonly PropertyKey[]; message: string }[]) =>
-  issues.map((issue) => `${issue.path.map(String).join(".") || "headers"}: ${issue.message}`).join("; ");
-
-/** Apply after pruning so a provider change cannot inherit old secrets. Call inside the settings transaction. */
-export const storeAiRequestHeaderPlan = async (
-  plan: ReturnType<typeof planAiProfileRequestHeaders>,
-  db: SqlClient = sql,
-): Promise<void> => {
-  if (plan.error) throw new Error(plan.error);
-  await pruneAiRequestHeaders(plan.keepHeaderProfileIds, db);
-  for (const { profileId, patch } of plan.patches)
-    await setAiRequestHeaders(profileId, patchAiRequestHeaders(await getAiRequestHeaders(profileId, db), patch), db);
-};

package/src/ai/resource-refs.ts

@@ -13,7 +13,7 @@ import type { AiConversationResourceObservation } from "./types";
 
 const LinkedResourceReferenceSchema = CloudResourceReferenceSchema.extend({
   href: CloudResourceHrefSchema.optional(),
-});
+}).strip();
 
 export const addCloudResourceHrefs = <T>(
   value: T,
@@ -67,12 +67,14 @@ export const collectConversationResourceObservations = (...values: unknown[]): A
       return;
     }
 
-    const view = CloudResourceViewSchema.safeParse(value);
+    const view = CloudResourceViewSchema.strip().safeParse(value);
     if (view.success) {
       const resource: CloudResourceView = view.data;
       observations.set(observationKey(resource.ref), {
         ref: resource.ref,
         title: resource.title,
+        context: resource.context,
+        status: resource.status,
         preview: resource.preview,
         icon: resource.icon,
         href: resource.links.find((link) => link.rel === "open")?.href,
@@ -87,6 +89,8 @@ export const collectConversationResourceObservations = (...values: unknown[]): A
           ...previous,
           ref,
           ...(resource.title !== undefined ? { title: resource.title } : {}),
+          ...(resource.context !== undefined ? { context: resource.context } : {}),
+          ...(resource.status !== undefined ? { status: resource.status } : {}),
           ...(resource.preview !== undefined ? { preview: resource.preview } : {}),
           ...(resource.icon !== undefined ? { icon: resource.icon } : {}),
           ...(resource.href !== undefined ? { href: resource.href } : {}),

package/src/ai/routes.ts

@@ -37,7 +37,7 @@ import { coreSettings } from "../services/settings/api";
 import { resolveAppIdentityPresentation } from "../shared/app-presentation";
 import { readThemeFromCookieHeader } from "../shared/theme";
 import { type AiStoredActionReview, isLegacyActionReview, isUnknownActionOutcome, storedActionReview } from "./action-review";
-import { assistantAiSettingsState, listAssistantAiModels, resolveAssistantAudioModel, selectAssistantAiModelId } from "./assistant-models";
+import { assistantAiSettingsState, peopleAiModels, resolveAssistantAudioModel, selectAssistantAiModel } from "./assistant-models";
 import { AI_AUDIO_MAX_BYTES } from "./audio-format";
 import { buildAiCapabilityCatalog } from "./capabilities";
 import { checkAiCapability, resolveAiCapabilityActor } from "./capability-execution";
@@ -254,10 +254,10 @@ const publicMemory = async (userId: string, memory: Awaited<ReturnType<typeof ai
   (await publicMemories(userId, [memory]))[0]!;
 
 /** Fire-and-forget: remember the model this user actually ran a turn with (preselected for new chats). */
-const rememberLastUsedModel = (actor: RequestActor, modelProfileId: string | null | undefined): void => {
+const rememberLastUsedModel = (actor: RequestActor, model: import("../shared/ai-models").AiModelRequest | undefined): void => {
   const userId = aiPrefsUserId(actor);
-  if (!userId || !modelProfileId) return;
-  void aiUserPrefs.update(userId, { lastModelId: modelProfileId }).catch(() => undefined);
+  if (!userId || !model) return;
+  void aiUserPrefs.update(userId, { selection: model }).catch(() => undefined);
 };
 
 const conversationDetail = async (conversation: AiConversation, subject: AccessSubject) => {
@@ -348,7 +348,7 @@ export const aiRoutes = (() => {
         return c.json(await getAiChatQuotas(c.get("accessSubject")));
       })
       .get("/models", async (c) => {
-        return respond(c, ok(await listAssistantAiModels(c.get("accessSubject"))));
+        return respond(c, ok(await peopleAiModels(c.get("accessSubject"))));
       })
       .get("/prefs", async (c) => {
         const ctx = await resolveContext(c);
@@ -438,12 +438,11 @@ export const aiRoutes = (() => {
         const state = await readAiSettingsState();
         let previewProfile: ReturnType<typeof selectAiModelProfile> | null = null;
         if (state.ok && state.enabled) {
-          const models = await listAssistantAiModels(c.get("accessSubject"), ctx.modelPolicy);
-          const preferredId =
-            models.find((model) => model.id === prefs?.lastModelId)?.id ??
-            models.find((model) => model.id === state.defaultModelId)?.id ??
-            models[0]?.id;
-          if (preferredId) previewProfile = selectAiModelProfile(state, ctx.modelPolicy, preferredId);
+          try {
+            previewProfile = selectAiModelProfile(state, ctx.modelPolicy, prefs.selection ?? undefined);
+          } catch {
+            /* The prompt preview remains available without a usable model. */
+          }
         }
         const toolsSupported = Boolean(previewProfile?.capabilities.includes("tools"));
         const availableSkills = toolsSupported
@@ -1022,7 +1021,7 @@ export const aiRoutes = (() => {
             locale: getLocale(c),
             theme: readThemeFromCookieHeader(c.req.header("cookie")),
             timeZone: getTimeZone(c),
-            requestedModelId: body.modelProfileId ?? project?.defaultModelProfileId ?? undefined,
+            model: body.model ?? project?.defaultModel ?? undefined,
             modelPolicy: ctx.modelPolicy,
             project: project ?? undefined,
             clientToolIds: body.clientToolIds,
@@ -1043,7 +1042,7 @@ export const aiRoutes = (() => {
             return respond(c, ok({ queued: true }));
           }
           const result = await submitAiChatTurn(submission);
-          rememberLastUsedModel(ctx.actor, result.turn.modelProfileId);
+          rememberLastUsedModel(ctx.actor, body.model);
           return respond(
             c,
             ok({
@@ -1115,9 +1114,9 @@ export const aiRoutes = (() => {
         if (originalProject && !currentProject) return respond(c, fail(err.notFound("Project")));
 
         try {
-          const requestedModelId = await selectAssistantAiModelId(
+          const model = await selectAssistantAiModel(
             c.get("accessSubject"),
-            body.modelProfileId ?? originalProject?.defaultModelProfileId ?? undefined,
+            body.model ?? originalProject?.defaultModel ?? undefined,
             ctx.modelPolicy,
           );
           if ((await prepareConversationForMessageRetry(conversation.id)) === "busy") {
@@ -1134,7 +1133,7 @@ export const aiRoutes = (() => {
             locale: getLocale(c),
             theme: readThemeFromCookieHeader(c.req.header("cookie")),
             timeZone: getTimeZone(c),
-            requestedModelId,
+            model,
             modelPolicy: ctx.modelPolicy,
             systemPrompt,
             project: originalProject,
@@ -1158,7 +1157,7 @@ export const aiRoutes = (() => {
                 }
               : undefined,
           });
-          rememberLastUsedModel(ctx.actor, result.turn.modelProfileId);
+          rememberLastUsedModel(ctx.actor, body.model);
           return respond(
             c,
             ok({
@@ -1230,7 +1229,7 @@ export const aiRoutes = (() => {
           const result = await submitAiCompaction({
             conversationId: conversation.id,
             actor: ctx.actor,
-            requestedModelId: body.modelProfileId,
+            model: body.model,
             modelPolicy: ctx.modelPolicy,
           });
           return respond(c, ok({ turn: publicTurn(result.turn, conversation.shortId) }), 201);

package/src/ai/runtime.ts

@@ -8,6 +8,7 @@ import { type ApprovalDecisionChannel, approvals } from "../services/approvals";
 import { logger } from "../services/logging";
 import { superviseRuntimeTask } from "../services/runtime-lifecycle";
 import { coreSettings } from "../services/settings/api";
+import type { AiModelRequest } from "../shared/ai-models";
 import {
   AI_WEBSITE_APPROVAL_TOOL,
   type AiToolApprovalChangeContext,
@@ -15,16 +16,17 @@ import {
   aiTurnAllowsRememberedApprovals,
   rememberAiToolApproval,
 } from "./approvals";
-import { aiChatAccessSubject, selectAssistantAiModelId } from "./assistant-models";
+import { aiChatAccessSubject, selectAssistantAiModel } from "./assistant-models";
 import { startAiDictationRuntime } from "./dictation-runtime";
 import { AiTurnExecutor, type ExecutorConfig } from "./executor";
 import { canonicalizeAiConversationAttachments, snapshotAiConversationFiles } from "./file-context";
 import type { AiLocalClient, AiLocalContext } from "./local-tool-contracts";
 import { drainQueuedMessages } from "./message-queue";
+import { aiUserPrefs } from "./prefs";
 import { AI_TURN_LEASE_MS } from "./protocol";
 import { aiQuotas } from "./quotas";
 import { parseAiResourceMarker } from "./resource-markers";
-import { isAiVisionModelConfigured } from "./settings";
+import { isAiVisionModelConfigured, readAiSettingsState } from "./settings";
 import { aiConversations } from "./store";
 import { publishAiWireEvent } from "./stream";
 import { aiToolAudit } from "./tool-audit";
@@ -110,7 +112,7 @@ export type SubmitAiChatTurnInput = {
   theme?: "light" | "dark";
   timeZone?: string;
   modelPolicy?: AiModelPolicy;
-  requestedModelId?: string;
+  model?: AiModelRequest;
   /** Optional instructions that apply only to this turn. */
   systemPrompt?: string;
   project?: AiChatTurnRunConfig["project"];
@@ -143,21 +145,43 @@ export const prepareAiChatTurn = async (input: SubmitAiChatTurnInput) => {
   );
   const canonicalInput = files?.attached.length ? inputMessage.content : input.input;
   const hasImageAttachments = Boolean(files?.attached.some((file) => isAiImageMediaType(file.mediaType)));
+  const state = await readAiSettingsState();
   const canInspectAttachedImages =
     input.canInspectAttachedImages ??
-    (input.toolSource?.kind === "default" && (await isAiVisionModelConfigured(input.modelPolicy?.allowedDataBoundaries)));
-  const requestedModelId = input.assistantChat
-    ? await selectAssistantAiModelId(aiChatAccessSubject(input.actor), input.requestedModelId, input.modelPolicy)
-    : input.requestedModelId;
-  const { resolved } = await validateAiTurnRequest({
-    input: canonicalInput,
-    hasImageAttachments,
-    canInspectAttachedImages,
-    modelPolicy: input.modelPolicy,
-    requestedModelId,
-  });
+    (input.toolSource?.kind === "default" && (await isAiVisionModelConfigured(input.modelPolicy?.allowedDataBoundaries, state)));
+  let requested = input.model;
+  let previousLabel: string | undefined;
+  if (input.assistantChat) {
+    const latest = await aiConversations.getLatestTurn({ conversationId: input.conversationId, kind: "chat" });
+    const previous = latest ? await aiConversations.getTurnRunConfig({ conversationId: input.conversationId, turnId: latest.id }) : null;
+    const inherited = previous?.kind === "chat" ? previous.model : undefined;
+    requested ??= inherited;
+    if (inherited && "id" in inherited && requested && "id" in requested && requested.id === inherited.id) {
+      if (!state.profiles.some((profile) => profile.id === inherited.id)) {
+        previousLabel = previous?.kind === "chat" ? (previous.modelLabel ?? inherited.id) : inherited.id;
+        const subject = aiChatAccessSubject(input.actor);
+        const prefs = subject?.type === "user" ? await aiUserPrefs.get(subject.userId) : null;
+        requested = prefs?.selection && "class" in prefs.selection ? prefs.selection : { class: "balanced" };
+      }
+    }
+  }
+  const model = input.assistantChat
+    ? await selectAssistantAiModel(aiChatAccessSubject(input.actor), requested, input.modelPolicy, state)
+    : requested;
+  const { resolved } = await validateAiTurnRequest(
+    {
+      input: canonicalInput,
+      hasImageAttachments,
+      canInspectAttachedImages,
+      modelPolicy: input.modelPolicy,
+      model,
+    },
+    state,
+  );
   const quotaSubject = aiChatAccessSubject(input.actor);
-  if (input.assistantChat && quotaSubject) await aiQuotas.assertAllowed(quotaSubject, resolved.profile.id);
+  if (input.assistantChat && quotaSubject) await aiQuotas.assertAllowed(quotaSubject, resolved.profile.id, state);
+  const modelLabel =
+    resolved.profile.label + (resolved.profile.id !== resolved.profile.modelId ? ` · ${resolved.profile.variantLabel}` : "");
   const runConfig: AiChatTurnRunConfig = {
     kind: "chat",
     selectedSkillIds: [
@@ -177,7 +201,10 @@ export const prepareAiChatTurn = async (input: SubmitAiChatTurnInput) => {
     ...(input.theme ? { theme: input.theme } : {}),
     ...(input.timeZone ? { timeZone: input.timeZone } : {}),
     modelPolicy: input.modelPolicy,
-    requestedModelId,
+    model,
+    modelResolved: resolved.model,
+    modelLabel,
+    ...(previousLabel ? { modelReplacement: { kind: "model_replaced", previousLabel, nextLabel: modelLabel } } : {}),
     systemPrompt: input.systemPrompt,
     project: input.project,
     files,
@@ -191,7 +218,7 @@ export const prepareAiChatTurn = async (input: SubmitAiChatTurnInput) => {
 
   return {
     conversationId: input.conversationId,
-    modelProfileId: resolved.profile.id,
+    modelId: resolved.profile.id,
     runConfig,
     userMessage,
     truncateFromSeq: input.truncateFromSeq,
@@ -244,7 +271,7 @@ export const deliverAiInterChatMessage = async (input: {
   };
   const delivered = await aiConversations.deliverInterChatMessage({
     messageId: input.message.id,
-    modelProfileId: resolved.profile.id,
+    modelId: resolved.profile.id,
     runConfig,
     userMessage: { role: "user", content: [{ type: "text", text }] },
     sourceHref: input.sourceHref,
@@ -257,20 +284,21 @@ export type SubmitAiCompactionInput = {
   conversationId: string;
   actor?: RequestActor;
   modelPolicy?: AiModelPolicy;
-  requestedModelId?: string;
+  model?: AiModelRequest;
 };
 
 export const submitAiCompaction = async (input: SubmitAiCompactionInput): Promise<{ turn: AiTurn }> => {
-  const { resolved } = await validateAiTurnRequest({ input: "", modelPolicy: input.modelPolicy, requestedModelId: input.requestedModelId });
+  const { resolved } = await validateAiTurnRequest({ input: "", modelPolicy: input.modelPolicy, model: input.model });
   const runConfig: AiCompactionTurnRunConfig = {
     kind: "compact",
     actor: input.actor,
     modelPolicy: input.modelPolicy,
-    requestedModelId: input.requestedModelId,
+    model: { id: resolved.profile.id },
+    modelResolved: resolved.model,
   };
   const turn = await aiConversations.createCompactionTurn({
     conversationId: input.conversationId,
-    modelProfileId: resolved.profile.id,
+    modelId: resolved.profile.id,
     runConfig,
   });
   await enqueueAiTurn({ conversationId: input.conversationId, turnId: turn.id });