@inflexa-ai/harness 0.48.3 → 0.48.5

package/dist/contracts/schemas/chat-parts.d.ts

@@ -93,6 +93,59 @@ export declare const PresentationPartSchema: z.ZodObject<{
         version: z.ZodNumber;
     }, z.core.$strip>], "kind">;
 }, z.core.$strip>;
+export declare const AnalogyReportPartSchema: z.ZodObject<{
+    type: z.ZodLiteral<"data-analogy-report">;
+    id: z.ZodString;
+    report: z.ZodUnion<readonly [z.ZodObject<{
+        problemSummary: z.ZodString;
+        problemObjects: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            role: z.ZodString;
+        }, z.core.$strip>>;
+        problemRelations: z.ZodArray<z.ZodString>;
+        keyTerms: z.ZodArray<z.ZodString>;
+        schemaVersion: z.ZodLiteral<"1">;
+        analogies: z.ZodArray<z.ZodObject<{
+            targetDomain: z.ZodString;
+            analogyTitle: z.ZodString;
+            objectMappings: z.ZodArray<z.ZodObject<{
+                source: z.ZodString;
+                target: z.ZodString;
+                rationale: z.ZodString;
+            }, z.core.$strip>>;
+            sharedRelations: z.ZodString;
+            coverage: z.ZodEnum<{
+                available: "available";
+                not_loaded: "not_loaded";
+                queried_no_data: "queried_no_data";
+                search_failed: "search_failed";
+            }>;
+            solutions: z.ZodArray<z.ZodObject<{
+                title: z.ZodString;
+                sourceDomain: z.ZodString;
+                description: z.ZodString;
+                keyConcepts: z.ZodArray<z.ZodString>;
+                relevance: z.ZodString;
+                sources: z.ZodArray<z.ZodObject<{
+                    url: z.ZodURL;
+                    title: z.ZodString;
+                }, z.core.$strip>>;
+                githubRepos: z.ZodArray<z.ZodObject<{
+                    url: z.ZodURL;
+                    description: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"1">;
+        error: z.ZodObject<{
+            kind: z.ZodEnum<{
+                "extraction-failed": "extraction-failed";
+            }>;
+            message: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>]>;
+}, z.core.$strip>;
 export declare const PLAN_ID_RE: RegExp;
 export declare const PlanPartSchema: z.ZodObject<{
     type: z.ZodLiteral<"data-plan">;
@@ -600,6 +653,21 @@ export declare const PauseCauseSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"host">;
     reason: z.ZodString;
 }, z.core.$strip>], "kind">;
+export declare const PauseWaiterSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"turn">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"sub-agent">;
+    agentId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"step">;
+    stepId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"synthesis">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"run">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"profile">;
+}, z.core.$strip>], "kind">;
 export declare const PausePartSchema: z.ZodObject<{
     type: z.ZodLiteral<"data-pause">;
     id: z.ZodString;
@@ -609,21 +677,43 @@ export declare const PausePartSchema: z.ZodObject<{
         run: "run";
         turn: "turn";
     }>;
+    waiter: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"turn">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"sub-agent">;
+        agentId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"step">;
+        stepId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"synthesis">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"run">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"profile">;
+    }, z.core.$strip>], "kind">>;
     state: z.ZodEnum<{
         paused: "paused";
         retrying: "retrying";
         running: "running";
     }>;
-    cause: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    cause: z.ZodDiscriminatedUnion<[z.ZodObject<{
         kind: z.ZodLiteral<"outage">;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"credential">;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"host">;
         reason: z.ZodString;
-    }, z.core.$strip>], "kind">>;
+    }, z.core.$strip>], "kind">;
+    pausedAt: z.ZodString;
     attempt: z.ZodOptional<z.ZodNumber>;
     retryAt: z.ZodOptional<z.ZodString>;
+    endedAt: z.ZodOptional<z.ZodString>;
+    end: z.ZodOptional<z.ZodEnum<{
+        abort: "abort";
+        resume: "resume";
+        retry: "retry";
+    }>>;
 }, z.core.$strip>;
 /** Mirrors `ModelRefusalPart` without its `type`: the stored payload of the part. */
 export declare const ModelRefusalPayloadSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -720,6 +810,58 @@ export declare const ChatPartSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         accession: z.ZodString;
         version: z.ZodNumber;
     }, z.core.$strip>], "kind">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"data-analogy-report">;
+    id: z.ZodString;
+    report: z.ZodUnion<readonly [z.ZodObject<{
+        problemSummary: z.ZodString;
+        problemObjects: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            role: z.ZodString;
+        }, z.core.$strip>>;
+        problemRelations: z.ZodArray<z.ZodString>;
+        keyTerms: z.ZodArray<z.ZodString>;
+        schemaVersion: z.ZodLiteral<"1">;
+        analogies: z.ZodArray<z.ZodObject<{
+            targetDomain: z.ZodString;
+            analogyTitle: z.ZodString;
+            objectMappings: z.ZodArray<z.ZodObject<{
+                source: z.ZodString;
+                target: z.ZodString;
+                rationale: z.ZodString;
+            }, z.core.$strip>>;
+            sharedRelations: z.ZodString;
+            coverage: z.ZodEnum<{
+                available: "available";
+                not_loaded: "not_loaded";
+                queried_no_data: "queried_no_data";
+                search_failed: "search_failed";
+            }>;
+            solutions: z.ZodArray<z.ZodObject<{
+                title: z.ZodString;
+                sourceDomain: z.ZodString;
+                description: z.ZodString;
+                keyConcepts: z.ZodArray<z.ZodString>;
+                relevance: z.ZodString;
+                sources: z.ZodArray<z.ZodObject<{
+                    url: z.ZodURL;
+                    title: z.ZodString;
+                }, z.core.$strip>>;
+                githubRepos: z.ZodArray<z.ZodObject<{
+                    url: z.ZodURL;
+                    description: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"1">;
+        error: z.ZodObject<{
+            kind: z.ZodEnum<{
+                "extraction-failed": "extraction-failed";
+            }>;
+            message: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>]>;
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"data-plan">;
     id: z.ZodString;
@@ -1087,21 +1229,43 @@ export declare const ChatPartSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         run: "run";
         turn: "turn";
     }>;
+    waiter: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"turn">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"sub-agent">;
+        agentId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"step">;
+        stepId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"synthesis">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"run">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"profile">;
+    }, z.core.$strip>], "kind">>;
     state: z.ZodEnum<{
         paused: "paused";
         retrying: "retrying";
         running: "running";
     }>;
-    cause: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    cause: z.ZodDiscriminatedUnion<[z.ZodObject<{
         kind: z.ZodLiteral<"outage">;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"credential">;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"host">;
         reason: z.ZodString;
-    }, z.core.$strip>], "kind">>;
+    }, z.core.$strip>], "kind">;
+    pausedAt: z.ZodString;
     attempt: z.ZodOptional<z.ZodNumber>;
     retryAt: z.ZodOptional<z.ZodString>;
+    endedAt: z.ZodOptional<z.ZodString>;
+    end: z.ZodOptional<z.ZodEnum<{
+        abort: "abort";
+        resume: "resume";
+        retry: "retry";
+    }>>;
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"data-model-retry">;
     id: z.ZodString;

package/dist/contracts/schemas/chat-parts.js

@@ -2,6 +2,7 @@
  * Zod schemas for chat data parts — validation at boundaries.
  */
 import { z } from "zod";
+import { AnalogicalReasonerOutputSchema } from "../analogy-report.js";
 import { ToolCallOutcomeSchema } from "./chat-events.js";
 import { TokenUsageRollupSchema } from "./usage.js";
 // ── Presentation ────────────────────────────────────────────────────
@@ -77,6 +78,12 @@ export const PresentationPartSchema = z.object({
     title: z.string().optional(),
     content: PresentationContentSchema,
 });
+// ── Analogy report ──────────────────────────────────────────────────
+export const AnalogyReportPartSchema = z.object({
+    type: z.literal("data-analogy-report"),
+    id: z.string(),
+    report: AnalogicalReasonerOutputSchema,
+});
 // ── Plan reference ──────────────────────────────────────────────────
 // oxlint-disable-next-line eslint-js/no-restricted-syntax -- the issued plan-id shape: the pln- prefix plus 8 hex digits.
 export const PLAN_ID_RE = /^pln-[a-f0-9]{8}$/;
@@ -365,15 +372,27 @@ export const PauseCauseSchema = z.discriminatedUnion("kind", [
     z.object({ kind: z.literal("credential") }),
     z.object({ kind: z.literal("host"), reason: z.string() }),
 ]);
+export const PauseWaiterSchema = z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("turn") }),
+    z.object({ kind: z.literal("sub-agent"), agentId: z.string() }),
+    z.object({ kind: z.literal("step"), stepId: z.string() }),
+    z.object({ kind: z.literal("synthesis") }),
+    z.object({ kind: z.literal("run") }),
+    z.object({ kind: z.literal("profile") }),
+]);
 export const PausePartSchema = z.object({
     type: z.literal("data-pause"),
     id: z.string(),
     workId: z.string(),
     workKind: z.enum(["turn", "run", "profile"]),
+    waiter: PauseWaiterSchema.optional(),
     state: z.enum(["retrying", "paused", "running"]),
-    cause: PauseCauseSchema.optional(),
+    cause: PauseCauseSchema,
+    pausedAt: z.string(),
     attempt: z.number().int().nonnegative().optional(),
     retryAt: z.string().optional(),
+    endedAt: z.string().optional(),
+    end: z.enum(["retry", "resume", "abort"]).optional(),
 });
 // ── Model refusal ───────────────────────────────────────────────────
 const ModelRefusalFallbackShape = { id: z.string(), outcome: z.literal("fallback"), model: z.string() };
@@ -413,6 +432,7 @@ export const SubAgentActivityPartSchema = z.object({
 // ── Union ───────────────────────────────────────────────────────────
 export const ChatPartSchema = z.discriminatedUnion("type", [
     PresentationPartSchema,
+    AnalogyReportPartSchema,
     PlanPartSchema,
     RunCardPartSchema,
     PlanApprovalPartSchema,

package/dist/execution/run-event-stream.d.ts

@@ -31,10 +31,10 @@
  * writer it observes.
  */
 import type { ResultAsync } from "neverthrow";
-import type { Pool } from "pg";
 import type { ChatPart } from "../contracts/chat-parts.js";
 import { type DbError } from "../lib/db-result.js";
 import type { Logger } from "../lib/logger.js";
+import type { Querier } from "../state/db.js";
 import type { RunStatus } from "../state/schema.js";
 /** The part of a run row that the terminal part is made from. */
 export type RunEventRunRead = {
@@ -48,7 +48,7 @@ export type RunEventRunRead = {
  * having console forced on it.
  */
 export type RunEventStreamDeps = {
-    readonly pool: Pool;
+    readonly pool: Querier;
     readonly logger?: Logger;
     /** Reads the status and the error of the run row, `null` when no row exists. Defaults to `queryRun` on `pool`. */
     readonly readRun?: (runId: string) => ResultAsync<RunEventRunRead | null, DbError>;

package/dist/index.d.ts

@@ -108,7 +108,7 @@ export type { SubAgentActivityTracker } from "./contracts/subagent-activity.js";
 export type { TextPart, ToolCallPart, MessagePart, ChatMessage } from "./contracts/message.js";
 export type { TurnTerminal, ApplyFrameResult, ChatPartCheck } from "./contracts/chat-frame.js";
 export type { TokenUsageRollup } from "./contracts/usage.js";
-export type { ChatPart, PresentationPart, PresentationContent, PlanPart, RunCardPart, PlanApprovalPart, FileReferencePart, FileReferenceEntry, RunStartedPart, DagStatePart, DagStepState, PlanGraphStep, StepStatus, StepActivityPart, ActivityEntryPart, SubAgentActivityEntry, SubAgentActivityPart, StepPhase, StepFileTreePart, FileTreeEntry, StepOutputPart, StepOutputFile, StepSummaryPart, StepUsagePart, StepBlockedPart, RunSynthesisPart, FindingReference, SynthesizedFinding, BiologicalTheme, SynthesisProgressPart, SynthesisPhase, RunCompletedPart, RunCompletedFinding, RunFailedPart, CompactionPart, PauseCause, WorkKind, PausePart, ModelRetryPart, ModelRefusal, ModelRefusalPart, AskPart, ChildSessionStartedPart, ReportRenderedPart, } from "./contracts/chat-parts.js";
+export type { ChatPart, PresentationPart, PresentationContent, PlanPart, RunCardPart, PlanApprovalPart, FileReferencePart, FileReferenceEntry, RunStartedPart, DagStatePart, DagStepState, PlanGraphStep, StepStatus, StepActivityPart, ActivityEntryPart, SubAgentActivityEntry, SubAgentActivityPart, StepPhase, StepFileTreePart, FileTreeEntry, StepOutputPart, StepOutputFile, StepSummaryPart, StepUsagePart, StepBlockedPart, RunSynthesisPart, FindingReference, SynthesizedFinding, BiologicalTheme, SynthesisProgressPart, SynthesisPhase, RunCompletedPart, RunCompletedFinding, RunFailedPart, CompactionPart, PauseCause, PauseWaiter, PauseEnd, WorkKind, PausePart, ModelRetryPart, ModelRefusal, ModelRefusalPart, AskPart, ChildSessionStartedPart, ReportRenderedPart, AnalogyReportPart, } from "./contracts/chat-parts.js";
 export { PART_REGISTRY, isTransient, isReconciling, isSidebarPart } from "./contracts/part-registry.js";
 export type { ChatPartType, PartDescriptor, PartEmitter, PartConsumer } from "./contracts/part-registry.js";
 export { parseStructureUrl, alphafoldEntryUrl, alphafoldPredictionUrl } from "./contracts/structure-source.js";

package/dist/lib/regulatory-corpus/fetch-ich.js

@@ -12,6 +12,7 @@
  * `ich-<code>` with non-word chars sanitized.
  */
 import { readPdfText } from "../pdf-text.js";
+import { slugify } from "../slug.js";
 import { normalizeWhitespace } from "./normalize-whitespace.js";
 /**
  * Curated catalog of ICH guidelines to index into the corpus.
@@ -157,19 +158,3 @@ export async function fetchAndExtractIchDoc(stub) {
         },
     };
 }
-function slugify(s) {
-    let out = "";
-    let inRun = false;
-    for (const char of s.toLowerCase()) {
-        const isSlugChar = (char >= "a" && char <= "z") || (char >= "0" && char <= "9");
-        if (!isSlugChar) {
-            inRun = true;
-            continue;
-        }
-        if (inRun && out.length > 0)
-            out += "-";
-        inRun = false;
-        out += char;
-    }
-    return out;
-}

package/dist/lib/slug.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The shared lowercase slug: each run of characters outside `[a-z0-9]` becomes one dash.
+ *
+ * The helper holds the loop alone; each caller states its own cap and its own empty-result fallback beside
+ * the call.
+ */
+export type SlugifyOpts = {
+    /**
+     * The result never passes this length: the loop stops before the append that would cross it, and a
+     * final slice cuts a two-character append that straddled the cap. That slice keeps the dash, thus a
+     * capped result can end in a dash. A stop before an append cannot change the first characters of the
+     * result, because an append only extends the prefix.
+     */
+    maxLength?: number;
+    /** The result for an input with no slug character. Without a fallback the empty result stays empty. */
+    fallback?: string;
+};
+export declare function slugify(value: string, opts?: SlugifyOpts): string;

package/dist/lib/slug.js

@@ -0,0 +1,29 @@
+/**
+ * The shared lowercase slug: each run of characters outside `[a-z0-9]` becomes one dash.
+ *
+ * The helper holds the loop alone; each caller states its own cap and its own empty-result fallback beside
+ * the call.
+ */
+export function slugify(value, opts = {}) {
+    const { maxLength, fallback } = opts;
+    let out = "";
+    let inRun = false;
+    for (const char of value.toLowerCase()) {
+        if (maxLength !== undefined && out.length >= maxLength)
+            break;
+        const isSlugChar = (char >= "a" && char <= "z") || (char >= "0" && char <= "9");
+        if (!isSlugChar) {
+            inRun = true;
+            continue;
+        }
+        if (inRun && out.length > 0)
+            out += "-";
+        inRun = false;
+        out += char;
+    }
+    if (maxLength !== undefined && out.length > maxLength)
+        out = out.slice(0, maxLength);
+    if (out === "" && fallback !== undefined)
+        return fallback;
+    return out;
+}

package/dist/lib/test/pdf-fixture.d.ts

@@ -0,0 +1,5 @@
+/**
+ * A minimal single-font PDF with one text line per page, `latin1`-encoded. It carries just enough structure
+ * for the PDF text extractors of the suites to read one body line per page.
+ */
+export declare function buildPdf(pageCount: number): Buffer;

package/dist/lib/test/pdf-fixture.js

@@ -0,0 +1,14 @@
+/**
+ * A minimal single-font PDF with one text line per page, `latin1`-encoded. It carries just enough structure
+ * for the PDF text extractors of the suites to read one body line per page.
+ */
+export function buildPdf(pageCount) {
+    const objects = ["1 0 obj<</Type/Catalog/Pages 2 0 R>>endobj"];
+    const kids = Array.from({ length: pageCount }, (_, i) => `${4 + i * 2} 0 R`).join(" ");
+    objects.push(`2 0 obj<</Type/Pages/Kids[${kids}]/Count ${pageCount}>>endobj`, `3 0 obj<</Type/Font/Subtype/Type1/BaseFont/Helvetica>>endobj`);
+    for (let i = 0; i < pageCount; i++) {
+        const content = `BT /F1 12 Tf 72 720 Td (Page ${i + 1} body text) Tj ET`;
+        objects.push(`${4 + i * 2} 0 obj<</Type/Page/Parent 2 0 R/MediaBox[0 0 612 792]/Contents ${5 + i * 2} 0 R/Resources<</Font<</F1 3 0 R>>>>>>endobj`, `${5 + i * 2} 0 obj<</Length ${content.length}>>stream\n${content}\nendstream endobj`);
+    }
+    return Buffer.from(`%PDF-1.4\n${objects.join("\n")}\ntrailer<</Size ${3 + pageCount * 2}/Root 1 0 R>>`, "latin1");
+}

package/dist/loop/chat-stream.d.ts

@@ -16,7 +16,10 @@ import type { EmitFn } from "./types.js";
 export declare const CHAT_STREAM_KEY = "chat";
 /** The data part that names the child workflow of a sub-agent call in the stream of its caller. */
 export declare const SUB_AGENT_STREAM_PART = "data-subagent-stream";
-/** The chunk that carries one frame of the harness in the stream of a turn. A transient chunk is live only. */
+/**
+ * The chunk that carries one frame of the harness in the stream of a turn. A transient chunk is in the stream, and
+ * a reader gets it. A replay of the step does not write it again, and the stored transcript does not hold it.
+ */
 export declare function chunkOfFrame(frame: ChatFrame, transient?: boolean): UIMessageChunk;
 /** What the body of a turn workflow writes to its stream, and what each of its tool steps writes. */
 export type TurnStreamWriter = {

package/dist/loop/chat-stream.js

@@ -28,13 +28,16 @@ const HarnessFrameChunkSchema = z.object({
     type: z.literal(HARNESS_FRAME_CHUNK),
     data: z.looseObject({ type: z.string() }),
 });
-/** The chunk that carries one frame of the harness in the stream of a turn. A transient chunk is live only. */
+/**
+ * The chunk that carries one frame of the harness in the stream of a turn. A transient chunk is in the stream, and
+ * a reader gets it. A replay of the step does not write it again, and the stored transcript does not hold it.
+ */
 export function chunkOfFrame(frame, transient = false) {
     return transient ? { type: HARNESS_FRAME_CHUNK, data: frame, transient: true } : { type: HARNESS_FRAME_CHUNK, data: frame };
 }
 /**
- * Whether a frame from a tool step shows progress only. The library gives such a frame live, and a replay of the
- * step does not give it again. Each other frame of a tool step is checkpointed with the step, and the display of a
+ * Whether a frame from a step shows progress only. Such a frame goes to the stream at once, and a replay of the step
+ * does not write it again. Each other frame of a tool step is checkpointed with the step, and the display of a
  * round that a recovery stores keeps it: the end of each call, and each part of the root agent.
  */
 function isProgressFrame(frame) {
@@ -43,18 +46,27 @@ function isProgressFrame(frame) {
     return isKnownPartType(frame.type) && PART_REGISTRY[frame.type].transient;
 }
 /**
- * Run each body write of one workflow after the body write before it ends.
+ * Run each body write of one workflow after the body write before it ends, and each step write after the step write
+ * before it ends.
  *
  * DBOS gives a stream write its offset inside the insert, thus two writes in flight take the same offset, and the
  * write that loses sleeps 100 ms before it tries again. A body write must still take its function id at the call,
  * because a replay finds each checkpoint by the order of the calls. Thus the call reserves its id now, and the
- * chained write takes the reserved id from the context of the workflow when it starts.
+ * chained write takes the reserved id from the context of the workflow when it starts. A step write takes no
+ * function id, thus its chain reserves none.
  */
-function chainBodyWrites() {
-    let tail = Promise.resolve();
+function chainWrites() {
+    let bodyTail = Promise.resolve();
+    let stepTail = Promise.resolve();
+    const ended = (write) => write.then(() => undefined, () => undefined);
     return (start) => {
+        if (DBOS.isInStep()) {
+            const write = stepTail.then(start, start);
+            stepTail = ended(write);
+            return write;
+        }
         const ctx = getCurrentContextStore();
-        if (ctx === undefined || !DBOS.isInWorkflow() || DBOS.isInStep())
+        if (ctx === undefined || !DBOS.isInWorkflow())
             return start();
         const reserved = functionIDGetIncrement();
         const run = () => {
@@ -71,8 +83,8 @@ function chainBodyWrites() {
                 ctx.curWFFunctionId = next;
             }
         };
-        const write = tail.then(run, run);
-        tail = write.then(() => undefined, () => undefined);
+        const write = bodyTail.then(run, run);
+        bodyTail = ended(write);
         return write;
     };
 }
@@ -85,7 +97,7 @@ function chainBodyWrites() {
  */
 export function createTurnStreamWriter(rootSource, observe) {
     const pending = [];
-    const chained = chainBodyWrites();
+    const chained = chainWrites();
     const track = (write) => {
         // Observed now, thus a failure before the settle is not an unhandled rejection. The settle still sees it.
         write.catch(() => undefined);
@@ -114,10 +126,15 @@ export function createTurnStreamWriter(rootSource, observe) {
         const frame = toChatFrame(event, rootSource);
         if (frame === null)
             return;
-        // A tool step gives its frames to the library, which checkpoints each one that is not progress.
         if (DBOS.isInStep()) {
             const liveOnly = "transient" in event && event.transient === true;
-            toolWriter().write(chunkOfFrame(frame, liveOnly || isProgressFrame(frame)));
+            const transient = liveOnly || isProgressFrame(frame);
+            // A model step has no library writer, and a transient chunk is not checkpointed with its step. Thus the
+            // chunk goes straight to the stream. The library checkpoints each other frame with its tool step.
+            if (transient)
+                writer.write(chunkOfFrame(frame, true));
+            else
+                toolWriter().write(chunkOfFrame(frame));
             return;
         }
         await write(frame);

package/dist/loop/run-loop.js

@@ -526,6 +526,27 @@ async function runSeries(agent, opts, calls, log, target, spec) {
         const detail = computeDetail(tool, toolCall.input, log);
         return { detail: detail === undefined ? {} : { detail }, input: shownRoot ? viewInputValue(tool, toolCall.input, log) : undefined };
     };
+    /** The two events of a rejected tool call: the start names the call, and the finish states the outcome and the error text. */
+    const emitRejectedToolEvents = async (toolCall, shown, outcome, error) => {
+        await opts.emit({
+            type: "tool-started",
+            source,
+            toolUseId: toolCall.toolCallId,
+            name: toolCall.toolName,
+            ...shown.detail,
+            input: shown.input,
+        });
+        await opts.emit({
+            type: "tool-finished",
+            source,
+            toolUseId: toolCall.toolCallId,
+            name: toolCall.toolName,
+            outcome,
+            ...shown.detail,
+            input: shown.input,
+            error,
+        });
+    };
     const seriesSteps = [];
     let open = openStep();
     let failure;
@@ -561,24 +582,7 @@ async function runSeries(agent, opts, calls, log, target, spec) {
             if (refusal !== undefined) {
                 // A refused call does not run, thus its two events come from here.
                 const shown = callShownOf(toolCall);
-                await opts.emit({
-                    type: "tool-started",
-                    source,
-                    toolUseId: toolCall.toolCallId,
-                    name: toolCall.toolName,
-                    ...shown.detail,
-                    input: shown.input,
-                });
-                await opts.emit({
-                    type: "tool-finished",
-                    source,
-                    toolUseId: toolCall.toolCallId,
-                    name: toolCall.toolName,
-                    outcome: "error",
-                    ...shown.detail,
-                    input: shown.input,
-                    error: shownRoot ? textToolValue(refusal) : undefined,
-                });
+                await emitRejectedToolEvents(toolCall, shown, "error", shownRoot ? textToolValue(refusal) : undefined);
                 return { type: "denied", reason: refusal };
             }
             let denial;
@@ -595,23 +599,7 @@ async function runSeries(agent, opts, calls, log, target, spec) {
                 return undefined;
             deniedByTheUser.set(toolCall.toolCallId, denial);
             const shown = callShownOf(toolCall);
-            await opts.emit({
-                type: "tool-started",
-                source,
-                toolUseId: toolCall.toolCallId,
-                name: toolCall.toolName,
-                ...shown.detail,
-                input: shown.input,
-            });
-            await opts.emit({
-                type: "tool-finished",
-                source,
-                toolUseId: toolCall.toolCallId,
-                name: toolCall.toolName,
-                outcome: "denied",
-                ...shown.detail,
-                input: shown.input,
-            });
+            await emitRejectedToolEvents(toolCall, shown, "denied", undefined);
             return { type: "denied", reason: denial };
         },
         stopWhen: () => stops(),

package/dist/loop/sub-agent.d.ts

@@ -18,7 +18,7 @@
  * runs the body of the sub-agent in its own process.
  */
 import type { RunSession } from "../auth/types.js";
-import type { WorkKind, PausePart } from "../contracts/chat-parts.js";
+import type { PauseWaiter, WorkKind, PausePart } from "../contracts/chat-parts.js";
 import type { ToolContext } from "../tools/define-tool.js";
 import type { LoopOptions } from "./run-loop.js";
 /** The options of the loop of a sub-agent that the place where it runs decides. */
@@ -48,7 +48,7 @@ export type SubAgentWork = {
     readonly runSession?: RunSession;
 };
 /** Gives the pause of the loops of a child, which writes its part through `emit`. The assembly gives it. */
-export type SubAgentPauses = (work: SubAgentWork, emit: (part: PausePart) => Promise<void>) => LoopOptions["pause"];
+export type SubAgentPauses = (work: SubAgentWork, waiter: PauseWaiter, emit: (part: PausePart) => Promise<void>) => LoopOptions["pause"];
 /**
  * Run a sub-agent in the process of its caller, with no workflow: its loops fold their usage into the total of the
  * caller. A tool factory that a test builds many times takes this registrar, because DBOS registers a name one time.

package/dist/loop/sub-agent.js

@@ -78,7 +78,7 @@ export function registerSubAgent(name, body, pauses) {
         const source = { agentId: name, callPath: [...caller.callPath, name] };
         const pause = pauses === undefined || work === undefined
             ? undefined
-            : pauses(work, async (part) => {
+            : pauses(work, { kind: "sub-agent", agentId: name }, async (part) => {
                 await writer.emit({ type: "data-pause", source, data: part });
             });
         // A recovered child replays its model calls, and the usage middleware adds each one again. Thus the total

package/dist/loop/test/metric-reader.d.ts

@@ -0,0 +1,9 @@
+import { type MetricData } from "@opentelemetry/sdk-metrics";
+export type MetricReader = {
+    /** Flush the provider and return the flat list of exported metrics. */
+    collect(): Promise<MetricData[]>;
+    /** Shut the provider down and unbind the global meter provider. */
+    stop(): Promise<void>;
+};
+/** Bind a meter provider over an in-memory exporter for one test; `stop` undoes both bindings after it. */
+export declare function metricReader(): MetricReader;