@inflexa-ai/harness 0.26.1 → 0.26.3

package/dist/literature/sources/pubmed.js

@@ -24,6 +24,10 @@ const xmlParser = new XMLParser({
     attributeNamePrefix: "@_",
     isArray: (name) => ["PubmedArticle", "Author", "MeshHeading", "AbstractText", "sec", "p", "record"].includes(name),
     textNodeName: "#text",
+    // Each consumer reads a text node as a string. Without this option the
+    // parser turns a numeric text node into a number, and a year-only PubDate
+    // then crashes the year extraction in `parseEsummary`.
+    parseTagValue: false,
 });
 function getItemValue(items, name) {
     if (items === undefined)

package/dist/tasks/derive-table-exec.d.ts

@@ -12,6 +12,11 @@
  * The body owns the whole machine lifetime. It creates the container, submits one exec, awaits the terminal
  * result, and tears the container down on both paths. A teardown fault reaches the log alone, because the
  * work is done by then.
+ *
+ * The exec id is `${workflowId}:${stepId}:${fnId}`, the one shape that `workflowIdFromExec` parses. A
+ * callback host reads the owner workflow out of the exec id alone, thus a flat id makes the completion
+ * callback unroutable and it lands as a `400`. The pull backstop still settles such an exec, but it pays
+ * the quiet interval first.
  */
 import type { Logger } from "../lib/logger.js";
 import type { SandboxClient } from "../sandbox/client.js";
@@ -39,8 +44,13 @@ export declare function runDeriveTableExecBody(input: DeriveTableExecInput, deps
  * dispatches with `DBOS.startWorkflow`.
  */
 export declare function registerDeriveTableExecWorkflow(deps: DeriveTableExecDeps): (input: DeriveTableExecInput) => Promise<ExecResult>;
-/** The per-attempt workflow id. The execution id is unique already, and the nonce keeps a retry distinct. */
-export declare function deriveTableExecWorkflowId(executionId: string, nonce: string): string;
+/**
+ * The workflow id of one derivation.
+ *
+ * It carries exactly one colon, because `workflowIdFromExec` recovers the id by a strip of the last two
+ * colon-delimited segments of the exec id. The execution id is unique already, thus no nonce joins it.
+ */
+export declare function deriveTableExecWorkflowId(executionId: string): string;
 /**
  * The async edge. It starts the registered workflow and it awaits the terminal result.
  *

package/dist/tasks/derive-table-exec.js

@@ -12,9 +12,13 @@
  * The body owns the whole machine lifetime. It creates the container, submits one exec, awaits the terminal
  * result, and tears the container down on both paths. A teardown fault reaches the log alone, because the
  * work is done by then.
+ *
+ * The exec id is `${workflowId}:${stepId}:${fnId}`, the one shape that `workflowIdFromExec` parses. A
+ * callback host reads the owner workflow out of the exec id alone, thus a flat id makes the completion
+ * callback unroutable and it lands as a `400`. The pull backstop still settles such an exec, but it pays
+ * the quiet interval first.
  */
 import { DBOS } from "@dbos-inc/dbos-sdk";
-import { randomUUID } from "node:crypto";
 import { createNoopLogger } from "../lib/console-logger.js";
 import { mintSandboxIdentity } from "../sandbox/identity.js";
 import { buildDerivationExec, DERIVATION_DEADLINE_MS, DERIVATION_RESOURCES, DERIVE_RUN_LITERAL, DERIVE_STEP_LITERAL, } from "../tools/report-session/derive-table.js";
@@ -28,7 +32,10 @@ const noopEmit = () => { };
  */
 export async function runDeriveTableExecBody(input, deps) {
     const logger = (deps.logger ?? createNoopLogger()).named("derive-table-exec").with({ analysisId: input.analysisId });
-    const workflowId = DBOS.workflowID ?? `${DERIVE_RUN_LITERAL}:${input.executionId}`;
+    const workflowId = DBOS.workflowID ?? deriveTableExecWorkflowId(input.executionId);
+    // One workflow submits one exec, thus the function id is a constant. The three segments are what a
+    // callback host parses to find the workflow that awaits this exec.
+    const execId = `${workflowId}:${DERIVE_STEP_LITERAL}:fn-0`;
     const sandbox = await deps.sandboxClient.createSandbox({
         runId: DERIVE_RUN_LITERAL,
         stepId: DERIVE_STEP_LITERAL,
@@ -43,12 +50,12 @@ export async function runDeriveTableExecBody(input, deps) {
         const deadline = (await (deps.now ?? (() => DBOS.now()))()) + DERIVATION_DEADLINE_MS;
         await deps.sandboxClient.submitExec(sandbox, buildDerivationExec({
             script: input.script,
-            execId: input.executionId,
+            execId,
             workingDir: input.workingDir,
             inputs: input.inputs,
             output: input.output,
         }));
-        return await deps.sandboxClient.awaitExec(sandbox, input.executionId, noopEmit, deadline);
+        return await deps.sandboxClient.awaitExec(sandbox, execId, noopEmit, deadline);
     }
     finally {
         try {
@@ -66,9 +73,14 @@ export async function runDeriveTableExecBody(input, deps) {
 export function registerDeriveTableExecWorkflow(deps) {
     return DBOS.registerWorkflow((input) => runDeriveTableExecBody(input, deps), { name: "derive-table-exec" });
 }
-/** The per-attempt workflow id. The execution id is unique already, and the nonce keeps a retry distinct. */
-export function deriveTableExecWorkflowId(executionId, nonce) {
-    return `${DERIVE_RUN_LITERAL}:${executionId}:${nonce}`;
+/**
+ * The workflow id of one derivation.
+ *
+ * It carries exactly one colon, because `workflowIdFromExec` recovers the id by a strip of the last two
+ * colon-delimited segments of the exec id. The execution id is unique already, thus no nonce joins it.
+ */
+export function deriveTableExecWorkflowId(executionId) {
+    return `${DERIVE_RUN_LITERAL}:${executionId}`;
 }
 /**
  * The async edge. It starts the registered workflow and it awaits the terminal result.
@@ -78,7 +90,7 @@ export function deriveTableExecWorkflowId(executionId, nonce) {
  */
 export async function triggerDeriveTableExec(workflow, input) {
     const handle = (await DBOS.startWorkflow(workflow, {
-        workflowID: deriveTableExecWorkflowId(input.executionId, randomUUID()),
+        workflowID: deriveTableExecWorkflowId(input.executionId),
     })(input));
     return handle.getResult();
 }

package/dist/tools/research/literature-reviewer.js

@@ -14,7 +14,7 @@
  * entire tool call is one step in the parent loop (PR #3 caches it whole,
  * so the child never replays).
  */
-import { ok } from "neverthrow";
+import { err, ok } from "neverthrow";
 import { z } from "zod";
 import { finalText, runAgent } from "../../loop/run-agent.js";
 import { passthroughStep } from "../../loop/run-step.js";
@@ -70,7 +70,7 @@ export function createLiteratureReviewerTool(deps) {
         }),
         describeCall: "none",
         execute: async ({ brief }, ctx) => {
-            const { messages: transcript } = await runAgent(agent, [{ role: "user", content: brief }], forSubAgent(ctx.session, AGENT_ID), {
+            const { messages: transcript, finish } = await runAgent(agent, [{ role: "user", content: brief }], forSubAgent(ctx.session, AGENT_ID), {
                 provider: deps.provider,
                 signal: ctx.signal,
                 emit: ctx.emit,
@@ -82,7 +82,15 @@ export function createLiteratureReviewerTool(deps) {
                 // same frame, same call path, same loop-local step names.
                 invocationId: ctx.invocationId,
             });
-            return ok({ report: finalText(transcript) });
+            const report = finalText(transcript);
+            // A child run can end with no final text. Examples are a terminal
+            // reply with no text block, and a capped-out run whose wrap-up is
+            // empty. An ok result with an empty report hides that failure, so
+            // the tool returns an error that names the finish reason.
+            if (report.trim() === "") {
+                return err({ error: `The literature reviewer gave no report (finish reason: ${finish.reason}). Retry, or narrow the brief.`, retryable: true });
+            }
+            return ok({ report });
         },
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@inflexa-ai/harness",
-    "version": "0.26.1",
+    "version": "0.26.3",
     "description": "Host-agnostic bioinformatics agent harness — hand-rolled agent loop, DBOS-durable workflows, sandboxed compute.",
     "license": "Apache-2.0",
     "type": "module",