@k2b/cloud 0.42.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-slots.ts

@@ -1,4 +1,5 @@
 import { redis } from "bun";
+import type { AccessSubject } from "../server/services/access";
 import { logger } from "../services/logging";
 
 const LEASE_MS = 120_000;
@@ -20,8 +21,15 @@ const SLOT_SCRIPT = `
   return 1
 `;
 
-export const acquire = async ({ userId, limit }: { userId: string; limit: number }): Promise<{ release(): Promise<void> } | null> => {
-  const key = `cloud:ai:openai-api:slots:${userId}`;
+export const acquire = async ({
+  subject,
+  limit,
+}: {
+  subject: AccessSubject;
+  limit: number;
+}): Promise<{ release(): Promise<void> } | null> => {
+  const principal = subject.type === "user" ? `user:${subject.userId}` : `service_account:${subject.serviceAccountId}`;
+  const key = `cloud:ai:openai-api:slots:${principal}`;
   const slot = crypto.randomUUID();
   const granted = await redis.send("EVAL", [SLOT_SCRIPT, "1", key, slot, String(LEASE_MS), String(limit)]);
   if (granted !== 1) return null;

package/src/ai/openai-api.ts

@@ -9,12 +9,15 @@ 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";
 import { PROVIDER_TIMEOUTS } from "./provider";
-import { inferenceProvider } from "./quota-provider";
+import { AiProviderAdmissionError, inferenceProvider } from "./quota-provider";
 import { AiQuotaError } from "./quotas";
 import { resolveAiModel } from "./settings";
 
@@ -70,12 +73,16 @@ const usageBody = (usage: Usage) => ({
   total_tokens: usage.input + usage.output,
 });
 
+class ModelsCredentialRevoked extends AiProviderAdmissionError {}
+
 type Dependencies = {
   limit?: MiddlewareHandler<AuthContext>;
   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;
   inferenceProvider?: typeof inferenceProvider;
   keepaliveMs?: number;
@@ -85,21 +92,23 @@ 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;
   const wrapProvider = dependencies.inferenceProvider ?? inferenceProvider;
   const limit = dependencies.limit ?? rateLimit();
   const app = new Hono<AuthContext>();
   app.onError((error, c) => {
+    if (error instanceof ModelsCredentialRevoked) return errorResponse(c, 401, "invalid_api_key", "authentication_error");
     if (error instanceof AiQuotaError && error.code !== "quota_conflict")
       return errorResponse(c, 429, "insufficient_quota", "insufficient_quota");
     if (error instanceof Error && "aiError" in error) {
       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");
@@ -115,8 +124,7 @@ export const createAiOpenAiRoutes = (dependencies: Dependencies = {}) => {
       const token = c.req.header("Authorization")?.match(/^Bearer\s+(\S+)$/i)?.[1];
       const credential = await authenticate(token);
       if (!credential) return errorResponse(c, 401, "invalid_api_key", "authentication_error");
-      c.set("user", credential.user);
-      c.set("accessSubject", { type: "user", userId: credential.user.id });
+      c.set("accessSubject", credential.subject);
       c.header("Cache-Control", "no-store");
       await next();
     })
@@ -125,15 +133,22 @@ export const createAiOpenAiRoutes = (dependencies: Dependencies = {}) => {
       describeRoute({
         tags: ["AI"],
         summary: "List OpenAI-compatible models",
-        description: "Models-only OpenAI-compatible surface: lists the Assistant chat models this person may use.",
+        description: "Models-only OpenAI-compatible surface: lists the Assistant chat models this account may use.",
       }),
       async (c) => {
         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" })),
         });
       },
     )
@@ -150,7 +165,7 @@ export const createAiOpenAiRoutes = (dependencies: Dependencies = {}) => {
         const models = (await listModels(subject)).filter((model) => !model.capabilities.includes("transcription"));
         if (models.length === 0) return errorResponse(c, 404, "model_not_found", "invalid_request_error", "model");
         const slot = await acquireSlot({
-          userId: c.get("user").id,
+          subject,
           limit: await settings.get<number>("ai.openai_api_max_concurrent_requests"),
         });
         if (!slot) {
@@ -199,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)
@@ -230,7 +251,47 @@ export const createAiOpenAiRoutes = (dependencies: Dependencies = {}) => {
                     ? { generationConfig: { topP: data.top_p } }
                     : { top_p: data.top_p },
           };
-          const provider: Provider = wrapProvider(resolved.provider, resolved.profile, { kind: "chat", task: "openai-api", subject });
+          const token = c.req.header("Authorization")?.match(/^Bearer\s+(\S+)$/i)?.[1];
+          const credential = await authenticate(token);
+          if (!credential) throw new ModelsCredentialRevoked();
+          // Runs inside quota accounting, after admission and immediately before provider dispatch.
+          const admit = async () => {
+            try {
+              const current = await authenticate(token);
+              if (
+                !current ||
+                current.credentialId !== credential.credentialId ||
+                JSON.stringify(current.subject) !== JSON.stringify(subject)
+              )
+                throw new ModelsCredentialRevoked();
+              await assertModelAccess(resolved.profile.modelId, subject);
+            } catch (error) {
+              if (error instanceof ModelsCredentialRevoked) throw error;
+              if (error instanceof Error && "aiError" in error)
+                throw Object.assign(new AiProviderAdmissionError(error.message), { aiError: error.aiError });
+              throw new AiProviderAdmissionError("Model admission could not be checked");
+            }
+          };
+          const guarded: Provider = {
+            ...resolved.provider,
+            complete: async (request) => {
+              await admit();
+              if (request.signal?.aborted) throw new AiProviderAdmissionError("Request cancelled before dispatch");
+              return resolved.provider.complete(request);
+            },
+            stream: async function* (request) {
+              await admit();
+              if (request.signal?.aborted) throw new AiProviderAdmissionError("Request cancelled before dispatch");
+              yield* resolved.provider.stream(request);
+            },
+          };
+          const provider: Provider = wrapProvider(guarded, resolved.profile, {
+            kind: "chat",
+            modelRef: resolved.model,
+            task: "openai-api",
+            subject,
+            credentialId: credential.credentialId,
+          });
           const id = `chatcmpl-${crypto.randomUUID()}`;
           const created = Math.floor(Date.now() / 1000);
           let events: AsyncIterator<StreamEvent> | undefined;
@@ -284,7 +345,12 @@ export const createAiOpenAiRoutes = (dependencies: Dependencies = {}) => {
                 await events.return?.();
               }
             } catch (error) {
-              if (error instanceof AiQuotaError) throw error;
+              if (
+                error instanceof AiQuotaError ||
+                error instanceof ModelsCredentialRevoked ||
+                (error instanceof Error && "aiError" in error)
+              )
+                throw error;
               return errorResponse(c, 502, "upstream_error", "api_error");
             } finally {
               controller.abort();
@@ -312,7 +378,8 @@ export const createAiOpenAiRoutes = (dependencies: Dependencies = {}) => {
             } finally {
               controller.abort();
             }
-            if (error instanceof AiQuotaError) throw error;
+            if (error instanceof AiQuotaError || error instanceof ModelsCredentialRevoked || (error instanceof Error && "aiError" in error))
+              throw error;
             return errorResponse(c, 502, "upstream_error", "api_error");
           }
           const streamEvents = events;

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"],
 };