@inflexa-ai/harness 0.48.2 → 0.48.3

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

@@ -15,7 +15,7 @@
  */
 import type { AuthContext } from "../auth/types.js";
 import type { TokenUsageRollup } from "../contracts/usage.js";
-import type { ChatFrame } from "../contracts/chat-events.js";
+import type { ChatErrorEvent, ChatFrame, EventSource, FinishEvent } 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";
@@ -110,5 +110,7 @@ export declare const DEFAULT_ASK_WAIT_SECONDS: number;
  * finds the workflow of a recovery by its registered name.
  */
 export declare function registerChatTurns(deps: ChatTurnWorkflowDeps): ChatTurns;
+/** The last frame of a turn that ran: `error` for a failed turn, else `finish` with the stop reason of the turn. */
+export declare function endFrameOf(ran: ChatTurnRan, rootSource: EventSource): ChatErrorEvent | FinishEvent;
 /** How a turn that ran ended, as a host reads it. */
 export declare function chatTurnEndOf(ran: ChatTurnRan): ChatTurnEnd;

package/dist/app/chat-turn-workflow.js

@@ -277,9 +277,7 @@ async function runTurnWorkflow(deps, input, signal) {
     };
     const ran = await runOpenTurn(deps, { analysisId: input.analysisId, threadId: input.threadId, userInput: input.userText }, { kind: "ok", threadType: input.threadType, history: view, userMessage: opening.userMessage, contextRecords: opening.contextRecords }, agent.value, { session, author: input.author, startedAtMs: input.startedAtMs, promptCache: input.promptCache }, transport);
     const { outcome } = ran;
-    await writer.write(outcome.status === "failed"
-        ? { type: "error", message: outcome.reason, reason: outcome.code, source: rootSource }
-        : { type: "finish", source: rootSource, turnUsage: ran.turnUsage });
+    await writer.write(endFrameOf(ran, rootSource));
     await writer.settle();
     await closeDurableStream(CHAT_STREAM_KEY, outcome.status === "done" ? "stop" : outcome.status === "aborted" ? "aborted" : "error");
     // A sub-agent that a stop canceled in its pause leaves its row, thus the end of the turn clears each row of the turn.
@@ -287,6 +285,23 @@ async function runTurnWorkflow(deps, input, signal) {
     await DBOS.runStep(async () => unwrapOrThrow(await releaseThreadOfTurn(deps.pool, input.threadId, input.turnId)), { name: "chat-turn.release" });
     return chatTurnEndOf(ran);
 }
+/** The last frame of a turn that ran: `error` for a failed turn, else `finish` with the stop reason of the turn. */
+export function endFrameOf(ran, rootSource) {
+    const { outcome } = ran;
+    switch (outcome.status) {
+        case "failed":
+            return { type: "error", message: outcome.reason, reason: outcome.code, source: rootSource };
+        case "done":
+            return { type: "finish", source: rootSource, finishReason: outcome.finish.reason, turnUsage: ran.turnUsage };
+        // An abort that cut the run before its end leaves no finish of the loop.
+        case "aborted":
+            return { type: "finish", source: rootSource, finishReason: "aborted", turnUsage: ran.turnUsage };
+        default: {
+            const exhaustive = outcome;
+            throw new Error(`unhandled turn outcome: ${JSON.stringify(exhaustive)}`);
+        }
+    }
+}
 /** How a turn that ran ended, as a host reads it. */
 export function chatTurnEndOf(ran) {
     const { outcome } = ran;

package/dist/app/chat-turn.js

@@ -218,7 +218,7 @@ export async function runOpenTurn(deps, turn, prepared, agent, params, transport
     await flush({
         status: outcome.status,
         reason: outcome.status === "failed" ? outcome.reason : undefined,
-        note: outcome.status === "failed" ? conversationRecordTurn(failureNote(outcome.reason)) : outcome.status === "aborted" ? interruptionNote() : undefined,
+        note: closingNoteOf(outcome, recorder),
         turnUsage,
         turnDurationMs: durationMs,
     });
@@ -292,6 +292,32 @@ function failureReasonOf(err) {
             return findProviderError(err) === undefined ? "The turn stopped on an internal error." : "The model request failed.";
     }
 }
+/** The note that closes a turn: a failed, an aborted, or a declined turn has one, and a turn that the model answered has none. */
+function closingNoteOf(outcome, recorder) {
+    switch (outcome.status) {
+        case "failed":
+            return conversationRecordTurn(failureNote(outcome.reason));
+        case "aborted":
+            return interruptionNote();
+        case "done":
+            return outcome.finish.reason === "content-filter" ? declineNote(recorder) : undefined;
+        default: {
+            const exhaustive = outcome;
+            throw new Error(`unhandled turn outcome: ${JSON.stringify(exhaustive)}`);
+        }
+    }
+}
+/**
+ * The note of a turn that the content filter stopped. A declined request often gives no message, and a round
+ * with no message gives no row. The note is the row that holds the display of such a round, thus a reload
+ * shows the refusal. It also tells the next turn that this request has no reply.
+ */
+function declineNote(recorder) {
+    return {
+        modelMessages: [syntheticUserMessage("[The model provider declined the request above, thus it has no reply.]")],
+        displayMessages: recorder.takeRound([]),
+    };
+}
 /**
  * The note of an aborted turn. Without it, the next turn reads the request of the aborted turn as open, and
  * its reply also answers that request. The transcript shows the interruption from the turn record, thus the

package/dist/app/in-process-turn.js

@@ -6,7 +6,7 @@
  */
 import { randomUUID } from "node:crypto";
 import { toChatFrame } from "../contracts/chat-frame.js";
-import { chatTurnEndOf } from "./chat-turn-workflow.js";
+import { chatTurnEndOf, endFrameOf } from "./chat-turn-workflow.js";
 import { createConversationDisplayRecorder } from "../memory/conversation-display-recorder.js";
 import { prepareChatTurn, runOpenTurn, userTextOf, } from "./chat-turn.js";
 /** Prepare a turn and resolve its agent. A refusal comes back before any row of the turn exists. */
@@ -112,11 +112,8 @@ export function inProcessChatTurns(deps) {
                 promptCache: request.promptCache,
             })
                 .then((ran) => {
-                const turnEnd = chatTurnEndOf(ran);
-                log.push(turnEnd.status === "failed"
-                    ? { type: "error", message: turnEnd.reason ?? "The turn failed.", reason: turnEnd.code, source: rootSource }
-                    : { type: "finish", source: rootSource, turnUsage: turnEnd.turnUsage });
-                return turnEnd;
+                log.push(endFrameOf(ran, rootSource));
+                return chatTurnEndOf(ran);
             })
                 .catch(() => null)
                 .finally(() => log.close());

package/dist/contracts/chat-events.d.ts

@@ -162,6 +162,11 @@ export type ToolFinishedEvent = {
 export type FinishEvent = {
     type: "finish";
     source: EventSource;
+    /**
+     * Why the turn stopped: the finish reason of the last reply, for example `stop` or `content-filter`, or `aborted`,
+     * `max_iterations`, or `denied`. A word outside these stays as the provider sent it.
+     */
+    finishReason: string;
     /** What this loop's own LLM calls used. */
     usage?: TokenUsageRollup;
     /**

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

@@ -9,6 +9,7 @@
  *                    data-plan-approval (the record of an approved plan)
  *   Compaction:      data-compaction (a compaction of the conversation thread)
  *   Model retry:     data-model-retry (a retry of a model request inside the retry envelope of the provider)
+ *   Model refusal:   data-model-refusal (a model request that the provider declined)
  *   Run lifecycle:   run-started, dag-state, run-completed, run-failed, run-synthesis,
  *                    synthesis-progress
  *   Per-step live:   step-activity, step-file-tree
@@ -498,6 +499,23 @@ export type ModelRetryPart = {
     /** The HTTP status of the failed attempt. Absent for a failure with no status, for example a lost connection. */
     status?: number;
 };
+/**
+ * A model request that the provider declined. `fallback`: another model answered the request, and `model` names it.
+ * `stopped`: no model answered, thus the reply of the request ended with the content filter.
+ */
+export type ModelRefusal = {
+    /** The id of the model response. */
+    id: string;
+    outcome: "fallback";
+    model: string;
+} | {
+    /** The id of the model response. */
+    id: string;
+    outcome: "stopped";
+};
+export type ModelRefusalPart = {
+    type: "data-model-refusal";
+} & ModelRefusal;
 /** The kind of a durable work, and of the work that a pause belongs to. A sub-agent belongs to its turn, and a sandbox step to its run. */
 export type WorkKind = "turn" | "run" | "profile";
 /**
@@ -521,7 +539,7 @@ export type PausePart = {
     retryAt?: string;
 };
 /** The parts whose contracts this version of the package declares — the arms the part registry knows. */
-export type KnownChatPart = PresentationPart | PlanPart | RunCardPart | PlanApprovalPart | FileReferencePart | AskPart | RunStartedPart | DagStatePart | StepActivityPart | ActivityEntryPart | SubAgentActivityPart | StepFileTreePart | StepOutputPart | StepSummaryPart | StepUsagePart | StepBlockedPart | RunSynthesisPart | SynthesisProgressPart | RunCompletedPart | RunFailedPart | ChildSessionStartedPart | ReportRenderedPart | CompactionPart | PausePart | ModelRetryPart;
+export type KnownChatPart = PresentationPart | PlanPart | RunCardPart | PlanApprovalPart | FileReferencePart | AskPart | RunStartedPart | DagStatePart | StepActivityPart | ActivityEntryPart | SubAgentActivityPart | StepFileTreePart | StepOutputPart | StepSummaryPart | StepUsagePart | StepBlockedPart | RunSynthesisPart | SynthesisProgressPart | RunCompletedPart | RunFailedPart | ChildSessionStartedPart | ReportRenderedPart | CompactionPart | PausePart | ModelRetryPart | ModelRefusalPart;
 /**
  * A part of a known contract, or a part whose type this build does not know. An emitter newer than this
  * build can lead the registry, and such a part already rides through the check boundary and the live view

package/dist/contracts/chat-parts.js

@@ -9,6 +9,7 @@
  *                    data-plan-approval (the record of an approved plan)
  *   Compaction:      data-compaction (a compaction of the conversation thread)
  *   Model retry:     data-model-retry (a retry of a model request inside the retry envelope of the provider)
+ *   Model refusal:   data-model-refusal (a model request that the provider declined)
  *   Run lifecycle:   run-started, dag-state, run-completed, run-failed, run-synthesis,
  *                    synthesis-progress
  *   Per-step live:   step-activity, step-file-tree

package/dist/contracts/index.d.ts

@@ -2,7 +2,7 @@ export { ORGAN_SYSTEMS, OrganSystemSchema, ORGAN_SYSTEM_LABELS, organSystemLabel
 export type { OrganSystem } from "./organ-system.js";
 export { SEVERITIES, SeveritySchema } from "./severity.js";
 export type { Severity } from "./severity.js";
-export type { PlanStep, PresentationContent, PresentationPart, PlanPart, RunCardPart, PlanApprovalPart, FileReferenceEntry, FileReferencePart, AskPart, RunStartedPart, StepStatus, DagStepState, PlanGraphStep, DagStatePart, StepPhase, StepActivityPart, ActivityEntryPart, SubAgentActivityEntry, SubAgentActivityPart, FileTreeEntry, StepFileTreePart, StepOutputFile, StepOutputPart, StepSummaryPart, StepUsagePart, StepBlockedPart, FindingReference, SynthesizedFinding, BiologicalTheme, RunSynthesisPart, SynthesisPhase, SynthesisProgressPart, RunCompletedFinding, RunCompletedPart, RunFailedPart, ChildSessionStartedPart, ReportRenderedPart, CompactionPart, PauseCause, WorkKind, PausePart, ModelRetryPart, ChatPart, KnownChatPart, } from "./chat-parts.js";
+export type { PlanStep, PresentationContent, PresentationPart, PlanPart, RunCardPart, PlanApprovalPart, FileReferenceEntry, FileReferencePart, AskPart, RunStartedPart, StepStatus, DagStepState, PlanGraphStep, DagStatePart, StepPhase, StepActivityPart, ActivityEntryPart, SubAgentActivityEntry, SubAgentActivityPart, FileTreeEntry, StepFileTreePart, StepOutputFile, StepOutputPart, StepSummaryPart, StepUsagePart, StepBlockedPart, FindingReference, SynthesizedFinding, BiologicalTheme, RunSynthesisPart, SynthesisPhase, SynthesisProgressPart, RunCompletedFinding, RunCompletedPart, RunFailedPart, ChildSessionStartedPart, ReportRenderedPart, CompactionPart, PauseCause, WorkKind, PausePart, ModelRetryPart, ModelRefusal, ModelRefusalPart, ChatPart, KnownChatPart, } from "./chat-parts.js";
 export type { EventSource, TextDeltaEvent, IterationEvent, ToolStartedEvent, ToolFinishedEvent, ToolCallLeaf, ToolCallValue, FinishEvent, ChatErrorEvent, MessageStartEvent, ChatEvent, ChatFrame, ChatPartFrame, } from "./chat-events.js";
 export type { TokenUsageRollup } from "./usage.js";
 export { DATA_PROFILE_RUN_LITERAL } from "./data-profile.js";

package/dist/contracts/part-registry.js

@@ -24,6 +24,7 @@ export const PART_REGISTRY = {
     "data-compaction": { emitter: "conversation", consumer: "conversation", transient: true, reconciling: true },
     "data-pause": { emitter: "workflow", consumer: "conversation", transient: false, reconciling: true },
     "data-model-retry": { emitter: "conversation", consumer: "conversation", transient: true, reconciling: true },
+    "data-model-refusal": { emitter: "conversation", consumer: "conversation", transient: false, reconciling: false },
 };
 export function isTransient(type) {
     return PART_REGISTRY[type].transient;

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

@@ -259,6 +259,7 @@ export declare const FinishEventSchema: z.ZodObject<{
         callPath: z.ZodArray<z.ZodString>;
         invocationId: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
+    finishReason: z.ZodString;
     usage: z.ZodOptional<z.ZodObject<{
         inputTokens: z.ZodOptional<z.ZodNumber>;
         outputTokens: z.ZodOptional<z.ZodNumber>;
@@ -484,6 +485,7 @@ export declare const ChatEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         callPath: z.ZodArray<z.ZodString>;
         invocationId: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
+    finishReason: z.ZodString;
     usage: z.ZodOptional<z.ZodObject<{
         inputTokens: z.ZodOptional<z.ZodNumber>;
         outputTokens: z.ZodOptional<z.ZodNumber>;

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

@@ -625,6 +625,25 @@ export declare const PausePartSchema: z.ZodObject<{
     attempt: z.ZodOptional<z.ZodNumber>;
     retryAt: z.ZodOptional<z.ZodString>;
 }, 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;
@@ -1090,4 +1109,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

@@ -375,6 +375,15 @@ export const PausePartSchema = z.object({
     attempt: z.number().int().nonnegative().optional(),
     retryAt: z.string().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"),
@@ -428,4 +437,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, WorkKind, PausePart, ModelRetryPart, ModelRefusal, ModelRefusalPart, AskPart, ChildSessionStartedPart, ReportRenderedPart, } 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/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

@@ -654,6 +654,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 +752,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/memory/conversation-display-storage.d.ts

@@ -15,7 +15,7 @@
  * reconstruction.
  */
 import { type DataUIPart, type UIMessage } from "ai";
-import type { AskPart, ChildSessionStartedPart, CompactionPart, FileReferencePart, PlanApprovalPart, PlanPart, PresentationPart, ReportRenderedPart, RunCardPart, SubAgentActivityEntry, SubAgentActivityPart } from "../contracts/chat-parts.js";
+import type { AskPart, ChildSessionStartedPart, CompactionPart, FileReferencePart, ModelRefusal, ModelRefusalPart, PlanApprovalPart, PlanPart, PresentationPart, ReportRenderedPart, RunCardPart, SubAgentActivityEntry, SubAgentActivityPart } from "../contracts/chat-parts.js";
 import type { ToolCallOutcome } from "../contracts/chat-events.js";
 import type { ChatMessage, MessagePart, ToolCallPart } from "../contracts/message.js";
 import type { Logger } from "../lib/logger.js";
@@ -43,6 +43,7 @@ export type ConversationUIData = {
     "child-session-started": Payload<ChildSessionStartedPart>;
     "report-rendered": Payload<ReportRenderedPart>;
     compaction: Payload<CompactionPart>;
+    "model-refusal": ModelRefusal;
     "subagent-activity": Omit<Payload<SubAgentActivityPart>, "entries"> & {
         entries: (Omit<SubAgentActivityEntry, "outcome"> & {
             outcome: ToolCallOutcome;
@@ -65,7 +66,7 @@ export declare function parseStoredDisplayEnvelope(value: unknown, identity: str
 export type StoredSourcePart = Extract<Exclude<MessagePart, {
     type: "text";
 }>, {
-    type: ToolCallPart["type"] | PresentationPart["type"] | PlanPart["type"] | RunCardPart["type"] | PlanApprovalPart["type"] | FileReferencePart["type"] | AskPart["type"] | ChildSessionStartedPart["type"] | ReportRenderedPart["type"] | CompactionPart["type"] | SubAgentActivityPart["type"];
+    type: ToolCallPart["type"] | PresentationPart["type"] | PlanPart["type"] | RunCardPart["type"] | PlanApprovalPart["type"] | FileReferencePart["type"] | AskPart["type"] | ChildSessionStartedPart["type"] | ReportRenderedPart["type"] | CompactionPart["type"] | ModelRefusalPart["type"] | SubAgentActivityPart["type"];
 }>;
 /** Whether `part` is an arm the stored vocabulary can hold; anything else cannot become a stored card. */
 export declare function isStoredSourcePart(part: Exclude<MessagePart, {

package/dist/memory/conversation-display-storage.js

@@ -19,7 +19,7 @@ import { textOf } from "../lib/unknown-text.js";
 import { isDataUIPart, validateUIMessages } from "ai";
 import { z } from "zod";
 import { parseUnknownRecord } from "../lib/unknown-containers.js";
-import { AskPartSchema, ChildSessionStartedPartSchema, CompactionPartSchema, FileReferencePartSchema, PlanApprovalPartSchema, PlanPartSchema, PresentationPartSchema, ReportRenderedPartSchema, RunCardPartSchema, SubAgentActivityEntrySchema, SubAgentActivityPartSchema, } from "../contracts/schemas/chat-parts.js";
+import { AskPartSchema, ChildSessionStartedPartSchema, CompactionPartSchema, FileReferencePartSchema, ModelRefusalPayloadSchema, PlanApprovalPartSchema, PlanPartSchema, PresentationPartSchema, ReportRenderedPartSchema, RunCardPartSchema, SubAgentActivityEntrySchema, SubAgentActivityPartSchema, } from "../contracts/schemas/chat-parts.js";
 import { ToolCallOutcomeSchema, ToolCallValueSchema } from "../contracts/schemas/chat-events.js";
 export const SUPPORTED_DISPLAY_SCHEMA_VERSION = 1;
 const DisplayEnvelopeHeaderSchema = z.object({
@@ -77,6 +77,7 @@ const dataSchemas = {
     "child-session-started": ChildSessionStartedPartSchema.omit({ type: true }),
     "report-rendered": ReportRenderedPartSchema.omit({ type: true }),
     compaction: CompactionPartSchema.omit({ type: true }),
+    "model-refusal": ModelRefusalPayloadSchema,
     "subagent-activity": SubAgentActivityPartSchema.omit({ type: true }).extend({
         entries: z.array(SubAgentActivityEntrySchema.extend({ outcome: ToolCallOutcomeSchema })),
     }),
@@ -182,6 +183,7 @@ const STORED_SOURCE_TYPES = [
     "data-child-session-started",
     "data-report-rendered",
     "data-compaction",
+    "data-model-refusal",
     "data-subagent-activity",
 ];
 const STORED_SOURCE_TYPE_SET = new Set(STORED_SOURCE_TYPES);
@@ -255,6 +257,10 @@ export function conversationDisplayPart(part) {
             const { type: _type, ...data } = part;
             return { type: "data-compaction", id, data };
         }
+        case "data-model-refusal": {
+            const { type: _type, ...data } = part;
+            return { type: "data-model-refusal", id, data };
+        }
         case "data-subagent-activity": {
             const { type: _type, ...payload } = part;
             return { type: "data-subagent-activity", id, data: { ...payload, entries: part.entries.map(closedEntry) } };
@@ -315,6 +321,9 @@ export function conversationUIToChatMessages(messages) {
                     case "data-compaction":
                         parts.push({ type: "data-compaction", ...part.data });
                         break;
+                    case "data-model-refusal":
+                        parts.push({ type: "data-model-refusal", ...part.data });
+                        break;
                     case "data-subagent-activity":
                         parts.push({ type: "data-subagent-activity", ...part.data });
                         break;

package/dist/providers/ai-sdk.d.ts

@@ -118,6 +118,12 @@ export type AiSdkProviderConfig = {
      * Needs the `thinking-binding-controls-2026-08-01` beta header.
      */
     readonly thinkingBinding?: "drop_block" | "error" | "off";
+    /**
+     * `default`: when a safety classifier declines a request, the API sends it again to the model that it
+     * recommends for the category of the refusal, inside the same call. When the field is absent, a declined
+     * request ends with the content filter. A model with no fallback target keeps its refusal.
+     */
+    readonly fallbacks?: "default";
 } | {
     readonly kind: "openai";
     readonly baseURL?: string;
@@ -252,22 +258,19 @@ export declare function sessionKeyDigestOf(session: Pick<AgentSession, "scope" |
  * A model can refuse a request by category — a biology prompt is one such category —
  * and the API then re-serves it on another model. It reports the hop TWICE: as a
  * `fallback` content block inside the assistant turn, and on
- * `providerMetadata.anthropic.iterations`. `@ai-sdk/anthropic` keeps only the second,
- * because the AI SDK has no part for a model hop, and it drops the block from the
- * content it returns (`anthropic-messages-language-model`, the `content_block_start`
- * case). Thus the turn the harness holds is not the turn the API produced, and every
- * signed thinking block of that turn is rejected from the next request on.
+ * `providerMetadata.anthropic.iterations`. `@ai-sdk/anthropic` keeps the block as a
+ * custom part and sends it back on the next request, but it keeps each thinking block
+ * before it too. The API accepts no thinking block from before the hop, and a turn
+ * whose thinking blocks changed earns `thinking ... blocks in the latest assistant
+ * message cannot be modified`, which is a 400 that no retry can pass.
  *
- * The API holds the whole turn against the signature of each of its thinking blocks, so
- * echoing that turn earns `thinking ... blocks in the latest assistant message cannot be
- * modified`, which is a 400 that no retry can pass. A thinking block is optional on the
- * way back, thus the loop records the reply of a hop with no thinking block, and the next
- * request continues. The cost is the reasoning of this one turn and the cache write that
- * its new prefix pays for.
+ * A thinking block is optional on the way back, thus the loop records the reply of a
+ * hop with no thinking block, and the next request continues. The cost is the
+ * reasoning of this one turn and the cache write that its new prefix pays for.
  *
- * The response metadata of the package carries `message_start.message.model`, and that
- * field keeps the REQUESTED model across a hop. The iteration names the model that
- * answered, thus it wins for the usage record.
+ * The response metadata of the package carries `message_start.message.model`, and
+ * after a hop in the middle of a reply that field keeps the REQUESTED model. The
+ * iteration names the model that answered, thus it wins for the usage record.
  */
 export declare function fallbackModelOf(metadata: ProviderMetadata | undefined): string | undefined;
 /**

package/dist/providers/ai-sdk.js

@@ -108,22 +108,19 @@ function thinkingWithBinding(reasoning, mode) {
  * A model can refuse a request by category — a biology prompt is one such category —
  * and the API then re-serves it on another model. It reports the hop TWICE: as a
  * `fallback` content block inside the assistant turn, and on
- * `providerMetadata.anthropic.iterations`. `@ai-sdk/anthropic` keeps only the second,
- * because the AI SDK has no part for a model hop, and it drops the block from the
- * content it returns (`anthropic-messages-language-model`, the `content_block_start`
- * case). Thus the turn the harness holds is not the turn the API produced, and every
- * signed thinking block of that turn is rejected from the next request on.
+ * `providerMetadata.anthropic.iterations`. `@ai-sdk/anthropic` keeps the block as a
+ * custom part and sends it back on the next request, but it keeps each thinking block
+ * before it too. The API accepts no thinking block from before the hop, and a turn
+ * whose thinking blocks changed earns `thinking ... blocks in the latest assistant
+ * message cannot be modified`, which is a 400 that no retry can pass.
  *
- * The API holds the whole turn against the signature of each of its thinking blocks, so
- * echoing that turn earns `thinking ... blocks in the latest assistant message cannot be
- * modified`, which is a 400 that no retry can pass. A thinking block is optional on the
- * way back, thus the loop records the reply of a hop with no thinking block, and the next
- * request continues. The cost is the reasoning of this one turn and the cache write that
- * its new prefix pays for.
+ * A thinking block is optional on the way back, thus the loop records the reply of a
+ * hop with no thinking block, and the next request continues. The cost is the
+ * reasoning of this one turn and the cache write that its new prefix pays for.
  *
- * The response metadata of the package carries `message_start.message.model`, and that
- * field keeps the REQUESTED model across a hop. The iteration names the model that
- * answered, thus it wins for the usage record.
+ * The response metadata of the package carries `message_start.message.model`, and
+ * after a hop in the middle of a reply that field keeps the REQUESTED model. The
+ * iteration names the model that answered, thus it wins for the usage record.
  */
 export function fallbackModelOf(metadata) {
     const entries = metadata?.["anthropic"]?.["iterations"];
@@ -717,12 +714,13 @@ export function createConfiguredAiSdkProvider(deps) {
             maxRetries: config.maxRetries,
             requestTimeoutMs,
             reasoning: config.reasoning,
-            // The package sends the key as `metadata.user_id`, and the binding as
-            // `thinking.block_binding`.
+            // The package sends the key as `metadata.user_id`, the binding as
+            // `thinking.block_binding`, and the default fallback with its beta header.
             providerOptionsFor: ({ session, reasoning }) => ({
                 anthropic: {
                     metadata: { userId: sessionKeyDigestOf(session) },
                     thinking: binding === undefined ? undefined : thinkingWithBinding(reasoning, binding),
+                    fallbacks: config.fallbacks,
                 },
             }),
         });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@inflexa-ai/harness",
-    "version": "0.48.2",
+    "version": "0.48.3",
     "description": "Host-agnostic bioinformatics agent harness — an agent loop on the AI SDK, DBOS-durable workflows, sandboxed compute.",
     "license": "Apache-2.0",
     "type": "module",