@inflexa-ai/harness 0.48.2 → 0.48.4

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

@@ -70,6 +70,7 @@ export const ToolFinishedEventSchema = z.object({
 export const FinishEventSchema = z.object({
     type: z.literal("finish"),
     source: EventSourceSchema,
+    finishReason: z.string(),
     usage: TokenUsageRollupSchema.optional(),
     turnUsage: TokenUsageRollupSchema.optional(),
 });

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,22 +677,63 @@ 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<{
+    id: z.ZodString;
+    outcome: z.ZodLiteral<"fallback">;
+    model: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    outcome: z.ZodLiteral<"stopped">;
+}, z.core.$strip>], "outcome">;
+export declare const ModelRefusalPartSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodString;
+    outcome: z.ZodLiteral<"fallback">;
+    model: z.ZodString;
+    type: z.ZodLiteral<"data-model-refusal">;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    outcome: z.ZodLiteral<"stopped">;
+    type: z.ZodLiteral<"data-model-refusal">;
+}, z.core.$strip>], "outcome">;
 export declare const ModelRetryPartSchema: z.ZodObject<{
     type: z.ZodLiteral<"data-model-retry">;
     id: z.ZodString;
@@ -701,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;
@@ -1068,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;
@@ -1090,4 +1273,13 @@ export declare const ChatPartSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     maxRetries: z.ZodNumber;
     retryAt: z.ZodString;
     status: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>], "type">;
+}, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodString;
+    outcome: z.ZodLiteral<"fallback">;
+    model: z.ZodString;
+    type: z.ZodLiteral<"data-model-refusal">;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    outcome: z.ZodLiteral<"stopped">;
+    type: z.ZodLiteral<"data-model-refusal">;
+}, z.core.$strip>], "outcome">], "type">;

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,16 +372,37 @@ 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() };
+const ModelRefusalStoppedShape = { id: z.string(), outcome: z.literal("stopped") };
+/** Mirrors `ModelRefusalPart` without its `type`: the stored payload of the part. */
+export const ModelRefusalPayloadSchema = z.discriminatedUnion("outcome", [z.object(ModelRefusalFallbackShape), z.object(ModelRefusalStoppedShape)]);
+export const ModelRefusalPartSchema = z.discriminatedUnion("outcome", [
+    z.object({ type: z.literal("data-model-refusal"), ...ModelRefusalFallbackShape }),
+    z.object({ type: z.literal("data-model-refusal"), ...ModelRefusalStoppedShape }),
+]);
 // ── Model retry ─────────────────────────────────────────────────────
 export const ModelRetryPartSchema = z.object({
     type: z.literal("data-model-retry"),
@@ -404,6 +432,7 @@ export const SubAgentActivityPartSchema = z.object({
 // ── Union ───────────────────────────────────────────────────────────
 export const ChatPartSchema = z.discriminatedUnion("type", [
     PresentationPartSchema,
+    AnalogyReportPartSchema,
     PlanPartSchema,
     RunCardPartSchema,
     PlanApprovalPartSchema,
@@ -428,4 +457,5 @@ export const ChatPartSchema = z.discriminatedUnion("type", [
     CompactionPartSchema,
     PausePartSchema,
     ModelRetryPartSchema,
+    ModelRefusalPartSchema,
 ]);

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, 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.js

@@ -156,7 +156,7 @@ export function framesOfChunk(chunk, rootSource) {
         case "error":
             return [{ type: "error", message: chunk.errorText, source: rootSource }];
         case "abort":
-            return [{ type: "finish", source: rootSource }];
+            return [{ type: "finish", source: rootSource, finishReason: "aborted" }];
         default: {
             const frame = harnessFrameOf(chunk);
             return frame === undefined ? [] : [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(),
@@ -654,6 +642,9 @@ async function runSeries(agent, opts, calls, log, target, spec) {
             target.steps.push(loopStep);
             if (loopStep.calls.length > 0)
                 log.debug("iteration", { iteration: seriesSteps.length - 1, tools: loopStep.calls.map((call) => call.toolName) });
+            const refusal = refusalOf(step, loopStep);
+            if (refusal !== undefined)
+                await opts.emit({ type: "data-model-refusal", source, data: refusal });
             await opts.emit({ type: "iteration", source, index: seriesSteps.length - 1, final: !continuesAfter(loopStep) || stops() });
         },
     });
@@ -749,6 +740,19 @@ function loopStepOf(step, deniedByTheUser) {
     });
     return { finishReason: step.finishReason, rawFinishReason: step.rawFinishReason, calls };
 }
+/**
+ * The refusal of one step, when the provider declined its request. A reply that ends with the content filter
+ * stopped, also after a fallback hop, because a chain whose last model declined reports that hop too. A hop that
+ * names no model gives the served model of the response, as the usage record does.
+ */
+function refusalOf(step, loopStep) {
+    if (loopStep.finishReason === "content-filter")
+        return { id: step.response.id, outcome: "stopped" };
+    const servedBy = fallbackModelOf(step.providerMetadata);
+    if (servedBy === undefined)
+        return undefined;
+    return { id: step.response.id, outcome: "fallback", model: servedBy === "" ? step.response.modelId : servedBy };
+}
 /**
  * The messages of one step as the transcript records them. The request after
  * them sends them as they are recorded, thus the record is the prefix of the

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;

package/dist/loop/test/metric-reader.js

@@ -0,0 +1,33 @@
+import { metrics } from "@opentelemetry/api";
+import { AggregationTemporality, InMemoryMetricExporter, MeterProvider, PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
+import { __resetMetricsForTest } from "../metrics.js";
+/** Bind a meter provider over an in-memory exporter for one test; `stop` undoes both bindings after it. */
+export function metricReader() {
+    const exporter = new InMemoryMetricExporter(AggregationTemporality.CUMULATIVE);
+    const provider = new MeterProvider({
+        readers: [
+            new PeriodicExportingMetricReader({
+                exporter,
+                // Long interval — every export in a suite is a manual flush.
+                exportIntervalMillis: 3_600_000,
+            }),
+        ],
+    });
+    metrics.setGlobalMeterProvider(provider);
+    // Drop memoized instruments so they rebind to this fresh provider.
+    __resetMetricsForTest();
+    return {
+        async collect() {
+            await provider.forceFlush();
+            return exporter
+                .getMetrics()
+                .flatMap((rm) => rm.scopeMetrics)
+                .flatMap((sm) => sm.metrics);
+        },
+        async stop() {
+            await provider.shutdown();
+            metrics.disable();
+            __resetMetricsForTest();
+        },
+    };
+}

package/dist/loop/test/unnamed-model.d.ts

@@ -0,0 +1,6 @@
+/**
+ * One ChatProvider whose stream answers one text delta and one finish that carries the given input-token
+ * total and no output tokens. The usage suites feed it to the loop and read the counters back.
+ */
+import type { ChatProvider } from "../../providers/types.js";
+export declare function unnamedModel(inputTokens: number): ChatProvider;