@inflexa-ai/harness 0.48.1 → 0.48.2

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

@@ -20,7 +20,7 @@ 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 { 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.

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/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),

package/dist/tasks/data-profile.js

@@ -27,13 +27,12 @@ import { forStep, forSubAgent } from "../auth/types.js";
 import { presentFirst } from "../lib/present.js";
 import { collapseWhitespace } from "../lib/text.js";
 import { createDataProfilerAgent } from "../agents/sandbox/data-profiler.js";
-import { runWithSalvage, withRunScript } from "../loop/run-loop.js";
+import { runWithSalvage } from "../loop/run-loop.js";
 import { recordedInputOf } from "../loop/tool-adapter.js";
 import { createNoopLogger } from "../lib/console-logger.js";
 import { deliverNotice, passGate } from "../lib/hooks.js";
 import { unwrapOrThrow } from "../lib/result.js";
 import { defineTool } from "../tools/define-tool.js";
-import { createDetailResolver } from "../tools/detail-resolver.js";
 import { renderResources, renderWorkspace } from "../prompts/briefing.js";
 import { workPause } from "../workflows/pause.js";
 import { clearPausesOfWork } from "../state/paused-work.js";
@@ -109,6 +108,7 @@ export function createSubmitProfileTool(detected, menu) {
             "A submission whose operations do not resolve, or that leaves kept files unclaimed, comes back with " +
             "the errors; the repair is a FULL resubmit of the whole operation list. The last accepted submission is the profile.",
         inputSchema: ProfileSubmissionSchema,
+        view: "none",
         describeCall: "none",
         execute: (input) => {
             const resolution = resolveProfileSubmission(input, detected, menu, { finalRound: false });
@@ -545,9 +545,6 @@ export async function runDataProfileBody(input, deps) {
             const submitProfileTool = createSubmitProfileTool(detected, briefingMenu);
             const baseAgent = createDataProfilerAgent(sandboxAgentDeps);
             const agentDef = { ...baseAgent, tools: [...baseAgent.tools, submitProfileTool] };
-            // The profiler's own roster, `submit_profile` included, so every call it
-            // makes is phrased by the tool that was called.
-            const resolveDetail = createDetailResolver([...withRunScript(agentDef).tools, ...(agentDef.scriptTools ?? [])], logger);
             const signal = new AbortController().signal;
             // Covers the gap between a ready sandbox and the agent's first tool call, which would
             // otherwise still read as `Starting sandbox` long after the container was up. The run
@@ -563,7 +560,7 @@ export async function runDataProfileBody(input, deps) {
                 // happening now. The events of a tool call arrive from inside its step.
                 emit: async (event) => {
                     if (event.type === "tool-started")
-                        await activity.forTool(event.toolUseId, event.name, event.input, resolveDetail);
+                        await activity.forTool(event.toolUseId, event.name, event.detail);
                 },
                 invocationId: workflowId,
                 usageRecorder: deps.usageRecorder,

package/dist/tools/ad-hoc-router.js

@@ -125,6 +125,7 @@ function routeTool() {
         id: SUBMIT_ROUTE_TOOL_ID,
         description: "Submit the single specialist and the packages of the step. This is the only valid response.",
         inputSchema: routeSchema,
+        view: "none",
         describeCall: "none",
         execute: () => Promise.resolve(ok({ recorded: true })),
     });

package/dist/tools/bio/alphafold-prediction.js

@@ -29,6 +29,7 @@ export const alphafoldPredictionTool = defineTool({
     inputSchema: z.object({
         uniprotAccession: z.string().min(1).describe("A UniProt accession, for example 'P38398' (BRCA1) or 'P69905' (hemoglobin subunit alpha)."),
     }),
+    view: "none",
     describeCall: ({ uniprotAccession }) => uniprotAccession,
     execute: async ({ uniprotAccession }) => {
         // The client trims before it builds the URL, thus a miss echoes the same

package/dist/tools/bio/chembl.js

@@ -127,6 +127,7 @@ export const chemblTool = defineTool({
         "compounds here first. If ChEMBL misses the compound, resolve it via pubchem action='compound' and bridge back with pubchem action='crossrefs'.\n" +
         "An empty array is valid no-data, not an error — do not retry the same call.",
     inputSchema,
+    view: "none",
     describeCall: "none",
     execute: async ({ action, query, searchType, chemblId, idType, activityType, limit }) => {
         switch (action) {

package/dist/tools/bio/comptox.js

@@ -112,6 +112,7 @@ export function createComptoxTool(deps) {
             "This is environmental/industrial-chemical data: for drug-like compounds prefer PubChem or ChEMBL — dataset 'chemical' returns " +
             "`detail.pubchemCid` to bridge back.",
         inputSchema,
+        view: "none",
         describeCall: "none",
         execute: async (input) => {
             const headers = getEpaCcteHeaders(deps.apiKey);

package/dist/tools/bio/drug-gene-interactions.js

@@ -118,6 +118,7 @@ export function createDrugGeneInteractionsTool(deps) {
             "not be reached (a missing DRUGBANK_API_KEY lands here — state that the key is missing, and proceed with DGIdb). A `found: false` entry means the identifier " +
             "is not in DGIdb at all, usually a non-HUGO symbol or a brand name. Neither is worth retrying unchanged.",
         inputSchema,
+        view: "none",
         describeCall: "none",
         execute: async (input) => {
             const inputs = typeof input.query === "string" ? [input.query] : input.query;

package/dist/tools/bio/gene-disease-evidence.js

@@ -170,6 +170,7 @@ export function createGeneDiseaseEvidenceTool(deps) {
             "could not be reached (a missing DISGENET_API_KEY lands here — state that the key is missing, and proceed with the others); 'not_applicable' means that " +
             "corpus has no lookup for this queryType. Only 'no_data' is evidence of absence, and none is worth retrying unchanged.",
         inputSchema,
+        view: "none",
         describeCall: "none",
         execute: async (input) => {
             const applicable = applicableSources(input.queryType);

package/dist/tools/bio/gene-preclinical-profile.js

@@ -138,6 +138,7 @@ export const genePreclinicalProfileTool = defineTool({
         "with no phenotype terms means the gene has not been IMPC-phenotyped, which is common; an empty hpoTerms list means Monarch curates no human " +
         "phenotype for the gene, and a null geneCurie means the symbol anchored on no HGNC id.",
     inputSchema,
+    view: "none",
     describeCall: "none",
     execute: async ({ geneSymbol, include, species, minRank, tissueLimit, phenotypeLimit }) => {
         const halves = include ?? ["expression", "knockout"];

package/dist/tools/bio/lookup-annotation.js

@@ -156,6 +156,7 @@ export const lookupAnnotationTool = defineTool({
         "An empty terms / annotations / pathways array is valid no-data — report it and continue, do not retry the same input. An empty pathways array " +
         "for a pathwayId means neither database holds that identifier.",
     inputSchema,
+    view: "none",
     describeCall: "none",
     execute: async ({ vocabulary, query, pathwayId, goId, geneProductId, taxonId, organism, includeGenes, limit, }) => {
         const cap = limit ?? DEFAULT_LIMIT;

package/dist/tools/bio/opentargets.js

@@ -89,6 +89,7 @@ export const openTargetsTool = defineTool({
         "NO-DATA IS FINAL — do not retry the same id. Empty associations mean no evidence, or an id the platform does not hold. An empty candidates " +
         "list means the name matched no disease: rephrase it, do not invent an id.",
     inputSchema,
+    view: "none",
     describeCall: "none",
     execute: async (input) => {
         const limit = input.limit ?? DEFAULT_LIMIT;

package/dist/tools/bio/pubchem.js

@@ -83,6 +83,7 @@ export const pubchemTool = defineTool({
         "then chembl action='mechanism' / 'bioactivity' there for curated activity data. " +
         "An empty results / crossRefs / assays array is valid no-data (no match; the CID is in no external registry; the compound was never screened) — do not retry.",
     inputSchema,
+    view: "none",
     describeCall: "none",
     execute: async (input) => {
         switch (input.action) {

package/dist/tools/bio/pubmed.js

@@ -163,6 +163,7 @@ export function createPubMedTool(deps) {
             "Report it and continue, do not retry it.",
         inputSchema,
         outputSchema,
+        view: "none",
         // One tool, three jobs. The action alone would still render three
         // different searches identically, so each action names its own subject:
         // the query, how many articles, or which article.

package/dist/tools/bio/search-clinical-trials.js

@@ -76,6 +76,7 @@ export const searchClinicalTrialsTool = defineTool({
         message: "nctId is required when action is 'details' — one NCT ID, e.g. 'NCT00000102'. Find one with action 'search'.",
         path: ["nctId"],
     }),
+    view: "none",
     describeCall: "none",
     execute: async ({ action, query, nctId, phase, status, limit, includeSummaries }) => {
         if (action === "details") {

package/dist/tools/bio/search-faers.js

@@ -70,6 +70,7 @@ export const searchFaersTool = defineTool({
         message: `limit is capped at ${LABEL_MAX_LIMIT} for action 'label' — each label version carries whole prose sections`,
         path: ["limit"],
     }),
+    view: "none",
     describeCall: "none",
     execute: async ({ action, drugName, limit, serious }) => {
         switch (action) {

package/dist/tools/bio/search-gene.js

@@ -66,6 +66,7 @@ export const searchGeneTool = defineTool({
             .describe("Gene identifiers to look up, mixed freely (e.g. ['BRCA1', 'ENSG00000141510', 'P38398', 'HGNC:1100', 'CHEMBL5619'])"),
         species: z.string().default("homo_sapiens").describe("Species name (e.g. 'homo_sapiens', 'mus_musculus')"),
     }),
+    view: "none",
     // The identifiers are the call. A large batch is summarized here rather than
     // left to the emit-site cap: that cap cuts at a character, so a 200-symbol
     // join arrives ending in `TP5` — a fragment that reads as a real symbol and