@inflexa-ai/harness 0.48.1 → 0.48.3

package/dist/loop/tool-value.js

@@ -0,0 +1,249 @@
+/**
+ * The shown values of a tool call: its input, its result, and its error.
+ *
+ * The emit site makes each value one time, and a host only shows it. A tool declares what it shows through its view
+ * (`tools/tool-view.ts`), and {@link makeToolCallValue} turns the output of a view member into a value with a kind.
+ * Each leaf of a value gets the steps below on its own. The steps run in this order, because each step
+ * protects the next one: the control characters go first, thus a control byte inside a secret cannot stop a pattern.
+ * The secrets go before the cut, thus a cut cannot divide a secret and let one half pass. The shown text can differ
+ * from the text that the model reads.
+ */
+import { err, ok } from "neverthrow";
+import { z } from "zod";
+import { TOOL_CALL_FIELDS_MAX, ToolCallValueSchema } from "../contracts/schemas/chat-events.js";
+import { isUnknownArray } from "../lib/unknown-array.js";
+import { parseJsonAs } from "../lib/parse-json.js";
+import { describeZodIssueShapes } from "../lib/zod-issue-shape.js";
+import { parseUnknownRecord } from "../lib/unknown-containers.js";
+import { normalizeUnicode, redactSecretFields, redactSecretForms, redactSecrets } from "../input-sanitization.js";
+import { ViewCode, ViewFields, ViewJson, ViewText } from "../tools/tool-view.js";
+import { pairSafeIndex } from "./tool-output.js";
+/** A text longer than this is cut. The unit is the UTF-16 code unit. */
+export const TOOL_VALUE_CAP = 8 * 1024;
+/** The start of a cut text holds the shape of a value. */
+export const TOOL_VALUE_HEAD_CHARS = 3 * 1024;
+/** The end of a cut text holds the errors of a command, thus it gets more room than the start. */
+export const TOOL_VALUE_TAIL_CHARS = 5 * 1024;
+/**
+ * The text past each shown part that the rules also read. A secret at the edge of a shown part is whole in its window
+ * when it is shorter than this margin, thus the rules see it as they see it in the whole text.
+ */
+export const TOOL_VALUE_CLEAN_MARGIN = 8 * 1024;
+const HEAD_WINDOW = TOOL_VALUE_HEAD_CHARS + TOOL_VALUE_CLEAN_MARGIN;
+const TAIL_WINDOW = TOOL_VALUE_TAIL_CHARS + TOOL_VALUE_CLEAN_MARGIN;
+/**
+ * A text up to this length gets the rules whole. A longer text gets them on its two windows only, thus the cost of a
+ * value does not grow with the size of a result.
+ */
+const WHOLE_CLEAN_MAX = HEAD_WINDOW + TAIL_WINDOW;
+function cleanText(text) {
+    return redactSecrets(redactSecretForms(normalizeUnicode(text)));
+}
+function cleanStrings(value) {
+    if (typeof value === "string")
+        return cleanText(value);
+    if (isUnknownArray(value))
+        return value.map(cleanStrings);
+    const record = parseUnknownRecord(value);
+    if (record === undefined)
+        return value;
+    const out = {};
+    for (const [name, field] of Object.entries(record))
+        out[cleanText(name)] = cleanStrings(field);
+    return out;
+}
+/** The shown start of `head` and the shown end of `tail`, with a marker that counts the code units of `length` not shown. */
+function cutParts(head, tail, length) {
+    const shownHead = head.slice(0, pairSafeIndex(head, TOOL_VALUE_HEAD_CHARS, -1));
+    const shownTail = tail.slice(pairSafeIndex(tail, Math.max(0, tail.length - TOOL_VALUE_TAIL_CHARS), 1));
+    const marker = `[... ${Math.max(0, length - shownHead.length - shownTail.length)} characters not shown ...]`;
+    return { text: `${shownHead}\n${marker}\n${shownTail}`, cut: true };
+}
+function cutText(clean) {
+    return clean.length <= TOOL_VALUE_CAP ? { text: clean, cut: false } : cutParts(clean, clean, clean.length);
+}
+/** The shown text of a plain text. A long text gets the rules on its two windows, and its marker counts the original text. */
+function shownText(text) {
+    if (text.length <= WHOLE_CLEAN_MAX)
+        return cutText(cleanText(text));
+    const head = cleanText(text.slice(0, pairSafeIndex(text, HEAD_WINDOW, -1)));
+    const tail = cleanText(text.slice(pairSafeIndex(text, text.length - TAIL_WINDOW, 1)));
+    return cutParts(head, tail, text.length);
+}
+/** The JSON text of a value, or `undefined` for a function, a symbol, and `undefined`, which the lib type omits. */
+function jsonText(value) {
+    return JSON.stringify(value);
+}
+function serializeClean(value) {
+    return jsonText(cleanStrings(redactSecretFields(value)) ?? null) ?? "null";
+}
+/** The fields of a plain record whose JSON text is its own fields, or `undefined` for each other value. */
+function plainFields(value) {
+    if (value === null || value === undefined)
+        return undefined;
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null)
+        return undefined;
+    const fields = Object.entries(value);
+    return fields.some(([name, field]) => name === "toJSON" && typeof field === "function") ? undefined : fields;
+}
+/**
+ * A copy of one end of `value`: the JSON text of the copy starts (`head`) or ends (`tail`) with at least `budget.left`
+ * code units of the JSON text of `value`. The count of a string ignores its escapes, and an escape only makes the text
+ * longer, thus the copy never holds less than the budget. A value that is not an array, a plain record, or a string
+ * stays whole, because its JSON text comes from its own `toJSON`.
+ */
+function endOf(value, budget, end) {
+    if (typeof value === "string") {
+        const keep = Math.max(0, budget.left);
+        const kept = end === "head" ? value.slice(0, keep) : value.slice(Math.max(0, value.length - keep));
+        budget.left -= kept.length + 2;
+        return kept;
+    }
+    if (isUnknownArray(value)) {
+        budget.left -= 2;
+        const kept = [];
+        for (let index = 0; index < value.length && budget.left > 0; index += 1) {
+            kept.push(endOf(value[end === "head" ? index : value.length - 1 - index], budget, end));
+            budget.left -= 1;
+        }
+        return end === "head" ? kept : kept.reverse();
+    }
+    const fields = plainFields(value);
+    if (fields !== undefined) {
+        budget.left -= 2;
+        const kept = [];
+        for (let index = 0; index < fields.length && budget.left > 0; index += 1) {
+            const entry = fields[end === "head" ? index : fields.length - 1 - index];
+            // JSON text omits such a field, and a test of the field by its own serialization would read all of it.
+            if (entry === undefined || entry[1] === undefined || typeof entry[1] === "function" || typeof entry[1] === "symbol")
+                continue;
+            budget.left -= entry[0].length + 4;
+            kept.push([entry[0], endOf(entry[1], budget, end)]);
+        }
+        return Object.fromEntries(end === "head" ? kept : kept.reverse());
+    }
+    budget.left -= jsonText(value)?.length ?? 0;
+    return value;
+}
+/**
+ * The shown JSON text of a value: `ok(undefined)` when the value has no JSON text, and an error with the reason when
+ * the value does not serialize, for example a cycle.
+ */
+function shownJson(value) {
+    try {
+        const raw = jsonText(value);
+        if (raw === undefined)
+            return ok(undefined);
+        if (raw.length <= WHOLE_CLEAN_MAX)
+            return ok(cutText(serializeClean(value)));
+        const head = serializeClean(endOf(value, { left: HEAD_WINDOW }, "head"));
+        const tail = serializeClean(endOf(value, { left: TAIL_WINDOW }, "tail"));
+        return ok(cutParts(head, tail, raw.length));
+    }
+    catch {
+        return err("the value does not serialize to JSON");
+    }
+}
+function jsonLeaf(value) {
+    return shownJson(value).map((shown) => (shown === undefined ? undefined : { kind: "json", ...shown }));
+}
+/** The leaf of a plain text: control characters out, each secret out, then the cut. */
+export function textToolValue(text) {
+    return { kind: "text", ...shownText(text) };
+}
+/** The leaf of source code. The rules and the cut are those of {@link textToolValue}. `language` is checked with the whole value. */
+export function codeToolValue(language, text) {
+    return { kind: "code", language, ...shownText(text) };
+}
+/**
+ * The leaf of a JSON value. A string shows as a JSON string, and each other value shows as its JSON text.
+ * The field-name rule runs first, then the text rules on each string, then the serialization, then the cut: a text
+ * rule never meets a JSON escape, which would hide the end of a quoted secret.
+ * A long JSON text gets the rules on a copy of each end of the value only, and its marker counts the JSON text of the
+ * original value. Only the serialization of the whole value grows with its size, and the model path pays it already.
+ * A value with no JSON text, and a value that does not serialize, for example a cycle, give no leaf: a value is a
+ * diagnostic and never fails a call.
+ */
+export function jsonToolValue(value) {
+    return jsonLeaf(value).unwrapOr(undefined);
+}
+const AdapterErrorSchema = z.object({ error: z.string() });
+/**
+ * The leaf of an error text. The adapter writes the error of a tool as the JSON text `{ "error": message, ... }`, and
+ * the leaf shows the message. Each other error text, for example a refusal of the call policy, shows whole.
+ */
+export function errorToolValue(text) {
+    try {
+        return textToolValue(parseJsonAs(text, AdapterErrorSchema).error);
+    }
+    catch {
+        return textToolValue(text);
+    }
+}
+function leafValue(leaf) {
+    if (leaf instanceof ViewText)
+        return ok(textToolValue(leaf.text));
+    if (leaf instanceof ViewCode)
+        return ok(codeToolValue(leaf.language, leaf.text));
+    return jsonLeaf(leaf.value);
+}
+function fieldsValue(view) {
+    if (view.fields.length > TOOL_CALL_FIELDS_MAX)
+        return err(`a fields value holds more than ${TOOL_CALL_FIELDS_MAX} fields`);
+    const fields = [];
+    for (const { name, leaf } of view.fields) {
+        // A leaf that is not a leaf class is a nested `fields` value, which the kinds refuse.
+        if (!(leaf instanceof ViewText || leaf instanceof ViewCode || leaf instanceof ViewJson))
+            return err("a fields value holds a fields value");
+        const value = leafValue(leaf);
+        if (value.isErr())
+            return err(`the field ${name.slice(0, 40)}: ${value.error}`);
+        if (value.value !== undefined)
+            fields.push({ name, ...value.value });
+    }
+    return ok(fields.length === 0 ? undefined : { kind: "fields", fields });
+}
+function leafOfOutput(output) {
+    if (typeof output === "string")
+        return ok(textToolValue(output));
+    if (output instanceof ViewText || output instanceof ViewCode || output instanceof ViewJson)
+        return leafValue(output);
+    return jsonLeaf(output).andThen((leaf) => (leaf === undefined ? err("the value has no JSON text") : ok(leaf)));
+}
+/**
+ * The value of the output of a view member: a helper object gives its kind, a string gives a `text` leaf, and each other
+ * value gives a `json` leaf. Each leaf gets the cleaning and the cap of its kind. The result holds no value for an output
+ * that is absent (silent), and for a `fields` value with no field. It holds the reason for an output that cannot show: a
+ * value with no JSON text, a value that does not serialize, and a value that breaks a rule of the kinds (more fields than
+ * the limit, a nested `fields` value, a bad field name, a bad language). The caller logs the reason. It never throws.
+ */
+export function makeToolCallValue(output) {
+    if (output === undefined)
+        return ok(undefined);
+    const made = output instanceof ViewFields ? fieldsValue(output) : leafOfOutput(output);
+    return made.andThen((value) => {
+        if (value === undefined)
+            return ok(undefined);
+        const checked = ToolCallValueSchema.safeParse(value);
+        return checked.success ? ok(checked.data) : err(describeZodIssueShapes(checked.error, ToolCallValueSchema).join("; "));
+    });
+}
+/**
+ * The event without the three values. A forwarder of loop events to the stream of a run calls it, because no reader
+ * of that stream shows a value, and a value costs bytes on each event.
+ */
+export function withoutToolValues(event) {
+    switch (event.type) {
+        case "tool-started": {
+            const { input: _input, ...rest } = event;
+            return rest;
+        }
+        case "tool-finished": {
+            const { input: _input, result: _result, error: _error, ...rest } = event;
+            return rest;
+        }
+        default:
+            return event;
+    }
+}

package/dist/loop/types.d.ts

@@ -3,7 +3,7 @@
  * messages, and the flat event sink.
  */
 import type { ModelMessage } from "ai";
-import type { ToolCallDetail, ToolOutcome } from "../contracts/chat-events.js";
+import type { ToolCallDetail, ToolCallValue, ToolOutcome } from "../contracts/chat-events.js";
 import type { ChatStreamEvent, ProviderOptions } from "../providers/types.js";
 import type { Tool } from "../tools/define-tool.js";
 import type { CompactionRules } from "./compaction.js";
@@ -75,13 +75,14 @@ export type EmitEvent = {
     readonly source: EventSource;
     readonly toolUseId: string;
     readonly name: string;
-    readonly input: unknown;
     /**
      * One line naming what this call is doing, from the tool's own
      * `describeCall` hook. Absent — never empty — when the tool declares no
      * hook or the detail could not be produced (see `tool-detail.ts`).
      */
     readonly detail?: ToolCallDetail;
+    /** The input that the view of the tool declares, with each listed secret form removed and a cap. Absent for a call that is not a root call. */
+    readonly input?: ToolCallValue;
 } | {
     readonly type: "tool-finished";
     readonly source: EventSource;
@@ -101,6 +102,12 @@ export type EmitEvent = {
      * can fall back to its own observation.
      */
     readonly durationMs?: number;
+    /** The input again: a replay of a tool step does not give its `tool-started`. */
+    readonly input?: ToolCallValue;
+    /** The result of a call with the outcome `ok`. */
+    readonly result?: ToolCallValue;
+    /** The error text of a call with the outcome `error`. */
+    readonly error?: ToolCallValue;
 } | {
     /** The display recorder of a chat turn emits it, not the loop. See `MessageStartEvent`. */
     readonly type: "message-start";

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,8 +19,8 @@ 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 { ToolCallOutcomeSchema } from "../contracts/schemas/chat-events.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({
     kind: z.literal("ai-sdk-ui-messages"),
@@ -48,6 +48,9 @@ const ToolCallDisplaySchema = z.object({
     outcome: ToolCallOutcomeSchema,
     detail: z.string().optional(),
     durationMs: z.number().optional(),
+    input: ToolCallValueSchema.optional(),
+    result: ToolCallValueSchema.optional(),
+    error: ToolCallValueSchema.optional(),
 });
 /**
  * The schema behind each stored part key.
@@ -74,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 })),
     }),
@@ -179,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);
@@ -252,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) } };
@@ -312,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/memory/count-tokens.js

@@ -16,6 +16,33 @@ function enc() {
     encoder ??= getEncoding("cl100k_base");
     return encoder;
 }
+/**
+ * A run of this many characters with no whitespace is counted in chunks. The BPE merge of `js-tiktoken` is
+ * quadratic in the length of one pre-token, and a run of one repeated character of 20,000 characters takes
+ * about 13 s whole. A base64 blob or a sequence with no line break is such a run in a tool result.
+ */
+// oxlint-disable-next-line eslint-js/no-restricted-syntax -- a run of 256 or more characters with no whitespace; no builtin finds a run by its length.
+const LONG_RUN = /\S{256,}/g;
+/** The chunk of a long run. A chunk of 64 characters costs well under a millisecond in the worst case. */
+const RUN_CHUNK = 64;
+/**
+ * The token count of one text. A text with no long run is one encoding, thus its count is exact. Each long run
+ * is counted in chunks, which can add a token at each chunk edge: the count is an approximation already.
+ */
+function encodedLength(text) {
+    let total = 0;
+    let from = 0;
+    for (const run of text.matchAll(LONG_RUN)) {
+        if (run.index > from)
+            total += enc().encode(text.slice(from, run.index)).length;
+        for (let at = 0; at < run[0].length; at += RUN_CHUNK)
+            total += enc().encode(run[0].slice(at, at + RUN_CHUNK)).length;
+        from = run.index + run[0].length;
+    }
+    if (from < text.length)
+        total += enc().encode(text.slice(from)).length;
+    return total;
+}
 /**
  * The token-bearing text of one tool-result output.
  *
@@ -82,13 +109,13 @@ function tokenizableText(block) {
  */
 export function countTokens(content) {
     if (typeof content === "string") {
-        return content.length === 0 ? 0 : enc().encode(content).length;
+        return content.length === 0 ? 0 : encodedLength(content);
     }
     let total = 0;
     for (const block of content) {
         const text = tokenizableText(block);
         if (text.length > 0)
-            total += enc().encode(text).length;
+            total += encodedLength(text);
     }
     return total;
 }

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/dist/sandbox/sandbox-step-translate.d.ts

@@ -7,7 +7,6 @@
  */
 import type { ActivityEntryPart, StepActivityPart, StepPhase, SynthesisPhase, SynthesisProgressPart } from "../contracts/chat-parts.js";
 import type { ChatDataPart, EmitFn } from "../loop/types.js";
-import type { ToolDetailResolver } from "../tools/detail-resolver.js";
 /**
  * Stable reconciliation id for a step's reconciling parts
  * (`data-step-activity`, `data-step-file-tree`). One id per (runId, stepId)
@@ -49,11 +48,9 @@ export declare function synthesisEmission(runId: string, stepId: string, seq: nu
  * The live-activity phrase for one tool call: the tool's name, then its own
  * description of this call when it has one.
  *
- * The description comes from the tool's `describeCall` hook, resolved through
- * `resolveDetail` — the same resolver the chat chip and the reloaded transcript
- * use. A caller supplies the resolver for the agent whose calls it is
- * describing, because a sandbox agent's tool list is not the conversation
- * roster's and no single list serves both.
+ * The description is the `detail` of the loop event of the call, which the loop
+ * computed with the `describeCall` hook of the tool. The phrase never reads the
+ * input of the call.
  *
  * The name always leads, and that is load-bearing rather than cosmetic. This
  * phrase is rendered alone, with no tool name beside it — unlike the chat chip,
@@ -61,11 +58,10 @@ export declare function synthesisEmission(runId: string, stepId: string, seq: nu
  * `edit_file` both describe a call by its path, so a detail on its own would
  * render a write and an edit of the same file identically.
  *
- * A tool with no hook, an unknown tool, and an input its schema rejects all fall
- * back to the name alone. No verb is added: the phrase is carried on a part that
+ * An event with no detail falls back to the name alone. No verb is added: the phrase is carried on a part that
  * already states the phase, so "Running" would only restate it.
  */
-export declare function activityForTool(name: string, input?: unknown, resolveDetail?: ToolDetailResolver): string;
+export declare function activityForTool(name: string, detail?: string): string;
 /** On-change working-tree delta the sandbox executor posts per exec (paths
  *  only; the executor skips directories). */
 export type SandboxTreeDelta = {

package/dist/sandbox/sandbox-step-translate.js

@@ -54,11 +54,9 @@ export function synthesisEmission(runId, stepId, seq, phase, activity, at, extra
  * The live-activity phrase for one tool call: the tool's name, then its own
  * description of this call when it has one.
  *
- * The description comes from the tool's `describeCall` hook, resolved through
- * `resolveDetail` — the same resolver the chat chip and the reloaded transcript
- * use. A caller supplies the resolver for the agent whose calls it is
- * describing, because a sandbox agent's tool list is not the conversation
- * roster's and no single list serves both.
+ * The description is the `detail` of the loop event of the call, which the loop
+ * computed with the `describeCall` hook of the tool. The phrase never reads the
+ * input of the call.
  *
  * The name always leads, and that is load-bearing rather than cosmetic. This
  * phrase is rendered alone, with no tool name beside it — unlike the chat chip,
@@ -66,12 +64,10 @@ export function synthesisEmission(runId, stepId, seq, phase, activity, at, extra
  * `edit_file` both describe a call by its path, so a detail on its own would
  * render a write and an edit of the same file identically.
  *
- * A tool with no hook, an unknown tool, and an input its schema rejects all fall
- * back to the name alone. No verb is added: the phrase is carried on a part that
+ * An event with no detail falls back to the name alone. No verb is added: the phrase is carried on a part that
  * already states the phase, so "Running" would only restate it.
  */
-export function activityForTool(name, input, resolveDetail) {
-    const detail = resolveDetail?.(name, input);
+export function activityForTool(name, detail) {
     return detail === undefined ? name : `${name} ${detail}`;
 }
 const SandboxTreeDeltaSchema = z.object({

package/dist/tasks/data-profile-activity.d.ts

@@ -20,7 +20,6 @@
  * no terminal at all.
  */
 import type { Logger } from "../lib/logger.js";
-import type { ToolDetailResolver } from "../tools/detail-resolver.js";
 /**
  * Writes one part to the run-event stream. Injected rather than imported so this
  * module stays free of the durability engine and so a test can record what a
@@ -64,15 +63,12 @@ export type ProfileActivityEmitter = {
      * Reported per tool call the profiler agent makes, phrased by the shared
      * translator.
      *
-     * `resolveDetail` is built over the profiler agent's own tool list, so the
-     * phrase comes from the called tool's `describeCall` hook. It is passed per
-     * call rather than held by the emitter because the emitter exists before the
-     * agent does — `sandboxInit` is reported before the sandbox the agent's tools
-     * are bound to. The call site supplies a RESOLVER, never a phrase: the
+     * `detail` is the detail of the loop event, which the `describeCall` hook of
+     * the called tool made. The call site supplies a detail, never a phrase: the
      * phrases are this capability's observable contract, and a call site that
      * composed its own is a call site that can drift from it.
      */
-    forTool(toolUseId: string, name: string, input: unknown, resolveDetail?: ToolDetailResolver): Promise<void>;
+    forTool(toolUseId: string, name: string, detail?: string): Promise<void>;
     /** Reported for the vector-store pass that indexes per-file descriptions. */
     indexing(): Promise<void>;
     /** The success terminal. Emitted only after the terminal ledger write has landed. */

package/dist/tasks/data-profile-activity.js

@@ -58,7 +58,7 @@ export function createProfileActivityEmitter(write, frame, logger, now) {
         sandboxInit: () => emit("sandbox-init", "Starting sandbox"),
         scanning: () => emit("executing", "Scanning input files"),
         agentStarting: () => emit("executing", "Running data-profiler"),
-        forTool: (toolUseId, name, input, resolveDetail) => emit("executing", activityForTool(name, input, resolveDetail), toolUseId),
+        forTool: (toolUseId, name, detail) => emit("executing", activityForTool(name, detail), toolUseId),
         indexing: () => emit("indexing", "Indexing input descriptions for search"),
         complete: () => emit("complete", "Profile complete"),
         failed: (reason) => emit("failed", reason),