@botbotgo/agent-harness 0.0.96 → 0.0.98

package/dist/runtime/checkpoint-maintenance.d.ts

@@ -1,45 +1 @@
-import type { WorkspaceBundle } from "../contracts/types.js";
-type CheckpointMaintenanceConfig = {
-    enabled: boolean;
-    schedule: {
-        intervalSeconds: number;
-        runOnStartup: boolean;
-    };
-    policies: {
-        maxAgeSeconds?: number;
-        maxBytes?: number;
-    };
-    sqlite: {
-        sweepBatchSize: number;
-        vacuum: boolean;
-    };
-};
-type CheckpointMaintenanceTarget = {
-    agentId: string;
-    dbPath: string;
-};
-export type MaintenanceLoopStatus = {
-    lastStartedAt?: string;
-    lastCompletedAt?: string;
-    lastFailedAt?: string;
-    consecutiveFailures: number;
-    lastError?: string;
-};
-export declare function readCheckpointMaintenanceConfig(workspace: WorkspaceBundle): CheckpointMaintenanceConfig | null;
-export declare function discoverCheckpointMaintenanceTargets(workspace: WorkspaceBundle): CheckpointMaintenanceTarget[];
-export declare function maintainSqliteCheckpoints(dbPath: string, config: CheckpointMaintenanceConfig, nowMs?: number): Promise<{
-    deletedCount: number;
-}>;
-export declare class CheckpointMaintenanceLoop {
-    private readonly targets;
-    private readonly config;
-    private timer;
-    private running;
-    private status;
-    constructor(targets: CheckpointMaintenanceTarget[], config: CheckpointMaintenanceConfig);
-    runOnce(nowMs?: number): Promise<void>;
-    getStatus(): MaintenanceLoopStatus;
-    start(): Promise<void>;
-    stop(): Promise<void>;
-}
-export {};
+export * from "./maintenance/checkpoint-maintenance.js";

package/dist/runtime/checkpoint-maintenance.js

@@ -1,259 +1 @@
-import path from "node:path";
-import { SqliteSaver } from "@langchain/langgraph-checkpoint-sqlite";
-import { listProtectedCheckpointThreadIds } from "../persistence/sqlite-store.js";
-import { fileExists } from "../utils/fs.js";
-import { getRuntimeDefaults } from "../workspace/support/workspace-ref-utils.js";
-import { ManagedSqliteSaver } from "./sqlite-maintained-checkpoint-saver.js";
-function asObject(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
-}
-function readPositiveNumber(value, label, allowUndefined = true) {
-    if (value === undefined && allowUndefined) {
-        return undefined;
-    }
-    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
-        throw new Error(`${label} must be a positive number`);
-    }
-    return value;
-}
-export function readCheckpointMaintenanceConfig(workspace) {
-    const runtimeDefaults = getRuntimeDefaults(workspace.refs);
-    const maintenance = asObject(runtimeDefaults?.maintenance);
-    const checkpoints = asObject(maintenance?.checkpoints);
-    if (!checkpoints || checkpoints.enabled !== true) {
-        return null;
-    }
-    const schedule = asObject(checkpoints.schedule);
-    const policies = asObject(checkpoints.policies);
-    const sqlite = asObject(checkpoints.sqlite);
-    const config = {
-        enabled: true,
-        schedule: {
-            intervalSeconds: readPositiveNumber(schedule?.intervalSeconds, "runtime.maintenance.checkpoints.schedule.intervalSeconds") ?? 3600,
-            runOnStartup: schedule?.runOnStartup !== false,
-        },
-        policies: {
-            maxAgeSeconds: readPositiveNumber(policies?.maxAgeSeconds, "runtime.maintenance.checkpoints.policies.maxAgeSeconds"),
-            maxBytes: readPositiveNumber(policies?.maxBytes, "runtime.maintenance.checkpoints.policies.maxBytes"),
-        },
-        sqlite: {
-            sweepBatchSize: readPositiveNumber(sqlite?.sweepBatchSize, "runtime.maintenance.checkpoints.sqlite.sweepBatchSize") ?? 200,
-            vacuum: sqlite?.vacuum === true,
-        },
-    };
-    if (config.policies.maxAgeSeconds === undefined && config.policies.maxBytes === undefined) {
-        throw new Error("runtime.maintenance.checkpoints.enabled requires at least one cleanup policy");
-    }
-    return config;
-}
-function resolveSqliteCheckpointPath(binding) {
-    const config = binding.harnessRuntime.checkpointer;
-    if (!config || typeof config === "boolean") {
-        return null;
-    }
-    const kind = typeof config.kind === "string" ? config.kind : "FileCheckpointer";
-    if (kind !== "SqliteSaver") {
-        return null;
-    }
-    const configuredPath = typeof config.path === "string" ? String(config.path) : "checkpoints.sqlite";
-    return path.isAbsolute(configuredPath) ? configuredPath : path.join(binding.harnessRuntime.runRoot, configuredPath);
-}
-export function discoverCheckpointMaintenanceTargets(workspace) {
-    const deduped = new Map();
-    for (const binding of workspace.bindings.values()) {
-        const dbPath = resolveSqliteCheckpointPath(binding);
-        if (!dbPath) {
-            continue;
-        }
-        deduped.set(dbPath, {
-            agentId: binding.agent.id,
-            dbPath,
-        });
-    }
-    return Array.from(deduped.values());
-}
-function backfillCheckpointMetadata(db, nowMs = Date.now()) {
-    db.exec(`
-CREATE TABLE IF NOT EXISTS checkpoint_maintenance_meta (
-  thread_id TEXT NOT NULL,
-  checkpoint_ns TEXT NOT NULL DEFAULT '',
-  checkpoint_id TEXT NOT NULL,
-  created_at_ms INTEGER NOT NULL,
-  PRIMARY KEY (thread_id, checkpoint_ns, checkpoint_id)
-);`);
-    db.prepare(`INSERT OR IGNORE INTO checkpoint_maintenance_meta
-     (thread_id, checkpoint_ns, checkpoint_id, created_at_ms)
-     SELECT thread_id, checkpoint_ns, checkpoint_id, ?
-     FROM checkpoints`).run(nowMs);
-}
-function deleteCheckpointRows(db, rows) {
-    if (rows.length === 0) {
-        return 0;
-    }
-    const deleteCheckpoint = db.prepare(`DELETE FROM checkpoints
-     WHERE thread_id = ? AND checkpoint_ns = ? AND checkpoint_id = ?`);
-    const deleteWrites = db.prepare(`DELETE FROM writes
-     WHERE thread_id = ? AND checkpoint_ns = ? AND checkpoint_id = ?`);
-    const deleteMeta = db.prepare(`DELETE FROM checkpoint_maintenance_meta
-     WHERE thread_id = ? AND checkpoint_ns = ? AND checkpoint_id = ?`);
-    db.transaction((items) => {
-        for (const row of items) {
-            deleteCheckpoint.run(row.thread_id, row.checkpoint_ns, row.checkpoint_id);
-            deleteWrites.run(row.thread_id, row.checkpoint_ns, row.checkpoint_id);
-            deleteMeta.run(row.thread_id, row.checkpoint_ns, row.checkpoint_id);
-        }
-    })(rows);
-    return rows.length;
-}
-function selectOldestRows(db, limit) {
-    return db
-        .prepare(`SELECT
-         meta.thread_id,
-         meta.checkpoint_ns,
-         meta.checkpoint_id,
-         meta.created_at_ms,
-         COALESCE(LENGTH(cp.checkpoint), 0) + COALESCE(LENGTH(cp.metadata), 0) + COALESCE(SUM(LENGTH(w.value)), 0) AS size_bytes
-       FROM checkpoint_maintenance_meta AS meta
-       JOIN checkpoints AS cp
-         ON cp.thread_id = meta.thread_id
-        AND cp.checkpoint_ns = meta.checkpoint_ns
-        AND cp.checkpoint_id = meta.checkpoint_id
-       LEFT JOIN writes AS w
-         ON w.thread_id = meta.thread_id
-        AND w.checkpoint_ns = meta.checkpoint_ns
-        AND w.checkpoint_id = meta.checkpoint_id
-       GROUP BY meta.thread_id, meta.checkpoint_ns, meta.checkpoint_id, meta.created_at_ms, cp.checkpoint, cp.metadata
-       ORDER BY meta.created_at_ms ASC, meta.checkpoint_id ASC
-       LIMIT ?`)
-        .all(limit);
-}
-function totalCheckpointBytes(db) {
-    const checkpointsBytes = db
-        .prepare(`SELECT COALESCE(SUM(LENGTH(checkpoint) + LENGTH(metadata)), 0) AS total FROM checkpoints`)
-        .get();
-    const writesBytes = db
-        .prepare(`SELECT COALESCE(SUM(LENGTH(value)), 0) AS total FROM writes`)
-        .get();
-    return Number(checkpointsBytes.total ?? 0) + Number(writesBytes.total ?? 0);
-}
-export function maintainSqliteCheckpoints(dbPath, config, nowMs = Date.now()) {
-    return maintainSqliteCheckpointsInternal(dbPath, config, nowMs);
-}
-async function maintainSqliteCheckpointsInternal(dbPath, config, nowMs) {
-    if (!(await fileExists(dbPath))) {
-        return { deletedCount: 0 };
-    }
-    const saver = new ManagedSqliteSaver(SqliteSaver.fromConnString(dbPath).db);
-    const db = saver.db;
-    try {
-        saver.prepareMaintenance();
-        backfillCheckpointMetadata(db, nowMs);
-        const protectedThreadIds = await listProtectedCheckpointThreadIds(path.join(path.dirname(dbPath), "runtime.sqlite"));
-        let deletedCount = 0;
-        if (config.policies.maxAgeSeconds !== undefined) {
-            const cutoffMs = nowMs - config.policies.maxAgeSeconds * 1000;
-            const expired = db
-                .prepare(`SELECT
-             meta.thread_id,
-             meta.checkpoint_ns,
-             meta.checkpoint_id,
-             meta.created_at_ms,
-             0 AS size_bytes
-           FROM checkpoint_maintenance_meta AS meta
-           WHERE meta.created_at_ms <= ?
-           ORDER BY meta.created_at_ms ASC, meta.checkpoint_id ASC
-           LIMIT ?`)
-                .all(cutoffMs, config.sqlite.sweepBatchSize * 4);
-            deletedCount += deleteCheckpointRows(db, expired.filter((row) => !protectedThreadIds.has(row.thread_id)).slice(0, config.sqlite.sweepBatchSize));
-        }
-        if (config.policies.maxBytes !== undefined) {
-            let currentBytes = totalCheckpointBytes(db);
-            while (currentBytes > config.policies.maxBytes) {
-                const oldest = selectOldestRows(db, config.sqlite.sweepBatchSize * 4).filter((row) => !protectedThreadIds.has(row.thread_id));
-                if (oldest.length === 0) {
-                    break;
-                }
-                let reclaimed = 0;
-                const toDelete = [];
-                for (const row of oldest) {
-                    toDelete.push(row);
-                    reclaimed += Number(row.size_bytes ?? 0);
-                    if (currentBytes - reclaimed <= config.policies.maxBytes) {
-                        break;
-                    }
-                }
-                deletedCount += deleteCheckpointRows(db, toDelete);
-                currentBytes = totalCheckpointBytes(db);
-            }
-        }
-        if (deletedCount > 0 && config.sqlite.vacuum) {
-            db.exec("VACUUM");
-        }
-        return { deletedCount };
-    }
-    finally {
-        db.close();
-    }
-}
-export class CheckpointMaintenanceLoop {
-    targets;
-    config;
-    timer = null;
-    running = false;
-    status = {
-        consecutiveFailures: 0,
-    };
-    constructor(targets, config) {
-        this.targets = targets;
-        this.config = config;
-    }
-    async runOnce(nowMs = Date.now()) {
-        this.status = {
-            ...this.status,
-            lastStartedAt: new Date(nowMs).toISOString(),
-        };
-        try {
-            for (const target of this.targets) {
-                await maintainSqliteCheckpoints(target.dbPath, this.config, nowMs);
-            }
-            this.status = {
-                ...this.status,
-                lastCompletedAt: new Date(nowMs).toISOString(),
-                consecutiveFailures: 0,
-                lastError: undefined,
-            };
-        }
-        catch (error) {
-            this.status = {
-                ...this.status,
-                lastFailedAt: new Date(nowMs).toISOString(),
-                consecutiveFailures: this.status.consecutiveFailures + 1,
-                lastError: error instanceof Error ? error.message : String(error),
-            };
-            throw error;
-        }
-    }
-    getStatus() {
-        return { ...this.status };
-    }
-    async start() {
-        if (this.running) {
-            return;
-        }
-        this.running = true;
-        if (this.config.schedule.runOnStartup) {
-            await this.runOnce();
-        }
-        this.timer = setInterval(() => {
-            void this.runOnce();
-        }, this.config.schedule.intervalSeconds * 1000);
-        this.timer.unref?.();
-    }
-    async stop() {
-        if (this.timer) {
-            clearInterval(this.timer);
-            this.timer = null;
-        }
-        this.running = false;
-    }
-}
+export * from "./maintenance/checkpoint-maintenance.js";

package/dist/runtime/file-checkpoint-saver.d.ts

@@ -1,20 +1 @@
-import { MemorySaver } from "@langchain/langgraph";
-type MemorySaverConfig = Parameters<MemorySaver["getTuple"]>[0];
-type MemorySaverListOptions = Parameters<MemorySaver["list"]>[1];
-type MemorySaverPutCheckpoint = Parameters<MemorySaver["put"]>[1];
-type MemorySaverPutMetadata = Parameters<MemorySaver["put"]>[2];
-type MemorySaverPutWrites = Parameters<MemorySaver["putWrites"]>[1];
-type MemorySaverPutResult = ReturnType<MemorySaver["put"]>;
-export declare class FileCheckpointSaver extends MemorySaver {
-    private readonly filePath;
-    private loaded;
-    constructor(filePath: string);
-    private ensureLoaded;
-    private persist;
-    getTuple(config: MemorySaverConfig): Promise<import("@langchain/langgraph").CheckpointTuple | undefined>;
-    list(config: MemorySaverConfig, options?: MemorySaverListOptions): AsyncGenerator<import("@langchain/langgraph").CheckpointTuple, void, unknown>;
-    put(config: MemorySaverConfig, checkpoint: MemorySaverPutCheckpoint, metadata: MemorySaverPutMetadata): MemorySaverPutResult;
-    putWrites(config: MemorySaverConfig, writes: MemorySaverPutWrites, taskId: string): Promise<void>;
-    deleteThread(threadId: string): Promise<void>;
-}
-export { FileCheckpointSaver as FileCheckpointer };
+export * from "./maintenance/file-checkpoint-saver.js";

package/dist/runtime/file-checkpoint-saver.js

@@ -1,106 +1 @@
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import path from "node:path";
-import { MemorySaver } from "@langchain/langgraph";
-function encodeBinary(value) {
-    if (value instanceof Uint8Array) {
-        return {
-            __type: "Uint8Array",
-            data: Array.from(value),
-        };
-    }
-    if (Array.isArray(value)) {
-        return value.map((item) => encodeBinary(item));
-    }
-    if (typeof value === "object" && value) {
-        return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, encodeBinary(entry)]));
-    }
-    return value;
-}
-function decodeBinary(value) {
-    if (Array.isArray(value)) {
-        return value.map((item) => decodeBinary(item));
-    }
-    if (typeof value === "object" && value) {
-        const typed = value;
-        if (typed.__type === "Uint8Array" && Array.isArray(typed.data)) {
-            return new Uint8Array(typed.data.map((item) => Number(item)));
-        }
-        return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, decodeBinary(entry)]));
-    }
-    return value;
-}
-function pruneThreadEntries(record, threadId) {
-    for (const key of Object.keys(record)) {
-        if (key.includes(threadId)) {
-            delete record[key];
-            continue;
-        }
-        const value = record[key];
-        if (typeof value === "object" && value && !Array.isArray(value)) {
-            pruneThreadEntries(value, threadId);
-            if (Object.keys(value).length === 0) {
-                delete record[key];
-            }
-        }
-    }
-}
-export class FileCheckpointSaver extends MemorySaver {
-    filePath;
-    loaded = false;
-    constructor(filePath) {
-        super();
-        this.filePath = filePath;
-    }
-    async ensureLoaded() {
-        if (this.loaded) {
-            return;
-        }
-        try {
-            const raw = await readFile(this.filePath, "utf8");
-            const parsed = JSON.parse(raw);
-            this.storage = decodeBinary(parsed.storage ?? {});
-            this.writes = decodeBinary(parsed.writes ?? {});
-        }
-        catch {
-            this.storage = {};
-            this.writes = {};
-        }
-        this.loaded = true;
-    }
-    async persist() {
-        await mkdir(path.dirname(this.filePath), { recursive: true });
-        await writeFile(this.filePath, JSON.stringify({
-            storage: this.storage,
-            writes: this.writes,
-        }, (_, value) => encodeBinary(value), 2), "utf8");
-    }
-    async getTuple(config) {
-        await this.ensureLoaded();
-        return super.getTuple(config);
-    }
-    async *list(config, options) {
-        await this.ensureLoaded();
-        for await (const item of super.list(config, options)) {
-            yield item;
-        }
-    }
-    async put(config, checkpoint, metadata) {
-        await this.ensureLoaded();
-        const result = await super.put(config, checkpoint, metadata);
-        await this.persist();
-        return result;
-    }
-    async putWrites(config, writes, taskId) {
-        await this.ensureLoaded();
-        const result = await super.putWrites(config, writes, taskId);
-        await this.persist();
-        return result;
-    }
-    async deleteThread(threadId) {
-        await this.ensureLoaded();
-        pruneThreadEntries(this.storage, threadId);
-        pruneThreadEntries(this.writes, threadId);
-        await this.persist();
-    }
-}
-export { FileCheckpointSaver as FileCheckpointer };
+export * from "./maintenance/file-checkpoint-saver.js";

package/dist/runtime/{event-bus.d.ts → harness/events/event-bus.d.ts}

@@ -1,4 +1,4 @@
-import type { HarnessEvent, HarnessEventListener, HarnessEventProjection, RuntimeEventSink } from "../contracts/types.js";
+import type { HarnessEvent, HarnessEventListener, HarnessEventProjection, RuntimeEventSink } from "../../../contracts/types.js";
 export declare class EventBus implements RuntimeEventSink {
     private readonly sink;
     publish(event: HarnessEvent): void;

package/dist/runtime/{event-sink.d.ts → harness/events/event-sink.d.ts}

@@ -1,4 +1,4 @@
-import type { HarnessEvent, HarnessEventListener, HarnessEventProjection, RuntimeEventSink } from "../contracts/types.js";
+import type { HarnessEvent, HarnessEventListener, HarnessEventProjection, RuntimeEventSink } from "../../../contracts/types.js";
 export declare class RuntimeEventSinkImpl implements RuntimeEventSink {
     private readonly emitter;
     private readonly projections;

package/dist/runtime/{event-sink.js → harness/events/event-sink.js}

@@ -1,5 +1,5 @@
 import { EventEmitter } from "node:events";
-import { getEventSubscribers } from "../extensions.js";
+import { getEventSubscribers } from "../../../extensions.js";
 function dispatchListener(listener, event) {
     void Promise.resolve(listener(event));
 }

package/dist/runtime/harness/events/events.d.ts

@@ -0,0 +1,23 @@
+import type { HarnessEvent, InternalApprovalRecord, MessageContent, RunResult } from "../../../contracts/types.js";
+import type { RuntimePersistence } from "../../../persistence/types.js";
+type EventPersistence = Pick<RuntimePersistence, "appendEvent" | "setRunState" | "createApproval" | "createArtifact">;
+type EventRuntime = {
+    persistence: EventPersistence;
+    publishEvent: (event: HarnessEvent) => void;
+    trackBackgroundTask: (task: Promise<void>) => void;
+    backgroundEventTypes: ReadonlySet<string>;
+};
+export declare function emitHarnessEvent(runtime: EventRuntime, threadId: string, runId: string, sequence: number, eventType: string, payload: Record<string, unknown>, source?: HarnessEvent["source"]): Promise<HarnessEvent>;
+export declare function emitRunCreatedEvent(runtime: EventRuntime, threadId: string, runId: string, payload: Record<string, unknown>): Promise<HarnessEvent>;
+export declare function setRunStateAndEmitEvent(runtime: EventRuntime, threadId: string, runId: string, sequence: number, state: RunResult["state"], options: {
+    previousState: string | null;
+    checkpointRef?: string | null;
+    error?: string;
+}): Promise<HarnessEvent>;
+export declare function persistApproval(runtime: EventRuntime, threadId: string, runId: string, checkpointRef: string, input: MessageContent, interruptContent?: string): Promise<InternalApprovalRecord>;
+export declare function requestApprovalAndEmitEvent(runtime: EventRuntime, threadId: string, runId: string, input: MessageContent, interruptContent: string | undefined, checkpointRef: string, sequence: number): Promise<{
+    approval: InternalApprovalRecord;
+    event: HarnessEvent;
+}>;
+export declare function emitSyntheticFallbackEvent(runtime: EventRuntime, threadId: string, runId: string, selectedAgentId: string, error: unknown, sequence?: number): Promise<void>;
+export {};

package/dist/runtime/harness/events/events.js

@@ -0,0 +1,61 @@
+import { extractMessageText } from "../../../utils/message-content.js";
+import { createHarnessEvent, createPendingApproval } from "../../support/harness-support.js";
+export async function emitHarnessEvent(runtime, threadId, runId, sequence, eventType, payload, source = "runtime") {
+    const event = createHarnessEvent(threadId, runId, sequence, eventType, payload, source);
+    if (runtime.backgroundEventTypes.has(event.eventType)) {
+        runtime.trackBackgroundTask(runtime.persistence.appendEvent(event).catch(() => {
+            // Fail open for telemetry-style event persistence.
+        }));
+    }
+    else {
+        await runtime.persistence.appendEvent(event);
+    }
+    runtime.publishEvent(event);
+    return event;
+}
+export async function emitRunCreatedEvent(runtime, threadId, runId, payload) {
+    return emitHarnessEvent(runtime, threadId, runId, 1, "run.created", payload);
+}
+export async function setRunStateAndEmitEvent(runtime, threadId, runId, sequence, state, options) {
+    await runtime.persistence.setRunState(threadId, runId, state, options.checkpointRef ?? null);
+    return emitHarnessEvent(runtime, threadId, runId, sequence, "run.state.changed", {
+        previousState: options.previousState,
+        state,
+        checkpointRef: options.checkpointRef ?? null,
+        ...(options.error ? { error: options.error } : {}),
+    });
+}
+export async function persistApproval(runtime, threadId, runId, checkpointRef, input, interruptContent) {
+    const approval = createPendingApproval(threadId, runId, checkpointRef, extractMessageText(input), interruptContent);
+    await runtime.persistence.createApproval(approval);
+    const artifact = await runtime.persistence.createArtifact(threadId, runId, {
+        artifactId: `artifact-approval-${runId}`,
+        kind: "approval-packet",
+        path: `artifacts/approval-${runId}.json`,
+        createdAt: approval.requestedAt,
+    }, approval);
+    await emitHarnessEvent(runtime, threadId, runId, 5, "artifact.created", {
+        artifactId: artifact.artifactId,
+        kind: artifact.kind,
+        path: artifact.path,
+    });
+    return approval;
+}
+export async function requestApprovalAndEmitEvent(runtime, threadId, runId, input, interruptContent, checkpointRef, sequence) {
+    const approval = await persistApproval(runtime, threadId, runId, checkpointRef, input, interruptContent);
+    const event = await emitHarnessEvent(runtime, threadId, runId, sequence, "approval.requested", {
+        approvalId: approval.approvalId,
+        pendingActionId: approval.pendingActionId,
+        toolName: approval.toolName,
+        toolCallId: approval.toolCallId,
+        allowedDecisions: approval.allowedDecisions,
+        checkpointRef,
+    });
+    return { approval, event };
+}
+export async function emitSyntheticFallbackEvent(runtime, threadId, runId, selectedAgentId, error, sequence = 3) {
+    await emitHarnessEvent(runtime, threadId, runId, sequence, "runtime.synthetic_fallback", {
+        reason: error instanceof Error ? error.message : String(error),
+        selectedAgentId,
+    });
+}

package/dist/runtime/harness/events/streaming.d.ts

@@ -0,0 +1,19 @@
+import type { HarnessEvent, HarnessStreamItem, RunListeners, RunResult } from "../../../contracts/types.js";
+export declare function emitOutputDeltaAndCreateItem(emit: (threadId: string, runId: string, sequence: number, eventType: string, payload: Record<string, unknown>) => Promise<HarnessEvent>, threadId: string, runId: string, agentId: string, content: string): Promise<HarnessStreamItem>;
+export declare function createContentBlocksItem(threadId: string, runId: string, agentId: string, contentBlocks: unknown[]): HarnessStreamItem;
+export declare function createToolResultKey(toolName: string, output: unknown, isError?: boolean): string;
+export declare function dispatchRunListeners(stream: AsyncGenerator<HarnessStreamItem>, listeners: RunListeners, options: {
+    notifyListener: <T>(listener: ((value: T) => void | Promise<void>) | undefined, value: T) => Promise<void>;
+    getThread: (threadId: string) => Promise<{
+        currentState: RunResult["state"];
+        latestRunId: string;
+        entryAgentId: string;
+        runs: Array<{
+            agentId: string;
+        }>;
+        pendingDecision?: {
+            approvalId?: string;
+            pendingActionId?: string;
+        };
+    } | null>;
+}): Promise<RunResult>;

package/dist/runtime/harness/events/streaming.js

@@ -0,0 +1,96 @@
+import { createFallbackRunResultFromLatestEvent, mergeRunResultOutput } from "../run/helpers.js";
+export async function emitOutputDeltaAndCreateItem(emit, threadId, runId, agentId, content) {
+    await emit(threadId, runId, 3, "output.delta", {
+        content,
+    });
+    return {
+        type: "content",
+        threadId,
+        runId,
+        agentId,
+        content,
+    };
+}
+export function createContentBlocksItem(threadId, runId, agentId, contentBlocks) {
+    return {
+        type: "content-blocks",
+        threadId,
+        runId,
+        agentId,
+        contentBlocks,
+    };
+}
+export function createToolResultKey(toolName, output, isError) {
+    let serializedOutput = "";
+    try {
+        serializedOutput = JSON.stringify(output);
+    }
+    catch {
+        serializedOutput = String(output);
+    }
+    return JSON.stringify([toolName, serializedOutput, isError === true]);
+}
+export async function dispatchRunListeners(stream, listeners, options) {
+    let latestEvent;
+    let latestResult;
+    let output = "";
+    for await (const item of stream) {
+        if (item.type === "event") {
+            latestEvent = item.event;
+            await options.notifyListener(listeners.onEvent, item.event);
+            continue;
+        }
+        if (item.type === "upstream-event") {
+            await options.notifyListener(listeners.onUpstreamEvent, item.event);
+            continue;
+        }
+        if (item.type === "result") {
+            latestResult = item.result;
+            continue;
+        }
+        if (item.type === "content") {
+            output += item.content;
+            await options.notifyListener(listeners.onChunk, item.content);
+            continue;
+        }
+        if (item.type === "content-blocks") {
+            await options.notifyListener(listeners.onContentBlocks, item.contentBlocks);
+            continue;
+        }
+        if (item.type === "reasoning") {
+            await options.notifyListener(listeners.onReasoning, item.content);
+            continue;
+        }
+        if (item.type === "step") {
+            await options.notifyListener(listeners.onStep, item.content);
+            continue;
+        }
+        if (item.type === "tool-result") {
+            await options.notifyListener(listeners.onToolResult, {
+                toolName: item.toolName,
+                output: item.output,
+                isError: item.isError,
+            });
+        }
+    }
+    if (!latestEvent) {
+        throw new Error("run did not emit any events");
+    }
+    if (latestResult) {
+        return mergeRunResultOutput(latestResult, output);
+    }
+    const thread = await options.getThread(latestEvent.threadId);
+    if (!thread) {
+        throw new Error(`Unknown thread ${latestEvent.threadId}`);
+    }
+    return createFallbackRunResultFromLatestEvent({
+        latestEvent,
+        currentState: thread.currentState,
+        latestRunId: thread.latestRunId,
+        entryAgentId: thread.entryAgentId,
+        latestAgentId: thread.runs[0]?.agentId,
+        approvalId: thread.pendingDecision?.approvalId,
+        pendingActionId: thread.pendingDecision?.pendingActionId,
+        output,
+    });
+}

package/dist/runtime/harness/index.d.ts

@@ -0,0 +1,16 @@
+export * from "./events/event-bus.js";
+export * from "./events/event-sink.js";
+export * from "./events/events.js";
+export * from "./system/health-monitor.js";
+export * from "./run/helpers.js";
+export * from "./system/inventory.js";
+export * from "./system/policy-engine.js";
+export * from "./run/resources.js";
+export * from "./run/resume.js";
+export * from "./run/routing.js";
+export * from "./run/run-lifecycle.js";
+export * from "./run/run-queue.js";
+export * from "./system/skill-requirements.js";
+export * from "./system/store.js";
+export * from "./events/streaming.js";
+export * from "./system/thread-memory-sync.js";