@botbotgo/agent-harness 0.0.250 → 0.0.252

package/dist/runtime/harness/run/stream-run.js

@@ -2,7 +2,7 @@ import { AGENT_INTERRUPT_SENTINEL_PREFIX, RuntimeOperationTimeoutError } from ".
 import { renderRuntimeFailure, renderToolFailure } from "../../support/harness-support.js";
 import { getBindingPrimaryModel } from "../../support/compiled-binding.js";
 import { createContentBlocksItem, createToolResultKey, } from "../events/streaming.js";
-import { consumeRunInspectionUpstreamEvent, projectRuntimeSurfaceFromSingleUpstreamEvent } from "./inspection.js";
+import { projectRuntimeSurfaceFromSingleUpstreamEvent } from "./inspection.js";
 import { formatAgentName } from "../../../utils/agent-display.js";
 function normalizeStreamChunk(chunk) {
     if (typeof chunk === "string") {
@@ -73,44 +73,55 @@ export async function* streamHarnessRun(options) {
             const normalizedChunk = normalizeStreamChunk(rawChunk);
             if (normalizedChunk.kind === "upstream-event") {
                 upstreamEventOrdinal += 1;
+                const projectionBinding = options.getBinding(currentAgentId) ?? options.binding;
                 const surfaceProjection = projectRuntimeSurfaceFromSingleUpstreamEvent({
                     event: {
                         agentId: currentAgentId,
                         agentName: currentAgentName,
                         event: normalizedChunk.event,
                     },
-                    binding: options.binding,
+                    binding: projectionBinding,
                     currentAgentId,
                     currentAgentName,
-                    sourceEventId: `upstream:${upstreamEventOrdinal}`,
-                });
-                const inspection = consumeRunInspectionUpstreamEvent({
-                    event: normalizedChunk.event,
-                    currentAgentId,
                     delegationChain,
-                    binding: options.binding,
+                    sourceEventId: `upstream:${upstreamEventOrdinal}`,
                 });
-                currentAgentId = inspection.currentAgentId;
-                currentAgentName = formatAgentName(currentAgentId);
-                delegationChain = inspection.delegationChain;
+                currentAgentId = surfaceProjection.currentAgentId;
+                currentAgentName = surfaceProjection.currentAgentName;
+                delegationChain = surfaceProjection.delegationChain;
                 await options.updateRunInspection(options.threadId, options.runId, {
                     currentAgentId,
                     delegationChain,
-                    appendUpstreamEvent: {
+                });
+                if (surfaceProjection.items.length === 0) {
+                    await options.appendRunTraceItem(options.threadId, options.runId, {
                         agentId: currentAgentId,
                         agentName: currentAgentName,
                         event: normalizedChunk.event,
-                    },
-                });
-                yield {
-                    type: "upstream-event",
-                    threadId: options.threadId,
-                    runId: options.runId,
-                    agentId: currentAgentId,
-                    agentName: currentAgentName,
-                    surfaceItems: surfaceProjection.items,
-                    event: normalizedChunk.event,
-                };
+                    });
+                    yield {
+                        type: "upstream-event",
+                        threadId: options.threadId,
+                        runId: options.runId,
+                        event: normalizedChunk.event,
+                    };
+                    continue;
+                }
+                for (const surfaceItem of surfaceProjection.items) {
+                    await options.appendRunTraceItem(options.threadId, options.runId, {
+                        agentId: surfaceItem.agentId ?? currentAgentId,
+                        agentName: surfaceItem.agentName ?? currentAgentName,
+                        surfaceItem,
+                        event: normalizedChunk.event,
+                    });
+                    yield {
+                        type: "upstream-event",
+                        threadId: options.threadId,
+                        runId: options.runId,
+                        surfaceItem,
+                        event: normalizedChunk.event,
+                    };
+                }
                 continue;
             }
             nonUpstreamStreamActivityObserved = true;

package/dist/runtime/harness/run/surface-semantics.d.ts

@@ -0,0 +1,14 @@
+import type { CompiledAgentBinding, RuntimeSurfaceKind } from "../../../contracts/types.js";
+export declare function normalizeSurfaceToken(value: string): string;
+export declare function buildSurfaceId(kind: RuntimeSurfaceKind, value: string): string;
+export declare function stripStepPrefix(label: string): string;
+export declare function resolveSurfaceDisplayName(input: {
+    kind: RuntimeSurfaceKind;
+    step: string;
+    binding?: CompiledAgentBinding;
+}): string;
+export declare function resolveSurfaceAction(input: {
+    kind: RuntimeSurfaceKind;
+    step?: string;
+    event?: unknown;
+}): string;

package/dist/runtime/harness/run/surface-semantics.js

@@ -0,0 +1,106 @@
+import { readSkillMetadata } from "../../support/skill-metadata.js";
+import { formatAgentName } from "../../../utils/agent-display.js";
+import { getBindingMemorySources, getBindingSkills, } from "../../support/compiled-binding.js";
+function asObject(value) {
+    return typeof value === "object" && value !== null ? value : null;
+}
+function readStringArray(value) {
+    return Array.isArray(value) ? value.filter((item) => typeof item === "string" && item.trim().length > 0) : [];
+}
+function normalizeLabel(value) {
+    return value.replace(/\s+/g, " ").trim();
+}
+export function normalizeSurfaceToken(value) {
+    return value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 80) || "item";
+}
+export function buildSurfaceId(kind, value) {
+    void kind;
+    return normalizeSurfaceToken(value);
+}
+export function stripStepPrefix(label) {
+    return normalizeLabel(label)
+        .replace(/^Calling LLM\s+/i, "")
+        .replace(/^Completed LLM\s+/i, "")
+        .replace(/^Calling tool\s+/i, "")
+        .replace(/^Completed tool\s+/i, "")
+        .replace(/^Tool\s+/i, "")
+        .replace(/\s+failed$/i, "")
+        .replace(/^Calling skill\s+/i, "")
+        .replace(/^Completed skill\s+/i, "")
+        .replace(/^Accessing memory\s+/i, "")
+        .replace(/^Completed memory\s+/i, "");
+}
+function isGenericMemoryMiddlewareName(value) {
+    return /^(memorymiddleware\.before[_\s]?agent|memory middleware before agent)$/i.test(normalizeLabel(value));
+}
+function canonicalMemoryName(memorySource) {
+    const normalized = normalizeLabel(memorySource.replace(/^memory\//i, ""));
+    const segments = normalized.split(/[\\/]/).filter(Boolean);
+    return (segments.at(-1) ?? normalized).toLowerCase() || "memory";
+}
+function isGenericSkillMiddlewareName(value) {
+    return /^(skillsmiddleware\.before[_\s]?agent|skills middleware before agent)$/i.test(normalizeLabel(value));
+}
+export function resolveSurfaceDisplayName(input) {
+    const baseName = stripStepPrefix(input.step) || formatAgentName(input.kind);
+    if (input.kind === "memory" && input.binding && isGenericMemoryMiddlewareName(baseName)) {
+        const memorySources = getBindingMemorySources(input.binding).filter((name) => name.trim().length > 0);
+        return memorySources.length === 1 ? canonicalMemoryName(memorySources[0]) : baseName;
+    }
+    if (input.kind !== "skill" || !input.binding || !isGenericSkillMiddlewareName(baseName)) {
+        return baseName;
+    }
+    const skillNames = getBindingSkills(input.binding)
+        .map((skillPath) => readSkillMetadata(skillPath).name)
+        .filter((name) => typeof name === "string" && name.trim().length > 0);
+    return skillNames.length === 1 ? skillNames[0] : baseName;
+}
+function normalizeActionHint(value) {
+    return value
+        .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+        .replace(/[.:/]+/g, " ")
+        .replace(/[_-]+/g, " ")
+        .replace(/\s+/g, " ")
+        .trim()
+        .toLowerCase();
+}
+function resolveMemoryAction(event, step) {
+    const typed = asObject(event);
+    const hints = [
+        typeof typed?.event === "string" ? typed.event : "",
+        typeof typed?.name === "string" ? typed.name : "",
+        typeof typed?.run_type === "string" ? typed.run_type : "",
+        ...readStringArray(typed?.tags),
+        ...readStringArray(typed?.ns),
+        step,
+    ].map(normalizeActionHint);
+    if (hints.some((value) => /\b(store|memorize|sync|formation|ingestion|archive|write)\b/.test(value))) {
+        return "memorize";
+    }
+    if (hints.some((value) => /\b(recall|retrieve|memorymiddleware|before agent|checkpoint|context)\b/.test(value)
+        || value.includes("accessing memory")
+        || value.includes("access memory"))) {
+        return "recall";
+    }
+    return "access";
+}
+export function resolveSurfaceAction(input) {
+    switch (input.kind) {
+        case "agent":
+            return "handoff";
+        case "llm":
+            return "call";
+        case "tool":
+            return "execute";
+        case "skill":
+            return "apply";
+        case "memory":
+            return resolveMemoryAction(input.event, input.step ?? "");
+        default:
+            return "run";
+    }
+}

package/dist/runtime/harness/run/thread-records.js

@@ -1,41 +1,13 @@
 import { isTerminalRunState, toInspectableApprovalRecord } from "./helpers.js";
 import { projectRuntimeTimeline } from "../events/timeline.js";
-import { createUpstreamTimelineReducer } from "../../../upstream-events.js";
-import { projectRuntimeSurfaceFromUpstreamEvents } from "./inspection.js";
-function unwrapPersistedUpstreamEvent(event) {
-    if (typeof event !== "object" || event === null || Array.isArray(event)) {
-        return event;
-    }
-    const typed = event;
-    if (Object.prototype.hasOwnProperty.call(typed, "event")
-        && typeof typed.event === "object"
-        && typed.event !== null
-        && !Array.isArray(typed.event)) {
-        return typed.event;
-    }
-    return event;
-}
 function selectLatestPendingApproval(approvals) {
     return approvals
         .filter((approval) => approval.status === "pending")
         .sort((left, right) => right.requestedAt.localeCompare(left.requestedAt))[0];
 }
-function buildRunInspectionProjection(upstreamEvents) {
-    const reducer = createUpstreamTimelineReducer();
-    const history = upstreamEvents.flatMap((event) => reducer.consume(unwrapPersistedUpstreamEvent(event)));
-    return {
-        upstreamEvents,
-        history,
-    };
-}
 export async function buildRequestInspectionRecord(persistence, request) {
     const inspection = await persistence.getRunInspection(request.threadId, request.runId);
     const runtimeEvents = await persistence.listRunEvents(request.threadId, request.runId);
-    const { upstreamEvents, history } = buildRunInspectionProjection(inspection.upstreamEvents);
-    const runtimeSurface = projectRuntimeSurfaceFromUpstreamEvents({
-        upstreamEvents,
-        initialAgentId: request.agentId ?? inspection.currentAgentId ?? "agent",
-    });
     return {
         requestId: request.runId,
         sessionId: request.threadId,
@@ -54,9 +26,7 @@ export async function buildRequestInspectionRecord(persistence, request) {
         currentAgentId: request.currentAgentId,
         delegationChain: request.delegationChain,
         runtimeSnapshot: request.runtimeSnapshot,
-        upstreamEvents,
-        history,
-        runtimeSurface,
+        traceItems: inspection.traceItems,
         runtimeTimeline: projectRuntimeTimeline(runtimeEvents, {
             threadId: request.threadId,
             runId: request.runId,
@@ -82,9 +52,7 @@ function toRunRecord(request) {
         currentAgentId: request.currentAgentId,
         delegationChain: request.delegationChain,
         runtimeSnapshot: request.runtimeSnapshot,
-        upstreamEvents: request.upstreamEvents,
-        history: request.history,
-        runtimeSurface: request.runtimeSurface,
+        traceItems: request.traceItems,
         runtimeTimeline: request.runtimeTimeline,
     };
 }

package/dist/runtime/harness/system/store.d.ts

@@ -51,8 +51,13 @@ export declare class FileBackedStore {
 }
 export declare class SqliteBackedStore {
     readonly filePath: string;
-    private readonly db;
+    private client;
+    private initialized;
+    private initialization;
     constructor(filePath: string);
+    private getClient;
+    private ensureInitialized;
+    private selectAll;
     batch(operations: Array<Record<string, unknown>>): Promise<readonly unknown[]>;
     get(namespace: string[], key: string): Promise<{
         value: unknown;
@@ -61,7 +66,6 @@ export declare class SqliteBackedStore {
         createdAt: Date;
         updatedAt: Date;
     } | null>;
-    private getSync;
     search(namespacePrefix: string[]): Promise<Array<{
         value: unknown;
         key: string;
@@ -71,9 +75,7 @@ export declare class SqliteBackedStore {
         score?: number;
     }>>;
     put(namespace: string[], key: string, value: Record<string, any>, _index?: false | string[]): Promise<void>;
-    private putSync;
     delete(namespace: string[], key: string): Promise<void>;
-    private deleteSync;
     listNamespaces(): Promise<string[][]>;
 }
 export declare function createInMemoryStore(): StoreLike;

package/dist/runtime/harness/system/store.js

@@ -2,7 +2,7 @@ import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { mkdirSync } from "node:fs";
 import path from "node:path";
 import { InMemoryStore } from "@langchain/langgraph";
-import { loadBetterSqlite3 } from "../../support/sqlite-drivers.js";
+import { createClient } from "@libsql/client";
 const NAMESPACE_SEPARATOR = "\u001f";
 function encodeValue(value) {
     if (value instanceof Date) {
@@ -148,83 +148,117 @@ export class FileBackedStore {
 }
 export class SqliteBackedStore {
     filePath;
-    db;
+    client = null;
+    initialized = false;
+    initialization = null;
     constructor(filePath) {
         this.filePath = filePath;
         mkdirSync(path.dirname(filePath), { recursive: true });
-        const SqliteDatabase = loadBetterSqlite3();
-        this.db = new SqliteDatabase(filePath);
-        this.db.pragma("journal_mode = WAL");
-        this.db.exec(`
-      CREATE TABLE IF NOT EXISTS store_entries (
-        namespace TEXT NOT NULL,
-        namespace_json TEXT NOT NULL,
-        key TEXT NOT NULL,
-        value_json TEXT NOT NULL,
-        created_at TEXT NOT NULL,
-        updated_at TEXT NOT NULL,
-        PRIMARY KEY (namespace, key)
-      );
-      CREATE INDEX IF NOT EXISTS idx_store_entries_namespace ON store_entries(namespace);
-    `);
+    }
+    async getClient() {
+        if (!this.client) {
+            this.client = createClient({ url: `file:${this.filePath}` });
+        }
+        return this.client;
+    }
+    async ensureInitialized() {
+        if (this.initialized) {
+            return;
+        }
+        if (this.initialization) {
+            await this.initialization;
+            return;
+        }
+        this.initialization = (async () => {
+            const client = await this.getClient();
+            await client.execute("PRAGMA journal_mode=WAL");
+            await client.execute("PRAGMA foreign_keys=ON");
+            await client.execute("PRAGMA busy_timeout=5000");
+            await client.execute(`
+        CREATE TABLE IF NOT EXISTS store_entries (
+          namespace TEXT NOT NULL,
+          namespace_json TEXT NOT NULL,
+          key TEXT NOT NULL,
+          value_json TEXT NOT NULL,
+          created_at TEXT NOT NULL,
+          updated_at TEXT NOT NULL,
+          PRIMARY KEY (namespace, key)
+        )
+      `);
+            await client.execute("CREATE INDEX IF NOT EXISTS idx_store_entries_namespace ON store_entries(namespace)");
+            this.initialized = true;
+            this.initialization = null;
+        })();
+        await this.initialization;
+    }
+    async selectAll(sql, args = []) {
+        await this.ensureInitialized();
+        const client = await this.getClient();
+        const result = await client.execute({ sql, args });
+        return result.rows;
     }
     async batch(operations) {
-        const results = this.db.transaction((items) => items.map((operation) => {
+        const results = [];
+        for (const operation of operations) {
             const namespace = Array.isArray(operation.namespace) ? operation.namespace.filter((item) => typeof item === "string") : [];
             const key = typeof operation.key === "string" ? operation.key : "";
             if ("value" in operation) {
-                this.putSync(namespace, key, operation.value);
-                return undefined;
+                await this.put(namespace, key, operation.value);
+                results.push(undefined);
+                continue;
             }
             if (operation.delete === true) {
-                this.deleteSync(namespace, key);
-                return undefined;
+                await this.delete(namespace, key);
+                results.push(undefined);
+                continue;
             }
-            return this.getSync(namespace, key);
-        }))(operations);
+            results.push(await this.get(namespace, key));
+        }
         return results;
     }
     async get(namespace, key) {
-        return this.getSync(namespace, key);
-    }
-    getSync(namespace, key) {
-        const row = this.db.prepare(`SELECT namespace, namespace_json, key, value_json, created_at, updated_at
+        const rows = await this.selectAll(`SELECT namespace, namespace_json, key, value_json, created_at, updated_at
        FROM store_entries
-       WHERE namespace = ? AND key = ?`).get(serializeNamespace(namespace), key);
+       WHERE namespace = ? AND key = ?`, [serializeNamespace(namespace), key]);
+        const row = rows[0];
         return row ? parseRow(row) : null;
     }
     async search(namespacePrefix) {
         const prefix = serializeNamespace(namespacePrefix);
-        const rows = this.db.prepare(`SELECT namespace, namespace_json, key, value_json, created_at, updated_at
+        const rows = await this.selectAll(`SELECT namespace, namespace_json, key, value_json, created_at, updated_at
        FROM store_entries
        WHERE namespace = ? OR namespace LIKE ?
-       ORDER BY namespace ASC, key ASC`).all(prefix, `${prefix}${NAMESPACE_SEPARATOR}%`);
+       ORDER BY namespace ASC, key ASC`, [prefix, `${prefix}${NAMESPACE_SEPARATOR}%`]);
         return rows.map((row) => parseRow(row));
     }
     async put(namespace, key, value, _index) {
-        this.putSync(namespace, key, value);
-    }
-    putSync(namespace, key, value) {
+        await this.ensureInitialized();
+        const client = await this.getClient();
         const now = new Date().toISOString();
         const serializedNamespace = serializeNamespace(namespace);
         const encodedValue = JSON.stringify(encodeValue(value));
-        this.db.prepare(`INSERT INTO store_entries (namespace, namespace_json, key, value_json, created_at, updated_at)
+        await client.execute({
+            sql: `INSERT INTO store_entries (namespace, namespace_json, key, value_json, created_at, updated_at)
        VALUES (?, ?, ?, ?, ?, ?)
        ON CONFLICT(namespace, key) DO UPDATE SET
          namespace_json = excluded.namespace_json,
          value_json = excluded.value_json,
-         updated_at = excluded.updated_at`).run(serializedNamespace, JSON.stringify(namespace), key, encodedValue, now, now);
+         updated_at = excluded.updated_at`,
+            args: [serializedNamespace, JSON.stringify(namespace), key, encodedValue, now, now],
+        });
     }
     async delete(namespace, key) {
-        this.deleteSync(namespace, key);
-    }
-    deleteSync(namespace, key) {
-        this.db.prepare(`DELETE FROM store_entries WHERE namespace = ? AND key = ?`).run(serializeNamespace(namespace), key);
+        await this.ensureInitialized();
+        const client = await this.getClient();
+        await client.execute({
+            sql: `DELETE FROM store_entries WHERE namespace = ? AND key = ?`,
+            args: [serializeNamespace(namespace), key],
+        });
     }
     async listNamespaces() {
-        const rows = this.db.prepare(`SELECT DISTINCT namespace_json
+        const rows = await this.selectAll(`SELECT DISTINCT namespace_json
        FROM store_entries
-       ORDER BY namespace ASC`).all();
+       ORDER BY namespace ASC`);
         return rows.map((row) => JSON.parse(row.namespace_json));
     }
 }

package/dist/runtime/harness.js

@@ -38,6 +38,7 @@ import { consolidateStructuredMemoryScope } from "./harness/system/runtime-memor
 import { normalizeLangMemMemoryKind, readRuntimeMemoryMaintenanceConfig, readRuntimeMemoryPolicyConfig, resolveMemoryNamespace, scoreMemoryText, } from "./harness/system/runtime-memory-policy.js";
 import { resolveRuntimeAdapterOptions } from "./support/runtime-adapter-options.js";
 import { initializeHarnessRuntime, reclaimExpiredClaimedRuns as reclaimHarnessExpiredClaimedRuns, recoverStartupRuns as recoverHarnessStartupRuns, isStaleRunningRun as isHarnessStaleRunningRun, } from "./harness/run/startup-runtime.js";
+import { normalizeProcessExecutablePath } from "./support/runtime-env.js";
 import { streamHarnessRun } from "./harness/run/stream-run.js";
 import { defaultRequestedAgentId, prepareRunStart } from "./harness/run/start-run.js";
 import { buildRequestInspectionRecord, buildSessionInspectionRecord, deleteSessionRecord, deleteThreadRecord, getPublicApproval, listPublicApprovals, } from "./harness/run/thread-records.js";
@@ -180,6 +181,7 @@ export class AgentHarnessRuntime {
     constructor(workspace, runtimeAdapterOptions = {}) {
         this.workspace = workspace;
         this.runtimeAdapterOptions = runtimeAdapterOptions;
+        normalizeProcessExecutablePath();
         this.runtimeEntryBindings = inferRoutingBindings(this.workspace).runtimeEntryBindings;
         this.defaultRuntimeEntryBinding = this.runtimeEntryBindings[0];
         this.defaultRunRootValue = this.defaultRuntimeEntryBinding?.harnessRuntime.runRoot ?? `${this.workspace.workspaceRoot}/run-data`;
@@ -616,8 +618,7 @@ export class AgentHarnessRuntime {
                 currentAgentId: request.currentAgentId,
                 delegationChain: request.delegationChain,
                 runtimeSnapshot: request.runtimeSnapshot,
-                upstreamEvents: request.upstreamEvents,
-                history: request.history,
+                traceItems: request.traceItems,
                 runtimeTimeline: request.runtimeTimeline,
             }
             : null;
@@ -685,8 +686,7 @@ export class AgentHarnessRuntime {
                     currentAgentId: request.currentAgentId,
                     delegationChain: request.delegationChain,
                     runtimeSnapshot: request.runtimeSnapshot,
-                    upstreamEvents: request.upstreamEvents,
-                    history: request.history,
+                    traceItems: request.traceItems,
                     runtimeTimeline: request.runtimeTimeline,
                 })),
                 pendingDecision: session.pendingDecision,
@@ -1660,6 +1660,7 @@ export class AgentHarnessRuntime {
             isNewThread,
             runCreatedEventPromise,
             releaseRunSlotPromise,
+            getBinding: (agentId) => getWorkspaceBinding(this.workspace, agentId),
             loadPriorHistory: (threadId, runId) => this.loadPriorHistory(threadId, runId),
             stream: (binding, message, threadId, priorHistory, streamOptions) => this.runtimeAdapter.stream(binding, message, threadId, priorHistory, streamOptions),
             invokeWithHistory: (binding, input, threadId, runId) => this.invokeWithHistory(binding, input, threadId, runId),
@@ -1669,6 +1670,7 @@ export class AgentHarnessRuntime {
             appendAssistantMessage: (threadId, runId, content) => appendLifecycleAssistantMessage(this.persistence, threadId, runId, content),
             clearRunRequest: (threadId, runId) => this.persistence.clearRunRequest(threadId, runId),
             updateRunInspection: (threadId, runId, patch) => this.persistence.updateRunInspection(threadId, runId, patch),
+            appendRunTraceItem: (threadId, runId, item) => this.persistence.appendRunTraceItem(threadId, runId, item),
             emitSyntheticFallback: (threadId, runId, selectedAgentId, error) => this.runtimeEventOperations.emitSyntheticFallback(threadId, runId, selectedAgentId, error),
         });
         for await (const item of stream) {
@@ -1835,9 +1837,7 @@ function toSessionRecord(record) {
 function toRequestRecord(record) {
     return {
         ...toRequestSummary(record),
-        upstreamEvents: record.upstreamEvents,
-        history: record.history,
-        runtimeSurface: record.runtimeSurface,
+        traceItems: record.traceItems,
         runtimeTimeline: record.runtimeTimeline,
     };
 }