@k2b/cloud 0.25.0 → 0.27.0

package/src/ai/files-store.ts

@@ -31,6 +31,13 @@ type FileRow = {
 type FileContentRow = FileRow & { bytes: Uint8Array };
 export type AiFileContent = AiFileStat & { bytes: Uint8Array };
 
+/** `LIKE` pattern for every path below a folder; the folder name itself matches literally. */
+const pathsBelow = (folder: string): string => `${folder.endsWith("/") ? folder : `${folder}/`}`.replace(/[\\%_]/gu, "\\$&") + "%";
+
+/** Working files of a conversation live below this folder; the assistant keeps intermediate steps there. */
+export const AI_WORKING_FILES_FOLDER = "/temp/";
+export const isAiWorkingFilePath = (path: string): boolean => path.startsWith(AI_WORKING_FILES_FOLDER);
+
 const iso = (value: Date | string): string => (value instanceof Date ? value.toISOString() : new Date(value).toISOString());
 
 const toStat = (row: FileRow): AiFileStat => ({
@@ -246,7 +253,7 @@ export const aiFileStore = {
     if (input.limit !== undefined && (!Number.isInteger(input.limit) || input.limit < 1 || input.limit > 1000))
       throw new Error("Invalid file page limit");
     const prefix = input.prefix ?? "/";
-    const pattern = `${prefix.endsWith("/") ? prefix : `${prefix}/`}%`;
+    const pattern = pathsBelow(prefix);
     const rows = await sql<FileRow[]>`
       SELECT path, size, media_type, origin, dictation_recorded_at, updated_at, version
       FROM ai.files
@@ -467,20 +474,17 @@ export const aiFileStore = {
     return sql.begin(async (tx) => {
       await tx`SELECT id FROM ai.conversations WHERE id = ${input.conversationId} FOR UPDATE`;
       const path = await storedAiFilePath(tx, input.conversationId, input.path);
-      if (input.recursive) {
-        const pattern = `${path.endsWith("/") ? path : `${path}/`}%`;
-        const rows = await tx<{ id: string }[]>`
-          DELETE FROM ai.files
-          WHERE conversation_id = ${input.conversationId} AND (path = ${path} OR path LIKE ${pattern})
-          RETURNING id
-        `;
-        return rows.length;
-      }
+      const pattern = input.recursive ? pathsBelow(path) : null;
       const rows = await tx<{ id: string }[]>`
         DELETE FROM ai.files
-        WHERE conversation_id = ${input.conversationId} AND path = ${path}
+        WHERE conversation_id = ${input.conversationId} AND (path = ${path} OR path LIKE ${pattern})
         RETURNING id
       `;
+      // A result is the file it delivered. Once that file is gone, another file at the same path is not that result.
+      await tx`
+        DELETE FROM ai.conversation_sources
+        WHERE conversation_id = ${input.conversationId} AND kind = 'result' AND (source_key = ${path} OR source_key LIKE ${pattern})
+      `;
       return rows.length;
     });
   },
@@ -498,6 +502,19 @@ export const aiFileStore = {
       `;
       if (target[0]) return "conflict" as const;
       await tx`UPDATE ai.files SET path = ${input.to}, updated_at = now(), version = version + 1 WHERE id = ${source[0].id}::uuid`;
+      // A delivered result is the file, not its old name. A result row left at the new name belonged to a file that
+      // is gone and must not attach to this one; the moved file's own delivery, if any, moves there.
+      await tx`
+        DELETE FROM ai.conversation_sources
+        WHERE conversation_id = ${input.conversationId} AND kind = 'result' AND source_key = ${input.to}
+      `;
+      // A title that was only the old file name follows the new one; a title the assistant chose stays.
+      await tx`
+        UPDATE ai.conversation_sources
+        SET source_key = ${input.to},
+            title = CASE WHEN title = ${from.slice(from.lastIndexOf("/") + 1)} THEN ${input.to.slice(input.to.lastIndexOf("/") + 1)} ELSE title END
+        WHERE conversation_id = ${input.conversationId} AND kind = 'result' AND source_key = ${from}
+      `;
       return "renamed" as const;
     });
   },
@@ -534,6 +551,112 @@ export const aiFileStore = {
   },
 };
 
+export type AiConversationWorkingGroup = {
+  /** The first folder below `/temp/`; null for files directly in `/temp/`. */
+  folder: string | null;
+  count: number;
+  bytes: number;
+  updatedAt: string;
+  /** Number of files per media type. */
+  mediaTypes: Record<string, number>;
+};
+
+export type AiConversationFileOverview = {
+  /** Uploads and other files outside `/temp/`, newest first. */
+  files: AiFileStat[];
+  fileCount: number;
+  /** Working files below `/temp/`, one group per first subfolder, most recently changed first. */
+  groups: AiConversationWorkingGroup[];
+  groupCount: number;
+  /** Working files directly in `/temp/`, outside any group folder, newest first. */
+  looseWorkingFiles: AiFileStat[];
+  workingCount: number;
+  workingBytes: number;
+  /** Storage the conversation uses against its limit, dictation recordings included. */
+  usedBytes: number;
+  maxBytes: number;
+};
+
+/**
+ * A bounded view of a conversation's files for interfaces: files outside the working folder by name, working files
+ * as groups with counts. Load the files of a group with `listAiConversationFiles` and its folder as prefix.
+ * Authorized services may expose this after resolving the conversation owner.
+ */
+export const loadAiConversationFileOverview = async (
+  conversationId: string,
+  limits: { files: number; groups: number; looseWorkingFiles: number } = { files: 500, groups: 200, looseWorkingFiles: 100 },
+): Promise<AiConversationFileOverview> => {
+  const working = pathsBelow(AI_WORKING_FILES_FOLDER);
+  const [files, [counts], groups, looseWorkingFiles, usedBytes] = await Promise.all([
+    sql<FileRow[]>`
+      SELECT path, size, media_type, origin, dictation_recorded_at, updated_at, version
+      FROM ai.files
+      WHERE conversation_id = ${conversationId} AND path NOT LIKE ${working}
+      ORDER BY updated_at DESC, path ASC
+      LIMIT ${limits.files}
+    `,
+    sql<{ files: number | string; working: number | string; working_bytes: number | string }[]>`
+      SELECT count(*) FILTER (WHERE path NOT LIKE ${working}) AS files,
+             count(*) FILTER (WHERE path LIKE ${working}) AS working,
+             COALESCE(sum(size) FILTER (WHERE path LIKE ${working}), 0) AS working_bytes
+      FROM ai.files
+      WHERE conversation_id = ${conversationId}
+    `,
+    sql<
+      {
+        folder: string | null;
+        count: number | string;
+        bytes: number | string;
+        updated_at: Date | string;
+        media_types: Record<string, number | string>;
+        group_count: number | string;
+      }[]
+    >`
+      WITH working AS (
+        SELECT CASE WHEN path ~ '^/temp/[^/]+/' THEN split_part(path, '/', 3) END AS folder, media_type, size, updated_at
+        FROM ai.files
+        WHERE conversation_id = ${conversationId} AND path LIKE ${working}
+      ),
+      by_type AS (
+        SELECT folder, media_type, count(*) AS files, sum(size) AS bytes, max(updated_at) AS updated_at
+        FROM working
+        GROUP BY folder, media_type
+      )
+      SELECT folder, sum(files) AS count, sum(bytes) AS bytes, max(updated_at) AS updated_at,
+             jsonb_object_agg(media_type, files) AS media_types, count(*) OVER () AS group_count
+      FROM by_type
+      GROUP BY folder
+      ORDER BY max(updated_at) DESC, folder ASC NULLS LAST
+      LIMIT ${limits.groups}
+    `,
+    sql<FileRow[]>`
+      SELECT path, size, media_type, origin, dictation_recorded_at, updated_at, version
+      FROM ai.files
+      WHERE conversation_id = ${conversationId} AND path LIKE ${working} AND path !~ '^/temp/[^/]+/'
+      ORDER BY updated_at DESC, path ASC
+      LIMIT ${limits.looseWorkingFiles}
+    `,
+    aiConversationStoredBytes(sql, conversationId),
+  ]);
+  return {
+    files: files.map(toStat),
+    fileCount: Number(counts?.files ?? 0),
+    groups: groups.map((group) => ({
+      folder: group.folder,
+      count: Number(group.count),
+      bytes: Number(group.bytes),
+      updatedAt: iso(group.updated_at),
+      mediaTypes: Object.fromEntries(Object.entries(group.media_types).map(([type, count]) => [type, Number(count)])),
+    })),
+    groupCount: Number(groups[0]?.group_count ?? 0),
+    looseWorkingFiles: looseWorkingFiles.map(toStat),
+    workingCount: Number(counts?.working ?? 0),
+    workingBytes: Number(counts?.working_bytes ?? 0),
+    usedBytes,
+    maxBytes: AI_FILES_MAX_CONVERSATION_BYTES_DEFAULT,
+  };
+};
+
 /** Authorized services may expose this read after resolving the conversation owner. */
 export const listAiConversationFiles = (
   conversationId: string,

package/src/ai/grids-skill.ts

@@ -153,6 +153,6 @@ A left join preserves unmatched readable source records. A relation with many ta
 
 ## Read stored document files
 
-For download links, use the downloadUrl returned by document.list/read/create verbatim; each artifacts[] entry carries its own downloadUrl. Every format (PDF, CSV, JSON, XML, renderer artifacts) uses the same links. They require the user's current Cloud session and are not a public share. Studio/code tools needing file bytes use document.content.read plus capabilities.streams.read; do not fetch invented paths.
+For download links, use the downloadUrl returned by document.list/read/create verbatim; each artifacts[] entry carries its own downloadUrl. Every format (PDF, CSV, JSON, XML, renderer artifacts) uses the same links. They require the user's current Cloud session and are not a public share. Studio/code tools needing file bytes use document.content.read plus cloud.capabilities.streams.read; do not fetch invented paths.
 
-Use \`grids.document.read\` for metadata and available artifact keys. When the task needs actual PDF, XML or CSV bytes, use \`grids.document.content.read\` with the document ID and optional artifactKey; omission selects the primary artifact. In code mode, obtain the stream via capabilities.run in the current run and pass it to capabilities.streams.read to receive a File. Read XML/CSV as text or use an available PDF processor. A binary download alone does not extract PDF text or prove that you inspected its contents. Prefer GQL for structured data analysis. This is a read, not document issuance, a public share or sending a file. Respect the 50 MiB code-mode payload budget and 250 MiB total transfer budget; larger stored artifacts require a supported HTTP/CLI transfer. Streams expire, require current permissions and cannot be reused across turns or in mandate-backed background tasks. Never invent stream references or export capabilities.`;
+Use \`grids.document.read\` for metadata and available artifact keys. When the task needs actual PDF, XML or CSV bytes, use \`grids.document.content.read\` with the document ID and optional artifactKey; omission selects the primary artifact. In code mode, obtain the stream via cloud.capabilities.run in the current run and pass it to cloud.capabilities.streams.read to receive a File. Read XML/CSV as text or use an available PDF processor. A binary download alone does not extract PDF text or prove that you inspected its contents. Prefer GQL for structured data analysis. This is a read, not document issuance, a public share or sending a file. Respect the 50 MiB code-mode payload budget and 250 MiB total transfer budget; larger stored artifacts require a supported HTTP/CLI transfer. Streams expire, require current permissions and cannot be reused across turns or in mandate-backed background tasks. Never invent stream references or export capabilities.`;

package/src/ai/index.ts

@@ -75,14 +75,20 @@ export {
   shouldApplyEnrichedTitle,
 } from "./enrich";
 export { AiFileVersionConflict, AiFileWriteError, aiFileContentVersion } from "./file-content-version";
+export { aiConversationFileManifest } from "./file-context";
 export { AiFileLocation, AiFileReference } from "./file-reference-contracts";
 export {
   AI_FILES_MAX_CONVERSATION_BYTES_DEFAULT,
   AI_FILES_MAX_FILE_BYTES_DEFAULT,
+  AI_WORKING_FILES_FOLDER,
+  type AiConversationFileOverview,
+  type AiConversationWorkingGroup,
   type AiFileStat,
   createAiConversationArtifact,
   guessAiMediaType,
+  isAiWorkingFilePath,
   listAiConversationFiles,
+  loadAiConversationFileOverview,
   normalizeAiFilePath,
   readAiConversationFile,
   writeAiConversationFile,
@@ -245,6 +251,7 @@ export {
   validateAiSkillReferences,
 } from "./skill-format";
 export {
+  type AiConversationSkillUse,
   type AiLoadedSkillSnapshot,
   type AiSkill,
   type AiSkillAccess,

package/src/ai/memories.ts

@@ -206,6 +206,20 @@ export const formatAiMemories = (
 export const aiMemories = {
   list: search,
 
+  /** Active memories saved from one of the user's chats, newest first. */
+  async listFromConversation(userId: string, conversationId: string, limit = 50): Promise<AiMemory[]> {
+    const rows = await sql<MemoryRow[]>`
+      SELECT id, short_id, user_id, kind, content, priority, source, source_conversation_id, source_message_id,
+             resource_type, resource_id, created_at, updated_at
+      FROM ai.memories
+      WHERE user_id = ${userId}::uuid AND source_conversation_id = ${conversationId}::uuid
+        AND deleted_at IS NULL AND superseded_by_id IS NULL
+      ORDER BY updated_at DESC, id ASC
+      LIMIT ${Math.min(Math.max(Math.floor(limit), 1), 100)}
+    `;
+    return rows.map(toMemory);
+  },
+
   async resolveSourceConversationShortIds(userId: string, conversationIds: string[]): Promise<Map<string, string>> {
     if (conversationIds.length === 0) return new Map();
     const rows = await sql<{ id: string; short_id: string }[]>`

package/src/ai/migrate.ts

@@ -393,6 +393,12 @@ export const migrateCloudAi = async (): Promise<void> => {
     ON ai.messages(conversation_id, loop_id, seq ASC)
     WHERE compacted_at IS NULL AND loop_id IS NOT NULL
   `.simple();
+  // Chat positions of sources and results, also in turns that compaction archived; archived messages stay visible.
+  await sql`
+    CREATE INDEX IF NOT EXISTS idx_ai_messages_conversation_loop_seq
+    ON ai.messages(conversation_id, loop_id, seq ASC)
+    WHERE loop_id IS NOT NULL
+  `.simple();
 
   // Optional pg_textsearch ranking. Native weighted FTS above is always the
   // correctness path; missing extension support must never block startup.
@@ -559,6 +565,13 @@ export const migrateCloudAi = async (): Promise<void> => {
     ON ai.conversation_sources(conversation_id, last_seen_at DESC, kind, source_key)
   `.simple();
 
+  // A delivered result may be a Cloud resource, for example an app opened with code_open.
+  await sql`
+    ALTER TABLE ai.conversation_sources
+      ADD COLUMN IF NOT EXISTS resource_type TEXT,
+      ADD COLUMN IF NOT EXISTS resource_id TEXT
+  `.simple();
+
   await sql`
     CREATE TABLE IF NOT EXISTS ai.turn_steers (
       id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
@@ -1272,6 +1285,109 @@ export const migrateCloudAi = async (): Promise<void> => {
     END $$
   `.simple();
 
+  // Deliveries become `result` sources. The kind check widens once, and then the deliveries already stored in chat
+  // history are indexed once, so existing chats show their results from the start; this needs ai.files above. The
+  // widened check stays NOT VALID until that backfill committed: validating it marks the backfill done, and a start
+  // that stopped in between repeats it. The table is locked exclusively only while the check changes; the scan of the
+  // history leaves it readable.
+  const [kindCheck] = await sql<{ definition: string; validated: boolean }[]>`
+    SELECT pg_get_constraintdef(oid) AS definition, convalidated AS validated FROM pg_constraint
+    WHERE conname = 'ai_conversation_sources_kind_check' AND conrelid = 'ai.conversation_sources'::regclass
+  `;
+  const resultsAllowed = kindCheck?.definition.includes("'result'") === true;
+  if (!resultsAllowed)
+    await sql.begin(async (tx) => {
+      await tx`ALTER TABLE ai.conversation_sources DROP CONSTRAINT IF EXISTS ai_conversation_sources_kind_check`.simple();
+      await tx`
+        ALTER TABLE ai.conversation_sources
+        ADD CONSTRAINT ai_conversation_sources_kind_check CHECK (kind IN ('result', 'web', 'activity')) NOT VALID
+      `.simple();
+    });
+  if (!resultsAllowed || !kindCheck?.validated) {
+    await sql.begin(async (tx) => {
+      // History is not news: the backfill must not queue one live event per indexed row.
+      const liveTrigger = (state: "ENABLE" | "DISABLE") =>
+        tx.unsafe(`
+          DO $$ BEGIN
+            IF EXISTS (
+              SELECT 1 FROM pg_trigger
+              WHERE tgname = 'ai_live_conversation_sources_changed' AND tgrelid = 'ai.conversation_sources'::regclass
+            ) THEN
+              ALTER TABLE ai.conversation_sources ${state} TRIGGER ai_live_conversation_sources_changed;
+            END IF;
+          END $$
+        `);
+      await liveTrigger("DISABLE");
+      await tx`
+        WITH results AS (
+          SELECT message.conversation_id, message.loop_id, message.seq, message.created_at,
+                 CASE WHEN jsonb_typeof(message.message) = 'string' THEN (message.message #>> '{}')::jsonb ELSE message.message END AS payload
+          FROM ai.messages message
+          WHERE message.role = 'tool_result' AND message.kind = 'message'
+        ),
+        delivered AS (
+          SELECT result.*, result.payload ->> 'callId' AS call_id, result.payload ->> 'name' AS tool_name,
+                 result.payload -> 'result' AS output,
+                 (SELECT block -> 'args'
+                  FROM ai.messages call,
+                       jsonb_array_elements(CASE WHEN jsonb_typeof(call.message) = 'string' THEN (call.message #>> '{}')::jsonb ELSE call.message END -> 'content') block
+                  WHERE call.conversation_id = result.conversation_id AND call.loop_id = result.loop_id AND call.role = 'assistant'
+                    AND block ->> 'type' = 'tool_call' AND block ->> 'id' = result.payload ->> 'callId'
+                  LIMIT 1) AS args
+          FROM results result
+          WHERE result.payload ->> 'name' IN ('present', 'code_open', 'code_present')
+            AND COALESCE(result.payload ->> 'isError', 'false') <> 'true'
+            AND jsonb_typeof(result.payload -> 'result') = 'object'
+            -- Browser tools report a failure as a result with an error.
+            AND NOT (result.payload -> 'result' ? 'error')
+        ),
+        indexed AS (
+          SELECT DISTINCT ON (delivered.conversation_id, source_key)
+                 delivered.conversation_id, source_key, title, preview, icon, resource_type, resource_id,
+                 delivered.loop_id, delivered.call_id, delivered.created_at
+          FROM delivered,
+          LATERAL (
+            SELECT
+              CASE delivered.tool_name
+                WHEN 'present' THEN delivered.output ->> 'path'
+                WHEN 'code_open' THEN 'assistant.artifact:' || (delivered.args ->> 'id')
+                ELSE 'code_present:' || delivered.call_id
+              END AS source_key,
+              CASE delivered.tool_name
+                WHEN 'present' THEN COALESCE(NULLIF(btrim(delivered.args ->> 'title'), ''), regexp_replace(delivered.output ->> 'path', '^.*/', ''))
+                WHEN 'code_open' THEN 'Studio app'
+                ELSE COALESCE(NULLIF(btrim(delivered.args ->> 'title'), ''), NULLIF(btrim(delivered.output ->> 'title'), ''), 'Visualization')
+              END AS title,
+              CASE WHEN delivered.tool_name = 'present' THEN NULLIF(btrim(delivered.args ->> 'description'), '') END AS preview,
+              CASE delivered.tool_name WHEN 'present' THEN 'ti ti-file' WHEN 'code_open' THEN 'ti ti-app-window' ELSE 'ti ti-chart-dots' END AS icon,
+              CASE WHEN delivered.tool_name = 'code_open' THEN 'assistant.artifact' END AS resource_type,
+              CASE WHEN delivered.tool_name = 'code_open' THEN delivered.args ->> 'id' END AS resource_id
+          ) shape
+          WHERE (delivered.tool_name <> 'present' OR delivered.output ->> 'path' LIKE '/%')
+            -- A result is the file it delivered: a file deleted since then is not one, and its path may hold another.
+            AND (delivered.tool_name <> 'present' OR EXISTS (
+              SELECT 1 FROM ai.files file
+              WHERE file.conversation_id = delivered.conversation_id AND file.path = delivered.output ->> 'path'
+            ))
+            AND (delivered.tool_name <> 'code_open' OR NULLIF(delivered.args ->> 'id', '') IS NOT NULL)
+            AND (delivered.tool_name <> 'code_present' OR delivered.output ? 'presentationId')
+          ORDER BY delivered.conversation_id, source_key, delivered.seq DESC
+        )
+        INSERT INTO ai.conversation_sources (
+          conversation_id, kind, source_key, title, preview, icon, resource_type, resource_id,
+          source_turn_id, source_call_id, first_seen_at, last_seen_at
+        )
+        SELECT indexed.conversation_id, 'result', indexed.source_key, indexed.title, indexed.preview, indexed.icon,
+               indexed.resource_type, indexed.resource_id, turn.id, indexed.call_id, indexed.created_at, indexed.created_at
+        FROM indexed
+        LEFT JOIN ai.turns turn ON turn.id::text = indexed.loop_id AND turn.conversation_id = indexed.conversation_id
+        ON CONFLICT (conversation_id, kind, source_key) DO NOTHING
+      `.simple();
+      await liveTrigger("ENABLE");
+    });
+    await sql`ALTER TABLE ai.conversation_sources VALIDATE CONSTRAINT ai_conversation_sources_kind_check`.simple();
+  }
+
   // Inline image parts were an alpha transport detail. Move their bytes into
   // the authorized conversation file store and leave only stable references in
   // message history. Re-running is idempotent because the path is derived from
@@ -2209,6 +2325,15 @@ export const migrateCloudAi = async (): Promise<void> => {
     )
   `.simple();
 
+  await sql`
+    CREATE TABLE IF NOT EXISTS ai.model_request_headers (
+      profile_id TEXT PRIMARY KEY,
+      secret TEXT NOT NULL,
+      created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+      updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
+    )
+  `.simple();
+
   // One-time move of keys that were stored inside the profiles setting. Once
   // the blob holds no apiKey the split yields nothing and this is a no-op, so
   // it is safe to re-run. Dynamic imports keep the module free of store deps.

package/src/ai/model-request-settings.ts

@@ -0,0 +1,98 @@
+import { sql } from "bun";
+import { coreSettings } from "../services";
+import { audit } from "../services/audit";
+import { invalidateSettingsCache, set as setSetting } from "../services/settings";
+import { decryptValue } from "../services/settings/crypto";
+import {
+  type AiModelRequestSettings,
+  type AiModelRequestSettingsUpdate,
+  AiModelRequestSettingsUpdateSchema,
+} from "../shared/ai-model-request-settings";
+import { AiQuotaError } from "./quotas";
+import { getAiRequestHeaders, planAiProfileRequestHeaders, storeAiRequestHeaderPlan } from "./request-headers";
+import { parseAiModelProfiles } from "./settings";
+import type { AiModelProfile } from "./types";
+
+const key = "ai.model_profiles_json";
+export class AiModelRequestSettingsInvalid extends Error {}
+
+const readSnapshot = async (id: string, fallback: string, db: typeof sql, lock = false) => {
+  const rows = lock
+    ? await db<{ value: string }[]>`SELECT value FROM settings.entries WHERE key=${key} FOR UPDATE`
+    : await db<{ value: string }[]>`SELECT value FROM settings.entries WHERE key=${key}`;
+  const raw = rows[0] ? await decryptValue(rows[0].value) : fallback;
+  if (typeof raw !== "string") throw new AiModelRequestSettingsInvalid("Invalid model configuration.");
+  const parsed = parseAiModelProfiles(raw);
+  if (parsed.error) throw new AiModelRequestSettingsInvalid(parsed.error.fields?.[key] ?? parsed.error.message);
+  const profile = parsed.profiles.find((profile) => profile.id === id);
+  if (!profile) throw new AiQuotaError("quota_conflict", "Model no longer exists.");
+  const [headerRow] = await db<{ secret: string }[]>`SELECT secret FROM ai.model_request_headers WHERE profile_id=${id}`;
+  // Hash ciphertext, never secret values. Any settings/header change invalidates
+  // the snapshot, including replacement of a value under an unchanged name.
+  const revision = new Bun.CryptoHasher("sha256").update(JSON.stringify([rows[0]?.value ?? raw, headerRow?.secret ?? null])).digest("hex");
+  const requestHeaderNames = Object.keys(await getAiRequestHeaders(id, db)).sort();
+  return { profiles: parsed.profiles, profile, settings: present(profile, requestHeaderNames, revision) };
+};
+const present = (profile: AiModelProfile, requestHeaderNames: string[], revision: string): AiModelRequestSettings => ({
+  id: profile.id,
+  reasoningEffort: profile.reasoningEffort ?? null,
+  extraBody: profile.extraBody ?? null,
+  requestHeaderNames,
+  revision,
+});
+
+export const getAiModelRequestSettings = async (id: string): Promise<AiModelRequestSettings> =>
+  (await readSnapshot(id, await coreSettings.get<string>(key), sql)).settings;
+
+/** One transaction changes the non-secret profile and encrypted headers; audit contains names only. */
+export const setAiModelRequestSettings = async (
+  id: string,
+  input: AiModelRequestSettingsUpdate,
+  actorId: string,
+): Promise<AiModelRequestSettings> => {
+  const data = AiModelRequestSettingsUpdateSchema.parse(input);
+  const fallback = await coreSettings.get<string>(key);
+  const result = await sql.begin(async (db) => {
+    const current = await readSnapshot(id, fallback, db, true);
+    if (current.settings.revision !== data.expected)
+      throw new AiQuotaError("quota_conflict", "Model request settings changed. Read them again before updating.");
+    const nextProfile = { ...current.profile };
+    if (Object.hasOwn(data, "reasoningEffort")) {
+      if (data.reasoningEffort) nextProfile.reasoningEffort = data.reasoningEffort;
+      else delete nextProfile.reasoningEffort;
+    }
+    if (Object.hasOwn(data, "extraBody")) {
+      if (data.extraBody) nextProfile.extraBody = data.extraBody;
+      else delete nextProfile.extraBody;
+    }
+    const validated = parseAiModelProfiles(JSON.stringify([nextProfile]));
+    if (validated.error) throw new AiModelRequestSettingsInvalid(validated.error.fields?.[key] ?? validated.error.message);
+    const headers = data.clearRequestHeaders ? {} : await getAiRequestHeaders(id, db);
+    const plan = planAiProfileRequestHeaders({
+      currentProfiles: [current.profile],
+      nextProfiles: [nextProfile],
+      existingNames: { [id]: Object.keys(headers) },
+      submitted: data.requestHeaders === undefined ? [] : [{ profileId: id, patch: data.requestHeaders }],
+    });
+    if (plan.error) throw new AiModelRequestSettingsInvalid(plan.error);
+    // This endpoint owns one profile only. Never prune the other profiles.
+    const keepOthers = current.profiles.filter((profile) => profile.id !== id).map((profile) => profile.id);
+    plan.keepHeaderProfileIds = [...keepOthers, ...(data.clearRequestHeaders ? [] : plan.keepHeaderProfileIds)];
+    await storeAiRequestHeaderPlan(plan, db);
+    await setSetting(key, JSON.stringify(current.profiles.map((profile) => (profile.id === id ? validated.profiles[0] : profile))), db);
+    const saved = (await readSnapshot(id, fallback, db)).settings;
+    await audit.record(
+      {
+        action: "ai.model.request-settings",
+        outcome: "allowed",
+        actor: { userId: actorId },
+        target: { type: "ai-model", id },
+        metadata: { reasoningEffort: saved.reasoningEffort, extraBody: saved.extraBody, requestHeaderNames: saved.requestHeaderNames },
+      },
+      db,
+    );
+    return saved;
+  });
+  await invalidateSettingsCache([key]);
+  return result;
+};

package/src/ai/protocol.ts

@@ -19,6 +19,12 @@ import type { AiConversation, AiFrontendToolMode, AiStoredMessage, AiToolPresent
 
 export const AI_WIRE_VERSION = 1;
 
+/**
+ * Lease of a turn worker. A running turn whose worker is gone is claimed again after one lease, so a running turn
+ * that sends nothing for this long either works silently or lost an update; a client then reloads the turn's state.
+ */
+export const AI_TURN_LEASE_MS = 45_000;
+
 export type AiToolBlockStatus = "running" | "awaiting_approval" | "awaiting_client" | "completed" | "failed" | "rejected";
 
 export type AiTurnBlock =
@@ -39,6 +45,8 @@ export type AiTurnBlock =
       isError?: boolean;
       /** Present while status is awaiting_approval. */
       approval?: { message?: string; review?: CapabilityActionReview; allowAlways: boolean };
+      /** The user approved this call in the chat; the decided approval stays visible as a receipt. */
+      approved?: boolean;
       /** Present for frontend tools. */
       frontendMode?: AiFrontendToolMode;
       /** Saved Cloud-owned display snapshot for capability calls. */
@@ -67,6 +75,8 @@ export type AiWireEvent =
   | (AiWireEventBase & { type: "message_saved"; message: AiStoredMessage })
   | (AiWireEventBase & { type: "block_set"; block: AiTurnBlock })
   | (AiWireEventBase & { type: "block_delta"; blockId: string; blockKind: "text" | "thinking"; delta: string })
+  /** A model call failed transiently and waits for its retry. Transient: the next event of the turn ends it. */
+  | (AiWireEventBase & { type: "provider_retry" })
   | (AiWireEventBase & {
       type: "turn_finished";
       status: AiTurnFinishedStatus;
@@ -85,6 +95,10 @@ export type AiTurnSnapshot = {
   blocks: AiTurnBlock[];
   modelProfileId: string | null;
   createdAt: string;
+  /** Time the turn already waited for answered user actions such as approvals. Absent from older servers. */
+  actionWaitMs?: number;
+  /** Start of the user action the turn waits for now, or null while it works. Absent from older servers. */
+  waitingSince?: string | null;
 };
 
 /** Full projection seed sent as the first SSE event on every (re)connect. */
@@ -151,7 +165,12 @@ export const reconcileResolvedTurnActions = (
     const event = resolvedByCallId.get(block.callId);
     if (!event || event.callId !== block.callId) return block;
     if (block.status === "awaiting_approval" && event.type === "approval_response") {
-      return { ...block, status: event.approved ? "running" : "rejected", approval: undefined };
+      return {
+        ...block,
+        status: event.approved ? "running" : "rejected",
+        approval: undefined,
+        ...(event.approved ? { approved: true } : {}),
+      };
     }
     if (block.status === "awaiting_client" && event.type === "tool_result") {
       return { ...block, status: "completed", result: event.result, isError: false };
@@ -172,7 +191,7 @@ export const buildBlocksFromMessages = (
     meta?: {
       steerId?: string;
       toolPresentations?: Record<string, AiToolPresentation>;
-      toolOutcomes?: Record<string, "rejected">;
+      toolOutcomes?: Record<string, "rejected" | "approved">;
     } | null;
   }[],
 ): AiTurnBlock[] => {
@@ -196,6 +215,8 @@ export const buildBlocksFromMessages = (
             args: block.args,
             status: "running",
             presentation: meta?.toolPresentations?.[block.id],
+            // A turn that ended before an approved call returned records the approval on the call's message.
+            ...(meta?.toolOutcomes?.[block.id] === "approved" ? { approved: true } : {}),
           });
         }
       });
@@ -212,12 +233,13 @@ export const buildBlocksFromMessages = (
       const at = toolIndex.get(message.callId);
       const existing = at !== undefined ? blocks[at] : undefined;
       if (existing?.kind === "tool") {
-        const rejected = meta?.toolOutcomes?.[message.callId] === "rejected";
+        const outcome = meta?.toolOutcomes?.[message.callId];
         blocks[at!] = {
           ...existing,
-          status: rejected ? "rejected" : message.isError ? "failed" : "completed",
+          status: outcome === "rejected" ? "rejected" : message.isError ? "failed" : "completed",
           result: message.result,
           isError: message.isError,
+          ...(outcome === "approved" ? { approved: true } : {}),
         };
       }
     }