@inflexa-ai/harness 0.45.0 → 0.46.0

package/dist/agents/sandbox/shared.js

@@ -16,6 +16,7 @@
  * must map to a concrete `Tool`; unknown names throw at composition time
  * so misconfigured agents fail at startup, not at the first LLM call.
  */
+import { createEditIntentStore } from "../../state/edit-intents.js";
 import { sandboxOrientCorePromptFor, sandboxPackageLinkPrompt, sandboxAnalysisStepStandardsPrompt } from "../../prompts/sandbox-standards.js";
 import { composeSystemPrompt } from "../system-prompt.js";
 // Sandbox-environment introspection, plus the farm-extension seam face.
@@ -42,34 +43,49 @@ import { createSubmitFileMetadataTool } from "../../tools/sandbox/submit-file-me
 import { toSandboxPath } from "../../workspace/paths.js";
 import { SANDBOX_AGENT_DEFAULT_MAX_ITERATIONS } from "./types.js";
 import { createResolveCitationTool } from "../../tools/research/resolve-citation.js";
+import { createKnowledgeTemplateTool } from "../../tools/knowledge/index.js";
 /**
  * Tools every sandbox agent receives — sandbox-environment introspection,
- * library docs, and run inspection. Spread into each agent's
- * `meta.tools` so planner-facing metadata and the resolved tool record
+ * library docs, run inspection, and the knowledge template. Spread into each
+ * agent's `meta.tools` so planner-facing metadata and the resolved tool record
  * stay in sync. Keep minimal — only tools every agent genuinely needs.
+ *
+ * The knowledge template is here, not on a specialist, because the template
+ * follows the step: the planner binds a template to a step from the
+ * recommendation and routes that step to whichever specialist owns its data
+ * object. The tool acts only on the template the step grounding names, thus
+ * a step without a template costs nothing, and it attaches only when the
+ * embedder binds a knowledge client (see the registry below).
  */
-export const BASE_SANDBOX_TOOLS = ["listAvailablePackages", "listAvailableRefs", "resolveLibraryId", "queryDocs", "inspectRun"];
+export const BASE_SANDBOX_TOOLS = [
+    "listAvailablePackages",
+    "listAvailableRefs",
+    "resolveLibraryId",
+    "queryDocs",
+    "inspectRun",
+    "knowledgeTemplate",
+];
 /**
  * Resolve `meta.tools` into the bio/research tools record. The workspace
  * read/mutate tools and `inspect_data_profile` are added by `createSandboxAgent`
  * regardless of meta — they are the always-on substrate, not in the allowlist.
  */
-function resolveSandboxTools(deps, tools) {
+function resolveSandboxTools(deps, tools, mutator) {
     const ncbi = createNcbiTools(deps.bioKeys);
-    const chemDb = createChemDbTools(deps.bioKeys, { ...(deps.logger ? { logger: deps.logger } : {}) });
+    const chemDb = createChemDbTools(deps.bioKeys, { logger: deps.logger });
     const amass = createAmassTools(deps.bioKeys);
     if (tools.includes("resolve_citation") && deps.citationResolver === undefined) {
         throw new Error('createSandboxAgent: SandboxToolName "resolve_citation" requires a CitationResolver dependency.');
     }
     const registry = {
         listAvailablePackages: createListAvailablePackagesTool({
-            ...(deps.farmLockFile ? { farmLockFile: deps.farmLockFile } : {}),
-            ...(deps.imagePackagesFile ? { imagePackagesFile: deps.imagePackagesFile } : {}),
+            farmLockFile: deps.farmLockFile,
+            imagePackagesFile: deps.imagePackagesFile,
             // The bound seam adds `link_packages` below, and the description of
             // the listing must then stop at "absent", not at "missing".
             linkToolPresent: deps.extendAnalysisFarm !== undefined,
         }),
-        listAvailableRefs: createListAvailableRefsTool({ ...(deps.refStorePath ? { refStorePath: deps.refStorePath } : {}) }),
+        listAvailableRefs: createListAvailableRefsTool({ refStorePath: deps.refStorePath }),
         scanInputs: createScanInputsTool({
             workspaceFs: deps.workspaceFs,
             analysisId: deps.step.analysisId,
@@ -97,6 +113,15 @@ function resolveSandboxTools(deps, tools) {
         searchRegulatoryApprovals: amass.regulatoryApprovals,
         targetSafety: targetSafetyTool,
         comptox: chemDb.comptox,
+        knowledgeTemplate: deps.knowledge && mutator
+            ? createKnowledgeTemplateTool({
+                client: deps.knowledge,
+                mutator,
+                farmLockFile: deps.farmLockFile,
+                imagePackagesFile: deps.imagePackagesFile,
+                binding: deps.step.templateBinding,
+            })
+            : undefined,
     };
     const seen = new Set();
     const resolved = [];
@@ -105,6 +130,12 @@ function resolveSandboxTools(deps, tools) {
             continue;
         seen.add(name);
         const tool = registry[name];
+        // The knowledge template is the one optional member of the allowlist: every
+        // agent lists it through BASE_SANDBOX_TOOLS, and it attaches only when the
+        // embedder binds a client and the agent can write. Absence is a normal
+        // state, not a wiring fault.
+        if (name === "knowledgeTemplate" && !tool)
+            continue;
         if (!tool) {
             throw new Error(`createSandboxAgent: unknown SandboxToolName "${name}" — ` + `agent meta references a tool with no harness implementation.`);
         }
@@ -124,24 +155,30 @@ function buildWorkspaceTools(deps, readOnly) {
     // it is correct for non-step agents such as the data profiler too.
     const hostWorkingDir = step.allowedWritePrefix;
     const sandboxWorkingDir = toSandboxPath(step.workspaceRoot, step.analysisId, hostWorkingDir);
-    const mutateTools = readOnly
-        ? []
-        : (() => {
-            const mutator = createWorkspaceMutator({
-                workspaceRoot: step.workspaceRoot,
-                analysisId: step.analysisId,
-                workingDir: hostWorkingDir,
-                ...(lineageCollector ? { lineageCollector } : {}),
-            });
-            return [createWriteFileTool({ mutator }), createEditFileTool({ mutator, workspaceFilesystem: workspaceFs, workingDir: hostWorkingDir })];
-        })();
-    return [
+    const mutator = readOnly
+        ? undefined
+        : createWorkspaceMutator({
+            workspaceRoot: step.workspaceRoot,
+            analysisId: step.analysisId,
+            workingDir: hostWorkingDir,
+            lineageCollector,
+        });
+    const mutateTools = mutator
+        ? [
+            createWriteFileTool({ mutator }),
+            createEditFileTool({ mutator, workspaceFilesystem: workspaceFs, workingDir: hostWorkingDir, intents: createEditIntentStore(pool) }),
+        ]
+        : [];
+    const tools = [
         createExecuteCommandTool({
             sandboxClient,
             sandbox: step.sandbox,
             deadlineMs: step.deadlineMs,
             defaultCwd: sandboxWorkingDir,
-            ...(lineageCollector ? { lineageCollector, mountRoot: `/${step.analysisId}` } : {}),
+            lineageCollector,
+            mountRoot: `/${step.analysisId}`,
+            workspaceFilesystem: workspaceFs,
+            mutator,
         }),
         ...mutateTools,
         createReadFileTool(workspaceFs, hostWorkingDir),
@@ -150,6 +187,7 @@ function buildWorkspaceTools(deps, readOnly) {
         createGrepTool(workspaceFs, hostWorkingDir),
         ...(embedding ? [createWorkspaceSearchTool(pool, embedding)] : []),
     ];
+    return { tools, mutator };
 }
 /**
  * Build one sandbox `AgentDefinition`. The system prompt is composed once
@@ -185,8 +223,9 @@ export function createSandboxAgent(deps, meta, body, opts = {}) {
     const agentBody = [body, ...sandboxLayer].map((s) => s.trim()).join("\n\n");
     const systemPrompt = composeSystemPrompt(agentBody);
     const skillTools = deps.skillsDir ? Object.values(createSkillTools({ skillsDir: deps.skillsDir, skills: meta.skills })) : [];
+    const workspace = buildWorkspaceTools(deps, opts.readOnly ?? false);
     const tools = [
-        ...buildWorkspaceTools(deps, opts.readOnly ?? false),
+        ...workspace.tools,
         ...(deps.toolOutputStore ? [createReadToolOutputTool(deps.toolOutputStore)] : []),
         // Always-on, not in the `meta.tools` allowlist: the data profile is the only
         // record of what the analysis's input dataset IS, and no file carries it (the
@@ -199,8 +238,8 @@ export function createSandboxAgent(deps, meta, body, opts = {}) {
         // seam (the harness-sandbox-agents spec).
         ...(deps.extendAnalysisFarm ? [createLinkPackagesTool({ extendAnalysisFarm: deps.extendAnalysisFarm, analysisId: deps.step.analysisId })] : []),
         ...skillTools,
-        ...resolveSandboxTools(deps, meta.tools),
-        ...(deps.blockerHolder ? [createReportBlockerTool(deps.blockerHolder)] : []),
+        ...resolveSandboxTools(deps, meta.tools, workspace.mutator),
+        ...(deps.reportsBlocker === true ? [createReportBlockerTool()] : []),
         ...(deps.fileMetadata ? [createSubmitFileMetadataTool(deps.fileMetadata)] : []),
     ];
     return {

package/dist/agents/sandbox/translational-safety-agent.js

@@ -3,6 +3,11 @@
  */
 import { translationalSafetyAgentPrompt } from "../../prompts/sandbox/translational-safety-agent.js";
 import { BASE_SANDBOX_TOOLS, createSandboxAgent } from "./shared.js";
+/**
+ * Named once, because the capability phrase is the key of its own data requirement below and a
+ * plan step copies it verbatim. Two spellings of one capability would lose the pre-launch check.
+ */
+const MATCHED_NEGATIVE_CAPABILITY = "matched negative gene set for a tissue risk benchmark (annotation_free or tested_clean negatives) matched on tissue expression and PPI connectivity with mouse and human phenotype annotation exclusions";
 export const meta = {
     id: "translational-safety-agent",
     capabilities: [
@@ -20,6 +25,8 @@ export const meta = {
         "hematological toxicity assessment",
         "mouse KO phenotype lookup",
         "cross-species baseline expression lookup",
+        MATCHED_NEGATIVE_CAPABILITY,
+        "expression and PPI connectivity matching",
     ],
     suitableFor: [
         "safety-biomarkers",
@@ -29,6 +36,25 @@ export const meta = {
         "clinical-safety-labs",
         "drug-interaction-data",
         "pharmacogenomic-data",
+        "gene-lists",
+    ],
+    // The method of this capability reads six opt-in datasets. Without any one of them a negatives
+    // file would carry a label the run cannot defend, so the launch refuses rather than spend a run.
+    // The recommended datasets it also reads (the expression table, the network, the gene tables,
+    // the GO collection) stay out: a default store holds them, and declaring one would refuse a
+    // launch an embedder already provisioned.
+    dataRequirements: [
+        {
+            capability: MATCHED_NEGATIVE_CAPABILITY,
+            datasets: [
+                "string-aliases-human",
+                "mgi-mouse-human-homology",
+                "impc-phenotyping",
+                "hpo-annotations",
+                "opentargets-mouse-phenotype",
+                "opentargets-target-safety-event",
+            ],
+        },
     ],
     skills: ["translational-safety", "cheminformatics", "shared/omics-general"],
     tools: [

package/dist/agents/sandbox/types.d.ts

@@ -12,9 +12,23 @@
  * in the tool's `perSource` report; the rest of the call still answers.
  */
 /** Closed allowlist of tools any sandbox agent may declare. */
-export type SandboxToolName = "listAvailablePackages" | "listAvailableRefs" | "scanInputs" | "resolveLibraryId" | "queryDocs" | "inspectRun" | "pubmed" | "resolve_citation" | "searchGene" | "lookupAnnotation" | "searchInteractions" | "chembl" | "pubchem" | "opentargets" | "geneDiseaseEvidence" | "drugGeneInteractions" | "genePreclinicalProfile" | "searchFaers" | "searchClinicalTrials" | "searchGeoDatasets" | "searchRegulatoryApprovals" | "targetSafety" | "comptox";
+export type SandboxToolName = "listAvailablePackages" | "listAvailableRefs" | "scanInputs" | "resolveLibraryId" | "queryDocs" | "inspectRun" | "pubmed" | "resolve_citation" | "searchGene" | "lookupAnnotation" | "searchInteractions" | "chembl" | "pubchem" | "opentargets" | "geneDiseaseEvidence" | "drugGeneInteractions" | "genePreclinicalProfile" | "searchFaers" | "searchClinicalTrials" | "searchGeoDatasets" | "searchRegulatoryApprovals" | "targetSafety" | "comptox" | "knowledgeTemplate";
+/**
+ * The reference datasets that one capability of one agent cannot run without.
+ *
+ * A requirement belongs to a capability, never to the agent: an agent holds capabilities that need
+ * no reference data at all, so an agent-wide requirement would refuse a step that needs nothing.
+ * The skill of the agent still states what the data IS and how to use it. This states which catalog
+ * entry carries it, in a form a test can pin.
+ */
+export type CapabilityDataRequirement = {
+    /** One phrase of the same agent's `capabilities`, verbatim — the step copies it from the catalog. */
+    readonly capability: string;
+    /** Reference-catalog dataset ids. Declare only an opt-in dataset: a recommended one is already in a default store. */
+    readonly datasets: readonly string[];
+};
 /** Planner-facing metadata + tool allowlist for one sandbox agent. */
-export interface AgentMeta {
+export type AgentMeta = {
     /** Stable agent id — also the key in the catalog and the `AgentDefinition.id`. */
     readonly id: string;
     /** Capabilities surfaced to the planner. */
@@ -29,6 +43,15 @@ export interface AgentMeta {
     readonly defaultMaxSteps?: number;
     /** False for agents the planner must NOT assign to plan steps (executors, the profiler). */
     readonly plannable?: boolean;
-}
+    /**
+     * Per-capability reference-data requirements. Omitted by an agent whose capabilities all run on
+     * what a default store holds.
+     *
+     * The pre-launch pass resolves these against the live store, so an absent dataset refuses the
+     * launch instead of costing a run. The planner-facing projection deliberately drops this field:
+     * a prompt names no dataset, so the ids reach a caller through a tool and the launch through here.
+     */
+    readonly dataRequirements?: readonly CapabilityDataRequirement[];
+};
 /** Default runaway-guard for sandbox agents. */
 export declare const SANDBOX_AGENT_DEFAULT_MAX_ITERATIONS = 200;

package/dist/agents/sandbox/validate-skills.d.ts

@@ -10,9 +10,9 @@
  * for the per-agent skill list. Declared structurally so `AgentMeta` types
  * with `readonly` arrays work without a cast at the call site.
  */
-interface AgentMetaLike {
+type AgentMetaLike = {
     readonly id: string;
     readonly skills: readonly string[];
-}
+};
 export declare function validateAgentSkills(skillsDir: string, catalog: Readonly<Record<string, AgentMetaLike>>): void;
 export {};

package/dist/agents/sandbox/validate-skills.js

@@ -5,6 +5,8 @@
  * agent resolves to a readable SKILL.md. Catches Dockerfile drift and typos
  * in agent meta before the first analysis runs.
  */
+import { errorMessageOf } from "../../lib/thrown.js";
+import { textOf } from "../../lib/unknown-text.js";
 import { statSync } from "node:fs";
 import { join } from "node:path";
 export function validateAgentSkills(skillsDir, catalog) {
@@ -15,7 +17,7 @@ export function validateAgentSkills(skillsDir, catalog) {
         }
     }
     catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
+        const msg = errorMessageOf(err) ?? textOf(err);
         throw new Error(`SKILLS_DIR "${skillsDir}" is not accessible: ${msg}. ` + `Set SKILLS_DIR to a directory containing skill subfolders (one SKILL.md each).`, { cause: err });
     }
     const missing = [];

package/dist/agents/sandbox-catalog.d.ts

@@ -8,13 +8,27 @@
  * `{{AGENT_CATALOG}}` placeholder.
  */
 /** Planner-facing metadata for one sandbox agent. */
-export interface PlannerAgentMeta {
+export type PlannerAgentMeta = {
     readonly id: string;
     readonly capabilities: readonly string[];
     readonly suitableFor: readonly string[];
-}
+};
 /** The sandbox agents the planner may assign to analysis-plan steps. */
 export declare const PLANNABLE_AGENT_CATALOG: readonly PlannerAgentMeta[];
+/**
+ * The reference datasets one capability of one agent cannot run without, by catalog id.
+ *
+ * Empty for an unknown agent, for an agent that declares nothing, and for a phrase no declaration
+ * matches. An unmatched phrase must NOT refuse a launch: the pass can only demand what a
+ * declaration states, so a paraphrased phrase degrades to the behaviour of a step with no phrase.
+ */
+export declare function capabilityDataRequirement(agentId: string, capability: string): readonly string[];
+/** Every declared requirement, for a caller that asks what a capability wants before it plans. */
+export declare function declaredDataRequirements(): readonly {
+    agentId: string;
+    capability: string;
+    datasets: readonly string[];
+}[];
 /**
  * Ids of the agents the planner may assign — the `z.enum` domain for
  * `PlanStepSchema.agent`. A non-empty tuple, as `z.enum` requires.

package/dist/agents/sandbox-catalog.js

@@ -16,16 +16,35 @@ export const PLANNABLE_AGENT_CATALOG = Object.values(SANDBOX_AGENT_META)
     capabilities: [...meta.capabilities],
     suitableFor: [...meta.suitableFor],
 }));
+/**
+ * The reference datasets one capability of one agent cannot run without, by catalog id.
+ *
+ * Empty for an unknown agent, for an agent that declares nothing, and for a phrase no declaration
+ * matches. An unmatched phrase must NOT refuse a launch: the pass can only demand what a
+ * declaration states, so a paraphrased phrase degrades to the behaviour of a step with no phrase.
+ */
+export function capabilityDataRequirement(agentId, capability) {
+    const entry = SANDBOX_AGENT_META[agentId]?.dataRequirements?.find((requirement) => requirement.capability === capability);
+    return entry?.datasets ?? [];
+}
+/** Every declared requirement, for a caller that asks what a capability wants before it plans. */
+export function declaredDataRequirements() {
+    return Object.values(SANDBOX_AGENT_META).flatMap((meta) => (meta.dataRequirements ?? []).map((requirement) => ({
+        agentId: meta.id,
+        capability: requirement.capability,
+        datasets: requirement.datasets,
+    })));
+}
 /**
  * Ids of the agents the planner may assign — the `z.enum` domain for
  * `PlanStepSchema.agent`. A non-empty tuple, as `z.enum` requires.
  */
 export const PLANNABLE_AGENT_IDS = (() => {
-    const ids = PLANNABLE_AGENT_CATALOG.map((meta) => meta.id);
-    if (ids.length === 0) {
+    const [first, ...rest] = PLANNABLE_AGENT_CATALOG.map((meta) => meta.id);
+    if (first === undefined) {
         throw new Error("PLANNABLE_AGENT_CATALOG is empty");
     }
-    return ids;
+    return [first, ...rest];
 })();
 /**
  * Every sandbox agent id — plannable agents plus the workflow-dedicated

package/dist/agents/system-prompt.d.ts

@@ -29,7 +29,7 @@
  * Both flags default off, so the zero-argument call yields a fully guarded
  * headless agent — the safe default is also the shortest one to write.
  */
-export interface ComposeSystemPromptOptions {
+export type ComposeSystemPromptOptions = {
     /**
      * Include the SOUL identity layer (name, scope, refusal of harmful
      * requests, impersonation and external-action guardrails). Default `false`
@@ -41,7 +41,7 @@ export interface ComposeSystemPromptOptions {
      * Default `false` — opt in only for the conversation agent.
      */
     readonly conversational?: boolean;
-}
+};
 /**
  * Compose an agent's full system prompt: the always-on SOUL execution core, the
  * layers the agent opted into, then the agent's own prompt — joined by blank

package/dist/app/approve-plan.d.ts

@@ -23,12 +23,15 @@ export type ApprovePlanInput = {
     analysisId: string;
     threadId: string;
     planId: string;
+    /** The newest run of the plan in the view that the person approved, or `null` when that view showed no run. */
+    newestRunId: string | null;
     identity: Identity;
     auth: AuthContext;
 };
 /**
- * The outcome of an approval. `started` is false when a run of the plan was already active: the
- * approval then changed nothing, and `message` is `null`. `message` is also `null` when the record
+ * The outcome of an approval. `started` is false when a run of the plan was already active, or when the
+ * view of the person was stale: the approval then changed nothing, `runId` names the active run or the
+ * newest run of the plan, and `message` is `null`. `message` is also `null` when the record
  * could not be appended, because the run started anyway. It has no `createdAt`: the transcript read
  * adds the time of the row.
  */

package/dist/app/approve-plan.js

@@ -55,7 +55,7 @@ async function approve(deps, input) {
         scope: { kind: "analysis", analysisId, threadId },
         provenance: APPROVAL_PROVENANCE,
     };
-    const launched = await launchPlanRun(deps, { session, planId });
+    const launched = await launchPlanRun(deps, { session, planId, newestRunId: input.newestRunId });
     if (launched.isErr())
         return err(launched.error);
     const { runId, started } = launched.value;

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

@@ -0,0 +1,114 @@
+/**
+ * The chat turn as a DBOS workflow.
+ *
+ * The host opens a turn in its request: the harness checks the thread, resolves
+ * the agent, claims the thread for the turn, and starts the workflow. The
+ * workflow input holds ids and settings, the sanitized user text, and no
+ * credential. The live credential stays in the memory of the process, and the
+ * function of the host gives it to a turn that a recovery runs in a new process.
+ *
+ * The body prepares the opening in one step, reads the view of the thread up to
+ * the last row before the turn, and runs the turn of `chat-turn.ts` with the
+ * transport of a workflow: each model call and each tool call is a step, each
+ * write of the turn is a step with a key, and the frames go to the durable
+ * stream of the workflow. A host reads them with `read`.
+ */
+import type { AuthContext } from "../auth/types.js";
+import type { TokenUsageRollup } from "../contracts/usage.js";
+import type { ChatFrame } from "../contracts/chat-events.js";
+import type { AgentDefinition } from "../loop/types.js";
+import type { ThreadType } from "../memory/thread-store.js";
+import type { PromptCachePolicy } from "../providers/types.js";
+import type { AskReply } from "../tools/approval/contract.js";
+import type { AnswerOutcome } from "../tools/approval/queries.js";
+import { type ChatTurnRan, type ChatTurnRefusal, type ChatTurnSession, type RunChatTurnDeps } from "./chat-turn.js";
+/** The name of the turn workflow. */
+export declare const CHAT_TURN_WORKFLOW = "chat-turn";
+/** The input of a turn workflow: ids and settings, with no history and no credential. */
+export type ChatTurnInput = {
+    readonly turnId: string;
+    readonly analysisId: string;
+    readonly threadId: string;
+    readonly threadType: ThreadType;
+    /** The user text after the sanitization of the opening. */
+    readonly userText: string;
+    readonly userId: string;
+    readonly author?: string;
+    readonly startedAtMs: number;
+    readonly promptCache?: PromptCachePolicy;
+};
+/** How a turn workflow ended. */
+export type ChatTurnEnd = {
+    readonly status: "done" | "aborted" | "failed";
+    /** The text of a failure. */
+    readonly reason?: string;
+    /**
+     * The machine code of a failure: `provider` or `internal`. A turn with no workflow also gives the suspend reason of
+     * the host, `credential`, or `outage`, because only a workflow can pause on them.
+     */
+    readonly code?: string;
+    readonly durationMs: number;
+    /** True when the opening of the turn landed. */
+    readonly opened: boolean;
+    /** The stop reason of the root loop of a turn that ran to its end, for example `content-filter`. */
+    readonly finishReason?: string;
+    /** The word of the endpoint for the stop, when the provider captured one. */
+    readonly rawFinishReason?: string;
+    readonly turnUsage?: TokenUsageRollup;
+    /** The final text of a run that returned. */
+    readonly fallbackText?: string;
+    /** True when rows of the turn or its close did not land. */
+    readonly storeFailed?: boolean;
+};
+/** The values of a turn that a host opens. */
+export type OpenChatTurnRequest = {
+    readonly analysisId: string;
+    readonly threadId: string;
+    readonly userInput: string;
+    /** Who sent the user message. */
+    readonly author?: string;
+    /** When the host got the message. Absent counts from the open. */
+    readonly startedAtMs?: number;
+    readonly promptCache?: PromptCachePolicy;
+};
+export type ChatTurnStart = {
+    readonly kind: "started";
+    readonly turnId: string;
+    readonly agent: AgentDefinition;
+} | ChatTurnRefusal | {
+    readonly kind: "turn_in_progress";
+};
+/** The chat turns of a runtime, as a host uses them. */
+export type ChatTurns = {
+    /** Open a turn and start its workflow. A refusal comes back before the turn writes a row. */
+    open(session: ChatTurnSession, request: OpenChatTurnRequest): Promise<ChatTurnStart>;
+    /** The frames of a turn from its start, live, until the turn ends. A second read gives the same frames. */
+    read(turnId: string): AsyncGenerator<ChatFrame>;
+    /** Stop a turn. The turn closes as `aborted`. */
+    stop(turnId: string): Promise<void>;
+    /** Answer an ask. The turn that waits for it gets the answer, in the process that runs it. */
+    answer(askId: string, reply: AskReply): Promise<AnswerOutcome>;
+    /** How a turn ended, when its workflow ends. `null` for a turn whose workflow was canceled or failed. */
+    outcome(turnId: string): Promise<ChatTurnEnd | null>;
+};
+export type ChatTurnWorkflowDeps = RunChatTurnDeps & {
+    /**
+     * The credential of a turn that the process did not open, for example after a restart. A host with one fixed
+     * credential gives it for each turn. Absent, or `undefined` for a turn: the turn pauses with the cause `credential`
+     * before its next model call, until a resume gives a credential.
+     */
+    readonly credentialFor?: (turnId: string) => AuthContext | undefined;
+    /** The delays of the timer of an outage. Absent: the default of the pause. */
+    readonly pauseRetryDelaysMs?: readonly number[];
+    /** How long a turn waits for the answer of an ask. Absent: {@link DEFAULT_ASK_WAIT_SECONDS}. */
+    readonly askWaitSeconds?: number;
+};
+/** A turn waits half an hour for the answer of an ask, and then the ask expires. */
+export declare const DEFAULT_ASK_WAIT_SECONDS: number;
+/**
+ * Register the turn workflow and give the chat turns of the runtime. Call it before DBOS launches, because DBOS
+ * finds the workflow of a recovery by its registered name.
+ */
+export declare function registerChatTurns(deps: ChatTurnWorkflowDeps): ChatTurns;
+/** How a turn that ran ended, as a host reads it. */
+export declare function chatTurnEndOf(ran: ChatTurnRan): ChatTurnEnd;