@k2b/cloud 0.43.0 → 0.45.0

package/src/workflows/runtime/executor.ts

@@ -32,19 +32,32 @@ import type {
 
 export const DEFAULT_MAX_LOOP_ITEMS = 100;
 
-const EXACT_EXPRESSION = /^\$\{\{\s*([^{}]+?)\s*\}\}$/;
+// Callers trim the captured text; no `\s*` around the group keeps matching linear.
+const EXACT_EXPRESSION = /^\$\{\{([^{}]+)\}\}$/;
 
 class RuntimeVariableScope implements WorkflowVariableScope {
   readonly #values = new Map<string, WorkflowJsonValue>();
+  readonly #unknown = new Set<string>();
 
   constructor(
     initial: Record<string, WorkflowJsonValue> = {},
     readonly parent?: RuntimeVariableScope,
+    public dependsOnUnknown: boolean = parent?.dependsOnUnknown ?? false,
   ) {
     for (const [name, value] of Object.entries(initial)) this.#values.set(name, value);
   }
 
+  markUnknown(name: string): void {
+    this.#values.delete(name);
+    this.#unknown.add(name);
+  }
+
+  isUnknown(name: string): boolean {
+    return this.#unknown.has(name) || (!this.#values.has(name) && this.parent?.isUnknown(name) === true);
+  }
+
   get(name: string): WorkflowJsonValue | undefined {
+    if (this.#unknown.has(name)) return undefined;
     return this.#values.has(name) ? this.#values.get(name) : this.parent?.get(name);
   }
 
@@ -53,18 +66,18 @@ class RuntimeVariableScope implements WorkflowVariableScope {
   }
 
   set(name: string, value: WorkflowJsonValue): void {
+    this.#unknown.delete(name);
     this.#values.set(name, value);
   }
 
   snapshot(): Record<string, WorkflowJsonValue> {
-    return {
-      ...(this.parent?.snapshot() ?? {}),
-      ...Object.fromEntries(this.#values),
-    };
+    const values = { ...(this.parent?.snapshot() ?? {}), ...Object.fromEntries(this.#values) };
+    for (const name of this.#unknown) delete values[name];
+    return values;
   }
 
-  child(initial: Record<string, WorkflowJsonValue> = {}): RuntimeVariableScope {
-    return new RuntimeVariableScope(initial, this);
+  child(initial: Record<string, WorkflowJsonValue> = {}, unknown = this.dependsOnUnknown): RuntimeVariableScope {
+    return new RuntimeVariableScope(initial, this, unknown);
   }
 }
 
@@ -93,11 +106,18 @@ export class WorkflowRetryableStepError extends Error {
   }
 }
 
-class WorkflowValueError extends Error {}
+export class WorkflowValueError extends Error {
+  constructor(
+    message: string,
+    readonly code = "WORKFLOW_VALUE_UNAVAILABLE",
+  ) {
+    super(message);
+  }
+}
 
-class WorkflowValueWaiting extends Error {
+export class WorkflowValueWaiting extends Error {
   constructor(
-    reference: string,
+    readonly reference: string,
     readonly dependency: WorkflowDependency,
   ) {
     super(`workflow reference "${reference}" is waiting`);
@@ -189,7 +209,10 @@ const resolveLocalReference = (state: RuntimeState, scope: RuntimeVariableScope,
   if (rootName === "inputs") root = state.options.invocation.inputs;
   else if (rootName === "bindings") root = state.options.plan.bindings;
   else if (rootName === "context") root = state.options.invocation.context ?? {};
-  else root = scope.get(rootName);
+  else {
+    if (scope.isUnknown(rootName)) return { state: "waiting", dependency: { kind: "workflow.dry-run-value", key: rootName } };
+    root = scope.get(rootName);
+  }
   const value = root === undefined || segments.length === 0 ? root : readWorkflowValuePath(root, segments);
   return value === undefined ? { state: "missing" } : { state: "resolved", value };
 };
@@ -201,7 +224,8 @@ const resolveReference = async (
   path: Array<string | number> = [],
 ): Promise<WorkflowValueResolution> => {
   const local = () => resolveLocalReference(state, scope, reference);
-  if (!state.options.values) return local();
+  const localValue = local();
+  if (localValue.state === "waiting" || !state.options.values) return localValue;
   const resolved = await state.options.values.resolve({
     reference,
     path,
@@ -297,12 +321,43 @@ const evaluateCondition = async (
     if (waiting) throw waiting;
     return false;
   }
-  if (condition.operator === "not") return !(await evaluateCondition(state, scope, condition.condition, [...path, "not"]));
+  if (condition.operator === "not") {
+    const matched = !(await evaluateCondition(state, scope, condition.condition, [...path, "not"]));
+    if (state.options.mode === "dryRun") await emit(state, { type: "condition.evaluated", run: state.run, path, matched });
+    return matched;
+  }
   if (condition.operator === "exists") {
     const resolved = await resolveReference(state, scope, condition.reference, [...path, "exists"]);
     if (resolved.state === "waiting") throw new WorkflowValueWaiting(condition.reference, resolved.dependency);
     return resolved.state === "resolved" && resolved.value !== null && resolved.value !== "";
   }
+  if (
+    condition.operator === "greaterThan" ||
+    condition.operator === "lessThan" ||
+    condition.operator === "atLeast" ||
+    condition.operator === "atMost"
+  ) {
+    const numbers: number[] = [];
+    for (const [index, operand] of condition.operands.entries()) {
+      const expression = typeof operand === "string" ? EXACT_EXPRESSION.exec(operand)?.[1]?.trim() : undefined;
+      let value: WorkflowJsonValue;
+      if (expression && expression !== "now()") {
+        const resolved = await resolveReference(state, scope, expression, [...path, condition.operator, index]);
+        if (resolved.state === "waiting") throw new WorkflowValueWaiting(expression, resolved.dependency);
+        if (resolved.state === "missing") return false;
+        value = resolved.value;
+      } else {
+        value = await evaluateValue(state, scope, operand, [...path, condition.operator, index]);
+      }
+      if (typeof value !== "number" || !Number.isFinite(value)) return false;
+      numbers.push(value);
+    }
+    const [left, right] = numbers;
+    if (condition.operator === "greaterThan") return left! > right!;
+    if (condition.operator === "lessThan") return left! < right!;
+    if (condition.operator === "atLeast") return left! >= right!;
+    return left! <= right!;
+  }
   const left = await evaluateValue(state, scope, condition.operands[0], [...path, condition.operator, 0]);
   const right = await evaluateValue(state, scope, condition.operands[1], [...path, condition.operator, 1]);
   if (condition.operator === "equals") return jsonEqual(left, right);
@@ -363,7 +418,7 @@ const actionContext = (
   };
   return state.options.mode === "execute"
     ? ({ ...common, mode: "execute" } as WorkflowExecuteActionContext)
-    : ({ ...common, mode: "dryRun" } as WorkflowDryRunActionContext);
+    : ({ ...common, mode: "dryRun", dependsOnUnknown: scope.dependsOnUnknown } as WorkflowDryRunActionContext);
 };
 
 const invalidRestoration = (state: RuntimeState, step: WorkflowRuntimeStepIdentity, message: string): Flow =>
@@ -449,11 +504,18 @@ const restoreCompletedIfDescendants = async (
   irStep: Extract<WorkflowIrStep, { kind: "if" }>,
   iterationPath: number[],
   persistedTraversal: unknown,
+  unknown: boolean,
 ): Promise<Flow> => {
   const traversal = persistedIfTraversal(persistedTraversal);
   for (const branch of traversal.branches) {
-    const flow = await restoreCompletedSteps(state, scope.child(), branch === "then" ? irStep.then : irStep.else, iterationPath);
-    if (flow.state !== "continue") return flow;
+    const flow = await restoreCompletedSteps(
+      state,
+      scope.child({}, scope.dependsOnUnknown || unknown),
+      branch === "then" ? irStep.then : irStep.else,
+      iterationPath,
+    );
+    if (unknown && flow.state === "terminal_planned") scope.dependsOnUnknown = true;
+    else if (flow.state !== "continue") return flow;
   }
   return { state: "continue" };
 };
@@ -464,13 +526,15 @@ const restoreCompletedSwitchDescendants = async (
   irStep: Extract<WorkflowIrStep, { kind: "switch" }>,
   iterationPath: number[],
   persistedTraversal: unknown,
+  unknown: boolean,
 ): Promise<Flow> => {
   const traversal = persistedSwitchTraversal(irStep, persistedTraversal);
   for (const branch of traversal.branches) {
     const steps = branch === "default" ? irStep.default : irStep.cases[branch]?.steps;
     if (!steps) throw new WorkflowValueError(`completed switch step references unavailable branch "${branch}"`);
-    const flow = await restoreCompletedSteps(state, scope.child(), steps, iterationPath);
-    if (flow.state !== "continue") return flow;
+    const flow = await restoreCompletedSteps(state, scope.child({}, scope.dependsOnUnknown || unknown), steps, iterationPath);
+    if (unknown && flow.state === "terminal_planned") scope.dependsOnUnknown = true;
+    else if (flow.state !== "continue") return flow;
   }
   return { state: "continue" };
 };
@@ -481,6 +545,7 @@ const restoreCompletedForEachDescendants = async (
   irStep: Extract<WorkflowIrStep, { kind: "forEach" }>,
   iterationPath: number[],
   persistedTraversal: unknown,
+  unknown: boolean,
 ): Promise<Flow> => {
   const traversal = persistedForEachTraversal(persistedTraversal);
   const limit = loopItemLimit(state);
@@ -488,11 +553,11 @@ const restoreCompletedForEachDescendants = async (
     throw new WorkflowValueError(`completed forEach traversal has ${traversal.items.length} items; limit is ${limit}`);
   }
   for (let index = 0; index < traversal.items.length; index += 1) {
-    const flow = await restoreCompletedSteps(state, scope.child({ [irStep.alias]: traversal.items[index]! }), irStep.steps, [
-      ...iterationPath,
-      index,
-    ]);
-    if (flow.state !== "continue") return flow;
+    const child = scope.child({ [irStep.alias]: traversal.items[index]! }, scope.dependsOnUnknown || unknown);
+    if (unknown) child.markUnknown(irStep.alias);
+    const flow = await restoreCompletedSteps(state, child, irStep.steps, [...iterationPath, index]);
+    if (unknown && flow.state === "terminal_planned") scope.dependsOnUnknown = true;
+    else if (flow.state !== "continue") return flow;
   }
   return { state: "continue" };
 };
@@ -503,13 +568,14 @@ const restoreCompletedControlDescendants = (
   irStep: Exclude<WorkflowIrStep, { kind: "action" }>,
   iterationPath: number[],
   persistedTraversal: WorkflowControlTraversal | undefined,
+  unknown = false,
 ): Promise<Flow> => {
   if (!persistedTraversal) {
     throw new WorkflowValueError(`completed ${irStep.kind} step is missing its persisted control traversal`);
   }
-  if (irStep.kind === "if") return restoreCompletedIfDescendants(state, scope, irStep, iterationPath, persistedTraversal);
-  if (irStep.kind === "switch") return restoreCompletedSwitchDescendants(state, scope, irStep, iterationPath, persistedTraversal);
-  return restoreCompletedForEachDescendants(state, scope, irStep, iterationPath, persistedTraversal);
+  if (irStep.kind === "if") return restoreCompletedIfDescendants(state, scope, irStep, iterationPath, persistedTraversal, unknown);
+  if (irStep.kind === "switch") return restoreCompletedSwitchDescendants(state, scope, irStep, iterationPath, persistedTraversal, unknown);
+  return restoreCompletedForEachDescendants(state, scope, irStep, iterationPath, persistedTraversal, unknown);
 };
 
 const restoreCompletedState = async (
@@ -524,7 +590,14 @@ const restoreCompletedState = async (
       return restoreCompletedControlDescendants(state, scope, irStep, step.iterationPath, restored.outcome.control);
     }
     if (restored.mode === "dryRun" && restored.outcome.state === "planned") {
-      return restoreCompletedControlDescendants(state, scope, irStep, step.iterationPath, restored.outcome.control);
+      return restoreCompletedControlDescendants(
+        state,
+        scope,
+        irStep,
+        step.iterationPath,
+        restored.outcome.control,
+        restored.outcome.issues?.some((issue) => issue.step.key === step.key) ?? false,
+      );
     }
     return { state: "continue" };
   }
@@ -539,6 +612,16 @@ const restoreCompletedState = async (
       return invalidRestoration(state, step, `planner for action "${irStep.action}" is unavailable while restoring step "${step.key}"`);
     await handler.restoreCompleted?.(actionContext(state, scope, step) as WorkflowDryRunActionContext, irStep, restored.outcome);
   }
+  if (restored.mode === "dryRun") {
+    const savedName = irStep.action === "setVariable" ? irStep.config.name : irStep.config.saveAs;
+    if (
+      typeof savedName === "string" &&
+      (restored.outcome.state === "indeterminate" ||
+        restored.outcome.state === "unsupported" ||
+        (restored.outcome.state === "planned" && restored.outcome.output === undefined && restored.outcome.issues?.length))
+    )
+      scope.markUnknown(savedName);
+  }
   return { state: "continue" };
 };
 
@@ -639,6 +722,15 @@ const evaluateAction = async (
   const outcome: WorkflowPlanningOutcome = handler
     ? await handler.plan(actionContext(state, scope, step) as WorkflowDryRunActionContext, irStep)
     : { state: "unsupported", reason: `action "${irStep.action}" has no dry-run handler` };
+  const savedName = irStep.action === "setVariable" ? irStep.config.name : irStep.config.saveAs;
+  if (
+    typeof savedName === "string" &&
+    (outcome.state === "indeterminate" ||
+      outcome.state === "unsupported" ||
+      (outcome.state === "planned" && outcome.output === undefined && outcome.issues?.length))
+  ) {
+    scope.markUnknown(savedName);
+  }
   if (outcome.state === "planned" || outcome.state === "terminal") {
     state.effects.push(...outcome.effects);
     state.issues.push(...restoredIssues(state, outcome.issues));
@@ -729,8 +821,9 @@ const analyzeUnknownBranches = async (
   const branches =
     irStep.kind === "if" ? [irStep.then, irStep.else] : [...irStep.cases.map((candidate) => candidate.steps), irStep.default];
   for (const branch of branches) {
-    const flow = await runSteps(state, branch, scope.child(), iterationPath);
+    const flow = await runSteps(state, branch, scope.child({}, true), iterationPath);
     if (flow.state === "canceled") return flow;
+    if (flow.state === "terminal_planned") scope.dependsOnUnknown = true;
   }
   return { state: "continue" };
 };
@@ -786,10 +879,13 @@ const evaluateControl = async (
       if (state.options.mode !== "dryRun") throw new WorkflowValueError(reason);
       state.issues.push({ state: "indeterminate", reason, step: stepIdentity(state, irStep, iterationPath) });
       control = { kind: "forEach", items: [null] };
-      flow = await runSteps(state, irStep.steps, scope.child({ [irStep.alias]: null }), [...iterationPath, 0]);
+      const unknownScope = scope.child({}, true);
+      unknownScope.markUnknown(irStep.alias);
+      flow = await runSteps(state, irStep.steps, unknownScope, [...iterationPath, 0]);
       if (flow.state === "canceled") {
         return { flow, result: resultForHaltedControl(state, flow, effectsStart, issuesStart) };
       }
+      if (flow.state === "terminal_planned") scope.dependsOnUnknown = true;
       flow = { state: "continue" };
       return { flow, result: resultForCompletedControl(state, undefined, control, effectsStart, issuesStart) };
     }
@@ -842,6 +938,10 @@ const evaluateStep = async (
       };
     }
     if (error instanceof WorkflowValueWaiting) {
+      if (state.options.mode === "dryRun" && irStep.kind === "action") {
+        const name = irStep.action === "setVariable" ? irStep.config.name : irStep.config.saveAs;
+        if (typeof name === "string") scope.markUnknown(name);
+      }
       if (state.options.mode === "execute") {
         const outcome: WorkflowStepOutcome = { state: "waiting", dependency: error.dependency };
         return { flow: { state: "waiting", dependency: error.dependency, step }, result: { mode: "execute", outcome } };
@@ -850,16 +950,16 @@ const evaluateStep = async (
       return { flow: { state: "indeterminate", reason: outcome.reason, step }, result: { mode: "dryRun", outcome } };
     }
     if (state.options.mode === "dryRun") {
+      if (irStep.kind === "action") {
+        const name = irStep.action === "setVariable" ? irStep.config.name : irStep.config.saveAs;
+        if (typeof name === "string") scope.markUnknown(name);
+      }
       const outcome: WorkflowPlanningOutcome = { state: "indeterminate", reason: errorMessage(error) };
       return { flow: { state: "indeterminate", reason: outcome.reason, step }, result: { mode: "dryRun", outcome } };
     }
     const outcome: WorkflowStepOutcome = {
       state: "failed",
-      error: executionError(
-        error instanceof WorkflowValueError ? "WORKFLOW_VALUE_UNAVAILABLE" : "WORKFLOW_ACTION_ERROR",
-        errorMessage(error),
-        false,
-      ),
+      error: executionError(error instanceof WorkflowValueError ? error.code : "WORKFLOW_ACTION_ERROR", errorMessage(error), false),
     };
     return { flow: { state: "failed", error: outcome.error, step }, result: { mode: "execute", outcome } };
   }

package/src/workflows/runtime/index.ts

@@ -14,6 +14,8 @@ export {
   executeWorkflowPlan,
   WorkflowLeaseLostError,
   WorkflowRetryableStepError,
+  WorkflowValueError,
+  WorkflowValueWaiting,
 } from "./executor";
 export type {
   WorkflowActionStep,

package/src/workflows/runtime/ports.ts

@@ -78,7 +78,10 @@ type WorkflowActionContextBase<Mode extends WorkflowInvocationMode> = {
 };
 
 export type WorkflowExecuteActionContext = WorkflowActionContextBase<"execute">;
-export type WorkflowDryRunActionContext = WorkflowActionContextBase<"dryRun">;
+export type WorkflowDryRunActionContext = WorkflowActionContextBase<"dryRun"> & {
+  /** The containing branch cannot be selected without an unavailable value. */
+  dependsOnUnknown?: boolean;
+};
 
 export type WorkflowExecuteActionHandler = {
   execute(context: WorkflowExecuteActionContext, step: WorkflowActionStep): Promise<WorkflowStepOutcome>;
@@ -120,6 +123,7 @@ export interface WorkflowDryRunActionPort {
  * carried a copy of it would be one more thing to keep in step.
  */
 export type WorkflowTraceEvent =
+  | { type: "condition.evaluated"; run: WorkflowRuntimeRunIdentity; path: Array<string | number>; matched: boolean }
   | { type: "run.started"; run: WorkflowRuntimeRunIdentity }
   | { type: "step.started"; step: WorkflowRuntimeStepIdentity }
   | { type: "step.restored"; step: WorkflowRuntimeStepIdentity; restored: WorkflowRestoredStep }

package/src/workflows/store/actions.ts

@@ -434,7 +434,7 @@ export const createWorkflowDryRunPort = (module: DefinedWorkflowModule): Workflo
           applySaveAs(ctx, step, (planned.output ?? undefined) as WorkflowJsonValue | undefined);
           return {
             state: "planned" as const,
-            output: (planned.output ?? null) as WorkflowJsonValue,
+            ...(planned.outputUnavailable ? {} : { output: planned.output ?? null }),
             effects: [{ action: name, summary: planned.summary, ...(consumes ? { consumes } : {}) } as WorkflowJsonValue],
             // An issue names the step it belongs to, so the dry-run view can point
             // at what could not be determined rather than listing loose strings.

package/src/workflows/store/definitions.ts

@@ -145,6 +145,11 @@ export const deleteWorkflowScope = async (scope: { appId: string; scopeId: strin
       DELETE FROM workflows.workflow WHERE app_id = ${scope.appId} AND scope_id = ${scope.scopeId} RETURNING id
     `;
     await tx`DELETE FROM workflows.event WHERE app_id = ${scope.appId} AND scope_id = ${scope.scopeId}`;
+    const [ai] = await tx<{ present: boolean }[]>`SELECT to_regclass('ai.workflow_scope_budget') IS NOT NULL AS present`;
+    if (ai?.present) {
+      await tx`DELETE FROM ai.workflow_scope_budget WHERE app_id = ${scope.appId} AND scope_id = ${scope.scopeId}`;
+      await tx`DELETE FROM ai.workflow_scope_admission WHERE app_id = ${scope.appId} AND scope_id = ${scope.scopeId}`;
+    }
     return rows.length;
   });
 };

package/src/workflows/store/runs.ts

@@ -24,7 +24,7 @@ import type {
   WorkflowCoordinatorPort,
   WorkflowCoordinatorReleaseState,
 } from "../runtime/coordinator";
-import { WorkflowLeaseLostError } from "../runtime/executor";
+import { WorkflowLeaseLostError, WorkflowRetryableStepError } from "../runtime/executor";
 import type {
   WorkflowHeartbeatOutcome,
   WorkflowRestoredStep,
@@ -401,7 +401,7 @@ export const finishWorkflowRun = async (
  */
 export const releaseWorkflowRun = async (
   claim: { runId: string; executionGeneration: number; consecutiveFailures?: number },
-  options: { backoffMs?: number; db?: SQL } = {},
+  options: { backoffMs?: number; db?: SQL; error?: WorkflowJsonValue } = {},
 ): Promise<WorkflowCoordinatorReleaseState> => {
   const db = options.db ?? sql;
   const backoffMs =
@@ -413,6 +413,7 @@ export const releaseWorkflowRun = async (
         lease_expires_at = NULL,
         retry_after = now() + ${`${backoffMs} milliseconds`}::interval,
         consecutive_failures = consecutive_failures + 1,
+        error = ${options.error ?? null},
         updated_at = now()
     WHERE id = ${claim.runId}
       AND execution_generation = ${claim.executionGeneration}
@@ -545,7 +546,8 @@ export const createWorkflowCoordinatorPort = (options: {
   claim: () => claimWorkflowRun(options),
   renew: (claim) => renewWorkflowRunLease(claim, { leaseMs: options.leaseMs }),
   finish: (claim, result) => finishWorkflowRun(claim, result),
-  release: (claim) => releaseWorkflowRun(claim),
+  release: (claim, error) =>
+    releaseWorkflowRun(claim, { ...(error instanceof WorkflowRetryableStepError ? { error: error.executionError } : {}) }),
 });
 
 // ─── Scans ───────────────────────────────────────────────────────────────────

package/src/workflows/store/worker.ts

@@ -184,10 +184,15 @@ export const runOneWorkflow = async (options: WorkflowWorkerOptions & { runId?:
       const incompatible = await validateCurrentModule(claim, options.module);
       if (incompatible) return incompatible;
       if (claim.consecutiveFailures >= WORKFLOW_RUN_MAX_CONSECUTIVE_FAILURES) {
+        const [prior] = await db<{ code: string | null; message: string | null }[]>`
+          SELECT error ->> 'code' AS code, error ->> 'message' AS message FROM workflows.run WHERE id = ${claim.runId}::uuid
+        `;
+        const aiCode = prior?.code?.startsWith("WORKFLOW_AI_") ? prior.code : null;
         const error = {
-          code: "WORKFLOW_RETRY_EXHAUSTED",
-          message: `workflow failed ${claim.consecutiveFailures} consecutive attempts`,
+          code: aiCode ?? "WORKFLOW_RETRY_EXHAUSTED",
+          message: `${aiCode && prior?.message ? `${prior.message} ` : ""}Workflow failed ${claim.consecutiveFailures} consecutive attempts. Inspect the source or retry after capacity recovers.`,
           retryable: false,
+          ...(aiCode ? { details: { retryExhausted: true } } : {}),
         };
         await db`
           UPDATE workflows.step_outcome AS s

package/src/ai/model-pricing.ts

@@ -1,43 +0,0 @@
-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 AiModelPricing, AiModelPricingSchema } from "../shared/ai-costs";
-import { AiQuotaError } from "./quotas";
-import { parseAiModelProfiles } from "./settings";
-
-/** Change prices only, preserving credentials and model access in their own stores. */
-export async function setAiModelPricing(id: string, pricing: AiModelPricing | null, expected: AiModelPricing | null, actorId: string) {
-  if (pricing) AiModelPricingSchema.parse(pricing);
-  const key = "ai.model_profiles_json";
-  const fallback = await coreSettings.get<string>(key);
-  const result = await sql.begin(async (db) => {
-    const [row] = await db<{ value: string }[]>`SELECT value FROM settings.entries WHERE key=${key} FOR UPDATE`;
-    const raw = row ? await decryptValue(row.value) : fallback;
-    if (typeof raw !== "string") throw new Error("Invalid model configuration.");
-    const parsed = parseAiModelProfiles(raw);
-    if (parsed.error) throw new Error(parsed.error.message);
-    const profile = parsed.profiles.find((profile) => profile.id === id);
-    if (!profile) throw new AiQuotaError("quota_conflict", "Model no longer exists.");
-    if (profile.capabilities.includes("transcription")) throw new AiQuotaError("quota_conflict", "Audio pricing is not supported.");
-    if (JSON.stringify(profile.pricing ?? null) !== JSON.stringify(expected))
-      throw new AiQuotaError("quota_conflict", "Model prices changed. Read them again before updating.");
-    if (pricing) profile.pricing = pricing;
-    else delete profile.pricing;
-    await setSetting(key, JSON.stringify(parsed.profiles), db);
-    await audit.record(
-      {
-        action: "ai.model.pricing",
-        outcome: "allowed",
-        actor: { userId: actorId },
-        target: { type: "ai-model", id },
-        metadata: { pricing },
-      },
-      db,
-    );
-    return { id, pricing: profile.pricing ?? null };
-  });
-  await invalidateSettingsCache([key]);
-  return result;
-}

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

@@ -1,98 +0,0 @@
-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;
-};