@k2b/cloud 0.43.0 → 0.44.0

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 });