@inflexa-ai/harness 0.45.0 → 0.46.0

package/dist/app/chat-turn.js

@@ -1,23 +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 { finalText, runAgent } from "../loop/run-agent.js";
-import { passthroughStep } from "../loop/run-step.js";
+import { rulesForContextWindow } from "../loop/compaction.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";
@@ -28,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");
@@ -79,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;
@@ -152,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;
@@ -167,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,
@@ -178,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 };
@@ -208,63 +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);
     return {
-        ...agent.compaction,
-        // A streaming provider sends each text delta with no source, thus a delta of the summary would show as a reply.
-        provider: params.chat((event) => (event.type === "text-delta" ? undefined : emit(event))),
+        // The capabilities are read for each turn, because a host can switch the model of the conversation between turns.
+        ...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.
  *

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

@@ -11,6 +11,7 @@
  * older consumers already handled. Nothing it drops is unavailable — the full record is
  * on the row, and consumers that want the resolved structure read it directly.
  */
+import { presentFirst } from "../lib/present.js";
 /**
  * Every number the observations reported, side by side and de-duplicated.
  *
@@ -40,7 +41,7 @@ function examplesOf(dimension) {
     return [];
 }
 function fromGroup(group) {
-    const format = group.formats.length === 1 ? group.formats[0].format : undefined;
+    const format = group.formats.length === 1 ? presentFirst(group.formats, "the single group format").format : undefined;
     return {
         id: group.id,
         name: group.name,
@@ -48,9 +49,9 @@ function fromGroup(group) {
         description: group.description,
         count: group.count,
         pattern: group.displayPattern,
-        ...(format ? { format } : {}),
-        ...(group.slots ? { slotIds: group.slots.map((slot) => slot.id) } : {}),
-        ...(group.unclassified ? { unclassified: true } : {}),
+        format: format ? format : undefined,
+        slotIds: group.slots?.map((slot) => slot.id),
+        unclassified: group.unclassified ? true : undefined,
     };
 }
 /** The dataset's structure, from whichever field the snapshot carries it in. */
@@ -64,7 +65,7 @@ export function profileGroups(result) {
         description: kind.description,
         count: kind.count,
         pattern: kind.pathPattern,
-        ...(kind.format ? { format: kind.format } : {}),
+        format: kind.format ? kind.format : undefined,
     }));
 }
 /** What varies across the dataset, from whichever field the snapshot carries it in. */
@@ -74,14 +75,14 @@ export function profileDimensions(result) {
             label: dimension.label,
             cardinalities: dimensionCardinalities(dimension),
             exampleValues: examplesOf(dimension),
-            ...(dimension.description ? { description: dimension.description } : {}),
+            description: dimension.description ? dimension.description : undefined,
         }));
     }
     return (result.axes ?? []).map((axis) => ({
         label: axis.label,
         cardinalities: [axis.cardinality],
         exampleValues: axis.exampleValues ?? [],
-        ...(axis.description ? { description: axis.description } : {}),
+        description: axis.description ? axis.description : undefined,
     }));
 }
 /**
@@ -96,7 +97,7 @@ export function profileFileRecords(result) {
         return result.groups.flatMap((group) => (group.memberAnnotations ?? []).map((annotation) => ({
             path: annotation.path,
             description: annotation.note,
-            ...(group.formats.length === 1 ? { format: group.formats[0].format } : {}),
+            format: group.formats.length === 1 ? presentFirst(group.formats, "the single group format").format : undefined,
         })));
     }
     return result.files ?? [];

package/dist/app/in-process-turn.d.ts

@@ -0,0 +1,42 @@
+/**
+ * A chat turn in the process of a test, with no workflow. The turn of `chat-turn.ts` runs over a transport that
+ * streams to an emit sink and runs each write directly, thus a test drives the storage and the loop of a turn with
+ * no DBOS engine. A host reaches a turn through the turn workflow only, and `inProcessChatTurns` gives the test of
+ * a host the same surface over this turn.
+ */
+import { type ChatTurns } from "./chat-turn-workflow.js";
+import type { LoopOptions } from "../loop/run-loop.js";
+import type { EmitFn } from "../loop/types.js";
+import type { PromptCachePolicy } from "../providers/types.js";
+import type { AgentDefinition } from "../loop/types.js";
+import { type ChatTurnRan, type ChatTurnRefusal, type ChatTurnSession, type OpenChatTurnParams, type RunChatTurnDeps } from "./chat-turn.js";
+/** The transport values of a turn in process. */
+export type InProcessRunParams = {
+    readonly session: ChatTurnSession;
+    readonly emit: EmitFn;
+    readonly signal: AbortSignal;
+    readonly author?: string;
+    /** Absent counts from the open. */
+    readonly startedAtMs?: number;
+    readonly promptCache?: PromptCachePolicy;
+    /** The decision of the user on a call that asks for approval. Absent: the loop denies the call. */
+    readonly approve?: LoopOptions["approve"];
+};
+export type InProcessTurnParams = OpenChatTurnParams & InProcessRunParams;
+export type InProcessTurnResult = ChatTurnRefusal | ChatTurnRan;
+/** A prepared turn with its agent. Call `run` one time: each call stores a new opening of the same user message. */
+export type InProcessOpenTurn = {
+    readonly kind: "ready";
+    readonly agent: AgentDefinition;
+    readonly run: (params: InProcessRunParams) => Promise<ChatTurnRan>;
+};
+/** Prepare a turn and resolve its agent. A refusal comes back before any row of the turn exists. */
+export declare function openInProcessTurn(deps: RunChatTurnDeps, params: OpenChatTurnParams): Promise<InProcessOpenTurn | ChatTurnRefusal>;
+/** Open a turn in process and run it. */
+export declare function runInProcessTurn(deps: RunChatTurnDeps, params: InProcessTurnParams): Promise<InProcessTurnResult>;
+/**
+ * The chat turns of a host test, over the turn in process: `open` starts the turn at once, `read` gives its frames
+ * with the end frame of a turn workflow, `stop` aborts it, and `outcome` gives its end. An ask has no answer here,
+ * thus a call that asks for an approval is denied.
+ */
+export declare function inProcessChatTurns(deps: RunChatTurnDeps): ChatTurns;