@inflexa-ai/harness 0.48.1 → 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

@@ -67,6 +67,38 @@ export type ToolCallOutcome = ToolOutcome | "incomplete";
  * when the detail could not be produced.
  */
 export type ToolCallDetail = string;
+/**
+ * One shown text of a tool call value. The harness removes the control characters and each listed secret form from
+ * the text, and it cuts a text over its cap. `cut` is true when the cap cut the text.
+ *
+ * - `text`: plain text.
+ * - `json`: the JSON text of a value. A host can parse it only when `cut` is false, because a cut text is not valid JSON.
+ * - `code`: source code in `language`.
+ */
+export type ToolCallLeaf = {
+    kind: "text";
+    text: string;
+    cut: boolean;
+} | {
+    kind: "json";
+    text: string;
+    cut: boolean;
+} | {
+    kind: "code";
+    language: string;
+    text: string;
+    cut: boolean;
+};
+/**
+ * The shown value of a tool call: its input, its result, or its error. A host selects a renderer from `kind`.
+ * `fields` holds an ordered list of at most 4 named leaves, and a leaf never holds a `fields` value.
+ */
+export type ToolCallValue = ToolCallLeaf | {
+    kind: "fields";
+    fields: Array<{
+        name: string;
+    } & ToolCallLeaf>;
+};
 /**
  * A sub-agent loop started a request to its model. Only a sub-agent gives this frame, thus a consumer that
  * keeps the root frames only (`isRootFrame`) never sees it. A host reads it as "the sub-agent thinks".
@@ -84,6 +116,8 @@ export type ToolStartedEvent = {
     name: string;
     /** See {@link ToolCallDetail}. Absent — never empty — when none was produced. */
     detail?: ToolCallDetail;
+    /** See {@link ToolCallValue}. The input of the call. */
+    input?: ToolCallValue;
     source: EventSource;
 };
 /** A tool call has resolved. */
@@ -109,6 +143,12 @@ export type ToolFinishedEvent = {
      * it dispatches anything. Thus the fallback is correct only for one call.
      */
     durationMs?: number;
+    /** See {@link ToolCallValue}. The input again, because a replay of a tool step does not give its `tool-started`. */
+    input?: ToolCallValue;
+    /** The value of a call with the outcome `ok`. */
+    result?: ToolCallValue;
+    /** The error text of a call with the outcome `error`. */
+    error?: ToolCallValue;
     source: EventSource;
 };
 /**
@@ -122,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-frame.js

@@ -50,6 +50,7 @@ export function toChatFrame(event, fallbackSource) {
                 toolUseId: event.toolUseId,
                 name: event.name,
                 detail: event.detail,
+                input: event.input,
                 source: toSource(event.source),
             };
         case "tool-finished":
@@ -60,6 +61,9 @@ export function toChatFrame(event, fallbackSource) {
                 outcome: event.outcome,
                 detail: event.detail,
                 durationMs: event.durationMs,
+                input: event.input,
+                result: event.result,
+                error: event.error,
                 source: toSource(event.source),
             };
         case "text-delta":
@@ -161,6 +165,7 @@ function applyPartFrame(parts, frame) {
                     toolCallId: frame.toolUseId,
                     toolName: frame.name,
                     detail: frame.detail,
+                    input: frame.input,
                 },
             ];
         case "tool-finished": {
@@ -174,6 +179,12 @@ function applyPartFrame(parts, frame) {
                 finished.detail = frame.detail;
             if (frame.durationMs !== undefined)
                 finished.durationMs = frame.durationMs;
+            if (frame.input !== undefined)
+                finished.input = frame.input;
+            if (frame.result !== undefined)
+                finished.result = frame.result;
+            if (frame.error !== undefined)
+                finished.error = frame.error;
             const started = parts.some((p) => p.type === "tool-call" && p.toolCallId === frame.toolUseId);
             if (!started) {
                 // The stored transcript keeps a call whose start never arrived, thus a live view keeps it too.

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,8 +2,8 @@ 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 { EventSource, TextDeltaEvent, IterationEvent, ToolStartedEvent, ToolFinishedEvent, FinishEvent, ChatErrorEvent, MessageStartEvent, ChatEvent, ChatFrame, ChatPartFrame, } from "./chat-events.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";
 export type { DataProfileAxis, DataProfileChecked, DataProfileCompanionCompleteness, DataProfileCoverage, DataProfileDimension, DataProfileFile, DataProfileGroup, DataProfileGroupSlot, DataProfileInputSignature, DataProfileKind, DataProfileLifecycleStatus, DataProfileMemberAnnotation, DataProfileObservation, DataProfileOrganism, DataProfilePartition, DataProfileProbeReport, DataProfileQualityAssessment, DataProfileQuarantine, DataProfileRecipeStep, DataProfileResult, DataProfileSubjectSource, } from "./data-profile.js";

package/dist/contracts/message.d.ts

@@ -6,7 +6,7 @@
  * discriminant is `type`, so `switch (part.type) { case "data-child-session-started": ... }`
  * narrows the union member without any `as` cast.
  */
-import type { ToolCallDetail, ToolCallOutcome } from "./chat-events.js";
+import type { ToolCallDetail, ToolCallOutcome, ToolCallValue } from "./chat-events.js";
 import type { ChatPart } from "./chat-parts.js";
 import type { TokenUsageRollup } from "./usage.js";
 /** A plain assistant/user text run. */
@@ -40,6 +40,12 @@ export type ToolCallPart = {
     detail?: ToolCallDetail;
     /** The time in milliseconds around the dispatch of the call, from `tool-finished`. Absent when no measurement was taken. */
     durationMs?: number;
+    /** See {@link ToolCallValue}. Absent when the tool declares no input view, and in a row stored without one. */
+    input?: ToolCallValue;
+    /** The shown result of a call with the outcome `ok`. Absent when the tool declares no result view, for each other outcome, and in a row stored without one. */
+    result?: ToolCallValue;
+    /** The shown error of a call with the outcome `error`. Absent when the tool declares no error view, for each other outcome, and in a row stored without one. */
+    error?: ToolCallValue;
 };
 /** The discriminated union of every part the chat path can carry. */
 export type MessagePart = TextPart | ToolCallPart | ChatPart;

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;