@k2b/cloud 0.43.0 → 0.44.0

package/src/ai/model-delete.ts

@@ -0,0 +1,234 @@
+import { sql } from "bun";
+import { z } from "zod";
+import { recursiveGroupIdsSubquery } from "../services/accounts/group-sql";
+import { toPgTextArray } from "../services/postgres";
+import { type AiDeleteModelInput, type AiModel, type AiModelSlot, type AiProvider, aiReplacementProblem } from "../shared/ai-models";
+import type { WorkflowBoundPlan, WorkflowIrStep, WorkflowJsonValue } from "../workflows/contracts";
+import { hashWorkflowSource } from "../workflows/language/canonical";
+import { publishWorkflowVersion, type WorkflowActivationInput } from "../workflows/store/definitions";
+import { aiModelAccess } from "./model-access";
+import { AiConfigError, aiModelCatalog, assertAiRevision, lockAiModelCatalog, validateAiSlot } from "./model-catalog";
+
+export const validateAiReplacement = (source: AiProvider, target: AiProvider, original: AiModel, replacement: AiModel): void => {
+  const problem = aiReplacementProblem(source, target, original, replacement);
+  if (problem === "private_boundary")
+    throw new AiConfigError("invalid_configuration", "A private model cannot be replaced with a hosted model.");
+  if (problem === "incompatible_model")
+    throw new AiConfigError(
+      "invalid_configuration",
+      "The replacement must be enabled and support the original model's kind and capabilities.",
+    );
+};
+const referencedAiModels = (value: unknown): string[] => {
+  if (Array.isArray(value)) return value.flatMap(referencedAiModels);
+  if (value !== null && typeof value === "object") {
+    const parsed = z.record(z.string(), z.unknown()).parse(value);
+    return Object.entries(parsed).flatMap(([key, entry]) =>
+      key === "model"
+        ? (() => {
+            const model = z.object({ id: z.string() }).safeParse(entry);
+            return model.success ? [model.data.id] : referencedAiModels(entry);
+          })()
+        : referencedAiModels(entry),
+    );
+  }
+  return [];
+};
+const retargetJson = (value: WorkflowJsonValue, ids: string[], replacement: string): WorkflowJsonValue => {
+  if (Array.isArray(value)) return value.map((entry) => retargetJson(entry, ids, replacement));
+  if (value !== null && typeof value === "object")
+    return Object.fromEntries(
+      Object.entries(value).map(([key, entry]) => [
+        key,
+        key === "model" &&
+        entry !== null &&
+        !Array.isArray(entry) &&
+        typeof entry === "object" &&
+        typeof entry.id === "string" &&
+        ids.includes(entry.id)
+          ? { id: replacement }
+          : retargetJson(entry, ids, replacement),
+      ]),
+    );
+  return value;
+};
+const retargetSteps = (steps: WorkflowIrStep[], ids: string[], replacement: string): WorkflowIrStep[] =>
+  steps.map((step) => {
+    if (step.kind === "action")
+      return {
+        ...step,
+        config: Object.fromEntries(
+          Object.entries(step.config).map(([key, value]) => [
+            key,
+            key === "model" &&
+            value !== null &&
+            !Array.isArray(value) &&
+            typeof value === "object" &&
+            typeof value.id === "string" &&
+            ids.includes(value.id)
+              ? { id: replacement }
+              : value,
+          ]),
+        ),
+      };
+    if (step.kind === "if")
+      return { ...step, then: retargetSteps(step.then, ids, replacement), else: retargetSteps(step.else, ids, replacement) };
+    if (step.kind === "switch")
+      return {
+        ...step,
+        cases: step.cases.map((entry) => ({ ...entry, steps: retargetSteps(entry.steps, ids, replacement) })),
+        default: retargetSteps(step.default, ids, replacement),
+      };
+    return { ...step, steps: retargetSteps(step.steps, ids, replacement) };
+  });
+export const deleteAiCatalogEntry = async (
+  kind: "provider" | "model" | "variant",
+  id: string,
+  input: AiDeleteModelInput,
+  actorId: string,
+) =>
+  sql.begin(async (db) => {
+    // One catalog lock orders deletion with assignment and catalog writes.
+    await lockAiModelCatalog(db);
+    const current =
+      kind === "provider"
+        ? await aiModelCatalog.providerDetail(id, db)
+        : kind === "model"
+          ? await aiModelCatalog.modelDetail(id, db)
+          : await aiModelCatalog.variant(id, db, true);
+    await assertAiRevision(current, input.revision, db);
+    const allModels = await aiModelCatalog.models(db),
+      allVariants = await aiModelCatalog.variants(db),
+      providers = await aiModelCatalog.providers(db);
+    const affectedModels =
+      kind === "provider"
+        ? allModels.filter((model) => model.providerId === id)
+        : allModels.filter((model) => model.id === (kind === "model" ? id : allVariants.find((v) => v.id === id)?.modelId));
+    if (kind === "variant" && allVariants.find((v) => v.id === id)?.slug === "standard")
+      throw new AiConfigError("invalid_configuration", "The standard variant can only be deleted with its model.");
+    const affected = allVariants.filter((v) => (kind === "variant" ? v.id === id : affectedModels.some((m) => m.id === v.modelId)));
+    const ids = affected.map((v) => v.id),
+      pgIds = toPgTextArray(ids);
+    const target = (variantId: string, sourceModel: AiModel, slot?: AiModelSlot) => {
+      const variant = allVariants.find((v) => v.id === variantId && !ids.includes(v.id));
+      const model = allModels.find((m) => m.id === variant?.modelId),
+        provider = providers.find((p) => p.id === model?.providerId),
+        source = providers.find((p) => p.id === sourceModel.providerId);
+      if (!model || !provider || !source)
+        throw new AiConfigError("invalid_configuration", "Choose a replacement outside the deleted selection.");
+      validateAiReplacement(source, provider, sourceModel, model);
+      if (slot) validateAiSlot(slot, model);
+    };
+    const assignments = (await aiModelCatalog.assignments(db)).filter((a) => a.variantId && ids.includes(a.variantId));
+    for (const assignment of assignments) {
+      if (!Object.hasOwn(input.replacements, assignment.slot))
+        throw new AiConfigError("invalid_configuration", "Every affected assignment needs a replacement or an explicit empty choice.");
+      const replacement = input.replacements[assignment.slot];
+      const sourceModel = affectedModels.find((m) => m.id === affected.find((v) => v.id === assignment.variantId)?.modelId);
+      if (replacement && sourceModel) target(replacement, sourceModel, assignment.slot);
+    }
+    if (input.retarget && !input.retargetTo) throw new AiConfigError("invalid_configuration", "Retargeting requires a replacement.");
+    for (const assignment of assignments)
+      await db`UPDATE ai.model_assignments SET variant_id=${input.replacements[assignment.slot] ?? null},revision=revision+1,updated_by=${actorId}::uuid,updated_at=clock_timestamp() WHERE slot=${assignment.slot}`;
+    const projects = await db<
+      { id: string; short_id: string; name: string; default_model: { id: string } }[]
+    >`SELECT id,short_id,name,default_model FROM ai.projects WHERE default_model->>'id'=ANY(${pgIds}::text[]) FOR UPDATE`;
+    const workflows = await db<
+      {
+        id: string;
+        name: string;
+        created_by_kind: string;
+        created_by_id: string | null;
+        source: string;
+        plan: WorkflowBoundPlan;
+        effect_budget: Record<string, number>;
+      }[]
+    >`SELECT w.id,w.name,w.created_by_kind,w.created_by_id,v.source,v.plan,v.effect_budget FROM workflows.workflow w JOIN workflows.version v ON v.id=w.active_version_id WHERE EXISTS(SELECT 1 FROM jsonb_path_query(v.plan,'$.**.model.id') ref WHERE ref #>> '{}' = ANY(${pgIds}::text[])) FOR UPDATE OF w`;
+    if (input.retarget && input.retargetTo) {
+      const references = [
+        ...projects.map((project) => project.default_model.id),
+        ...workflows.flatMap((workflow) => referencedAiModels(workflow.plan)),
+      ];
+      for (const model of affectedModels.filter((model) =>
+        affected.some((variant) => variant.modelId === model.id && references.includes(variant.id)),
+      ))
+        target(input.retargetTo, model);
+    }
+    const scheduled = await db<
+      { sponsor_user_id: string; name: string }[]
+    >`SELECT task.sponsor_user_id,left(task.prompt,120) AS name FROM ai.chat_tasks task JOIN ai.conversations c ON c.id=task.conversation_id JOIN ai.projects p ON p.id=c.project_id WHERE p.default_model->>'id'=ANY(${pgIds}::text[])`;
+    for (const task of scheduled)
+      await db`INSERT INTO ai.model_change_notices(user_id,name,retargeted) VALUES(${task.sponsor_user_id}::uuid,${task.name},${input.retarget})`;
+    for (const project of projects) {
+      const owners = await db<
+        { id: string }[]
+      >`SELECT DISTINCT u.id FROM ai.project_access p JOIN auth.access a ON a.id=p.access_id JOIN auth.users u ON a.user_id=u.id OR a.authenticated_only OR a.group_id IN (${recursiveGroupIdsSubquery(db`u.id`)}) WHERE p.project_id=${project.id}::uuid AND a.permission='admin'`;
+      for (const owner of owners)
+        await db`INSERT INTO ai.model_change_notices(user_id,name,retargeted) VALUES(${owner.id}::uuid,${project.name},${input.retarget})`;
+      if (input.retarget)
+        await db`UPDATE ai.projects SET default_model=${JSON.stringify({ id: input.retargetTo })}::text::jsonb,revision=revision+1,updated_at=clock_timestamp() WHERE id=${project.id}::uuid`;
+    }
+    for (const workflow of workflows) {
+      if (workflow.created_by_kind === "user" && workflow.created_by_id)
+        await db`INSERT INTO ai.model_change_notices(user_id,name,retargeted) VALUES(${workflow.created_by_id}::uuid,${workflow.name},${input.retarget})`;
+      if (!input.retarget || !input.retargetTo) continue;
+      const activations = await db<
+        (WorkflowActivationInput & { event_type: string; authorization_snapshot: WorkflowJsonValue })[]
+      >`SELECT key,event_type,config,enabled,authorization_snapshot FROM workflows.activation WHERE workflow_id=${workflow.id}::uuid`;
+      const parsed: WorkflowJsonValue = z.json().parse(Bun.YAML.parse(workflow.source));
+      const source = Bun.YAML.stringify(retargetJson(parsed, ids, input.retargetTo));
+      const plan: WorkflowBoundPlan = {
+        ...workflow.plan,
+        sourceHash: await hashWorkflowSource(source),
+        steps: retargetSteps(workflow.plan.steps, ids, input.retargetTo),
+        bindings: Object.fromEntries(
+          Object.entries(workflow.plan.bindings).map(([key, value]) => [
+            key,
+            key === "model" &&
+            value !== null &&
+            !Array.isArray(value) &&
+            typeof value === "object" &&
+            typeof value.id === "string" &&
+            ids.includes(value.id)
+              ? { id: input.retargetTo! }
+              : retargetJson(value, ids, input.retargetTo!),
+          ]),
+        ),
+      };
+      await publishWorkflowVersion(
+        {
+          workflowId: workflow.id,
+          source,
+          plan,
+          effectBudget: workflow.effect_budget,
+          author: { kind: "user", id: actorId },
+          activations: activations.map((a) => ({ ...a, eventType: a.event_type })),
+        },
+        { db },
+      );
+      for (const activation of activations)
+        await db`UPDATE workflows.activation SET authorization_snapshot=${JSON.stringify(activation.authorization_snapshot)}::text::jsonb WHERE workflow_id=${workflow.id}::uuid AND key=${activation.key}`;
+    }
+    if (kind === "variant") await db`DELETE FROM ai.model_variants WHERE id=${id}`;
+    else if (kind === "model") await db`DELETE FROM ai.models WHERE id=${id}`;
+    else await db`DELETE FROM ai.providers WHERE id=${id}`;
+    if (kind !== "variant") {
+      const modelIds = affectedModels.map((m) => m.id);
+      const [config] = await db<{ rules: WorkflowJsonValue[] }[]>`SELECT rules FROM ai.cost_config WHERE singleton FOR UPDATE`;
+      const rules = (config?.rules ?? []).filter(
+        (rule) =>
+          rule === null ||
+          Array.isArray(rule) ||
+          typeof rule !== "object" ||
+          typeof rule.scope !== "string" ||
+          !modelIds.includes(rule.scope),
+      );
+      await db`UPDATE ai.cost_config SET rules=${JSON.stringify(rules)}::text::jsonb,revision=revision+1 WHERE singleton`;
+      await aiModelAccess.syncModels(
+        (await aiModelCatalog.models(db)).map((model) => model.id),
+        [],
+        db,
+      );
+    }
+    return { deleted: true };
+  });

package/src/ai/model-fixture.ts

@@ -0,0 +1,39 @@
+import type { AiModelAssignment, AiModelSlot } from "../shared/ai-models";
+import type { AiModelProfile, AiSettingsState } from "./types";
+
+/** Fixed snapshots for tests; production reads the catalog. */
+export const aiModelFixture = (overrides: Partial<AiModelProfile> = {}): AiModelProfile => ({
+  id: "chat",
+  modelId: "chat",
+  providerId: "provider",
+  label: "Chat",
+  variantLabel: "Standard",
+  description: "For everyday work",
+  icon: { kind: "provider" },
+  showInPicker: true,
+  provider: "ollama",
+  model: "chat",
+  enabled: true,
+  capabilities: ["tools"],
+  dataBoundary: "private",
+  ...overrides,
+});
+export const aiAssignmentFixture = (slot: AiModelSlot, variantId: string | null): AiModelAssignment => ({
+  slot,
+  variantId,
+  revision: 1,
+  updatedAt: "2026-10-16T00:00:00.000Z",
+  updatedBy: null,
+});
+export const aiSettingsFixture = (overrides: Partial<AiSettingsState> = {}): AiSettingsState => ({
+  ok: true,
+  enabled: true,
+  profiles: [aiModelFixture()],
+  assignments: [aiAssignmentFixture("balanced", "chat")],
+  globalInstructions: "",
+  localClientInstructions: "",
+  compactionInstructions: "",
+  maxToolResultChars: 2_000_000,
+  firecrawlConfigured: false,
+  ...overrides,
+});

package/src/ai/model-icon.tsx

@@ -0,0 +1,36 @@
+import type { JSX } from "solid-js";
+import { type AiModelIcon as AiModelIconSetting, type AiPeopleModelIcon, aiProviderMark } from "../shared/ai-models";
+
+/** The icon a person sees for a model: its emoji or image, else its provider's neutral mark. */
+export const aiModelDisplayIcon = (icon: AiModelIconSetting, provider: { id: string; label: string }): AiPeopleModelIcon =>
+  icon.kind === "image"
+    ? { kind: "image", src: icon.dataUrl }
+    : icon.kind === "emoji"
+      ? icon
+      : { kind: "mark", ...aiProviderMark(provider) };
+
+const sizes = { xs: "size-5 rounded-[5px] text-[9px]", sm: "size-7 rounded-md text-[10px]", md: "size-10 rounded-lg text-xs" } as const;
+
+/**
+ * A model's icon, the one mark that tells models apart in a chooser. It is decoration: the model's name always sits
+ * next to it, so it stays hidden from assistive technology.
+ */
+export function AiModelIcon(props: { icon: AiPeopleModelIcon; size?: keyof typeof sizes; class?: string }): JSX.Element {
+  const box = () =>
+    `inline-grid shrink-0 place-items-center overflow-hidden leading-none ${sizes[props.size ?? "xs"]} ${props.class ?? ""}`;
+  const icon = () => props.icon;
+  return (
+    <span class={box()} aria-hidden="true" data-ai-model-icon={icon().kind}>
+      {(() => {
+        const current = icon();
+        if (current.kind === "image") return <img src={current.src} alt="" class="size-full object-cover" />;
+        if (current.kind === "emoji") return <span class="text-[1.15em]">{current.emoji}</span>;
+        return (
+          <span class="grid size-full place-items-center font-semibold tracking-wide text-white" style={{ background: current.color }}>
+            {current.text}
+          </span>
+        );
+      })()}
+    </span>
+  );
+}

package/src/ai/model-overview.ts

@@ -0,0 +1,53 @@
+import { coreSettings } from "../services";
+import { AI_MODEL_CLASSES, type AiModelClass, type AiModelSlot, type AiProvider } from "../shared/ai-models";
+import { aiModelCatalog } from "./model-catalog";
+import { resolveAiModelRef } from "./settings";
+
+export type AiAdminOverview = {
+  enabled: boolean;
+  providers: (Pick<
+    AiProvider,
+    "id" | "type" | "label" | "enabled" | "status" | "statusCode" | "statusMessage" | "statusCheckedAt" | "logo" | "credentialSet"
+  > & {
+    modelCount: number;
+  })[];
+  assignments: Record<AiModelSlot, { variantId: string | null; revision: number; updatedAt: string; updatedBy: string | null }>;
+  effective: Record<AiModelClass, { class: AiModelClass | null; variantId: string | null }>;
+};
+
+/** What the AI area's first column and the class rows need, read once for the page and the API. */
+export const readAiAdminOverview = async (): Promise<AiAdminOverview> => {
+  const [enabled, providers, models, assignments] = await Promise.all([
+    coreSettings.get<boolean>("ai.enabled"),
+    aiModelCatalog.providers(),
+    aiModelCatalog.models(),
+    aiModelCatalog.assignments(),
+  ]);
+  return {
+    enabled,
+    providers: providers.map((p) => ({
+      id: p.id,
+      type: p.type,
+      label: p.label,
+      enabled: p.enabled,
+      status: p.status,
+      statusCode: p.statusCode,
+      statusMessage: p.statusMessage,
+      statusCheckedAt: p.statusCheckedAt,
+      credentialSet: p.credentialSet,
+      modelCount: models.filter((m) => m.providerId === p.id).length,
+      logo: p.logo,
+    })),
+    assignments: Object.fromEntries(assignments.map(({ slot, ...assignment }) => [slot, assignment])) as AiAdminOverview["assignments"],
+    effective: Object.fromEntries(
+      AI_MODEL_CLASSES.map((modelClass) => {
+        try {
+          const ref = resolveAiModelRef({ enabled: true, assignments }, { class: modelClass });
+          return [modelClass, { class: ref.class ?? null, variantId: ref.id }];
+        } catch {
+          return [modelClass, { class: null, variantId: null }];
+        }
+      }),
+    ) as AiAdminOverview["effective"],
+  };
+};

package/src/ai/model-usage.ts

@@ -0,0 +1,45 @@
+import { sql } from "bun";
+import { toPgTextArray } from "../services/postgres";
+import type { AiModelUsage } from "../shared/ai-models";
+import { aiModelCatalog } from "./model-catalog";
+import { aiPeopleAtLimit } from "./quota-limits";
+import { aiQuotas } from "./quotas";
+
+export const aiModelUsage = async (variantIds: string[], modelIds: string[], db = sql): Promise<AiModelUsage> => {
+  const ids = toPgTextArray(variantIds);
+  const [assignments, projects, workflows, scheduledTasks, counts, stats, config, people] = await Promise.all([
+    aiModelCatalog.assignments(db),
+    db<
+      { id: string; name: string }[]
+    >`SELECT short_id AS id,name FROM ai.projects WHERE default_model->>'id'=ANY(${ids}::text[]) ORDER BY name,id`,
+    db<
+      { id: string; name: string }[]
+    >`SELECT w.id,w.name FROM workflows.workflow w JOIN workflows.version v ON v.id=w.active_version_id WHERE EXISTS (SELECT 1 FROM jsonb_path_query(v.plan,'$.**.model.id') ref WHERE ref #>> '{}' = ANY(${ids}::text[])) ORDER BY w.name,w.id`,
+    db<
+      { id: string; name: string }[]
+    >`SELECT task.short_id AS id,left(task.prompt,120) AS name FROM ai.chat_tasks task JOIN ai.conversations c ON c.id=task.conversation_id LEFT JOIN ai.projects p ON p.id=c.project_id WHERE p.default_model->>'id'=ANY(${ids}::text[]) ORDER BY task.id`,
+    db<{ chats: number }[]>`SELECT count(DISTINCT conversation_id)::int AS chats FROM ai.turns WHERE model_profile_id=ANY(${ids}::text[])`,
+    db<AiModelUsage["stats"][]>`WITH answers AS (
+      SELECT COALESCE(turn_id,id) AS answer, CASE WHEN bool_and(cost IS NOT NULL) THEN sum(cost) END AS cost,
+        extract(epoch FROM max(finished_at)-min(started_at)) AS seconds
+      FROM ai.inference_calls WHERE model_profile_id=ANY(${ids}::text[]) AND started_at>=now()-interval '14 days'
+        AND kind='chat' AND status='ok' GROUP BY COALESCE(turn_id,id)
+    ) SELECT count(*)::int AS "answers14d", CASE WHEN count(*)>=20 THEN avg(cost)::float8 END AS "avgCostPerAnswer", CASE WHEN count(*)>=20 THEN avg(seconds)::float8 END AS "avgSecondsPerAnswer" FROM answers`,
+    aiQuotas.config(db),
+    // Count exhausted people per rule, then deduplicate global and model scopes.
+    aiPeopleAtLimit(db),
+  ]);
+  return {
+    assignments: assignments
+      .filter((assignment) => assignment.variantId && variantIds.includes(assignment.variantId))
+      .map((assignment) => assignment.slot),
+    projects,
+    workflows,
+    scheduledTasks,
+    chats: counts[0]?.chats ?? 0,
+    budgetRules: config.rules.filter((rule) => modelIds.includes(rule.scope)).map((rule) => ({ id: rule.scope, label: rule.scope })),
+    peopleAtLimit: new Set(people.filter((rule) => rule.scope === "*" || modelIds.includes(rule.scope)).flatMap((rule) => rule.people))
+      .size,
+    stats: stats[0] ?? { answers14d: 0, avgCostPerAnswer: null, avgSecondsPerAnswer: null },
+  };
+};

package/src/ai/openai-api-messages.ts

@@ -14,8 +14,6 @@ const catalog = i18n.define({
       context_length_exceeded: "Your messages exceed this model's context window. Shorten them and try again.",
       request_too_large: "The request body exceeds the limit derived from your available models' context windows.",
       ai_disabled: "AI is turned off. Contact an administrator.",
-      model_access_denied: "You do not have access to this model. Contact an administrator.",
-      missing_provider_credential: "This model's provider is not configured. Contact an administrator.",
       insufficient_quota:
         "Your Assistant usage limit is reached, or your usage could not be measured. Wait for the reset or contact an administrator.",
       too_many_concurrent_requests: "You have too many simultaneous requests. Wait for a request to finish and try again.",
@@ -35,8 +33,6 @@ const catalog = i18n.define({
       context_length_exceeded: "Deine Nachrichten überschreiten das Kontextfenster dieses Modells. Kürze sie und versuche es erneut.",
       request_too_large: "Deine Anfrage überschreitet die aus den Kontextfenstern deiner verfügbaren Modelle abgeleitete Größenbegrenzung.",
       ai_disabled: "KI ist ausgeschaltet. Wende dich an einen Administrator.",
-      model_access_denied: "Dieses Modell ist nicht für dich freigegeben. Wende dich an einen Administrator.",
-      missing_provider_credential: "Der Anbieter dieses Modells ist nicht eingerichtet. Wende dich an einen Administrator.",
       insufficient_quota:
         "Dein Nutzungslimit im Assistenten ist erreicht, oder deine Nutzung konnte nicht gemessen werden. Warte auf das Zurücksetzen oder wende dich an einen Administrator.",
       too_many_concurrent_requests: "Du hast zu viele gleichzeitige Anfragen. Warte, bis eine Anfrage beendet ist, und versuche es erneut.",

package/src/ai/openai-api.ts

@@ -9,8 +9,10 @@ import { type AuthContext, getLocale, rateLimit } from "../server";
 import { REQUEST_IDLE_TIMEOUT_SECONDS, setRequestTimeout } from "../server/request-timeout";
 import { authenticateModelsOnlyCredential } from "../services/identity/models-only-auth";
 import { coreSettings } from "../services/settings/api";
+import { AI_MODEL_CLASSES, AiModelRequestSchema } from "../shared/ai-models";
 import { listAssistantAiModels } from "./assistant-models";
 import { aiModelAccess } from "./model-access";
+import { aiModelCatalog } from "./model-catalog";
 import { type OpenAiErrorCode, openAiApiMessages } from "./openai-api-messages";
 import { acquire } from "./openai-api-slots";
 import { personalAiModelPolicy } from "./personal-agent";
@@ -78,6 +80,7 @@ type Dependencies = {
   settings?: Pick<typeof coreSettings, "get">;
   authenticate?: typeof authenticateModelsOnlyCredential;
   listModels?: typeof listAssistantAiModels;
+  assignments?: typeof aiModelCatalog.assignments;
   resolveModel?: typeof resolveAiModel;
   assertModelAccess?: typeof aiModelAccess.assertAllowed;
   acquire?: typeof acquire;
@@ -89,6 +92,7 @@ export const createAiOpenAiRoutes = (dependencies: Dependencies = {}) => {
   const settings = dependencies.settings ?? coreSettings;
   const authenticate = dependencies.authenticate ?? authenticateModelsOnlyCredential;
   const listModels = dependencies.listModels ?? listAssistantAiModels;
+  const assignments = dependencies.assignments ?? (() => aiModelCatalog.assignments());
   const resolveModel = dependencies.resolveModel ?? resolveAiModel;
   const assertModelAccess = dependencies.assertModelAccess ?? aiModelAccess.assertAllowed;
   const acquireSlot = dependencies.acquire ?? acquire;
@@ -103,9 +107,8 @@ export const createAiOpenAiRoutes = (dependencies: Dependencies = {}) => {
       const parsed = z.object({ code: z.string() }).safeParse(error.aiError);
       if (parsed.success) {
         if (parsed.data.code === "ai_disabled") return errorResponse(c, 403, "ai_disabled", "permission_error");
-        if (parsed.data.code === "model_access_denied") return errorResponse(c, 403, "model_access_denied", "permission_error", "model");
-        if (parsed.data.code === "model_policy_mismatch") return errorResponse(c, 404, "model_not_found", "invalid_request_error", "model");
-        if (parsed.data.code === "missing_provider_credential") return errorResponse(c, 502, "missing_provider_credential", "api_error");
+        if (parsed.data.code === "model_policy_mismatch" || parsed.data.code === "ai_no_model")
+          return errorResponse(c, 404, "model_not_found", "invalid_request_error", "model");
       }
     }
     return errorResponse(c, 500, "internal_error", "api_error");
@@ -136,9 +139,16 @@ export const createAiOpenAiRoutes = (dependencies: Dependencies = {}) => {
         const models = await listModels(c.get("accessSubject"));
         return c.json({
           object: "list",
-          data: models
-            .filter((model) => !model.capabilities.includes("transcription"))
-            .map((model) => ({ id: model.id, object: "model", created: 0, owned_by: "cloud" })),
+          data: [
+            ...models.filter((model) => !model.capabilities.includes("transcription")).map((model) => model.id),
+            ...(await assignments()).flatMap((assignment) =>
+              AI_MODEL_CLASSES.some((cls) => cls === assignment.slot) &&
+              assignment.variantId &&
+              models.some((model) => model.id === assignment.variantId)
+                ? [`cloud/${assignment.slot}`]
+                : [],
+            ),
+          ].map((id) => ({ id, object: "model", created: 0, owned_by: "cloud" })),
         });
       },
     )
@@ -204,9 +214,15 @@ export const createAiOpenAiRoutes = (dependencies: Dependencies = {}) => {
             else if (message.role === "user") messages.push({ role: "user", content: [text] });
             else messages.push({ role: "assistant", content: [{ type: "text", text }] });
           }
-          if (!models.some((model) => model.id === data.model))
+          if (
+            !models.some((model) => model.id === data.model) &&
+            !(data.model.startsWith("cloud/") && AI_MODEL_CLASSES.some((cls) => `cloud/${cls}` === data.model))
+          )
             return errorResponse(c, 404, "model_not_found", "invalid_request_error", "model");
-          const resolved = await resolveModel(personalAiModelPolicy, data.model);
+          const resolved = await resolveModel(
+            personalAiModelPolicy,
+            AiModelRequestSchema.parse(data.model.startsWith("cloud/") ? { class: data.model.slice(6) } : { id: data.model }),
+          );
           const systemPrompt = system.join("\n\n");
           const inputTokens = estimateTokens(messages) + Math.ceil(systemPrompt.length / 4);
           if (resolved.provider.contextWindow !== undefined && inputTokens > resolved.provider.contextWindow)
@@ -248,7 +264,7 @@ export const createAiOpenAiRoutes = (dependencies: Dependencies = {}) => {
                 JSON.stringify(current.subject) !== JSON.stringify(subject)
               )
                 throw new ModelsCredentialRevoked();
-              await assertModelAccess(resolved.profile.id, subject);
+              await assertModelAccess(resolved.profile.modelId, subject);
             } catch (error) {
               if (error instanceof ModelsCredentialRevoked) throw error;
               if (error instanceof Error && "aiError" in error)
@@ -271,6 +287,7 @@ export const createAiOpenAiRoutes = (dependencies: Dependencies = {}) => {
           };
           const provider: Provider = wrapProvider(guarded, resolved.profile, {
             kind: "chat",
+            modelRef: resolved.model,
             task: "openai-api",
             subject,
             credentialId: credential.credentialId,

package/src/ai/personal-agent.ts

@@ -2,5 +2,5 @@ import type { AiModelPolicy } from "./types";
 
 export const personalAiModelPolicy: AiModelPolicy = {
   kind: "selectable",
-  requiredCapabilities: ["streaming", "tools"],
+  requiredCapabilities: ["tools"],
 };

package/src/ai/prefs.ts

@@ -1,5 +1,6 @@
 import { sql } from "bun";
 import type { RequestActor } from "../server";
+import { type AiModelRequest, AiModelRequestSchema } from "../shared/ai-models";
 
 /**
  * Learning from private chats applies to everyone who has not chosen.
@@ -12,8 +13,8 @@ export type AiUserPrefs = {
   memoryEnabled: boolean;
   /** Effective setting: the user's explicit choice, otherwise the default. */
   memoryLearningEnabled: boolean;
-  /** Model profile id of the user's most recent chat turn — preselected for new chats. */
-  lastModelId: string;
+  /** Class or explicit variant choice, preselected for new chats. */
+  selection: AiModelRequest | null;
   updatedAt: string;
 };
 
@@ -21,7 +22,7 @@ type PrefsRow = {
   user_id: string;
   memory_enabled: boolean;
   memory_learning_enabled: boolean | null;
-  last_model_id: string | null;
+  model_choice: unknown;
   updated_at: string | Date;
 };
 
@@ -29,7 +30,7 @@ const toPrefs = (row: PrefsRow): AiUserPrefs => ({
   userId: row.user_id,
   memoryEnabled: row.memory_enabled,
   memoryLearningEnabled: row.memory_learning_enabled ?? AI_MEMORY_LEARNING_DEFAULT_ENABLED,
-  lastModelId: row.last_model_id ?? "",
+  selection: row.model_choice ? AiModelRequestSchema.parse(row.model_choice) : null,
   updatedAt: new Date(row.updated_at).toISOString(),
 });
 
@@ -37,7 +38,7 @@ const emptyPrefs = (userId: string): AiUserPrefs => ({
   userId,
   memoryEnabled: true,
   memoryLearningEnabled: AI_MEMORY_LEARNING_DEFAULT_ENABLED,
-  lastModelId: "",
+  selection: null,
   updatedAt: new Date(0).toISOString(),
 });
 
@@ -59,25 +60,26 @@ export const aiUserPrefs = {
 
   async update(
     userId: string,
-    patch: { memoryEnabled?: boolean; memoryLearningEnabled?: boolean; lastModelId?: string },
+    patch: { memoryEnabled?: boolean; memoryLearningEnabled?: boolean; selection?: AiModelRequest | null },
   ): Promise<AiUserPrefs> {
     const memoryEnabled = patch.memoryEnabled ?? null;
     const memoryLearningEnabled = patch.memoryLearningEnabled ?? null;
     // Records when the person last saved the learning switch, so a stored "off"
     // from an earlier release stays distinguishable from a choice made since.
     const learningChosen = memoryLearningEnabled !== null;
-    const lastModelId = patch.lastModelId?.trim().slice(0, 200) ?? null;
+    const choiceChanged = Object.hasOwn(patch, "selection");
+    const modelChoice = patch.selection ? JSON.stringify(AiModelRequestSchema.parse(patch.selection)) : null;
     const rows = (await sql`
-      INSERT INTO ai.user_prefs (user_id, memory_enabled, memory_learning_enabled, memory_learning_chosen_at, last_model_id, updated_at)
+      INSERT INTO ai.user_prefs (user_id, memory_enabled, memory_learning_enabled, memory_learning_chosen_at, model_choice, updated_at)
       VALUES (
         ${userId}, ${memoryEnabled ?? true}, ${memoryLearningEnabled},
-        CASE WHEN ${learningChosen}::boolean THEN now() END, ${lastModelId ?? ""}, now()
+        CASE WHEN ${learningChosen}::boolean THEN now() END, ${modelChoice}::text::jsonb, now()
       )
       ON CONFLICT (user_id) DO UPDATE SET
         memory_enabled = COALESCE(${memoryEnabled}, ai.user_prefs.memory_enabled),
         memory_learning_enabled = COALESCE(${memoryLearningEnabled}, ai.user_prefs.memory_learning_enabled),
         memory_learning_chosen_at = CASE WHEN ${learningChosen}::boolean THEN now() ELSE ai.user_prefs.memory_learning_chosen_at END,
-        last_model_id = COALESCE(${lastModelId}, ai.user_prefs.last_model_id),
+        model_choice = CASE WHEN ${choiceChanged} THEN ${modelChoice}::text::jsonb ELSE ai.user_prefs.model_choice END,
         updated_at = now()
       RETURNING *
     `) as PrefsRow[];

package/src/ai/projects-routes.ts

@@ -6,6 +6,7 @@ import { AuthenticatedPrincipalSchema } from "../contracts/shared";
 import { type AuthContext, auth, err, fail, getLocale, ok, rateLimit, respond, v } from "../server";
 import { noTransform } from "../server/middleware/no-transform";
 import { ImageMetadataError } from "../services/image-metadata";
+import { AiModelRequestSchema } from "../shared/ai-models";
 import { aiChatMessages } from "./chat/messages";
 import { decodeAiFileContent } from "./files-store";
 import {
@@ -27,7 +28,7 @@ const ProjectFieldsSchema = z.object({
   description: z.string().trim().max(AI_PROJECT_DESCRIPTION_MAX_CHARS).default(""),
   icon: z.string().trim().min(1).max(80).default("ti ti-folders"),
   instructions: z.string().trim().max(AI_PROJECT_INSTRUCTIONS_MAX_CHARS).default(""),
-  defaultModelProfileId: z.string().trim().min(1).max(120).nullable().optional(),
+  defaultModel: AiModelRequestSchema.nullable().optional(),
 });
 
 const UpdateProjectSchema = ProjectFieldsSchema.partial().refine((input) => Object.keys(input).length > 0, "No changes supplied.");