@inflexa-ai/harness 0.42.0 → 0.42.1

package/dist/contracts/chat-frame.d.ts

@@ -24,7 +24,8 @@ export type ChatPartCheck = {
 export declare function toChatFrame(event: EmitEvent | ChatStreamEvent | ChatDataPart, fallbackSource: EmitEvent["source"]): ChatFrame | null;
 /**
  * Check a part frame against the schema of its type, one time, where it arrives. The schema drops a field that it
- * does not know. A type that the registry does not know passes unchanged, because a newer emitter can send it.
+ * does not know. A type that the registry does not know passes unchanged, because a newer emitter can send it. The
+ * source is checked for each type, because {@link isRootFrame} reads its call path.
  */
 export declare function checkChatPart(frame: ChatPartFrame): ChatPartCheck;
 /** A frame of the root agent of a chat turn, whose call path is `[agent.id]`. A longer path is a sub-agent. */

package/dist/contracts/chat-frame.js

@@ -1,5 +1,6 @@
 // The one translation path of a chat stream. Browser-safe: each import from outside `contracts/` is a type import.
 import { isReconciling, PART_REGISTRY } from "./part-registry.js";
+import { EventSourceSchema } from "./schemas/chat-events.js";
 import { ChatPartSchema } from "./schemas/chat-parts.js";
 function toSource(source) {
     return { agentId: source.agentId, callPath: [...source.callPath] };
@@ -44,12 +45,18 @@ export function toChatFrame(event, fallbackSource) {
 }
 /**
  * Check a part frame against the schema of its type, one time, where it arrives. The schema drops a field that it
- * does not know. A type that the registry does not know passes unchanged, because a newer emitter can send it.
+ * does not know. A type that the registry does not know passes unchanged, because a newer emitter can send it. The
+ * source is checked for each type, because {@link isRootFrame} reads its call path.
  */
 export function checkChatPart(frame) {
+    const { source, ...part } = frame;
+    if (source !== undefined) {
+        const checkedSource = EventSourceSchema.safeParse(source);
+        if (!checkedSource.success)
+            return { ok: false, error: checkedSource.error.message };
+    }
     if (!Object.hasOwn(PART_REGISTRY, frame.type))
         return { ok: true, frame };
-    const { source, ...part } = frame;
     const parsed = ChatPartSchema.safeParse(part);
     if (!parsed.success)
         return { ok: false, error: parsed.error.message };

package/dist/execution/run-event-parts.d.ts

@@ -1,12 +1,11 @@
 /**
- * The two input-only rules of the run-event read seam: narrowing a raw durable
- * stream value to the chat data-part contract, and the latest-wins reconciling
- * fold applied before delivery.
+ * The rules of the run-event read side that need no database and no durability
+ * engine: narrowing a raw durable stream value to the chat data-part contract,
+ * and the latest-wins reconciling fold, as a batch for `createRunEventStream`
+ * and live for an embedder that reads the run streams itself.
  *
- * They live apart from the reader because they are the only part of the seam
- * whose correctness is a function of its argument alone — no database, no
- * durability engine, no clock — and keeping them here is what lets that be
- * proven directly instead of inferred from a driven subscription.
+ * They live apart from the reader, thus a test drives them directly instead of
+ * through a subscription.
  */
 import type { ChatPart } from "../contracts/chat-parts.js";
 /**
@@ -42,3 +41,12 @@ export declare function parseRunEventPart(value: unknown): ChatPart | null;
  * the parts that are delivered is the order they were written.
  */
 export declare function foldRunEventParts(parts: readonly ChatPart[]): ChatPart[];
+/**
+ * The live form of {@link foldRunEventParts}, for a stream that stays open. An
+ * entry with a reconcile key waits `flushMs`, and a later entry with the same
+ * key replaces it. Thus a catch-up burst delivers each key once, and a live
+ * update lands one window later. Every other entry, also one of a type that the
+ * registry does not know, goes to `emit` at once, thus it can overtake a held
+ * entry. The held entries go to `emit` when the stream ends.
+ */
+export declare function pipeFoldedRunEvents<T>(entries: AsyncIterable<T>, emit: (entry: T) => Promise<void>, flushMs: number): Promise<void>;

package/dist/execution/run-event-parts.js

@@ -1,12 +1,11 @@
 /**
- * The two input-only rules of the run-event read seam: narrowing a raw durable
- * stream value to the chat data-part contract, and the latest-wins reconciling
- * fold applied before delivery.
+ * The rules of the run-event read side that need no database and no durability
+ * engine: narrowing a raw durable stream value to the chat data-part contract,
+ * and the latest-wins reconciling fold, as a batch for `createRunEventStream`
+ * and live for an embedder that reads the run streams itself.
  *
- * They live apart from the reader because they are the only part of the seam
- * whose correctness is a function of its argument alone — no database, no
- * durability engine, no clock — and keeping them here is what lets that be
- * proven directly instead of inferred from a driven subscription.
+ * They live apart from the reader, thus a test drives them directly instead of
+ * through a subscription.
  */
 import { reconcileKey } from "../contracts/chat-frame.js";
 import { PART_REGISTRY } from "../contracts/part-registry.js";
@@ -67,3 +66,59 @@ export function foldRunEventParts(parts) {
     }
     return folded;
 }
+/**
+ * The live form of {@link foldRunEventParts}, for a stream that stays open. An
+ * entry with a reconcile key waits `flushMs`, and a later entry with the same
+ * key replaces it. Thus a catch-up burst delivers each key once, and a live
+ * update lands one window later. Every other entry, also one of a type that the
+ * registry does not know, goes to `emit` at once, thus it can overtake a held
+ * entry. The held entries go to `emit` when the stream ends.
+ */
+export async function pipeFoldedRunEvents(entries, emit, flushMs) {
+    const latestByKey = new Map();
+    const pendingKeys = new Set();
+    let flushTimer = null;
+    let flushChain = Promise.resolve();
+    const flushPending = async () => {
+        flushTimer = null;
+        const keys = [...pendingKeys];
+        pendingKeys.clear();
+        for (const key of keys) {
+            const entry = latestByKey.get(key);
+            if (entry !== undefined)
+                await emit(entry);
+        }
+    };
+    const scheduleFlush = () => {
+        if (flushTimer !== null)
+            return;
+        flushTimer = setTimeout(() => {
+            // A timed flush has no caller to report to. A lasting emit failure
+            // still reaches the caller, through the next direct emit or the
+            // final flush.
+            flushChain = flushChain.then(flushPending).catch(() => undefined);
+        }, flushMs);
+    };
+    try {
+        for await (const entry of entries) {
+            const part = parseRunEventPart(entry);
+            const key = part === null ? undefined : reconcileKey(part);
+            if (key === undefined) {
+                await emit(entry);
+                continue;
+            }
+            latestByKey.set(key, entry);
+            pendingKeys.add(key);
+            scheduleFlush();
+        }
+    }
+    finally {
+        if (flushTimer !== null) {
+            clearTimeout(flushTimer);
+            flushTimer = null;
+        }
+        await flushChain;
+        if (pendingKeys.size > 0)
+            await flushPending();
+    }
+}

package/dist/index.d.ts

@@ -170,6 +170,7 @@ export { registerSandboxStep } from "./workflows/sandbox-step.js";
 export type { SandboxStepDeps, SandboxStepInput, SandboxStepResult, SandboxAgentBuildContext } from "./workflows/sandbox-step.js";
 export { createRunEventStream } from "./execution/run-event-stream.js";
 export type { RunEventStream, RunEventStreamDeps, RunEventSubscribeOptions, RunEventPartHandler } from "./execution/run-event-stream.js";
+export { pipeFoldedRunEvents } from "./execution/run-event-parts.js";
 export { createSandboxAgents, SANDBOX_AGENT_META } from "./agents/sandbox/index.js";
 export type { SandboxAgentDeps, SandboxStepCoords, AgentMeta } from "./agents/sandbox/index.js";
 export { AnalysisPlanSchema } from "./schemas/workflow-state.js";

package/dist/index.js

@@ -271,6 +271,7 @@ export { registerSandboxStep } from "./workflows/sandbox-step.js";
 // Nothing in the signature belongs to the durability engine, so an embedder
 // consumes run events without depending on it.
 export { createRunEventStream } from "./execution/run-event-stream.js";
+export { pipeFoldedRunEvents } from "./execution/run-event-parts.js";
 // Sandbox-agent catalog. `buildAgent` maps a `SandboxAgentBuildContext` onto
 // `SandboxAgentDeps`, then selects the per-step agent by id from this record;
 // `SANDBOX_AGENT_META` is the planner-facing meta the same ids key.

package/package.json

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