@inflexa-ai/harness 0.48.0 → 0.48.2

package/dist/tools/sandbox/link-packages.js

@@ -70,6 +70,7 @@ export function createLinkPackagesTool(deps) {
             "After a `collision` of one name that BOTH tracks hold, call this tool again for that package with the prefixed form, `python:<name>` or `r:<name>`. " +
             "A collision is terminal only after that second call also refuses, or when it names two versions of one distribution — then report it and continue without the package.",
         inputSchema: LinkPackagesInputSchema,
+        view: "none",
         describeCall: ({ packages }) => packages.join(", "),
         execute: async (input) => {
             // Every entry parses before any link lands. A partial link over a

package/dist/tools/sandbox/list-available-packages.js

@@ -495,6 +495,11 @@ export function createListAvailablePackagesTool(deps = {}) {
             "`limit`: cap the packages listed; the response always carries the true `total` and a `hasMore` flag, so truncation is never silent. " +
             "Each entry renders as `name==version` where the source pins a version, and a `names` check also reports the store directory and the content hash where the source records them.",
         inputSchema: ListAvailablePackagesInputSchema,
+        view: {
+            input: (input) => input,
+            result: (_input, result) => result,
+            error: true,
+        },
         // `queryPackages` returns on `names` before it reads another field, thus
         // the presence check comes first. An empty array is not a presence check.
         // `names` are exact identifiers a caller checks for, thus they name the

package/dist/tools/sandbox/list-available-refs.js

@@ -600,6 +600,11 @@ export function createListAvailableRefsTool(deps) {
             "An empty result means the dataset is absent right now — not that it is unobtainable. Say so; never guess a path, and never silently substitute a different dataset. " +
             "The store is provisioned by the host and is NOT frozen: datasets can be added through the host's own provisioning path between runs, and whatever is added shows up in a later run. Within one run the listing does not change, thus one call per question is enough.",
         inputSchema: ListAvailableRefsInputSchema,
+        view: {
+            input: (input) => input,
+            result: (_input, result) => result,
+            error: true,
+        },
         // `execute` resolves `path ?? category` for the subtree it inspects, and
         // it ignores `category` when `path` is present. `query` is an ADDITIVE
         // filter over that subtree, thus the target keeps naming the call and the

package/dist/tools/sandbox/report-blocker.js

@@ -37,6 +37,7 @@ export function createReportBlockerToolFor(deps) {
         id: REPORT_BLOCKER_TOOL_ID,
         description: `Terminal. ${deps.blockedWhen} Pass a clear reason. Stop immediately after calling — take no further actions.`,
         inputSchema: ReportBlockerInputSchema,
+        view: "none",
         describeCall: "none",
         execute: (input) => Promise.resolve(ok({ kind: "blocker", reason: input.reason, message: "Blocker recorded. You are done — stop now and do not take further actions." })),
     });

package/dist/tools/sandbox/skills.js

@@ -63,6 +63,7 @@ export function createSkillTools(deps) {
             "and the first line that holds a query word — ranked by how many distinct query words the file " +
             "holds. Then `skill_read` the file. No matches returns a data variant.",
         inputSchema: SkillSearchInputSchema,
+        view: "none",
         describeCall: "none",
         execute: async ({ query, topK }) => {
             if (allowed.size === 0) {
@@ -121,6 +122,7 @@ export function createSkillTools(deps) {
             "found via skill_search). Confined to your declared skills. Undeclared " +
             "skills and missing paths return a data variant.",
         inputSchema: SkillReadInputSchema,
+        view: "none",
         describeCall: "none",
         execute: async ({ skill, path }) => {
             if (!allowed.has(skill)) {

package/dist/tools/sandbox/submit-file-metadata.js

@@ -43,6 +43,7 @@ export function createSubmitFileMetadataTool(cell) {
             "accepted=true means every file now has metadata — STOP. Otherwise drop " +
             "the unknownPaths and describe the remaining files.",
         inputSchema: SubmitFileMetadataInputSchema,
+        view: "none",
         describeCall: "none",
         execute: (input) => {
             const knownPaths = cell.knownPaths;

package/dist/tools/script/file-tools.js

@@ -165,6 +165,7 @@ function createReadTableTool(deps) {
             "A larger table, or another format such as h5ad, is work for an analysis run.",
         inputSchema: readTableInput,
         outputSchema: ReadTableOutputSchema,
+        view: "none",
         describeCall: ({ path, entry }) => (entry === undefined ? path : `${path} : ${entry}`),
         describeResult: (_input, result) => `${String(result.rowCount)} rows`,
         execute: async ({ path, entry, columns }, ctx) => {
@@ -201,6 +202,7 @@ function createListArchiveTool(deps) {
             "`read_table` and `read_pdf` then read one of them as their `entry`.",
         inputSchema: listArchiveInput,
         outputSchema: ListArchiveOutputSchema,
+        view: "none",
         describeCall: ({ path }) => path,
         describeResult: (_input, result) => `${String(result.entries.length)} files`,
         execute: async ({ path }, ctx) => {
@@ -266,6 +268,7 @@ export function createReadPdfTool(deps) {
             "A scanned page with no text layer reads as an empty text.",
         inputSchema: readPdfInput,
         outputSchema: ReadPdfOutputSchema,
+        view: "none",
         describeCall: ({ path, entry, firstPage, lastPage }) => {
             const file = entry === undefined ? path : `${path} : ${entry}`;
             return firstPage === undefined && lastPage === undefined ? file : `${file}, pages ${String(firstPage ?? 1)}-${String(lastPage ?? "")}`;
@@ -359,6 +362,7 @@ function createWriteDerivedTool(deps) {
             "A name holds one file: a second write of the name with other content is refused.",
         inputSchema: writeDerivedInput,
         outputSchema: WrittenOutputSchema,
+        view: "none",
         describeCall: ({ name }) => name,
         describeResult: (_input, result) => result.path,
         execute: async ({ name, content, rows }, ctx) => {
@@ -400,6 +404,7 @@ function createRenderChartTool(deps) {
             "To show a chart in the chat, use `show_user`.",
         inputSchema: renderChartInput,
         outputSchema: WrittenOutputSchema,
+        view: "none",
         describeCall: ({ name }) => name,
         describeResult: (_input, result) => result.path,
         execute: async ({ name, spec, width }, ctx) => {
@@ -447,6 +452,7 @@ function createExportPdfTool(deps) {
             "Charts that `render_chart` wrote can appear in it as images. The PDF reads no URL.",
         inputSchema: exportPdfInput,
         outputSchema: ExportPdfOutputSchema,
+        view: "none",
         describeCall: ({ name }) => name,
         describeResult: (_input, result) => result.path,
         execute: async ({ name, markdown, title }, ctx) => {

package/dist/tools/script/run-script.js

@@ -24,6 +24,7 @@ import { parseUnknownRecord, UnknownArraySchema } from "../../lib/unknown-contai
 import { computeDetail, computeResultDetail } from "../../loop/tool-detail.js";
 import { buildFileReferenceCardData, MAX_FILES } from "../../memory/card-builders.js";
 import { defineTool, readToolCallRecord, readToolResultImages, withToolCallRecord, } from "../define-tool.js";
+import { viewCode, viewFields, viewJson, viewText } from "../tool-view.js";
 import { ScriptFileEffectSchema } from "./file-tools.js";
 import { recordScriptRun } from "./metrics.js";
 export const RUN_SCRIPT_TOOL_ID = "run_script";
@@ -141,7 +142,7 @@ async function runNestedCall(tool, ctx, state, log, args, signal) {
     const invocationId = state.nextInvocationId();
     const detail = computeDetail(tool, args, log);
     const started = performance.now();
-    const startFrame = { type: "tool-started", source: state.source, toolUseId: invocationId, name: tool.id, input: args, detail };
+    const startFrame = { type: "tool-started", source: state.source, toolUseId: invocationId, name: tool.id, detail };
     state.observe(startFrame);
     await ctx.emit(startFrame);
     const finish = async (outcome, finishedDetail) => {
@@ -245,6 +246,7 @@ function descriptionOf(tools) {
     return ("Run a JavaScript script that calls the tools below as functions, in a JavaScript VM on the host with no files and no network. " +
         "Use it for lookups and for light work on tables: call several tools in parallel with Promise.all, filter, join, and count their results, and print only what you need. " +
         "Only the printed output and the returned value come back to you.\n" +
+        "Each file that the script writes is already shown to the user in one card with the script.\n" +
         "API: `await tools.<name>(args)` returns the JSON result of the tool and throws an Error on a failed call. " +
         '`await describe("<name>")` returns the full description of a tool, with the meaning of each argument. ' +
         "`text(value)` and `console.log` print. `return` gives a value. There are no timers, no fetch, and no modules.\n" +
@@ -273,6 +275,18 @@ function filesCard(description, writes, script) {
         shown.push({ path: script.path, caption: "The script that derived these files." });
     return buildFileReferenceCardData({ title: description ?? "Derived files", files: shown });
 }
+/**
+ * The shown result of a script. A failed script puts its failure first, because the failure is what the reader looks for.
+ * The nested calls and the files stay out: the activity part and the file card of the call carry them. A script that
+ * printed nothing and returned nothing gives no result.
+ */
+function scriptResultView(result) {
+    const output = result.output === "" ? undefined : viewText(result.output);
+    const fields = !result.ok
+        ? viewFields({ error: result.error === undefined ? undefined : viewText(result.error), output })
+        : viewFields({ output, value: result.value === undefined ? undefined : viewJson(result.value) });
+    return fields.fields.length === 0 ? undefined : fields;
+}
 /** The `run_script` tool over the script tools of an agent. */
 export function createRunScriptTool(scriptTools, runtime = {}, options = {}) {
     const vm = sandboxRuntimeOf(runtime);
@@ -283,6 +297,11 @@ export function createRunScriptTool(scriptTools, runtime = {}, options = {}) {
         id: RUN_SCRIPT_TOOL_ID,
         description: descriptionOf(scriptTools),
         inputSchema,
+        view: {
+            input: ({ code }) => viewCode("javascript", code),
+            result: (_input, result) => scriptResultView(result),
+            error: true,
+        },
         describeCall: ({ description }) => description,
         describeResult: ({ description }, result) => {
             const tools = result.calls.length === 0 ? undefined : result.calls.map((call) => call.tool).join(", ");

package/dist/tools/start-report-session.js

@@ -141,6 +141,7 @@ export function createStartReportSessionTool(deps) {
             "`no_browser` means that this deployment has no browser for the report agent, thus no report session can start; tell the user. " +
             "`refused`, `parent_not_found`, `parent_not_a_conversation`, and `failed` mean that nothing started, and `detail` gives the reason where there is one.",
         inputSchema: startReportSessionInput,
+        view: "none",
         describeCall: "none",
         execute: async (input, ctx) => {
             const brief = {

package/dist/tools/tool-view.d.ts

@@ -0,0 +1,63 @@
+/**
+ * The view of a tool: what a call of the tool shows to a host.
+ *
+ * A tool declares a `ToolCallView`, or `"none"`, in `defineTool`. A member gives the value to show, and the emit site of
+ * the loop (`loop/tool-value.ts`) cleans it: control characters out, each listed secret form out, then the cap. A member
+ * gives a string for a `text` value, any other plain value for a `json` value, or the result of one of the helpers
+ * below for a value of a kind that the author chooses.
+ */
+export declare class ViewText {
+    readonly text: string;
+    readonly kind = "text";
+    constructor(text: string);
+}
+export declare class ViewJson {
+    readonly value: unknown;
+    readonly kind = "json";
+    constructor(value: unknown);
+}
+export declare class ViewCode {
+    readonly language: string;
+    readonly text: string;
+    readonly kind = "code";
+    constructor(language: string, text: string);
+}
+/** A value of one kind that holds no other value. */
+export type ViewLeaf = ViewText | ViewJson | ViewCode;
+export declare class ViewFields {
+    readonly fields: ReadonlyArray<{
+        readonly name: string;
+        readonly leaf: ViewLeaf;
+    }>;
+    readonly kind = "fields";
+    constructor(fields: ReadonlyArray<{
+        readonly name: string;
+        readonly leaf: ViewLeaf;
+    }>);
+}
+export type ViewValue = ViewLeaf | ViewFields;
+/**
+ * What a tool shows of its calls. Each member is synchronous and pure, and it never reaches the model. A member that is
+ * absent shows nothing. A member that throws, or that gives a value that breaks a rule of the kinds, shows nothing, and
+ * the call runs as before.
+ */
+export type ToolCallView<Input, Output> = {
+    /** The shown input. It reads the input after the parse with the input schema of the tool. */
+    input?(input: Input): unknown;
+    /** The shown result of a call that ended `ok`. It reads the ok value that the tool returned. */
+    result?(input: Input, result: Output): unknown;
+    /** Show the error text of a call that ended `error`. */
+    readonly error?: true;
+};
+/** A plain text. */
+export declare function viewText(text: string): ViewText;
+/** The JSON text of a value. A string shows as a JSON string, with its quotes. */
+export declare function viewJson(value: unknown): ViewJson;
+/** Source code. `language` has 1 to 20 characters of lowercase letters, digits, `+`, `#`, `.`, and `-`. */
+export declare function viewCode(language: string, text: string): ViewCode;
+/**
+ * An ordered list of named values, at most 4. A name has 1 to 40 characters of letters, digits, `_`, and `-`. A field
+ * whose leaf is `undefined` is left out. The order is the order of the keys, except that a name made of digits only
+ * goes first, as a JavaScript object orders such a key.
+ */
+export declare function viewFields(leaves: Readonly<Record<string, ViewLeaf | undefined>>): ViewFields;

package/dist/tools/tool-view.js

@@ -0,0 +1,68 @@
+/**
+ * The view of a tool: what a call of the tool shows to a host.
+ *
+ * A tool declares a `ToolCallView`, or `"none"`, in `defineTool`. A member gives the value to show, and the emit site of
+ * the loop (`loop/tool-value.ts`) cleans it: control characters out, each listed secret form out, then the cap. A member
+ * gives a string for a `text` value, any other plain value for a `json` value, or the result of one of the helpers
+ * below for a value of a kind that the author chooses.
+ */
+/*
+ * Each helper returns an instance of one of these classes, and the emit site tests the class with `instanceof`. A tool
+ * result with a field named `kind` is a plain object, thus it is never read as a kind. The constructors stay out of the
+ * public barrel, thus only the helpers make an instance.
+ */
+export class ViewText {
+    text;
+    kind = "text";
+    constructor(text) {
+        this.text = text;
+    }
+}
+export class ViewJson {
+    value;
+    kind = "json";
+    constructor(value) {
+        this.value = value;
+    }
+}
+export class ViewCode {
+    language;
+    text;
+    kind = "code";
+    constructor(language, text) {
+        this.language = language;
+        this.text = text;
+    }
+}
+export class ViewFields {
+    fields;
+    kind = "fields";
+    constructor(fields) {
+        this.fields = fields;
+    }
+}
+/** A plain text. */
+export function viewText(text) {
+    return new ViewText(text);
+}
+/** The JSON text of a value. A string shows as a JSON string, with its quotes. */
+export function viewJson(value) {
+    return new ViewJson(value);
+}
+/** Source code. `language` has 1 to 20 characters of lowercase letters, digits, `+`, `#`, `.`, and `-`. */
+export function viewCode(language, text) {
+    return new ViewCode(language, text);
+}
+/**
+ * An ordered list of named values, at most 4. A name has 1 to 40 characters of letters, digits, `_`, and `-`. A field
+ * whose leaf is `undefined` is left out. The order is the order of the keys, except that a name made of digits only
+ * goes first, as a JavaScript object orders such a key.
+ */
+export function viewFields(leaves) {
+    const fields = [];
+    for (const [name, leaf] of Object.entries(leaves)) {
+        if (leaf !== undefined)
+            fields.push({ name, leaf });
+    }
+    return new ViewFields(fields);
+}

package/dist/tools/workspace/edit-file.js

@@ -153,6 +153,11 @@ export function createEditFileTool(deps) {
             "`invalid_pattern` / `invalid_arguments` data variants — never throws on expected outcomes. " +
             "A data variant other than `ok` writes nothing.",
         inputSchema: EditFileInputSchema,
+        view: {
+            input: (input) => input,
+            result: (_input, result) => result,
+            error: true,
+        },
         // The path only. The replaced text is file content, not a description.
         describeCall: ({ path }) => path,
         execute: async ({ path, old_string, new_string, replace_all: replaceAll, regex: useRegex, expected_matches }, ctx) => {

package/dist/tools/workspace/execute-command.js

@@ -75,6 +75,7 @@ export function createExecuteCommandTool(deps) {
             "so use them to confirm that a command ran. A result that you compute with 'python -c' or an inline " +
             "one-liner and read from stdout is lost. Write a script and persist its outputs to output/.",
         inputSchema: ExecuteCommandInputSchema,
+        view: "none",
         // The script is what a reader recognises, and it survives a long
         // invocation whose flags would otherwise push it past the length cap.
         // When nothing in the argv looks like a script, the joined argv is the
@@ -83,8 +84,10 @@ export function createExecuteCommandTool(deps) {
         // `env` never rides along. It is the channel this tool documents for
         // secrets, so it is the one field guaranteed to hold them. An argv can
         // hold one too (`--password …` is a real habit), and the emit-site
-        // redaction only matches the structured, prefixed formats — so the join
-        // is a deliberate trade, not a claim of safety.
+        // redaction removes only the secret forms that it lists, so the join
+        // is a deliberate trade, not a claim of safety. The view is `"none"` for
+        // the same reason: the argv, the env, and the output of a command show
+        // no value.
         //
         // Know what the trade costs. This tool is sandbox-gated, so the only
         // surface that reads its detail is a workflow's live-activity line — and

package/dist/tools/workspace/file-stat.js

@@ -22,6 +22,11 @@ export function createFileStatTool(fs, workingDir) {
             "in bytes. It reads the workspace directly and runs no sandbox command. Use before reading to size a file. Missing and out-of-scope " +
             "paths return a data variant, not an error.",
         inputSchema: FileStatInputSchema,
+        view: {
+            input: (input) => input,
+            result: (_input, result) => result,
+            error: true,
+        },
         describeCall: "none",
         execute: async ({ path }, ctx) => {
             const result = unwrapOrThrow(await fs.stat({ session: ctx.session, path, workingDir }));

package/dist/tools/workspace/grep.js

@@ -45,6 +45,10 @@ export function createGrepTool(fs, workingDir, lineage) {
             "in its first KiB is skipped as binary. A `truncated` status means the match cap or the file cap cut the search; " +
             "narrow your path or pattern. No matches, missing paths, and out-of-scope paths return data variants, not errors.",
         inputSchema: GrepInputSchema,
+        view: {
+            input: (input) => input,
+            error: true,
+        },
         // Both fields, because either alone loses the call: the same pattern over
         // two trees and two patterns over one tree are both ordinary sequences.
         describeCall: ({ pattern, path }) => `${pattern} in ${path}`,

package/dist/tools/workspace/list-files.js

@@ -24,6 +24,11 @@ export function createListFilesTool(fs, workingDir) {
             "else: it never reaches a directory outside the analysis, including the host process's current " +
             "working directory. Missing and out-of-scope paths return a data variant, not an error.",
         inputSchema: ListFilesInputSchema,
+        view: {
+            input: (input) => input,
+            result: (_input, result) => result,
+            error: true,
+        },
         // The directory IS the call — two listings differ by nothing else.
         describeCall: ({ path }) => path,
         execute: async ({ path }, ctx) => {

package/dist/tools/workspace/read-file.js

@@ -69,6 +69,10 @@ export function createReadFileTool(fs, workingDir, lineage) {
             "back as a `binary` data variant rather than decoded garbage. Missing " +
             "paths and paths outside the analysis tree return a data variant — not an error.",
         inputSchema: ReadFileInputSchema,
+        view: {
+            input: (input) => input,
+            error: true,
+        },
         describeCall: ({ path, headLines, tailLines }) => {
             if (headLines !== undefined)
                 return `${path} (first ${headLines} lines)`;

package/dist/tools/workspace/scan-inputs.js

@@ -44,6 +44,11 @@ export function createScanInputsTool(deps) {
             "or to check a grouping you are unsure about. " +
             "It reports observations only: which files are one KIND of data, and what a varying position MEANS, are yours to decide.",
         inputSchema: ScanInputsInputSchema,
+        view: {
+            input: (input) => input,
+            result: (_input, result) => result,
+            error: true,
+        },
         describeCall: ({ path }) => path,
         execute: async ({ path }, ctx) => {
             const scan = await scanInputTree({

package/dist/tools/workspace/show-file.js

@@ -42,6 +42,7 @@ export const showFileTool = defineTool({
         "calls in one batch, in reading order: a section, then the `show_file` for its figures, then the next section " +
         "(markdown image syntax pointing at a workspace file does NOT render — this tool is the only way to show one).",
     inputSchema: ShowFileInputSchema,
+    view: "none",
     // `.min(1)` on `files` makes index 0 total after the parse.
     describeCall: ({ files }) => (files.length === 1 ? presentFirst(files, "the shown file").path : `${files.length} files`),
     execute: async (input, ctx) => {

package/dist/tools/workspace/show-plan.js

@@ -34,6 +34,7 @@ export function createShowPlanTool(pool) {
             "card — that renders a second, divergent copy of the same plan. " +
             "`shown: false` with `plan_not_found` means that the planId is no longer valid: generate a new plan, because a retry of the same planId fails the same way.",
         inputSchema: ShowPlanInputSchema,
+        view: "none",
         describeCall: ({ planId }) => planId,
         execute: async ({ planId, title }, ctx) => {
             const resourceId = scopeResource(ctx.session.scope).resourceId;

package/dist/tools/workspace/workspace-search.js

@@ -89,6 +89,11 @@ export function createWorkspaceSearchTool(pool, embedding) {
             "its members. Most input files carry no entry of their own — find them through their " +
             "group and the listing tools.",
         inputSchema: WorkspaceSearchInputSchema,
+        view: {
+            input: (input) => input,
+            result: (_input, result) => result,
+            error: true,
+        },
         describeCall: ({ query, type }) => (type === undefined ? query : `${query} (${type})`),
         execute: async ({ query, type, limit }, ctx) => {
             const [vector] = unwrapOrThrow(await embedding.embed([query], ctx.session));

package/dist/tools/workspace/write-file.js

@@ -30,8 +30,13 @@ export function createWriteFileTool(deps) {
             "`out_of_scope`, and a symbolic link on the path returns `symlink_denied`. A path under the staged " +
             "inputs returns `read_only` with the reason.",
         inputSchema: WriteFileInputSchema,
-        // The path only. `content` is a whole file and must never ride a display
-        // channel, which the emit-site length cap enforces regardless.
+        view: {
+            input: (input) => input,
+            result: (_input, result) => result,
+            error: true,
+        },
+        // The path only: the detail is a one-line label, and `content` is a whole file. The view shows the
+        // content, and the cap of the emit site bounds it.
         describeCall: ({ path }) => path,
         execute: async ({ path, content }, ctx) => {
             const write = await deps.mutator.writeFile({

package/dist/workflows/execute-analysis.js

@@ -82,6 +82,7 @@ import { addChatUsage, hasReportedUsage } from "../loop/metrics.js";
 import { flattenDataPart } from "../contracts/chat-frame.js";
 import { SYNTHESIS_AGENT_ID, loadStepSummariesFromDisk } from "../execution/run-synthesis.js";
 import { MAX_UPSTREAM_ARTIFACTS, composeStepBriefing, emptyStepMemory, } from "../prompts/briefing.js";
+import { withoutToolValues } from "../loop/tool-value.js";
 import { SYNTHESIS_STEP_ID, runDir, runStepDir, stepSubdir, stepWritePrefix, toSandboxPath } from "../workspace/paths.js";
 import { isChatDataPart, synthesisEmission } from "../sandbox/sandbox-step-translate.js";
 import { synthesizeRun } from "../app/synthesize-run.js";
@@ -516,7 +517,7 @@ export function synthesizeFindings(args) {
             ? flattenDataPart(event)
             : {
                 type: "data-loop-event",
-                data: { stepId: "synthesis", event },
+                data: { stepId: "synthesis", event: withoutToolValues(event) },
             };
         return DBOS.writeStream("events", part);
     };

package/dist/workflows/sandbox-step.js

@@ -38,9 +38,9 @@ import { unwrapOrThrow } from "../lib/result.js";
 import { maskExcept } from "../loop/call-policy.js";
 import { runLoop, withRunScript } from "../loop/run-loop.js";
 import { READ_TOOL_OUTPUT_TOOL_ID } from "../loop/tool-output.js";
+import { withoutToolValues } from "../loop/tool-value.js";
 import { lastExecOutcome } from "../sandbox/exec-outcome.js";
 import { activityEmission, activityForTool, applyTreeDelta, isChatDataPart, sandboxTreeDelta, stepPartId, toolActivityKey, } from "../sandbox/sandbox-step-translate.js";
-import { createDetailResolver } from "../tools/detail-resolver.js";
 import { forSubAgent } from "../auth/types.js";
 import { walkStepArtifacts } from "../execution/post-step.js";
 import { collectStepOutputs, describeStepRegistrationFailure, generateStepFileMetadata, generateStepSummaryAndWrite, reconcileAndRegisterStepArtifacts, vectorIndexStepOutputs, } from "../execution/post-step-pipeline.js";
@@ -196,11 +196,7 @@ export async function runSandboxStepBody(input, deps) {
     if (deps.toolOutputStore !== undefined && !agent.tools.some((tool) => tool.id === READ_TOOL_OUTPUT_TOOL_ID)) {
         logger.warn("the step agent declares no read_tool_output, thus its loops keep no text of a cut tool result");
     }
-    // Built over THIS agent's tools, not a shared table: a sandbox agent's roster
-    // differs per agent type, and each tool describes its own calls.
-    // The declared tools and `run_script` describe the calls of the agent, and its script tools describe the nested calls.
     const declared = withRunScript(agent).tools;
-    const resolveDetail = createDetailResolver([...declared, ...(agent.scriptTools ?? [])], logger);
     // Forward every loop event onto the child's own DBOS `"events"` stream
     // (the route fans-in parent + every active child stream — Pattern A).
     // Pre-shaped chat data parts (e.g. `data-sandbox-event` from `run-exec.ts`)
@@ -306,9 +302,9 @@ export async function runSandboxStepBody(input, deps) {
         }
         // Forward the raw orchestration / model-delta event under the loop-event
         // envelope, and surface each tool call as live step activity.
-        await safeEmit({ type: "data-loop-event", data: { stepId: input.stepId, event } });
+        await safeEmit({ type: "data-loop-event", data: { stepId: input.stepId, event: withoutToolValues(event) } });
         if (event.type === "tool-started") {
-            await emitActivity("executing", activityForTool(event.name, event.input, resolveDetail), event.toolUseId);
+            await emitActivity("executing", activityForTool(event.name, event.detail), event.toolUseId);
         }
     };
     const initial = [{ role: "user", content: input.prompt }];

package/package.json

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

package/dist/tools/detail-resolver.d.ts

@@ -1,40 +0,0 @@
-/**
- * The name-plus-input detail resolver.
- *
- * The live loop holds the resolved `Tool` at dispatch and needs nothing. Every
- * other surface — the reload converter, a workflow's live-activity line — has a
- * tool NAME and a persisted input, so it needs a way back to the tool. This is
- * that way, and it is deliberately built over a tool list the CALLER supplies:
- *
- * - A name map internal to the harness could never see an embedder's tools. A
- *   host contributes tools through the host-tools seam, and those calls are as
- *   ambiguous in a transcript as any other.
- * - Two harness tools legitimately share one id (`write_file` exists in both the
- *   workspace surface and the report version store). A resolver built from one
- *   agent's list cannot hold both, because a tool list rejects a duplicate id at
- *   registry construction.
- *
- * It resolves through the same `computeDetail` the loop uses, so a reloaded
- * thread shows the same CALL detail the live turn showed.
- *
- * The bound is the input. A reload reconstructs from the persisted call alone, and a
- * tool that describes its own RESULT names a fact that the input cannot carry — a page
- * path, a recorded version. That line reaches the live surface on the finished event and
- * it does not reappear here, thus a reloaded call falls back to its call detail. Nothing
- * is persisted: storage stays the pure model transcript.
- */
-import { type ToolCallDetail } from "../loop/tool-detail.js";
-import type { Logger } from "../lib/logger.js";
-import type { Tool } from "./define-tool.js";
-/**
- * Maps a tool name plus a call's input to that call's detail. Yields
- * `undefined` for an unknown tool, a tool with no hook, and an input the tool's
- * schema rejects.
- */
-export type ToolDetailResolver = (toolName: string, input: unknown) => ToolCallDetail | undefined;
-/**
- * Build a resolver over `tools`. A duplicate id resolves to the first tool
- * declaring it; callers pass one agent's composed list, which a registry has
- * already rejected duplicates from.
- */
-export declare function createDetailResolver(tools: readonly Tool[], logger?: Logger): ToolDetailResolver;

package/dist/tools/detail-resolver.js

@@ -1,44 +0,0 @@
-/**
- * The name-plus-input detail resolver.
- *
- * The live loop holds the resolved `Tool` at dispatch and needs nothing. Every
- * other surface — the reload converter, a workflow's live-activity line — has a
- * tool NAME and a persisted input, so it needs a way back to the tool. This is
- * that way, and it is deliberately built over a tool list the CALLER supplies:
- *
- * - A name map internal to the harness could never see an embedder's tools. A
- *   host contributes tools through the host-tools seam, and those calls are as
- *   ambiguous in a transcript as any other.
- * - Two harness tools legitimately share one id (`write_file` exists in both the
- *   workspace surface and the report version store). A resolver built from one
- *   agent's list cannot hold both, because a tool list rejects a duplicate id at
- *   registry construction.
- *
- * It resolves through the same `computeDetail` the loop uses, so a reloaded
- * thread shows the same CALL detail the live turn showed.
- *
- * The bound is the input. A reload reconstructs from the persisted call alone, and a
- * tool that describes its own RESULT names a fact that the input cannot carry — a page
- * path, a recorded version. That line reaches the live surface on the finished event and
- * it does not reappear here, thus a reloaded call falls back to its call detail. Nothing
- * is persisted: storage stays the pure model transcript.
- */
-import { computeDetail } from "../loop/tool-detail.js";
-import { createNoopLogger } from "../lib/console-logger.js";
-/**
- * Build a resolver over `tools`. A duplicate id resolves to the first tool
- * declaring it; callers pass one agent's composed list, which a registry has
- * already rejected duplicates from.
- */
-export function createDetailResolver(tools, logger) {
-    const log = (logger ?? createNoopLogger()).named("tool-detail");
-    const byId = new Map();
-    for (const tool of tools) {
-        if (!byId.has(tool.id))
-            byId.set(tool.id, tool);
-    }
-    return (toolName, input) => {
-        const tool = byId.get(toolName);
-        return tool === undefined ? undefined : computeDetail(tool, input, log);
-    };
-}