@k2b/cloud 0.26.0 → 0.28.0

package/src/ai/turn-policy.ts

@@ -0,0 +1,248 @@
+import type { Provider, Tool, ToolResolver } from "@k2b/nessi";
+import type { AiToolBlockStatus } from "./protocol";
+import { AiTurnFailure } from "./turn-failure";
+
+/** Calls that only find or load other tools. */
+const DISCOVERY_TOOL_NAMES = new Set(["search_tools", "list_apps", "load_tools"]);
+/** Discovery calls in a row, without a completed working step, that earn a hint: three app lookups of search plus load. */
+const DISCOVERY_STREAK_LIMIT = 6;
+/** The last tenth of a turn's run time limit is kept for the answer. */
+const FINAL_ANSWER_BUDGET_SHARE = 0.1;
+
+export type AiTurnFinalReason = "tool_rounds" | "run_time" | "loop";
+export type AiTurnHint = "repeated_failure" | "discovery_loop";
+export type AiTurnPolicyDecision = { kind: "hint"; hints: AiTurnHint[] } | { kind: "final_answer"; reason: AiTurnFinalReason };
+
+/** A finished tool call under the name the model called it by. */
+export type AiTurnPolicyToolCall = { name: string; args?: unknown; status: AiToolBlockStatus; result?: unknown };
+
+const FINAL_ANSWER_CAUSE: Record<AiTurnFinalReason, string> = {
+  tool_rounds: "The configured tool-round budget has been reached, so no more tools are available in this turn.",
+  run_time: "The run time limit of this turn is almost reached, so no more tools are available in this turn.",
+  loop: "This turn kept repeating steps that made no progress, so no more tools are available in this turn.",
+};
+
+const FINAL_ANSWER_CLOSE: Record<AiTurnFinalReason, string> = {
+  tool_rounds: "",
+  run_time: " Say which parts are still open; the user can continue the task with a new message.",
+  loop: " Say what blocked you and what the user can do about it.",
+};
+
+const finalAnswerPrompt = (reason: AiTurnFinalReason) =>
+  `# Final response
+${FINAL_ANSWER_CAUSE[reason]} Answer the user's request now with the best result supported by the evidence already gathered. State any material uncertainty or incomplete part clearly.${FINAL_ANSWER_CLOSE[reason]}`;
+
+const listFormat = new Intl.ListFormat("en", { type: "conjunction" });
+
+/** Names a hint may repeat: only tools the model was offered, never a name it made up. */
+const offeredNames = (names: readonly string[], offered: ReadonlySet<string>) => {
+  const known = names.filter((name) => offered.has(name));
+  return listFormat.format(known.length < names.length ? [...known, "a tool that is not available"] : known);
+};
+
+const hintPrompt = (hints: { repeatedFailures: string[]; discoveryStreak: number | null }, offered: ReadonlySet<string>) =>
+  [
+    "# Turn check",
+    hints.repeatedFailures.length > 0
+      ? `Calls to ${offeredNames(hints.repeatedFailures, offered)} failed twice with the same input. Do not repeat them with that input. Change your approach, or tell the user what blocks you.`
+      : undefined,
+    hints.discoveryStreak !== null
+      ? `You searched for or loaded tools ${hints.discoveryStreak} times in a row without completing another step. Stop searching. Use the tools you already have, load the ones a search found, or tell the user what is not available in this turn.`
+      : undefined,
+  ]
+    .filter(Boolean)
+    .join("\n");
+
+/** A completed load_tools call that made at least one more tool callable. */
+const loadedTools = ({ name, status, result }: AiTurnPolicyToolCall) =>
+  name === "load_tools" &&
+  status === "completed" &&
+  typeof result === "object" &&
+  result !== null &&
+  "loaded" in result &&
+  Array.isArray(result.loaded) &&
+  result.loaded.length > 0;
+
+const canonicalJson = (value: unknown): string => {
+  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+  if (value && typeof value === "object")
+    return `{${Object.entries(value)
+      .filter(([, item]) => item !== undefined)
+      .sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0))
+      .map(([key, item]) => `${JSON.stringify(key)}:${canonicalJson(item)}`)
+      .join(",")}}`;
+  return JSON.stringify(value) ?? "null";
+};
+
+const withPrompt = (systemPrompt: string | undefined, suffix: string | null) =>
+  suffix ? `${systemPrompt ?? ""}\n\n${suffix}`.trim() : systemPrompt;
+
+/**
+ * Keeps a chat turn from ending without an answer (#530).
+ *
+ * The policy is checked before every model call:
+ * - the same call (tool name and input) failing twice, or six discovery calls
+ *   in a row without a completed working step, adds a one-time hint to the next
+ *   model call;
+ * - either pattern after its hint, a positive `maxToolRounds` that is used up,
+ *   or the last tenth of the run time limit ends tool use: the next model call
+ *   gets no tools and a prompt to answer with what the turn has. If that call
+ *   still asks for tools, the turn fails instead of looping without them.
+ *
+ * Rejected approvals are user decisions, not failures, and loading tools a
+ * search found does not continue a discovery loop. A steering message starts
+ * the loop checks over. The deadline abort stays as the backstop when a single
+ * model or tool call outlasts the reserve. Calls a resumed attempt already
+ * finished seed the counts without a hint of their own; a hint the earlier
+ * attempt gave is not remembered.
+ */
+export const applyAiTurnPolicy = (input: {
+  provider: Provider;
+  tools: Tool[] | ToolResolver;
+  maxToolRounds?: number;
+  issuedToolRounds: number;
+  completedToolRounds: number;
+  /** Epoch milliseconds when the run time limit ends; null without a limit. */
+  deadline: number | null;
+  runBudgetMs: number | null;
+  /** Tool calls this turn finished before this attempt and after its last steering message, oldest first. */
+  finishedToolCalls?: readonly AiTurnPolicyToolCall[];
+  onDecision?: (decision: AiTurnPolicyDecision) => void;
+  now?: () => number;
+}): {
+  provider: Provider;
+  tools: ToolResolver;
+  maxTurns?: number;
+  noteToolRound: () => void;
+  noteToolCall: (call: AiTurnPolicyToolCall) => void;
+  noteSteering: () => void;
+} => {
+  const now = input.now ?? Date.now;
+  const limit = Math.floor(input.maxToolRounds ?? 0);
+  const issuedAtStart = Math.max(0, Math.floor(input.issuedToolRounds));
+  let completed = Math.max(0, Math.floor(input.completedToolRounds));
+  // nessi resolves the tools once more to finish a round an earlier attempt left open.
+  let resumingRound = issuedAtStart > completed;
+  const reserveMs = input.runBudgetMs && input.runBudgetMs > 0 ? input.runBudgetMs * FINAL_ANSWER_BUDGET_SHARE : 0;
+
+  const failures = new Map<string, number>();
+  let repeatedFailures = new Set<string>();
+  let discoveryStreak = 0;
+  // A discovery call since the last check that made no new tool callable.
+  let discoveredSinceCheck = false;
+  const hinted = new Set<AiTurnHint>();
+  let finalReason: AiTurnFinalReason | null = null;
+  let completedAtFinal = 0;
+  let pendingHint: string | null = null;
+  let offered = new Set<string>();
+
+  const noteToolCall = (call: AiTurnPolicyToolCall) => {
+    const { name, args, status } = call;
+    if (status !== "completed" && status !== "failed") return;
+    if (status === "failed") {
+      const key = `${name}\u0000${canonicalJson(args)}`;
+      const count = (failures.get(key) ?? 0) + 1;
+      failures.set(key, count);
+      if (count >= 2) repeatedFailures.add(name);
+    }
+    if (DISCOVERY_TOOL_NAMES.has(name)) {
+      discoveryStreak += 1;
+      if (!loadedTools(call)) discoveredSinceCheck = true;
+    } else if (status === "completed") {
+      discoveryStreak = 0;
+    }
+  };
+  for (const call of input.finishedToolCalls ?? []) noteToolCall(call);
+  repeatedFailures = new Set();
+  discoveredSinceCheck = false;
+
+  const reserveReached = () => input.deadline !== null && reserveMs > 0 && input.deadline - now() <= reserveMs;
+  const endToolUse = (reason: AiTurnFinalReason) => {
+    finalReason = reason;
+    completedAtFinal = completed;
+    pendingHint = null;
+    input.onDecision?.({ kind: "final_answer", reason });
+  };
+
+  const check = () => {
+    if (finalReason) return;
+    if (limit > 0 && completed >= limit) endToolUse("tool_rounds");
+    else if (reserveReached()) endToolUse("run_time");
+    else {
+      const triggered: AiTurnHint[] = [];
+      if (repeatedFailures.size > 0) triggered.push("repeated_failure");
+      if (discoveredSinceCheck && discoveryStreak >= DISCOVERY_STREAK_LIMIT) triggered.push("discovery_loop");
+      if (triggered.some((hint) => hinted.has(hint))) endToolUse("loop");
+      else if (triggered.length > 0) {
+        for (const hint of triggered) hinted.add(hint);
+        pendingHint = hintPrompt(
+          {
+            repeatedFailures: triggered.includes("repeated_failure") ? [...repeatedFailures] : [],
+            discoveryStreak: triggered.includes("discovery_loop") ? discoveryStreak : null,
+          },
+          offered,
+        );
+        input.onDecision?.({ kind: "hint", hints: triggered });
+      }
+    }
+    repeatedFailures = new Set();
+    discoveredSinceCheck = false;
+  };
+
+  const tools: ToolResolver = async () => {
+    if (resumingRound) resumingRound = false;
+    else check();
+    if (finalReason) {
+      if (completed > completedAtFinal) throw new AiTurnFailure("step_limit", "The model did not produce a final answer without tools.");
+      return [];
+    }
+    const resolved = typeof input.tools === "function" ? await input.tools() : input.tools;
+    offered = new Set(resolved.map((tool) => tool.def.name));
+    return resolved;
+  };
+  const provider: Provider = {
+    name: input.provider.name,
+    family: input.provider.family,
+    model: input.provider.model,
+    contextWindow: input.provider.contextWindow,
+    capabilities: input.provider.capabilities,
+    complete: (request) => input.provider.complete(request),
+    stream: async function* (request) {
+      // Compaction may run between the tool check and this call; the reserve still holds.
+      if (!finalReason && reserveReached()) endToolUse("run_time");
+      let overflowed = false;
+      for await (const event of input.provider.stream({
+        ...request,
+        tools: finalReason ? [] : request.tools,
+        systemPrompt: withPrompt(request.systemPrompt, finalReason ? finalAnswerPrompt(finalReason) : pendingHint),
+      })) {
+        if (event.type === "issue" && event.issue.kind === "provider_error" && event.issue.contextOverflow) overflowed = true;
+        yield event;
+      }
+      // nessi compacts an overflowed request and sends it again; the hint goes with it.
+      if (!overflowed) pendingHint = null;
+    },
+  };
+
+  return {
+    provider,
+    tools,
+    // Nessi checks this before provider calls. The extra round is the tool-free
+    // synthesis call after the last allowed tool-using round.
+    ...(limit > 0 ? { maxTurns: Math.max(1, limit - issuedAtStart + 1) } : {}),
+    noteToolRound: () => {
+      completed += 1;
+    },
+    noteToolCall,
+    noteSteering: () => {
+      // New user input: the loop checks start over, and a loop's final answer may use tools again.
+      failures.clear();
+      repeatedFailures = new Set();
+      discoveryStreak = 0;
+      discoveredSinceCheck = false;
+      hinted.clear();
+      pendingHint = null;
+      finalReason = null;
+    },
+  };
+};

package/src/ai/types.ts

@@ -45,6 +45,8 @@ export type AiModelProfile = {
   contextWindow?: number;
   temperature?: number;
   maxOutputTokens?: number;
+  reasoningEffort?: string;
+  extraBody?: Record<string, unknown>;
   /** Maximum deferred tools retained per conversation. Missing or <= 0 keeps all loaded tools. */
   maxLoadedTools?: number;
   /** Tool-using model rounds per chat turn. Missing or <= 0 is unlimited. */
@@ -156,6 +158,8 @@ export type AiConversation = {
   runStatus: AiConversationRunStatus;
   /** Error from the latest turn when `runStatus` is `failed`. */
   runError: string | null;
+  /** Public ID of the latest turn, which `runStatus` and `runError` describe; null before the first turn. */
+  runTurnId?: string | null;
   unreadCompletion: boolean;
   /** Optional shared project context; the conversation itself remains private to its owner. */
   projectId: string | null;
@@ -297,6 +301,8 @@ export type AiStoredMessage = {
     };
     toolPresentations?: Record<string, AiToolPresentation>;
     toolOutcomes?: Record<string, "rejected" | "approved">;
+    /** Why the turn failed, on the last message of its loop. The chat words it in the reader's language. */
+    turnError?: AiTurnError;
   } | null;
   /** Private owner feedback for this rendered assistant response. Never enters model context. */
   feedback?: AiMessageFeedback | null;
@@ -317,6 +323,23 @@ export type AiConversationTimelineEntry = {
   createdAt: string;
 };
 
+/**
+ * Why a turn failed, as a stable code. `limitMinutes` comes with `time_limit` when the turn had a run time limit.
+ * Codes are never translated; clients word them in the reader's language.
+ */
+export type AiTurnErrorCode =
+  | "model_unavailable"
+  | "quota_exhausted"
+  | "context_full"
+  | "time_limit"
+  | "step_limit"
+  | "wait_expired"
+  | "interrupted"
+  | "not_allowed"
+  | "failed";
+
+export type AiTurnError = { code: AiTurnErrorCode; limitMinutes?: number };
+
 export type AiTurnStatus = "queued" | "running" | "waiting_for_action" | "completed" | "failed" | "aborted";
 
 export type AiTurnSteerStatus = "pending" | "consumed" | "discarded";
@@ -437,10 +460,10 @@ export type AiClientToolId =
   | "code_run"
   | "code_action"
   | "code_inspect"
-  | "code_interact"
   | "code_stop"
   | "code_open"
   | "code_present"
+  | "code_check"
   | "code_export"
   | "code_secret";
 
@@ -510,7 +533,14 @@ export type AiConversationResourceOccurrence = AiConversationResourceRef & {
   chat: Pick<AiConversation, "shortId" | "title" | "updatedAt">;
 };
 
-export type AiConversationSourceKind = "web" | "file" | "resource" | "activity";
+/**
+ * - `result`: something the assistant delivered with `present` (a file, `path` set), `code_open` (an app, `ref` set) or
+ *   `code_present` (a chat visualization, neither set; `sourceCallId` names it).
+ * - `web`: a page read with `web_extract`; `activity`: a web search, one entry per query.
+ * - `resource`: a Cloud resource a tool call read, or one indexed as Project context without a call.
+ * - `file`: a conversation file.
+ */
+export type AiConversationSourceKind = "result" | "web" | "file" | "resource" | "activity";
 
 export type AiConversationSource = {
   kind: AiConversationSourceKind;
@@ -528,15 +558,23 @@ export type AiConversationSource = {
   lastSeenAt: string;
   sourceTurnId: string | null;
   sourceCallId: string | null;
+  /**
+   * Chat position of the source: the assistant message that holds `sourceCallId`, otherwise the start of its turn.
+   * Use it as the `message` link target; null when the turn is gone.
+   */
+  sourceMessageSeq: number | null;
 };
 
 export type AiConversationSourceObservation = {
-  kind: "web" | "activity";
+  kind: "result" | "web" | "activity";
   key: string;
   title: string;
+  /** For `result`, the delivered description; a new delivery always replaces it, also with none. */
   preview?: string;
   icon?: string;
   href?: string;
+  /** The delivered Cloud resource of a `result`, for example an opened app. */
+  ref?: CloudResourceRef;
 };
 
 export type AiConversationFileSnapshotEntry = {
@@ -571,6 +609,9 @@ export type AiChatTurnRunConfig = {
   /** Stable public ID exposed as runtime context, not instructions. */
   chatId?: string;
   actor?: RequestActor;
+  /** Browser preferences retained for managed HTML self-tests. */
+  theme?: "light" | "dark";
+  timeZone?: string;
   /** Request locale persisted with the turn so async execution keeps the caller preference. */
   locale?: string;
   modelPolicy?: AiModelPolicy;
@@ -707,7 +748,11 @@ export type AiConversationService = {
     search?: string;
     before?: string;
     limit?: number;
-  }): Promise<{ sources: AiConversationSource[]; nextCursor?: string }>;
+    /** Only these kinds; all kinds when omitted. */
+    kinds?: readonly AiConversationSourceKind[];
+    /** Only resources a tool call read; leaves out resources indexed as Project context without a call. */
+    observed?: boolean;
+  }): Promise<{ sources: AiConversationSource[]; nextCursor?: string; total: number }>;
   getCapabilityInvocationOrigin(input: { idempotencyKey: string; toolName: string }): Promise<{
     conversationId: string;
     conversationShortId: string;
@@ -911,7 +956,10 @@ export type AiConversationService = {
     conversationId: string;
     turnId: string;
     status: "completed" | "failed" | "aborted";
+    /** The reason a person reads, such as in `runError`; never raw provider text. */
     error?: string | null;
+    /** Recorded on the turn's last message so its history shows why it failed. */
+    turnError?: AiTurnError | null;
     /** When set, only the lease owner may finalize; otherwise only ownerless turns are finalized. */
     leaseOwner?: string;
   }): Promise<AiTurnCompletionResult>;

package/src/api/admin-ai-quotas.ts

@@ -1,12 +1,15 @@
 import { Hono, type MiddlewareHandler } from "hono";
+import { describeRoute } from "hono-openapi";
 import { z } from "zod";
 import { AiBackgroundCostError, backgroundCostState, releaseBackgroundCostStop } from "../ai/inference-calls";
 import { setAiModelPricing } from "../ai/model-pricing";
+import { AiModelRequestSettingsInvalid, getAiModelRequestSettings, setAiModelRequestSettings } from "../ai/model-request-settings";
 import { quotaAdminConfig, quotaReport } from "../ai/quota-report";
 import { AiQuotaError, aiQuotas } from "../ai/quotas";
 import { readAiSettingsState } from "../ai/settings";
-import { type AuthContext, auth, v } from "../server";
+import { type AuthContext, auth, jsonResponse, requiresAdmin, v } from "../server";
 import { AiModelPricingSchema, hasBillableAiPricing } from "../shared/ai-costs";
+import { AiModelRequestSettingsSchema, AiModelRequestSettingsUpdateSchema } from "../shared/ai-model-request-settings";
 import {
   AiQuotaConfigSchema,
   AiQuotaIdentitySchema,
@@ -21,6 +24,7 @@ export const createAdminAiQuotaRoutes = (authenticate: MiddlewareHandler<AuthCon
   new Hono<AuthContext>()
     .use("*", authenticate)
     .onError((error, c) => {
+      if (error instanceof AiModelRequestSettingsInvalid) return c.json({ message: error.message }, 400);
       if (error instanceof AiQuotaError || error instanceof AiBackgroundCostError)
         return c.json({ error: error.code, message: error.message }, 409);
       throw error;
@@ -46,6 +50,37 @@ export const createAdminAiQuotaRoutes = (authenticate: MiddlewareHandler<AuthCon
         return c.json(await setAiModelPricing(c.req.param("id")!, data.pricing, data.expected, c.get("user")!.id));
       },
     )
+    .get(
+      "/models/:id/settings",
+      describeRoute({
+        tags: ["Administration"],
+        summary: "Read masked model request settings",
+        ...requiresAdmin,
+        responses: { 200: jsonResponse(AiModelRequestSettingsSchema, "Model request settings (header names only)") },
+      }),
+      async (c) => {
+        c.header("Cache-Control", "no-store");
+        return c.json(await getAiModelRequestSettings(c.req.param("id")!));
+      },
+    )
+    .put(
+      "/models/:id/settings",
+      describeRoute({
+        tags: ["Administration"],
+        summary: "Patch model request settings with a revision guard",
+        ...requiresAdmin,
+        responses: {
+          200: jsonResponse(AiModelRequestSettingsSchema, "Updated model request settings (header names only)"),
+          400: jsonResponse(z.object({ message: z.string() }), "Invalid model request settings"),
+          409: jsonResponse(z.object({ message: z.string(), error: z.string() }), "Model request settings changed"),
+        },
+      }),
+      v("json", AiModelRequestSettingsUpdateSchema),
+      async (c) => {
+        c.header("Cache-Control", "no-store");
+        return c.json(await setAiModelRequestSettings(c.req.param("id")!, c.req.valid("json"), c.get("user")!.id));
+      },
+    )
     .get("/background", async (c) => c.json(await backgroundCostState()))
     .post("/background/release", async (c) => c.json(await releaseBackgroundCostStop(c.get("user")!.id)))
     .get("/report", v("query", AiQuotaReportQuerySchema), async (c) => c.json(await quotaReport(c.req.valid("query"))))

package/src/api/admin-core-settings.ts

@@ -19,6 +19,7 @@ import {
   aiModelAccess,
   splitAiModelAccess,
 } from "../ai/model-access";
+import { listAiRequestHeaderNames, planAiProfileRequestHeaders, storeAiRequestHeaderPlan } from "../ai/request-headers";
 import { parseAiModelProfiles, planAiProfileCredentials, validateAiSettingsConfiguration } from "../ai/settings";
 import { type AiSettingsIssueWithMessage, aiSettingsNotSavedMessage, describeAiSettingsIssues } from "../ai/settings-messages";
 import { type AuthContext, auth, getLocale, jsonResponse, requiresAdmin, v } from "../server";
@@ -27,7 +28,6 @@ import { readAccountCategoryPolicy } from "../services/account-category-policy";
 import { audit } from "../services/audit";
 import { validateFreeIpaCaCert } from "../services/freeipa-config";
 import { testFreeIpaConnection } from "../services/ipa/connection";
-import { sendEmail } from "../services/notifications/email";
 import { GotenbergRenderError, testGotenberg } from "../services/pdf";
 import * as settings from "../services/settings";
 import { SETTINGS_MAP, validateSettingValue } from "../services/settings/defaults";
@@ -43,10 +43,6 @@ const BulkSaveSchema = z.union([
     .strict(),
   z.record(z.string(), z.unknown()).transform((updates) => ({ updates, resets: [] as string[] })),
 ]);
-const TestEmailSchema = z.object({
-  recipient: z.email(),
-});
-
 const LEGAL_DOCUMENTS = [
   { kind: "terms", path: "/legal/terms" },
   { kind: "privacy", path: "/legal/privacy" },
@@ -101,6 +97,7 @@ type AiSettingsMutationPlan = {
   /** Structured validation issues with stable codes; `errors` carries the same messages keyed by setting. */
   issues?: AiSettingsIssueWithMessage[];
   keepCredentialProfileIds?: string[];
+  headerPlan?: ReturnType<typeof planAiProfileRequestHeaders>;
   modelProfileIds?: string[];
 };
 
@@ -168,6 +165,17 @@ const prepareAiSettingsMutation = async (
     keepCredentialProfileIds = credentialPlan.keepCredentialProfileIds;
   }
 
+  const headerPlan =
+    profilesUpdated || profilesReset
+      ? planAiProfileRequestHeaders({
+          currentProfiles: currentParsed.profiles,
+          nextProfiles: nextParsed.profiles,
+          existingNames: profilesUpdated ? await listAiRequestHeaderNames() : {},
+          submitted: aiSplit?.requestHeaders ?? [],
+        })
+      : undefined;
+  if (headerPlan?.error) return { errors: { [AI_PROFILES_KEY]: headerPlan.error } };
+
   const issues = validateAiSettingsConfiguration({
     enabled: nextEnabled,
     defaultModelId: String(valueAfterMutation(AI_DEFAULT_MODEL_KEY, currentDefaultModelId ?? "", updates, resets)),
@@ -183,6 +191,7 @@ const prepareAiSettingsMutation = async (
   return {
     errors: described.errors,
     issues: described.issues,
+    headerPlan,
     keepCredentialProfileIds,
     modelProfileIds: profilesUpdated || profilesReset ? nextParsed.profiles.map((profile) => profile.id) : undefined,
   };
@@ -294,24 +303,6 @@ const app = new Hono<AuthContext>()
   .delete("/legacy", auth.requireRole("admin"), async (c) => {
     return c.json(await settingsDeleteLegacyKeys(await liveSettingKeys()));
   })
-  .post("/test-email", auth.requireRole("admin"), v("json", TestEmailSchema), async (c) => {
-    const { recipient } = c.req.valid("json");
-    const sentAt = new Date().toISOString();
-
-    try {
-      await sendEmail(recipient, "Cloud test email", {
-        rawHtml: `
-          <p>This is a test email from Cloud.</p>
-          <p>If you received this message, SMTP delivery is configured correctly.</p>
-          <p style="margin-top:24px;color:#71717a;font-size:12px;">Sent at ${sentAt}</p>
-        `,
-      });
-      return c.json({ ok: true });
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Failed to send test email";
-      return c.json({ message }, 500);
-    }
-  })
   .post("/run-ai-enrichment", auth.requireRole("admin"), async (c) => {
     try {
       // Small manual batch — the cron handles bulk; this is "kick it now".
@@ -463,6 +454,7 @@ const app = new Hono<AuthContext>()
         } else if (aiPlan.keepCredentialProfileIds) {
           await pruneAiCredentials(aiPlan.keepCredentialProfileIds, tx);
         }
+        if (aiPlan.headerPlan) await storeAiRequestHeaderPlan(aiPlan.headerPlan, tx);
         if (aiPlan.modelProfileIds) {
           await aiModelAccess.syncProfiles(aiPlan.modelProfileIds, accessChanges, tx);
         }
@@ -524,6 +516,7 @@ const app = new Hono<AuthContext>()
         if (aiPlan.keepCredentialProfileIds) {
           await pruneAiCredentials(aiPlan.keepCredentialProfileIds, tx);
         }
+        if (aiPlan.headerPlan) await storeAiRequestHeaderPlan(aiPlan.headerPlan, tx);
         if (aiPlan.modelProfileIds) {
           await aiModelAccess.syncProfiles(aiPlan.modelProfileIds, [], tx);
         }