mirror of
https://github.com/MBombeck/HealthLog.git
synced 2026-11-18 16:12:11 +00:00
Eight call sites (Coach turn, status texts, briefing, comprehensive insights, medication extraction, about-me questions, both lab OCR paths, the saved-config connection test) answered an empty chain by calling the single-provider resolver, which ignores the chain's switches. A person who kept only the local model on and lost its address got the ChatGPT sign-in or the operator key instead, and every copy tagged that provider as the operator key, so consent and cost attribution saw the wrong owner. The rule now lives once in `resolveProviderChain`, and the presence probe reads the same rule: a saved chain is the person's word, so an empty one stays empty. Only a chain never saved falls back, to the OpenAI-compatible gateway picked under Settings, AI, because the default chain has no entry for it; that entry carries its real type. The callers drop their copies, and the presence helpers that restated the old fallback go with them.
437 lines
17 KiB
TypeScript
437 lines
17 KiB
TypeScript
import { probeProviderPresence, resolveProviderChain } from "@/lib/ai/provider";
|
|
import { aiCapabilityForRecord } from "@/lib/ai/capabilities/gate";
|
|
import type {
|
|
AiCapabilityKey,
|
|
AiUnavailableReason,
|
|
} from "@/lib/ai/capabilities/types";
|
|
import { runRawCompletionWithFallback } from "@/lib/ai/provider-runner";
|
|
import { spentOnFailure } from "@/lib/ai/reasoning/answerless";
|
|
import { aiEgressRefusal } from "@/lib/ai/capabilities/egress";
|
|
import { annotate } from "@/lib/logging/context";
|
|
import {
|
|
buildDateKey,
|
|
reconcileSpend,
|
|
reserveBudget,
|
|
resolveCostOwner,
|
|
resolveDailyCapFor,
|
|
type BudgetCostOwner,
|
|
} from "@/lib/ai/coach/budget";
|
|
import {
|
|
AI_BUDGETS,
|
|
REFERENCE_AI_SEED,
|
|
STATUS_MODEL_CALLS,
|
|
} from "@/lib/ai/ai-budgets";
|
|
import { singleUserTurn } from "@/lib/ai/types";
|
|
import { STATUS_PROVIDER_TIMEOUT_MS, withTimeout } from "./with-timeout";
|
|
import { prisma } from "@/lib/db";
|
|
import { resolveEffectiveTimeoutMs } from "@/lib/ai/effective-timeout";
|
|
import {
|
|
REASONING_THINKING_BUDGET,
|
|
type BackgroundReasoningJob,
|
|
} from "@/lib/ai/reasoning/levels";
|
|
import { resolveJobReasoning } from "@/lib/ai/reasoning/controls";
|
|
import {
|
|
holdStatusNoteWhileBenched,
|
|
statusNoteCoolingDown,
|
|
} from "./status-negative-window";
|
|
|
|
/**
|
|
* v1.41 — the fallback ceiling for a status-path call that reasons. Thinking
|
|
* is spent before the first answer token, so the 60 s status budget would cut
|
|
* a medium-effort narrative off mid-thought. A positive per-record setting
|
|
* still wins, as everywhere.
|
|
*/
|
|
export const REASONING_JOB_TIMEOUT_MS = 90_000;
|
|
|
|
/**
|
|
* The outer bound of one status run: the per-call timeout for each of the
|
|
* `STATUS_MODEL_CALLS` calls the run may make in a row. Bounded at one call,
|
|
* a thinking model whose first answer was reasoning alone timed out in the
|
|
* middle of the repeat that would have answered, and a slow local model the
|
|
* person had given 300 s or more per call never landed its note (#1274).
|
|
* Every caller is a background job; the job expiries in `queue-runtime.ts`
|
|
* sit above this at the largest setting.
|
|
*/
|
|
export function statusRunBoundMs(effectiveTimeoutMs: number): number {
|
|
return effectiveTimeoutMs * STATUS_MODEL_CALLS;
|
|
}
|
|
|
|
/**
|
|
* Shared provider plumbing for the seven `*-status.ts` generators.
|
|
*
|
|
* Before this, each generator resolved a single provider via
|
|
* `resolveProvider()` and raced one `generateCompletion()` call against
|
|
* a 20 s cap. A degraded primary provider could not cascade, and the
|
|
* cap fired below the providers' own 60 s floor — converting healthy-
|
|
* but-slow generations into the generic fallback.
|
|
*
|
|
* This helper mirrors the Coach (`chat/route.ts`): resolve the user's
|
|
* provider chain and run `runRawCompletionWithFallback` so a degraded
|
|
* provider cascades to the next. The whole thing is still wrapped in
|
|
* `withTimeout` (`statusRunBoundMs`) so a total stall cannot hold the job —
|
|
* but a timeout / error is reported as a transient miss (the caller serves
|
|
* the fallback without persisting it), never as the day's cached assessment.
|
|
*/
|
|
|
|
export type StatusProviderResult =
|
|
/**
|
|
* Nothing was sent: no provider, or the capability is unavailable for this
|
|
* record (operator switch, opt-out, module, consent, …). Callers serve the
|
|
* deterministic line and persist nothing; `reason` says which layer said no.
|
|
*/
|
|
| { kind: "none"; reason: AiUnavailableReason }
|
|
| { kind: "timeout" }
|
|
| { kind: "error" }
|
|
| {
|
|
kind: "ok";
|
|
content: string;
|
|
providerType: string;
|
|
model: string;
|
|
tokensUsed: number | null;
|
|
};
|
|
|
|
interface RunStatusCompletionArgs {
|
|
userId: string;
|
|
cacheAction: string;
|
|
systemPrompt: string;
|
|
userPrompt: string;
|
|
temperature?: number;
|
|
maxTokens?: number;
|
|
/**
|
|
* v1.18.7 — optional deterministic seed override. Defaults to
|
|
* `REFERENCE_AI_SEED` for every status/reference surface (reproducible
|
|
* QA); the period narrative passes the same constant explicitly.
|
|
*/
|
|
seed?: number;
|
|
/**
|
|
* v1.18.7 — output contract of this generation. The per-metric status
|
|
* cards return a JSON `{ "summary": ... }` (the default), so they opt the
|
|
* non-OpenAI chains into their strongest JSON mode. The period narrative
|
|
* returns PLAIN TEXT and passes `"text"` to suppress that.
|
|
*/
|
|
responseFormat?: "json" | "text";
|
|
/**
|
|
* The AI capability this generation serves (`statusText`, `periodNarrative`,
|
|
* `workoutInsights`, `coach`, …). Required: the chokepoint re-checks it
|
|
* immediately before anything leaves the machine, so a job enqueued before
|
|
* an operator flipped a switch, or before the person withdrew consent or
|
|
* turned AI analysis off, still stops here. The capability also names the
|
|
* consent kinds an operator-held chain entry needs.
|
|
*/
|
|
capability: AiCapabilityKey;
|
|
/**
|
|
* v1.41 — the background job this call is, when it is one of the few that
|
|
* may reason (`BACKGROUND_REASONING_JOBS`: the period narratives and the
|
|
* Coach memory passes). Absent for every status card, batch note, derived
|
|
* score and workout line, which therefore send exactly what they sent
|
|
* before reasoning existed; `background-reasoning-inventory.test.ts`
|
|
* freezes which call sites set it. The operator's switch and cap apply.
|
|
*/
|
|
reasoningJob?: BackgroundReasoningJob;
|
|
}
|
|
|
|
/**
|
|
* Whether any configured provider could serve text for `userId`: the one
|
|
* presence probe (`probeProviderPresence`). No client construction, no token
|
|
* refresh, no network.
|
|
*/
|
|
export async function hasUsableStatusProvider(
|
|
userId: string,
|
|
): Promise<boolean> {
|
|
return probeProviderPresence(userId, "text");
|
|
}
|
|
|
|
/**
|
|
* Run a status generation across the user's provider chain, bounded by the
|
|
* per-user response-timeout setting (falling back to `STATUS_PROVIDER_TIMEOUT_MS`
|
|
* when unset) for each call the run may make (`statusRunBoundMs`). The result discriminates between
|
|
* no-provider / timeout / provider-error / success so the caller can
|
|
* decide what to persist — only `ok` is ever cached as the day's
|
|
* assessment.
|
|
*/
|
|
export async function runStatusCompletion(
|
|
args: RunStatusCompletionArgs,
|
|
): Promise<StatusProviderResult> {
|
|
const { userId, cacheAction, systemPrompt, userPrompt } = args;
|
|
|
|
// The capability, re-checked at the wire. Every caller resolved it earlier
|
|
// (a worker before building its snapshot, a route before enqueueing), but
|
|
// switches, opt-outs and consent can change between the enqueue and here.
|
|
const capability = await aiCapabilityForRecord(userId, args.capability);
|
|
if (!capability.available) {
|
|
const reason = capability.reason ?? "check_failed";
|
|
annotate({
|
|
action: { name: "insights.status.capability_unavailable" },
|
|
meta: { cacheAction, capability: args.capability, reason },
|
|
});
|
|
return { kind: "none", reason };
|
|
}
|
|
|
|
const chain = await resolveProviderChain(userId);
|
|
if (chain.length === 0) {
|
|
return { kind: "none", reason: "no_provider" };
|
|
}
|
|
|
|
// #1279 — a note whose last generations ended without one waits out its
|
|
// window here, whichever path selected it again (a data sync, a warm pass,
|
|
// a queued job). Reported as `error`, the transient miss, like a stall.
|
|
if (await statusNoteCoolingDown(userId, cacheAction)) {
|
|
annotate({
|
|
action: { name: "insights.status.cooling_down" },
|
|
meta: { cacheAction },
|
|
});
|
|
return { kind: "error" };
|
|
}
|
|
|
|
// The wire re-check for exactly this chain (`aiEgressRefusal`, the one
|
|
// helper every chokepoint uses): the capability again, and whether sending
|
|
// to these providers needs a consent receipt under the capability's rule
|
|
// (the operator's key or the shared central Codex does; a person's own key
|
|
// or a local model does not). Fails closed like the rest: a chain that
|
|
// COULD cascade to an operator-held entry needs the receipt.
|
|
const refusal = await aiEgressRefusal(
|
|
args.capability,
|
|
userId,
|
|
chain.map((entry) => entry.providerType),
|
|
);
|
|
if (refusal) {
|
|
annotate({
|
|
action: { name: "insights.status.capability_unavailable" },
|
|
meta: {
|
|
cacheAction,
|
|
capability: args.capability,
|
|
reason: refusal.reason,
|
|
at: "wire",
|
|
},
|
|
});
|
|
return { kind: "none", reason: refusal.reason };
|
|
}
|
|
|
|
// The per-user response-timeout setting (Settings → AI), threaded here onto
|
|
// every status / reference surface at once. A positive stored value wins
|
|
// (seconds → ms); unset falls back to the status-path budget. Applied to the
|
|
// call's own `timeoutMs` and, times the calls a run may make, to the outer
|
|
// `withTimeout` cap, so a raised value is not clipped by a shorter bound.
|
|
const settingsRow = await prisma.user.findUnique({
|
|
where: { id: userId },
|
|
select: { aiResponseTimeoutSeconds: true },
|
|
});
|
|
// v1.41 — resolved once per call, after the capability and egress checks
|
|
// so a refused call never reads the controls. `undefined` (the operator
|
|
// switched reasoning off, or the job resolved off) is today's wire.
|
|
const reasoning = args.reasoningJob
|
|
? await resolveJobReasoning(args.reasoningJob, chain, userId)
|
|
: undefined;
|
|
const thinkingTokens =
|
|
reasoning && reasoning.effort !== "off"
|
|
? REASONING_THINKING_BUDGET[reasoning.effort]
|
|
: 0;
|
|
|
|
const effectiveTimeoutMs = resolveEffectiveTimeoutMs(
|
|
settingsRow?.aiResponseTimeoutSeconds,
|
|
thinkingTokens > 0 ? REASONING_JOB_TIMEOUT_MS : STATUS_PROVIDER_TIMEOUT_MS,
|
|
);
|
|
|
|
// The answer budget. Each client adds the thinking budget on top itself.
|
|
const maxTokens = args.maxTokens ?? AI_BUDGETS.status.maxTokens;
|
|
|
|
// The day's token ledger, for EVERY status/reference family (the cards, the
|
|
// batched assessment, the derived scores, the period narrative, and the
|
|
// off-request Coach memory workers).
|
|
//
|
|
// The reservation is atomic (single upsert-increment), matching the Coach and
|
|
// document paths: a read-then-write check would let concurrent generations
|
|
// each observe a sub-cap total and all proceed. We reserve an ESTIMATE up
|
|
// front — the output ceiling plus a ~4-chars-per-token approximation of the
|
|
// prompt we are about to send — and reconcile against the provider's reported
|
|
// count afterwards, refunding in full when nothing was generated.
|
|
//
|
|
// The cap follows the COST OWNER: `resolveDailyCapFor` charges
|
|
// the operator ceiling only when the chain's primary is the operator's own
|
|
// credential (`admin-openai` / `admin-codex`). A self-hoster on their own key
|
|
// or a local model is measured against the generous user-plan ceiling, so
|
|
// their own hardware/plan is never rationed by the operator's bill.
|
|
const dateKey = await buildDateKey(userId);
|
|
// Thinking is billed as output, so a reasoning call reserves its thinking
|
|
// budget too; the reconcile below settles on the reported count.
|
|
const estimatedTokens =
|
|
maxTokens +
|
|
thinkingTokens +
|
|
Math.ceil((systemPrompt.length + userPrompt.length) / 4);
|
|
// v1.38.19 — a background surface: half the day's ceiling when the
|
|
// operator funds the chain.
|
|
const jobCap = resolveDailyCapFor("job", chain);
|
|
const reservation = await reserveBudget(
|
|
userId,
|
|
estimatedTokens,
|
|
dateKey,
|
|
jobCap,
|
|
resolveCostOwner(chain),
|
|
"job",
|
|
);
|
|
if (!reservation.allowed) {
|
|
annotateBudgetRefusal(cacheAction, reservation, jobCap);
|
|
return { kind: "error" };
|
|
}
|
|
|
|
// #1279 — the run's bound aborts the call it cuts off, so a provider call
|
|
// the bound gave up on (and any repeat inside it) stops instead of running
|
|
// on detached, with its spend reported nowhere.
|
|
const abort = new AbortController();
|
|
const raced = await withTimeout(
|
|
() =>
|
|
runRawCompletionWithFallback({
|
|
userId,
|
|
providers: chain,
|
|
// A background generator: an operator-funded fallback hop is rationed
|
|
// at the job share, exactly as the reservation above was.
|
|
surface: "job",
|
|
params: {
|
|
...singleUserTurn({
|
|
system: systemPrompt,
|
|
user: userPrompt,
|
|
temperature: args.temperature ?? AI_BUDGETS.status.temperature,
|
|
maxTokens,
|
|
// v1.18.7 — status/reference output is reproducible: pin the
|
|
// deterministic seed unless a caller overrides it.
|
|
seed: args.seed ?? REFERENCE_AI_SEED,
|
|
// Status cards are JSON by default; the narrative opts out via
|
|
// `"text"`.
|
|
responseFormat: args.responseFormat === "text" ? undefined : "json",
|
|
timeoutMs: effectiveTimeoutMs,
|
|
}),
|
|
signal: abort.signal,
|
|
// v1.41 — only a named job ever carries this; see `reasoningJob`.
|
|
...(reasoning ? { reasoning } : {}),
|
|
},
|
|
}),
|
|
statusRunBoundMs(effectiveTimeoutMs),
|
|
null,
|
|
() => abort.abort(),
|
|
);
|
|
|
|
if (raced.timedOut || raced.errored || raced.value === null) {
|
|
return failedRun(raced, { userId, cacheAction, dateKey, reservation });
|
|
}
|
|
|
|
const { result, workingProvider, tokensSpent } = raced.value;
|
|
// What the provider reported, plus (#1279) what the hops that failed before
|
|
// it spent. The empty-content branch is charged too: those tokens were
|
|
// burned upstream. No count falls back to the reservation, never to zero.
|
|
const actualTokens =
|
|
(result.tokensUsed ?? reservation.reserved) + tokensSpent;
|
|
await reconcileSpend(userId, reservation.reserved, actualTokens, dateKey, 0, {
|
|
servedBy: workingProvider.providerType,
|
|
reservedOwner: reservation.owner,
|
|
});
|
|
|
|
const content = result.content;
|
|
if (typeof content !== "string" || content.trim().length === 0) {
|
|
annotate({
|
|
action: { name: "insights.status.empty_content" },
|
|
meta: { cacheAction, providerType: workingProvider.providerType },
|
|
});
|
|
return { kind: "error" };
|
|
}
|
|
|
|
// Consent withdrawn while the call was in flight. The withdrawal purged the
|
|
// stored text in its own transaction; a reply persisted after it would
|
|
// bring that text back under a consent that no longer exists. So the rule
|
|
// runs once more, against the provider that actually answered, with a fresh
|
|
// receipt read, and a refused reply is dropped as if it had never arrived.
|
|
// The tokens stay on the ledger: they were spent upstream.
|
|
const late = await aiEgressRefusal(args.capability, userId, [
|
|
workingProvider.providerType,
|
|
]);
|
|
if (late) {
|
|
annotate({
|
|
action: { name: "insights.status.capability_unavailable" },
|
|
meta: {
|
|
cacheAction,
|
|
capability: args.capability,
|
|
reason: late.reason,
|
|
at: "reply",
|
|
},
|
|
});
|
|
return { kind: "none", reason: late.reason };
|
|
}
|
|
|
|
return {
|
|
kind: "ok",
|
|
content,
|
|
providerType: workingProvider.providerType,
|
|
model: result.model ?? "unknown",
|
|
tokensUsed: result.tokensUsed ?? null,
|
|
};
|
|
}
|
|
|
|
/**
|
|
* A run that timed out or failed. It charges only what a reply reported
|
|
* spending, never an invented figure; #1279 — a failed chain's report counts,
|
|
* since a model that reasons without answering bills every call, and a full
|
|
* refund let background work spend without the day's ceiling seeing it. A
|
|
* chain that sent nothing (the bench) holds the note without counting it.
|
|
*/
|
|
async function failedRun(
|
|
raced: { timedOut: boolean; error?: unknown },
|
|
run: {
|
|
userId: string;
|
|
cacheAction: string;
|
|
dateKey: string;
|
|
reservation: { reserved: number; owner: BudgetCostOwner };
|
|
},
|
|
): Promise<StatusProviderResult> {
|
|
const spent = spentOnFailure(raced.error);
|
|
await reconcileSpend(
|
|
run.userId,
|
|
run.reservation.reserved,
|
|
spent,
|
|
run.dateKey,
|
|
0,
|
|
{
|
|
servedBy: null,
|
|
reservedOwner: run.reservation.owner,
|
|
},
|
|
);
|
|
if ((raced.error as { sentNothing?: unknown } | null)?.sentNothing === true) {
|
|
await holdStatusNoteWhileBenched({
|
|
userId: run.userId,
|
|
cacheAction: run.cacheAction,
|
|
todayKey: run.dateKey,
|
|
});
|
|
}
|
|
return { kind: raced.timedOut ? "timeout" : "error" };
|
|
}
|
|
|
|
/**
|
|
* Over the day's ceiling. Reported as `error` — a TRANSIENT miss the caller
|
|
* serves the fallback for without persisting it — deliberately NOT `none`,
|
|
* which callers cache as the settled "no provider configured" assessment.
|
|
* The distinct annotation keeps the refusal observable even though the
|
|
* result shape is shared.
|
|
*
|
|
* v1.38.19 — the shared `error` outcome cannot say WHY the generation
|
|
* stopped, so the annotation has to. `surface: "job"` plus `cap` separates
|
|
* "this job used up the background share" from "the whole day is spent", and
|
|
* `limit` says which counter tripped. The operator sees the same split on the
|
|
* admin provider-health card.
|
|
*/
|
|
function annotateBudgetRefusal(
|
|
cacheAction: string,
|
|
reservation: Awaited<ReturnType<typeof reserveBudget>>,
|
|
jobCap: number,
|
|
): void {
|
|
annotate({
|
|
action: { name: "insights.status.budget_exceeded" },
|
|
meta: {
|
|
cacheAction,
|
|
owner: reservation.owner,
|
|
surface: "job",
|
|
limit: reservation.limit,
|
|
cap: jobCap,
|
|
totalAfter: reservation.totalAfter,
|
|
operatorAfter: reservation.operatorAfter,
|
|
},
|
|
});
|
|
}
|