@inflexa-ai/harness 0.48.3 → 0.48.5

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

@@ -20,7 +20,6 @@ import { z } from "zod";
 import { createSubAgentActivityTracker } from "../../contracts/subagent-activity.js";
 import { createNoopLogger } from "../../lib/console-logger.js";
 import { parseJsonAs } from "../../lib/parse-json.js";
-import { parseUnknownRecord, UnknownArraySchema } from "../../lib/unknown-containers.js";
 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";
@@ -59,8 +58,8 @@ function bounded(text) {
 function plainJson(value) {
     return value === undefined ? null : parseJsonAs(JSON.stringify(value), z.json());
 }
-function describeTool(tool) {
-    return renderToolSample({ name: tool.id, description: tool.description, inputSchema: inputSchemaOf(tool), outputSchema: tool.outputJsonSchema });
+function describeTool(tool, schemas) {
+    return renderToolSample({ name: tool.id, description: tool.description, inputSchema: schemas.input, outputSchema: schemas.output });
 }
 function issuesOf(error) {
     return error.issues.map((issue) => `${issue.path.join(".") || "input"}: ${issue.message}`).join("; ");
@@ -129,12 +128,12 @@ function collectEffect(state, value) {
  * The script gets the JSON of a result, and the JSON has no pictures. Thus a result with pictures is a failed call: the
  * script would otherwise read the result as complete.
  */
-function scriptToolOf(tool, ctx, state, log, inCallContext) {
+function scriptToolOf(tool, schemas, ctx, state, log, inCallContext) {
     return {
         name: tool.id,
         description: tool.description,
-        inputSchema: inputSchemaOf(tool),
-        outputSchema: tool.outputJsonSchema,
+        inputSchema: schemas.input,
+        outputSchema: schemas.output,
         execute: (args, options) => inCallContext(() => runNestedCall(tool, ctx, state, log, args, options.signal)),
     };
 }
@@ -187,56 +186,54 @@ async function runNestedCall(tool, ctx, state, log, args, signal) {
     await finish("ok", computeResultDetail(tool, parsed.data, result.value, log) ?? detail);
     return plainJson(result.value);
 }
-/** A JSON schema without its prose: the types and the constraints stay, the descriptions and the examples go. */
-function withoutProse(schema) {
-    const array = UnknownArraySchema.safeParse(schema);
-    if (array.success)
-        return array.data.map(withoutProse);
-    const record = parseUnknownRecord(schema);
-    if (record === undefined)
-        return schema;
-    return Object.fromEntries(Object.entries(record)
-        .filter(([key]) => key !== "description" && key !== "examples")
-        .map(([key, value]) => [key, withoutProse(value)]));
-}
 /**
- * A JSON schema as a script reads it. A tool can union its real shape with the empty schema to keep its runtime parse
- * permissive (`add_block` does, thus a malformed block reaches its typed refusal). The type of such a union is
- * `unknown`, which hides the real shape, thus the empty member goes. The VM only renders the schema and validates
- * nothing, and the tool still parses each input with its own schema.
+ * Shape one node of a JSON schema for a script. A tool can union its real shape with the empty schema to keep its
+ * runtime parse permissive (`add_block` does, thus a malformed block reaches its typed refusal). The type of such a
+ * union is `unknown`, which hides the real shape, thus the empty member goes. The VM only renders the schema and
+ * validates nothing, and the tool still parses each input with its own schema. Without prose, the `description` and the
+ * `examples` of the node go too. Zod calls this for each schema node and never for a field name, thus a field with the
+ * name `description` stays.
  */
-function printableSchema(schema) {
-    const array = UnknownArraySchema.safeParse(schema);
-    if (array.success)
-        return array.data.map(printableSchema);
-    const record = parseUnknownRecord(schema);
-    if (record === undefined)
-        return schema;
-    let out = Object.fromEntries(Object.entries(record).map(([key, value]) => [key, printableSchema(value)]));
-    for (const key of ["anyOf", "oneOf"]) {
-        const members = UnknownArraySchema.safeParse(out[key]);
-        if (!members.success)
-            continue;
-        const shaped = members.data.filter((member) => Object.keys(parseUnknownRecord(member) ?? {}).length > 0);
-        if (shaped.length === 0 || shaped.length === members.data.length)
-            continue;
-        const rest = Object.fromEntries(Object.entries(out).filter(([name]) => name !== key));
-        out = shaped.length > 1 ? { ...rest, [key]: shaped } : { ...rest, ...parseUnknownRecord(shaped[0]) };
+function shapeForScript(jsonSchema, prose) {
+    if (!prose) {
+        delete jsonSchema.description;
+        delete jsonSchema.examples;
+    }
+    const anyOf = shapedMembers(jsonSchema.anyOf);
+    if (anyOf !== undefined) {
+        delete jsonSchema.anyOf;
+        Object.assign(jsonSchema, anyOf.length > 1 ? { anyOf } : anyOf[0]);
     }
-    return out;
+    const oneOf = shapedMembers(jsonSchema.oneOf);
+    if (oneOf !== undefined) {
+        delete jsonSchema.oneOf;
+        Object.assign(jsonSchema, oneOf.length > 1 ? { oneOf } : oneOf[0]);
+    }
+}
+/** The members of a union that are not the empty schema, or `undefined` when the union keeps each member. */
+function shapedMembers(members) {
+    if (members === undefined)
+        return undefined;
+    const shaped = members.filter((member) => Object.keys(member).length > 0);
+    return shaped.length === 0 || shaped.length === members.length ? undefined : shaped;
 }
-/** The input schema of a tool as a script reads it. See {@link printableSchema}. */
-function inputSchemaOf(tool) {
-    return parseUnknownRecord(printableSchema(tool.jsonSchema)) ?? tool.jsonSchema;
+/** The schemas of a tool as a script reads them, built with the same options as the schemas of {@link defineTool}. */
+function scriptSchemasOf(tool, prose) {
+    const override = ({ jsonSchema }) => shapeForScript(jsonSchema, prose);
+    const { $schema: _inputDialect, ...input } = z.toJSONSchema(tool.inputSchema, { override });
+    if (tool.outputSchema === undefined)
+        return { input };
+    const { $schema: _outputDialect, ...output } = z.toJSONSchema(tool.outputSchema, { io: "output", unrepresentable: "any", override });
+    return { input, output };
 }
 /** The longest result type that the catalog shows. A longer type shows as `unknown`, and `describe()` gives it whole. */
 const MAX_CATALOG_RESULT_TYPE_CHARS = 800;
 /** One catalog entry: the first sentence of the description, then the signature with no prose. */
 function catalogEntry(tool) {
-    const output = tool.outputJsonSchema === undefined ? undefined : parseUnknownRecord(withoutProse(tool.outputJsonSchema));
+    const { input, output } = scriptSchemasOf(tool, false);
     const resultType = output === undefined ? "unknown" : schemaToType(output, { maxChars: MAX_CATALOG_RESULT_TYPE_CHARS });
     // pi renders a signature with no result schema as `...: Promise<unknown>;`, thus the catalog puts its capped type there.
-    const untyped = renderToolSignature({ name: tool.id, inputSchema: parseUnknownRecord(withoutProse(inputSchemaOf(tool))) ?? {} });
+    const untyped = renderToolSignature({ name: tool.id, inputSchema: input });
     const signature = `${untyped.slice(0, -"unknown>;".length)}${resultType}>;`;
     return `/** ${firstSentence(tool.description)} */\n${signature}`;
 }
@@ -290,7 +287,7 @@ function scriptResultView(result) {
 /** The `run_script` tool over the script tools of an agent. */
 export function createRunScriptTool(scriptTools, runtime = {}, options = {}) {
     const vm = sandboxRuntimeOf(runtime);
-    const byId = new Map(scriptTools.map((tool) => [tool.id, tool]));
+    const byId = new Map(scriptTools.map((tool) => [tool.id, { tool, schemas: scriptSchemasOf(tool, true) }]));
     const log = (options.logger ?? createNoopLogger()).named("run-script");
     const { scratch } = options;
     return defineTool({
@@ -312,7 +309,7 @@ export function createRunScriptTool(scriptTools, runtime = {}, options = {}) {
                 scratch?.recordRun(record.run);
             for (const entry of record.nested) {
                 try {
-                    byId.get(entry.tool)?.foldCallRecord?.(entry.record);
+                    byId.get(entry.tool)?.tool.foldCallRecord?.(entry.record);
                 }
                 catch (err) {
                     log.error("the call record of a nested call did not fold", { tool: entry.tool, ...log.errorFields(err) });
@@ -356,15 +353,15 @@ export function createRunScriptTool(scriptTools, runtime = {}, options = {}) {
             // example the durable step of the call, which DBOS keeps in an AsyncLocalStorage.
             const inCallContext = AsyncLocalStorage.snapshot();
             const sandbox = new CodemodeSandbox({
-                tools: scriptTools.map((tool) => scriptToolOf(tool, ctx, state, log, inCallContext)),
+                tools: [...byId.values()].map(({ tool, schemas }) => scriptToolOf(tool, schemas, ctx, state, log, inCallContext)),
                 globals: [
                     {
                         name: "describe",
                         execute: (name) => {
-                            const tool = typeof name === "string" ? byId.get(name) : undefined;
-                            if (tool === undefined)
+                            const entry = typeof name === "string" ? byId.get(name) : undefined;
+                            if (entry === undefined)
                                 throw new Error(`no script tool ${JSON.stringify(name)}; the tools are ${[...byId.keys()].join(", ")}`);
-                            return describeTool(tool);
+                            return describeTool(entry.tool, entry.schemas);
                         },
                     },
                 ],

package/dist/workflows/execute-analysis.js

@@ -590,17 +590,18 @@ export async function runExecuteAnalysisBody(input, deps) {
     // the run authorization is already minted and rides in `input.runSession`.
     const runId = input.runSession.runFrame.runId;
     const workflowId = runId;
-    const pause = workPause({
+    const pauseAs = (waiter) => workPause({
         pool: deps.pool,
         workId: runId,
         workKind: "run",
+        waiter,
         analysisId: input.analysisId,
         emit: emitStreamPart,
         retryDelaysMs: deps.pauseRetryDelaysMs,
         run: { session: input.runSession, authorizer: deps.runAuthorizer },
         logger,
     });
-    const init = await validateAndInit(input, runId, deps, pause);
+    const init = await validateAndInit(input, runId, deps, pauseAs({ kind: "run" }));
     if (init.kind === "joined-existing") {
         return {
             runId: init.runId,
@@ -728,7 +729,7 @@ export async function runExecuteAnalysisBody(input, deps) {
                 completedSteps: [...final.completed],
                 session: input.runSession,
                 deps,
-                pause,
+                pause: pauseAs({ kind: "synthesis" }),
             });
             synthesisFindings = synthOut.findings;
             synthesisOutcome = { status: synthOut.synthesisStatus, reason: synthOut.synthesisReason };

package/dist/workflows/pause.d.ts

@@ -11,7 +11,7 @@
  * with the message of a resume, or with a stop. The server never sends that message by itself.
  */
 import type { RunSession } from "../auth/types.js";
-import type { PauseCause, WorkKind, PausePart } from "../contracts/chat-parts.js";
+import type { PauseCause, PauseEnd, PauseWaiter, WorkKind, PausePart } from "../contracts/chat-parts.js";
 import type { RunAuthorizer } from "../execution/run-authorizer.js";
 import type { Logger } from "../lib/logger.js";
 import type { Querier } from "../state/db.js";
@@ -29,14 +29,14 @@ export declare const HOLD_MESSAGE: {
 export declare function pauseTopic(pauseId: string): string;
 /** The cause of a pause in a failure, or `undefined` for a failure that no person or time can repair. */
 export declare function pauseCauseOf(failure: unknown): PauseCause | undefined;
-/** How a wait ended: the deadline of `retrying`, the message of a resume, or a stop of the work. */
-export type PauseEnd = "retry" | "resume" | "abort";
 /** The work that a pause belongs to, and where the part of the pause goes. */
 export type PauseScope = {
     readonly pool: Querier;
     /** The turn id, the run id, or the id of the profile workflow. A sub-agent names its turn, and a step its run. */
     readonly workId: string;
     readonly workKind: WorkKind;
+    /** What waits in this workflow. */
+    readonly waiter: PauseWaiter;
     readonly analysisId: string;
     readonly threadId?: string;
     /** Writes the part of the pause to the stream of the work. */

package/dist/workflows/pause.js

@@ -96,10 +96,11 @@ export function workPause(scope) {
         const delayMs = cause.kind === "outage" ? delays[attempt] : undefined;
         const state = delayMs === undefined ? "paused" : "retrying";
         const pauseId = await DBOS.randomUUID();
-        const pausedAt = await DBOS.now();
-        const retryAt = delayMs === undefined ? undefined : new Date(pausedAt + delayMs).toISOString();
+        const pausedAtMs = await DBOS.now();
+        const pausedAt = new Date(pausedAtMs).toISOString();
+        const retryAt = delayMs === undefined ? undefined : new Date(pausedAtMs + delayMs).toISOString();
         const topic = pauseTopic(pauseId);
-        const work = { workId: scope.workId, workKind: scope.workKind };
+        const work = { workId: scope.workId, workKind: scope.workKind, waiter: scope.waiter };
         await DBOS.runStep(async () => unwrapOrThrow(await recordPause(scope.pool, {
             workflowId,
             ...work,
@@ -110,7 +111,7 @@ export function workPause(scope) {
             attempt,
             retryAt,
             topic,
-            pausedAt: new Date(pausedAt).toISOString(),
+            pausedAt,
             runSession: scope.run?.session,
         })), { name: "pause.record" });
         // Only a person ends a wait in `paused`, thus the credential stops until the renewal of the resume.
@@ -122,7 +123,7 @@ export function workPause(scope) {
         };
         if (state === "paused")
             await suspendCredential("pause.suspend");
-        await scope.emit({ type: "data-pause", id: workflowId, ...work, state, cause, attempt, retryAt });
+        await scope.emit({ type: "data-pause", id: workflowId, ...work, state, cause, pausedAt, attempt, retryAt });
         log.warn("work paused", { workflowId, ...work, state, cause: cause.kind, attempt });
         let end;
         const untrack = trackWorkPaused({ workKind: scope.workKind });
@@ -139,11 +140,11 @@ export function workPause(scope) {
                     cause,
                     attempt,
                     topic,
-                    pausedAt: new Date(pausedAt).toISOString(),
+                    pausedAt,
                     runSession: scope.run?.session,
                 })), { name: "pause.hold" });
                 await suspendCredential("pause.hold.suspend");
-                await scope.emit({ type: "data-pause", id: workflowId, ...work, state: "paused", cause, attempt });
+                await scope.emit({ type: "data-pause", id: workflowId, ...work, state: "paused", cause, pausedAt, attempt });
                 log.info("work held", { workflowId, ...work, attempt });
                 const held = await waitForMessage(topic, undefined, signal);
                 end = held === "hold" ? "resume" : held;
@@ -155,8 +156,13 @@ export function workPause(scope) {
         finally {
             untrack();
         }
-        await DBOS.runStep(async () => unwrapOrThrow(await clearPause(scope.pool, workflowId)), { name: "pause.clear" });
-        await scope.emit({ type: "data-pause", id: workflowId, ...work, state: "running" });
+        // The time is read inside the step, thus a recovery replays the recorded time and the end keeps one time.
+        // The replayed step output is `undefined` when the recorded step has no time.
+        const endedAt = await DBOS.runStep(async () => {
+            unwrapOrThrow(await clearPause(scope.pool, workflowId));
+            return new Date().toISOString();
+        }, { name: "pause.clear" });
+        await scope.emit({ type: "data-pause", id: workflowId, ...work, state: "running", cause, pausedAt, endedAt, end });
         log.info("pause ended", { workflowId, ...work, end });
         return end;
     };

package/dist/workflows/sandbox-step.js

@@ -157,6 +157,7 @@ export async function runSandboxStepBody(input, deps) {
         pool: deps.pool,
         workId: input.runId,
         workKind: "run",
+        waiter: { kind: "step", stepId: input.stepId },
         analysisId: input.analysisId,
         emit: safeEmit,
         retryDelaysMs: deps.pauseRetryDelaysMs,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@inflexa-ai/harness",
-    "version": "0.48.3",
+    "version": "0.48.5",
     "description": "Host-agnostic bioinformatics agent harness — an agent loop on the AI SDK, DBOS-durable workflows, sandboxed compute.",
     "license": "Apache-2.0",
     "type": "module",
@@ -37,8 +37,10 @@
         "build": "tsc -p tsconfig.build.json && node scripts/copy-assets.mjs",
         "design:fixture": "bun scripts/render-fixture.ts",
         "design:gallery": "bun scripts/render-gallery.ts",
-        "format": "prettier --write src/",
-        "format:file": "prettier --write",
+        "dupes": "jscpd src scripts --exit-code --fail-on-empty",
+        "format": "oxfmt src/",
+        "format:check": "oxfmt --check src/",
+        "format:file": "oxfmt",
         "gallery:data": "bash scripts/gallery-data.sh",
         "lint": "bun --bun oxlint",
         "lint:python": "ruff check src/input-scan/decoder && ruff format --check src/input-scan/decoder",
@@ -119,9 +121,10 @@
         "@typescript/native": "npm:typescript@7.0.2",
         "csstree-validator": "^4.0.1",
         "html-validate": "^11.6.2",
+        "jscpd": "5.4.2",
+        "oxfmt": "0.71.0",
         "oxlint": "1.85.0",
         "oxlint-tsgolint": "7.0.2003",
-        "prettier": "^3.9.5",
         "testcontainers": "^10.28.0",
         "typescript": "^6.0.3"
     },