@inflexa-ai/harness 0.45.1 → 0.46.2

package/dist/app/chat-turn.d.ts

@@ -1,26 +1,28 @@
 /**
- * The chat turn of a host: a turn is `runChatTurn`, which is `openChatTurn` and then the `run` of the
- * open turn. `prepareChatTurn` is the first step of the open. The host gives only its transport
- * values, and the harness stores the opening, each round, and the outcome.
+ * The run of one chat turn: `runOpenTurn` runs the root loop over a prepared turn, stores the opening and each
+ * round, and closes the turn with its outcome. A transport gives the surface and the store of the turn. The turn
+ * workflow (`chat-turn-workflow.ts`) gives the transport of a workflow, and a host reaches the turn through it.
  */
-import type { Pool } from "pg";
+import type { LanguageModelMiddleware, ModelMessage, UIMessageStreamWriter } from "ai";
 import type { RequestSession } from "../auth/types.js";
 import type { UsageRecorder } from "../billing/usage-recorder.js";
 import type { TokenUsageRollup } from "../contracts/usage.js";
-import type { DbError } from "../lib/db-result.js";
-import { type AgentFinish } from "../loop/run-agent.js";
+import { type Connectable, type DbError } from "../lib/db-result.js";
+import type { Querier } from "../state/db.js";
+import { type AgentFinish, type LoopOptions } from "../loop/run-loop.js";
 import type { AgentDefinition, EmitFn } from "../loop/types.js";
+import type { ConversationDisplayRecorder } from "../memory/conversation-display-recorder.js";
 import { type ThreadType } from "../memory/thread-store.js";
-import type { AgentChat, PromptCachePolicy } from "../providers/types.js";
+import type { ChatProvider, PromptCachePolicy } from "../providers/types.js";
 import type { ThreadAgentResolver } from "../runtime/assemble.js";
-import type { AskApproval, AskRequest } from "../tools/approval/contract.js";
+import type { AskGateway } from "../tools/approval/gateway.js";
 import { type AssembledMessages } from "./message-assembly.js";
 import type { Logger } from "../lib/logger.js";
 import { type ProvenanceSeam } from "../provenance/seam.js";
-export interface PrepareChatTurnDeps {
+export type PrepareChatTurnDeps = {
     /** Operational logging seam; omitted falls back to no-op. */
     readonly logger?: Logger;
-    readonly pool: Pool;
+    readonly pool: Querier & Connectable;
     /**
      * The provenance seam. The turn reads its session emit member, and no other
      * member. The turn holds the one site that writes the conversation thread of
@@ -31,58 +33,65 @@ export interface PrepareChatTurnDeps {
      * of a report session.
      */
     readonly provenance?: ProvenanceSeam;
-}
-export interface PrepareChatTurnParams {
+};
+export type PrepareChatTurnParams = {
     readonly analysisId: string;
     readonly threadId: string;
     readonly userInput: string;
-}
+};
 export type PrepareChatTurnResult = ({
     readonly kind: "ok";
     readonly threadType: ThreadType;
 } & AssembledMessages) | {
     readonly kind: "not_found";
 };
+/** A prepared turn: the type of its thread, the view of the thread, and the opening. */
+export type PreparedChatTurn = Extract<PrepareChatTurnResult, {
+    kind: "ok";
+}>;
 /**
  * Prepare one chat turn: resolve thread ownership, seed the title, load
  * analysis status, and assemble the message array. Input sanitization stays
  * inside {@link assembleMessages} (applied once to the new user input only).
  */
 export declare function prepareChatTurn(deps: PrepareChatTurnDeps, params: PrepareChatTurnParams): Promise<PrepareChatTurnResult>;
-export interface RunChatTurnDeps extends PrepareChatTurnDeps {
+/**
+ * Open the thread of a turn: check that the analysis owns it, make it when it is absent, and seed its title. A
+ * thread that a different analysis owns is `not_found`.
+ */
+export declare function openThread(deps: PrepareChatTurnDeps, params: PrepareChatTurnParams): Promise<{
+    readonly kind: "ok";
+    readonly threadType: ThreadType;
+} | {
+    readonly kind: "not_found";
+}>;
+/** The analysis context and the run activity of a turn. A failed read gives the fallback of its kind. */
+export declare function readTurnContext(pool: Querier, analysisId: string): Promise<{
+    readonly analysisContext: string | null;
+    readonly runActivityContext: string;
+}>;
+/** The runtime values of a turn. `assembleCoreRuntime` gives them to the turn workflow. */
+export type RunChatTurnDeps = PrepareChatTurnDeps & {
     /** The agent of a turn comes from the thread type, which only the preparation knows. */
     readonly agents: ThreadAgentResolver;
-}
+    /** The model of the conversation. A host that switches the model swaps the provider between two turns. */
+    readonly provider: ChatProvider;
+    /** Each model call of the turn reaches it, the calls of a sub-agent included. */
+    readonly usageRecorder: UsageRecorder;
+    /** The ledger of the asks of a turn. Absent, the loop denies each call that asks for an approval. */
+    readonly askGateway?: AskGateway;
+};
 /**
  * The session of a turn without its provenance. The harness sets the provenance from the agent that
  * it resolves, because only the preparation knows the thread type.
  */
 export type ChatTurnSession = Omit<RequestSession, "provenance">;
 /** What opens a turn: the thread and the user input. */
-export interface OpenChatTurnParams {
+export type OpenChatTurnParams = {
     readonly analysisId: string;
     readonly threadId: string;
     readonly userInput: string;
-}
-/** The transport values of a turn that is open. */
-export interface RunOpenChatTurnParams {
-    readonly session: ChatTurnSession;
-    /** Makes the provider of the turn over the emit sink of the display recorder. */
-    readonly chat: (emit: EmitFn) => AgentChat;
-    readonly emit: EmitFn;
-    readonly signal: AbortSignal;
-    readonly usageRecorder: UsageRecorder;
-    /** The approval binding. It gets the emit sink of the display recorder, thus the display records each `data-ask`. */
-    readonly ask?: (request: AskRequest, emit: EmitFn) => Promise<AskApproval>;
-    /** Who sent the user message. */
-    readonly author?: string;
-    /** When the host opened the turn. Absent counts from the call to {@link openChatTurn}. */
-    readonly startedAtMs?: number;
-    /** The cache policy of the root loop. Absent gives {@link CONVERSATION_PROMPT_CACHE}. */
-    readonly promptCache?: PromptCachePolicy;
-}
-/** The values of one whole turn. */
-export type RunChatTurnParams = OpenChatTurnParams & RunOpenChatTurnParams;
+};
 export type ChatTurnOutcome = {
     readonly status: "done";
     readonly finish: AgentFinish;
@@ -92,6 +101,7 @@ export type ChatTurnOutcome = {
 } | {
     readonly status: "failed";
     readonly reason: string;
+    readonly code: string;
     readonly cause: unknown;
 };
 /** A turn that ended before its run. It wrote no row and no turn record. */
@@ -104,7 +114,7 @@ export type ChatTurnRefusal = {
     readonly kind: "agent_unresolved";
     readonly threadType: ThreadType;
 };
-export interface ChatTurnRan {
+export type ChatTurnRan = {
     readonly kind: "ran";
     readonly outcome: ChatTurnOutcome;
     /** True when the opening of the turn landed. */
@@ -115,25 +125,43 @@ export interface ChatTurnRan {
     readonly turnUsage?: TokenUsageRollup;
     /** The final text of a run that returned. */
     readonly fallbackText?: string;
-}
-export type ChatTurnResult = ChatTurnRefusal | ChatTurnRan;
-/**
- * A turn that is prepared, with its agent resolved. Call `run` one time: each call stores a new
- * opening of the same user message.
- */
-export interface OpenChatTurn {
-    readonly kind: "ready";
-    /** The agent that runs the turn. The harness stamps its provenance on the session of the run. */
-    readonly agent: AgentDefinition;
-    readonly run: (params: RunOpenChatTurnParams) => Promise<ChatTurnRan>;
-}
-/**
- * Open one chat turn: prepare it and resolve its agent. A refusal comes back before any row of the
- * turn exists, thus a host can answer it before it starts a stream.
- */
-export declare function openChatTurn(deps: RunChatTurnDeps, params: OpenChatTurnParams): Promise<OpenChatTurn | ChatTurnRefusal>;
+};
+/** How a turn reaches its surface and its store. A turn workflow streams to its durable stream and runs each write as a step. */
+export type TurnTransport = {
+    readonly signal: AbortSignal;
+    /** The emit sink of the loop. */
+    readonly emit: EmitFn;
+    /** Receives each text delta of the root reply. A turn workflow gives none, because its model calls stream the text. */
+    readonly onText?: (text: string) => void | Promise<void>;
+    /** The durable stream that the model calls write their text to. */
+    readonly chatStream?: string;
+    /** Receives the chunks of each tool step, on a replay too. */
+    readonly toolWriter?: UIMessageStreamWriter;
+    readonly recorder: ConversationDisplayRecorder;
+    /** Runs one write of the turn. A turn workflow runs it as a step. */
+    readonly durably: <T>(name: string, write: () => Promise<T>) => Promise<T>;
+    /** The key of the group of the turn at an index, thus a write that runs again stores nothing. */
+    readonly groupKey?: (index: number) => string;
+    /** Called when the display starts a new assistant message, after a marker. */
+    readonly announce?: (messageId: string) => Promise<void>;
+    /** Model middleware inside the step of each model call. */
+    readonly modelMiddleware?: readonly LanguageModelMiddleware[];
+    /** The decision of the user on a call whose tool asks for approval. Absent: the loop denies such a call. */
+    readonly approve?: LoopOptions["approve"];
+    /** The pause of the turn. A turn workflow gives it. Absent: each failure of a request fails the turn. */
+    readonly pause?: LoopOptions["pause"];
+};
+/** The values of a turn that its run reads. */
+export type TurnRunParams = {
+    readonly session: ChatTurnSession;
+    readonly author?: string;
+    readonly startedAtMs: number;
+    readonly promptCache?: PromptCachePolicy;
+};
 /**
- * Run one chat turn: open it, store its opening, run the root loop with a round sink that stores
- * each round, and close the turn with its outcome.
+ * Run a prepared turn: store its opening, run the root loop with a round sink that stores each round, and close the
+ * turn with its outcome.
  */
-export declare function runChatTurn(deps: RunChatTurnDeps, params: RunChatTurnParams): Promise<ChatTurnResult>;
+export declare function runOpenTurn(deps: RunChatTurnDeps, turn: OpenChatTurnParams, prepared: PreparedChatTurn, agent: AgentDefinition, params: TurnRunParams, transport: TurnTransport): Promise<ChatTurnRan>;
+/** The sanitized text of the user message, thus the display never holds a secret that the model does not see. */
+export declare function userTextOf(message: ModelMessage): string;

package/dist/app/chat-turn.js

@@ -1,24 +1,25 @@
 /**
- * The chat turn of a host: a turn is `runChatTurn`, which is `openChatTurn` and then the `run` of the
- * open turn. `prepareChatTurn` is the first step of the open. The host gives only its transport
- * values, and the harness stores the opening, each round, and the outcome.
+ * The run of one chat turn: `runOpenTurn` runs the root loop over a prepared turn, stores the opening and each
+ * round, and closes the turn with its outcome. A transport gives the surface and the store of the turn. The turn
+ * workflow (`chat-turn-workflow.ts`) gives the transport of a workflow, and a host reaches the turn through it.
  */
+import { presentFirst } from "../lib/present.js";
+import { errorNameOf } from "../lib/thrown.js";
 import { unwrapOrThrow } from "../lib/result.js";
 import { rulesForContextWindow } from "../loop/compaction.js";
-import { finalText, runAgent } from "../loop/run-agent.js";
-import { passthroughStep } from "../loop/run-step.js";
+import { finalText, runLoop } from "../loop/run-loop.js";
+import { isTurnCredentialMissing } from "../loop/turn-credentials.js";
 import { compactionExchangeOf, syntheticUserMessage } from "../memory/ai-sdk-message-storage.js";
-import { createConversationDisplayRecorder } from "../memory/conversation-display-recorder.js";
 import { deriveThreadTitle } from "../memory/derive-thread-title.js";
 import { conversationRecordTurn, createThreadHistory } from "../memory/thread-history.js";
 import { createThreadStore } from "../memory/thread-store.js";
+import { isWorkflowCancellation } from "../runtime/dbos.js";
 import { createWorkingMemory } from "../memory/working-memory.js";
-import { findProviderError } from "../providers/errors.js";
+import { findProviderError, modelFailureOf } from "../providers/errors.js";
 import { MEMORY_COMPACTION_REQUEST, SUMMARY_COMPACTION_REQUEST } from "../prompts/compaction.js";
 import { CONVERSATION_PROMPT_CACHE } from "../providers/prompt-cache.js";
 import { loadAnalysisStatus, queryNonTerminalRunsByAnalysis } from "../state/index.js";
 import { createToolOutputStore } from "../state/tool-outputs.js";
-import { suspensionOfFailure } from "../workflows/suspension.js";
 import { assembleMessages, contextRecordsFor } from "./message-assembly.js";
 import { renderRunActivity, renderRunActivityUnavailable, RUN_ACTIVITY_DETAIL_LIMIT } from "./run-activity.js";
 import { createNoopLogger } from "../lib/console-logger.js";
@@ -29,6 +30,28 @@ import { bindSessionEmit } from "../provenance/seam.js";
  * inside {@link assembleMessages} (applied once to the new user input only).
  */
 export async function prepareChatTurn(deps, params) {
+    const opened = await openThread(deps, params);
+    if (opened.kind === "not_found")
+        return opened;
+    const { pool } = deps;
+    const { analysisId, threadId, userInput } = params;
+    const assembled = await assembleMessages({
+        threadId,
+        threadType: opened.threadType,
+        analysisId,
+        userInput,
+        ...(await readTurnContext(pool, analysisId)),
+        history: createThreadHistory(pool),
+        workingMemory: createWorkingMemory(pool),
+        logger: deps.logger,
+    });
+    return { kind: "ok", threadType: opened.threadType, ...assembled };
+}
+/**
+ * Open the thread of a turn: check that the analysis owns it, make it when it is absent, and seed its title. A
+ * thread that a different analysis owns is `not_found`.
+ */
+export async function openThread(deps, params) {
     const { pool } = deps;
     const { analysisId, threadId, userInput } = params;
     const logger = (deps.logger ?? createNoopLogger()).named("harness.chat");
@@ -80,69 +103,30 @@ export async function prepareChatTurn(deps, params) {
     catch (err) {
         logger.warn("title-seed failed (non-fatal)", logger.errorFields(err));
     }
-    const assembled = await assembleMessages({
-        threadId,
-        threadType,
-        analysisId,
-        userInput,
-        ...(await readTurnContext(pool, analysisId)),
-        history: createThreadHistory(pool),
-        workingMemory: createWorkingMemory(pool),
-        ...(deps.logger ? { logger: deps.logger } : {}),
-    });
-    return { kind: "ok", threadType, ...assembled };
+    return { kind: "ok", threadType };
 }
 /** The analysis context and the run activity of a turn. A failed read gives the fallback of its kind. */
-async function readTurnContext(pool, analysisId) {
+export async function readTurnContext(pool, analysisId) {
     const analysisState = await loadAnalysisStatus(pool, analysisId).unwrapOr(null);
     const runActivityContext = await queryNonTerminalRunsByAnalysis(pool, analysisId, RUN_ACTIVITY_DETAIL_LIMIT).match((activity) => renderRunActivity(activity), () => renderRunActivityUnavailable());
     return { analysisContext: analysisState?.context ?? null, runActivityContext };
 }
 /**
- * Open one chat turn: prepare it and resolve its agent. A refusal comes back before any row of the
- * turn exists, thus a host can answer it before it starts a stream.
- */
-export async function openChatTurn(deps, params) {
-    const openedAtMs = Date.now();
-    let prepared;
-    try {
-        prepared = await prepareChatTurn(deps, params);
-    }
-    catch (cause) {
-        return { kind: "prepare_failed", cause };
-    }
-    if (prepared.kind === "not_found")
-        return prepared;
-    const agent = deps.agents.forThread(prepared.threadType);
-    if (agent.isErr())
-        return { kind: "agent_unresolved", threadType: prepared.threadType };
-    const ready = prepared;
-    return {
-        kind: "ready",
-        agent: agent.value,
-        run: (run) => runOpenTurn(deps, params, ready, agent.value, { ...run, startedAtMs: run.startedAtMs ?? openedAtMs }),
-    };
-}
-/**
- * Run one chat turn: open it, store its opening, run the root loop with a round sink that stores
- * each round, and close the turn with its outcome.
+ * Run a prepared turn: store its opening, run the root loop with a round sink that stores each round, and close the
+ * turn with its outcome.
  */
-export async function runChatTurn(deps, params) {
-    const { analysisId, threadId, userInput, ...run } = params;
-    const opened = await openChatTurn(deps, { analysisId, threadId, userInput });
-    if (opened.kind !== "ready")
-        return opened;
-    return opened.run(run);
-}
-async function runOpenTurn(deps, turn, prepared, agent, params) {
+export async function runOpenTurn(deps, turn, prepared, agent, params, transport) {
     const logger = (deps.logger ?? createNoopLogger()).named("harness.chat");
     const session = { ...params.session, provenance: { agentId: agent.id, callPath: [agent.id] } };
     const history = createThreadHistory(deps.pool, deps.logger);
-    const recorder = createConversationDisplayRecorder({
-        userText: userTextOf(prepared.userMessage),
-        agentId: agent.id,
-        sink: params.emit,
-    });
+    const { recorder } = transport;
+    let groupIndex = 0;
+    /** The group with its key in the turn, when the transport keys its writes. */
+    const keyed = (group) => {
+        const index = groupIndex;
+        groupIndex += 1;
+        return transport.groupKey === undefined ? group : { ...group, key: transport.groupKey(index) };
+    };
     // The groups that did not land yet, in the order of the turn. A failed write keeps them for the next write.
     let pending = [];
     let startSeq;
@@ -153,9 +137,11 @@ async function runOpenTurn(deps, turn, prepared, agent, params) {
         // A turn that ends before its user message was sent has no rows to close.
         if (!opened() || (pending.length === 0 && close === undefined))
             return;
-        const closing = close === undefined ? {} : { close };
-        const write = startSeq === undefined ? { opening: pending[0], rounds: pending.slice(1), ...closing } : { startSeq, rounds: pending, ...closing };
-        (await history.writeTurn(turn.threadId, write)).match((written) => {
+        const closing = close === undefined ? {} : { close: close.note === undefined ? close : { ...close, note: keyed(close.note) } };
+        const write = startSeq === undefined
+            ? { opening: presentFirst(pending, "the pending turn"), rounds: pending.slice(1), ...closing }
+            : { startSeq, rounds: pending, ...closing };
+        (await transport.durably("chat-turn.write", async () => await history.writeTurn(turn.threadId, write))).match((written) => {
             pending = [];
             startSeq = written.startSeq;
             storeError = undefined;
@@ -168,7 +154,8 @@ async function runOpenTurn(deps, turn, prepared, agent, params) {
         if (!opened() && round.messages[0] !== prepared.userMessage) {
             // A turn-start compaction comes before the user message, thus its rows land before the turn opens. A later
             // write cannot keep that order, thus a failed write is not tried again, and the next turn compacts again.
-            const appended = await history.appendTurn(turn.threadId, { modelMessages: round.messages, displayMessages: recorder.takeRound(round.messages) });
+            const group = keyed({ modelMessages: round.messages, displayMessages: recorder.takeRound(round.messages) });
+            const appended = await transport.durably("chat-turn.compaction-write", async () => await history.appendTurn(turn.threadId, group));
             if (appended.isErr()) {
                 logger.warn("chat turn compaction write failed", {
                     threadId: turn.threadId,
@@ -179,28 +166,34 @@ async function runOpenTurn(deps, turn, prepared, agent, params) {
             return;
         }
         const author = params.author === undefined ? {} : { author: params.author };
-        pending.push(opened()
+        const assistantBefore = recorder.assistantMessageId();
+        pending.push(keyed(opened()
             ? { modelMessages: round.messages, displayMessages: recorder.takeRound(round.messages) }
-            : { modelMessages: round.messages, displayMessages: recorder.takeOpening(), ...author });
+            : { modelMessages: round.messages, displayMessages: recorder.takeOpening(), ...author }));
         await flush();
+        if (recorder.assistantMessageId() !== assistantBefore)
+            await transport.announce?.(recorder.assistantMessageId());
     };
-    const { ask } = params;
-    const compaction = compactionPolicy(deps, turn.analysisId, params, prepared.threadType, agent, recorder.emit);
+    const compaction = compactionPolicy(deps, turn.analysisId, prepared.threadType, agent);
     let outcome;
     let fallbackText;
     try {
-        const run = await runAgent(agent, prepared.history, session, {
-            provider: params.chat(recorder.emit),
-            signal: params.signal,
-            emit: recorder.emit,
-            runStep: passthroughStep,
-            usageRecorder: params.usageRecorder,
+        const run = await runLoop(agent, prepared.history, session, {
+            provider: deps.provider,
+            signal: transport.signal,
+            emit: transport.emit,
+            onText: transport.onText,
+            chatStream: transport.chatStream,
+            toolWriter: transport.toolWriter,
+            modelMiddleware: transport.modelMiddleware,
+            usageRecorder: deps.usageRecorder,
             toolOutputStore: createToolOutputStore(deps.pool),
             promptCache: params.promptCache ?? CONVERSATION_PROMPT_CACHE,
             turnInput: [prepared.userMessage, ...prepared.contextRecords],
-            ...(compaction === undefined ? {} : { compaction }),
-            ...(deps.logger === undefined ? {} : { logger: deps.logger }),
-            ...(ask === undefined ? {} : { ask: (request) => ask(request, recorder.emit) }),
+            compaction,
+            logger: deps.logger,
+            approve: transport.approve,
+            pause: transport.pause,
             onRound: storeRound,
         });
         outcome = run.finish.reason === "aborted" ? { status: "aborted", finish: run.finish } : { status: "done", finish: run.finish };
@@ -209,65 +202,95 @@ async function runOpenTurn(deps, turn, prepared, agent, params) {
         fallbackText = finalText(run.messages.slice(prepared.history.length).filter((message) => compactionExchangeOf(message) === undefined));
     }
     catch (cause) {
+        // A canceled workflow writes nothing more: its recovery, or the stop of its host, closes the turn.
+        if (isWorkflowCancellation(cause))
+            throw cause;
         // A provider failure that races an abort stays a failure, thus both facts must hold.
-        const aborted = params.signal.aborted && cause instanceof Error && cause.name === "AbortError";
-        outcome = aborted ? { status: "aborted" } : { status: "failed", reason: failureReasonOf(cause), cause };
+        const aborted = transport.signal.aborted && errorNameOf(cause) === "AbortError";
+        outcome = aborted ? { status: "aborted" } : { status: "failed", reason: failureReasonOf(cause), code: failureCodeOf(cause), cause };
+        // A host gets the scrubbed text and the code of the failure. This record is the one place where the whole
+        // cause survives.
+        if (outcome.status === "failed")
+            logger.error("chat turn failed", { threadId: turn.threadId, code: outcome.code, ...logger.errorFields(cause) });
     }
     const durationMs = Date.now() - params.startedAtMs;
     const turnUsage = outcome.status === "failed" ? undefined : outcome.finish?.turnUsage;
     await flush({
         status: outcome.status,
-        ...(outcome.status === "failed" ? { reason: outcome.reason, note: conversationRecordTurn(failureNote(outcome.reason)) } : {}),
-        ...(outcome.status === "aborted" ? { note: interruptionNote() } : {}),
-        ...(turnUsage === undefined ? {} : { turnUsage }),
+        reason: outcome.status === "failed" ? outcome.reason : undefined,
+        note: outcome.status === "failed" ? conversationRecordTurn(failureNote(outcome.reason)) : outcome.status === "aborted" ? interruptionNote() : undefined,
+        turnUsage,
         turnDurationMs: durationMs,
     });
+    const storeErrorField = storeError === undefined ? undefined : { storeError };
     return {
         kind: "ran",
         outcome,
         opened: startSeq !== undefined,
-        ...(storeError === undefined ? {} : { storeError }),
         durationMs,
-        ...(turnUsage === undefined ? {} : { turnUsage: { ...turnUsage } }),
-        ...(fallbackText === undefined ? {} : { fallbackText }),
+        turnUsage: turnUsage === undefined ? undefined : { ...turnUsage },
+        fallbackText,
+        ...storeErrorField,
     };
 }
 /** The sanitized text of the user message, thus the display never holds a secret that the model does not see. */
-function userTextOf(message) {
+export function userTextOf(message) {
     if (typeof message.content === "string")
         return message.content;
     return message.content.map((part) => (part.type === "text" ? part.text : "")).join("");
 }
 const WORKING_MEMORY_TOOL_ID = "update_working_memory";
-function compactionPolicy(deps, analysisId, params, threadType, agent, emit) {
+function compactionPolicy(deps, analysisId, threadType, agent) {
     if (agent.compaction === undefined)
         return undefined;
     // A report thread reads a frozen copy of the working memory, thus its agent declares no memory tool.
     const remembers = agent.tools.some((tool) => tool.id === WORKING_MEMORY_TOOL_ID);
     const workingMemory = createWorkingMemory(deps.pool);
-    // A streaming provider sends each text delta with no source, thus a delta of the summary would show as a reply.
-    const provider = params.chat((event) => (event.type === "text-delta" ? undefined : emit(event)));
     return {
         // The capabilities are read for each turn, because a host can switch the model of the conversation between turns.
-        ...rulesForContextWindow(agent.compaction, provider.capabilities.contextWindow),
-        provider,
+        ...rulesForContextWindow(agent.compaction, deps.provider.capabilities.contextWindow),
         request: remembers ? MEMORY_COMPACTION_REQUEST : SUMMARY_COMPACTION_REQUEST,
         mask: remembers ? { allow: [WORKING_MEMORY_TOOL_ID] } : "none",
         keepFirstTurn: threadType === "report",
         recordsAfter: async (view) => contextRecordsFor({ threadType, analysisId, workingMemory, ...(await readTurnContext(deps.pool, analysisId)) }, view),
     };
 }
+/**
+ * The machine code of a failure, which the end frame of a turn carries for a host. A turn workflow pauses on a
+ * suspend error, a refused or missing credential, and an outage, thus their codes come only from a turn with no
+ * workflow: the suspend reason of the host, `credential`, or `outage`. Each other provider error gives `provider`,
+ * and each other error gives `internal`.
+ */
+function failureCodeOf(err) {
+    if (isTurnCredentialMissing(err))
+        return "credential";
+    const failure = modelFailureOf(err);
+    switch (failure.kind) {
+        case "billing":
+            return failure.reason;
+        case "credential":
+            return "credential";
+        case "outage":
+            return "outage";
+        case "other":
+            return findProviderError(err) === undefined ? "internal" : "provider";
+    }
+}
 /** The reason of a failed turn. It never holds the error message, because each later turn sends the note to the vendor. */
 function failureReasonOf(err) {
-    const suspension = suspensionOfFailure(err);
-    if (suspension !== undefined)
-        return suspension.reason;
-    const providerError = findProviderError(err);
-    if (providerError?.type === "auth")
-        return "The model endpoint refused the credential.";
-    if (providerError !== undefined)
-        return "The model request failed.";
-    return "The turn stopped on an internal error.";
+    if (isTurnCredentialMissing(err))
+        return "The turn has no credential of its user.";
+    const failure = modelFailureOf(err);
+    switch (failure.kind) {
+        case "billing":
+            return failure.reason;
+        case "credential":
+            return "The model endpoint refused the credential.";
+        case "outage":
+            return "The model request failed.";
+        case "other":
+            return findProviderError(err) === undefined ? "The turn stopped on an internal error." : "The model request failed.";
+    }
 }
 /**
  * The note of an aborted turn. Without it, the next turn reads the request of the aborted turn as open, and

package/dist/app/data-profile-orientation.js

@@ -38,6 +38,8 @@
  * form resolves to the same file in every frame, including the conversation agent's, so
  * the projection is unconditional.
  */
+import { presentFirst } from "../lib/present.js";
+import { collapseWhitespace } from "../lib/text.js";
 import { toAnalysisRootPath } from "../workspace/paths.js";
 import { profileCaveats, profileDimensions, profileFileRecords, profileGroups } from "./data-profile-view.js";
 /**
@@ -99,11 +101,11 @@ function clamp(text, max) {
  * keeps one record on one line.
  */
 function clip(text, max) {
-    return clamp(text.replace(/\s+/g, " ").trim(), max);
+    return clamp(collapseWhitespace(text), max);
 }
 /** Non-empty, whitespace-collapsed value, or `undefined` — nulls and blanks read the same. */
 function present(value) {
-    const flat = value?.replace(/\s+/g, " ").trim();
+    const flat = value === null || value === undefined ? undefined : collapseWhitespace(value);
     return flat ? flat : undefined;
 }
 /** `Homo sapiens (taxon 9606)`, plus a confidence marker when the profiler was unsure. */
@@ -128,9 +130,9 @@ function identityLine(result) {
     const identity = [
         [present(result.domain), present(result.subtype)].filter((f) => f !== undefined).join(" / ") || undefined,
         formatOrganism(result.organism),
-        present(result.tissue) ? `tissue: ${present(result.tissue)}` : undefined,
-        present(result.cellType) ? `cells: ${present(result.cellType)}` : undefined,
-        present(result.condition) ? `condition: ${present(result.condition)}` : undefined,
+        present(result.tissue) ? `tissue: ${String(present(result.tissue))}` : undefined,
+        present(result.cellType) ? `cells: ${String(present(result.cellType))}` : undefined,
+        present(result.condition) ? `condition: ${String(present(result.condition))}` : undefined,
     ].filter((f) => f !== undefined);
     return `Dataset: ${identity.length > 0 ? identity.join(" — ") : clip(result.summary, MAX_IDENTITY_CHARS)}`;
 }
@@ -175,7 +177,7 @@ function formatCensus(view, group) {
     if (formats.length === 0)
         return present(view.format);
     if (formats.length === 1)
-        return present(formats[0].format);
+        return present(presentFirst(formats, "the single group format").format);
     const shown = formats.slice(0, MAX_GROUP_FORMATS).map((entry) => `${entry.format} ${entry.count}`);
     return `${shown.join(", ")}${formats.length > shown.length ? `, +${formats.length - shown.length}` : ""}`;
 }
@@ -278,7 +280,7 @@ function caveatsSection(caveats, budget) {
             return line;
     }
     const room = budget - render([""]).length;
-    return room >= MIN_PROSE_CHARS ? render([clamp(capped[0], room)]) : undefined;
+    return room >= MIN_PROSE_CHARS ? render([clamp(presentFirst(capped, "the shortened caveat"), room)]) : undefined;
 }
 /**
  * Fit the body sections into `budget`, in order, each one whole or absent.
@@ -380,7 +382,7 @@ export function buildDataProfileOrientation(result, analysisId, maxChars = DATA_
     // what remains, so the one line saying how much of the dataset is accounted for
     // cannot be the line the body's budget drops.
     const identityBudget = Math.max(0, Math.min(MAX_IDENTITY_CHARS, maxChars - (census ? census.length + 1 : 0)));
-    const header = [clamp(identityLine(result), identityBudget), census].filter((line) => Boolean(line)).join("\n");
+    const header = [clamp(identityLine(result), identityBudget), census].flatMap((line) => (line ? [line] : [])).join("\n");
     const headerText = clamp(header, maxChars);
     const bodyBudget = maxChars - headerText.length - 1;
     if (bodyBudget <= 0)

package/dist/app/data-profile-view.d.ts

@@ -13,7 +13,7 @@
  */
 import type { DataProfileDimension, DataProfileFile, DataProfileResult } from "../contracts/data-profile.js";
 /** A group as consumers read it, whether it was authored as a group or as a kind. */
-export interface ProfileGroupView {
+export type ProfileGroupView = {
     readonly id: string;
     readonly name: string;
     readonly memberRepresents: string;
@@ -26,18 +26,18 @@ export interface ProfileGroupView {
     /** The scanner slots this group carries, on a groups-era row. */
     readonly slotIds?: readonly string[];
     readonly unclassified?: boolean;
-}
+};
 /**
  * A dimension as consumers read it. `cardinalities` carries every number the
  * observations reported, side by side: there is no canonical count, and a single field
  * would be a silent judgement between disagreeing sources.
  */
-export interface ProfileDimensionView {
+export type ProfileDimensionView = {
     readonly label: string;
     readonly cardinalities: readonly number[];
     readonly exampleValues: readonly string[];
     readonly description?: string;
-}
+};
 /**
  * Every number the observations reported, side by side and de-duplicated.
  *