@botbotgo/agent-harness 0.0.258 → 0.0.260

package/dist/api.js

@@ -6,6 +6,7 @@ import { serveAcpOverHttp } from "./protocol/acp/http.js";
 import { serveAcpOverStdio } from "./protocol/acp/stdio.js";
 import { normalizeMessageContent } from "./utils/message-content.js";
 import { loadWorkspace } from "./workspace/compile.js";
+import { traceStartupStage } from "./runtime/startup-tracing.js";
 export { AgentHarnessAcpServer, createAcpServer } from "./acp.js";
 export { createAcpStdioClient } from "./protocol/acp/client.js";
 export { AgentHarnessRuntime } from "./runtime/harness.js";
@@ -173,9 +174,15 @@ function toPublicRequestSummary(run) {
     };
 }
 export async function createAgentHarness(workspaceRoot = process.cwd(), options = {}) {
-    const workspace = await loadWorkspace(workspaceRoot, options.load ?? {});
-    const harness = new AgentHarnessRuntime(workspace, options.adapter ?? {});
-    await harness.initialize();
+    const workspace = await traceStartupStage("createAgentHarness.loadWorkspace", () => loadWorkspace(workspaceRoot, options.load ?? {}), {
+        workspaceRoot,
+    });
+    const harness = await traceStartupStage("createAgentHarness.constructRuntime", async () => new AgentHarnessRuntime(workspace, options.adapter ?? {}), {
+        workspaceRoot,
+    });
+    await traceStartupStage("createAgentHarness.initializeRuntime", () => harness.initialize(), {
+        workspaceRoot,
+    });
     return harness;
 }
 export function normalizeUserChatInput(input, options = {}) {

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.257";
+export declare const AGENT_HARNESS_VERSION = "0.0.259";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.257";
+export const AGENT_HARNESS_VERSION = "0.0.259";

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

@@ -1,7 +1,10 @@
 import { recoverQueuedStartupRun, recoverResumingStartupRun, recoverRunningStartupRun, } from "./recovery.js";
+import { traceStartupStage } from "../../startup-tracing.js";
 export async function initializeHarnessRuntime(input) {
-    await input.persistence.initialize();
-    await input.healthMonitor?.start();
+    await traceStartupStage("runtime.initialize.persistence", () => input.persistence.initialize());
+    if (input.healthMonitor) {
+        await traceStartupStage("runtime.initialize.healthMonitor", () => input.healthMonitor.start());
+    }
 }
 export async function recoverStartupRuns(input) {
     if (!input.recoveryConfig.enabled) {

package/dist/runtime/harness/system/health-monitor.js

@@ -24,6 +24,14 @@ const DEFAULT_HEALTH_CONFIG = {
         },
     },
 };
+const ACTIVE_RUN_STATES = [
+    "queued",
+    "claimed",
+    "running",
+    "waiting_for_approval",
+    "resuming",
+    "cancelling",
+];
 function asObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
 }
@@ -146,10 +154,10 @@ export class HealthMonitor {
     async evaluate(nowMs = Date.now()) {
         const updatedAt = new Date(nowMs).toISOString();
         const [runs, approvals] = await Promise.all([
-            this.options.persistence.listRuns(),
-            this.options.persistence.listApprovals(),
+            Promise.all(ACTIVE_RUN_STATES.map((state) => this.options.persistence.listRuns({ state }))).then((groups) => groups.flat()),
+            this.options.persistence.listApprovals({ status: "pending" }),
         ]);
-        const pendingApprovals = approvals.filter((approval) => approval.status === "pending").length;
+        const pendingApprovals = approvals.length;
         const stuckRuns = this.countStuckRuns(runs, nowMs);
         const llmCheck = this.evaluateLlmCheck(updatedAt, nowMs);
         const workloadCheck = this.evaluateWorkloadCheck(updatedAt, pendingApprovals, stuckRuns);

package/dist/runtime/harness.js

@@ -38,10 +38,19 @@ 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 { traceStartupStage } from "./startup-tracing.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";
+const ACTIVE_RUN_STATES = [
+    "queued",
+    "claimed",
+    "running",
+    "waiting_for_approval",
+    "resuming",
+    "cancelling",
+];
 function normalizeSessionListText(content, limit) {
     if (!content) {
         return undefined;
@@ -324,7 +333,7 @@ export class AgentHarnessRuntime {
             persistence: this.persistence,
             healthMonitor: this.healthMonitor,
         });
-        await this.recoverStartupRuns();
+        await traceStartupStage("runtime.initialize.startupRecovery", () => this.recoverStartupRuns());
         this.initialized = true;
     }
     subscribe(listener) {
@@ -339,8 +348,8 @@ export class AgentHarnessRuntime {
     async getOperatorOverview(options) {
         const [health, runs, approvals] = await Promise.all([
             this.getHealth(),
-            this.listRuns(),
-            this.listApprovals(),
+            Promise.all(ACTIVE_RUN_STATES.map((state) => this.listRuns({ state }))).then((groups) => groups.flat()),
+            this.listApprovals({ status: "pending" }),
         ]);
         return projectOperatorOverview({
             health,

package/dist/runtime/startup-tracing.d.ts

@@ -0,0 +1 @@
+export declare function traceStartupStage<T>(stage: string, operation: () => Promise<T>, detail?: Record<string, unknown>): Promise<T>;

package/dist/runtime/startup-tracing.js

@@ -0,0 +1,37 @@
+function startupTimingEnabled() {
+    return process.env.AGENT_HARNESS_STARTUP_TIMING === "1";
+}
+function formatDurationMs(startedAt) {
+    return (Date.now() - startedAt).toString();
+}
+function writeStartupTrace(stage, phase, durationMs, detail) {
+    if (!startupTimingEnabled()) {
+        return;
+    }
+    const fields = [
+        "[agent-harness.startup]",
+        `stage=${stage}`,
+        `phase=${phase}`,
+        ...(durationMs ? [`durationMs=${durationMs}`] : []),
+        ...Object.entries(detail ?? {})
+            .filter(([, value]) => value !== undefined && value !== null && `${value}`.length > 0)
+            .map(([key, value]) => `${key}=${JSON.stringify(value)}`),
+    ];
+    process.stderr.write(`${fields.join(" ")}\n`);
+}
+export async function traceStartupStage(stage, operation, detail) {
+    const startedAt = Date.now();
+    writeStartupTrace(stage, "start", undefined, detail);
+    try {
+        const result = await operation();
+        writeStartupTrace(stage, "success", formatDurationMs(startedAt), detail);
+        return result;
+    }
+    catch (error) {
+        writeStartupTrace(stage, "failure", formatDurationMs(startedAt), {
+            ...detail,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        throw error;
+    }
+}

package/dist/workspace/compile.js

@@ -12,6 +12,7 @@ import { discoverSubagents, ensureDiscoverySources } from "./support/discovery.j
 import { collectAgentDiscoverySourceRefs, collectToolSourceRefs } from "./support/source-collectors.js";
 import { getRoutingDefaultAgentId, getRuntimeResources, getRoutingRules, resolveRefId, } from "./support/workspace-ref-utils.js";
 import { hydrateAgentMcpTools, hydrateResourceAndExternalTools } from "./tool-hydration.js";
+import { traceStartupStage } from "../runtime/startup-tracing.js";
 function collectParsedResources(refs) {
     const embeddings = new Map();
     const mcpServers = new Map();
@@ -204,22 +205,38 @@ function resolveAgentSkillNames(agents, skillRegistry, skillCollectionRoots) {
     }
 }
 export async function loadWorkspace(workspaceRoot, options = {}) {
-    const loaded = await loadWorkspaceObjects(workspaceRoot, options);
-    loaded.agents = await discoverSubagents(loaded.agents, workspaceRoot);
+    const loaded = await traceStartupStage("workspace.load.objects", () => loadWorkspaceObjects(workspaceRoot, options), {
+        workspaceRoot,
+    });
+    loaded.agents = await traceStartupStage("workspace.discover.subagents", () => discoverSubagents(loaded.agents, workspaceRoot), {
+        workspaceRoot,
+    });
     const discoverySourceRefs = collectAgentDiscoverySourceRefs(loaded.agents);
-    await ensureDiscoverySources(discoverySourceRefs, workspaceRoot);
+    await traceStartupStage("workspace.ensure.discoverySources", () => ensureDiscoverySources(discoverySourceRefs, workspaceRoot), {
+        workspaceRoot,
+        sourceCount: discoverySourceRefs.length,
+    });
     for (const agent of loaded.agents) {
         loaded.refs.set(`agent/${agent.id}`, agent);
     }
     const { embeddings, mcpServers, models, vectorStores, tools } = collectParsedResources(loaded.refs);
-    await hydrateAgentMcpTools(loaded.agents, mcpServers, tools);
+    await traceStartupStage("workspace.hydrate.agentMcpTools", () => hydrateAgentMcpTools(loaded.agents, mcpServers, tools), {
+        workspaceRoot,
+        agentCount: loaded.agents.length,
+    });
     const configuredResources = Array.from(new Set([
         ...getRuntimeResources(loaded.refs),
         ...(options.resources ?? []),
     ]));
-    const resolvedConfiguredResources = await resolveConfiguredResources(configuredResources, workspaceRoot);
+    const resolvedConfiguredResources = await traceStartupStage("workspace.resolve.configuredResources", () => resolveConfiguredResources(configuredResources, workspaceRoot), {
+        workspaceRoot,
+        configuredResourceCount: configuredResources.length,
+    });
     for (const resource of resolvedConfiguredResources) {
-        await registerAttachedResourceTools(tools, resource.root);
+        await traceStartupStage("workspace.register.attachedResourceTools", () => registerAttachedResourceTools(tools, resource.root), {
+            workspaceRoot,
+            resourceRoot: resource.root,
+        });
     }
     const localResourceRoot = resolveResourcePackageRoot(workspaceRoot);
     const skillCollectionRoots = [
@@ -227,15 +244,24 @@ export async function loadWorkspace(workspaceRoot, options = {}) {
         ...(localResourceRoot ? [path.join(localResourceRoot, "skills")] : []),
         ...resolvedConfiguredResources.map((resource) => path.join(resource.root, "skills")),
     ];
-    const skillRegistry = await registerWorkspaceSkillRegistry(skillCollectionRoots);
+    const skillRegistry = await traceStartupStage("workspace.register.skillRegistry", () => registerWorkspaceSkillRegistry(skillCollectionRoots), {
+        workspaceRoot,
+        skillCollectionRootCount: skillCollectionRoots.length,
+    });
     resolveAgentSkillNames(loaded.agents, skillRegistry, skillCollectionRoots);
     const collectedResources = collectToolSourceRefs(tools, loaded.agents, {
         ...options,
         resources: configuredResources,
     });
     const externalResources = collectedResources.filter((resource) => isExternalSourceLocator(resource));
-    await ensureResourceSources(externalResources, workspaceRoot);
-    await hydrateResourceAndExternalTools(tools, externalResources, workspaceRoot);
+    await traceStartupStage("workspace.ensure.externalResourceSources", () => ensureResourceSources(externalResources, workspaceRoot), {
+        workspaceRoot,
+        externalResourceCount: externalResources.length,
+    });
+    await traceStartupStage("workspace.hydrate.externalTools", () => hydrateResourceAndExternalTools(tools, externalResources, workspaceRoot), {
+        workspaceRoot,
+        externalResourceCount: externalResources.length,
+    });
     validateToolNameConflicts(tools);
     const resources = Array.from(new Set([
         ...(localResourceRoot ? [localResourceRoot] : []),

package/dist/workspace/tool-hydration.js

@@ -72,6 +72,9 @@ function shouldIncludeRemoteMcpTool(filter, toolName) {
     }
     return true;
 }
+function canResolveMcpToolsFromExplicitNamesOnly(filter) {
+    return filter.includeNames.size > 0 && filter.includePatterns.length === 0;
+}
 function normalizeAgentMcpServerUsage(item) {
     const config = asObject(item.config);
     if (!config) {
@@ -235,7 +238,11 @@ export async function hydrateAgentMcpTools(agents, mcpServers, tools) {
                 mcpServers.set(serverId, parsedServer);
             }
             const filter = compileMcpToolFilter(item);
-            const remoteTools = await listRemoteMcpTools(toMcpServerConfig(parsedServer));
+            const remoteTools = canResolveMcpToolsFromExplicitNamesOnly(filter)
+                ? Array.from(filter.includeNames)
+                    .filter((toolName) => shouldIncludeRemoteMcpTool(filter, toolName))
+                    .map((toolName) => ({ name: toolName }))
+                : await listRemoteMcpTools(toMcpServerConfig(parsedServer));
             for (const remoteTool of remoteTools) {
                 if (!shouldIncludeRemoteMcpTool(filter, remoteTool.name)) {
                     continue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.258",
+  "version": "0.0.260",
   "description": "Workspace runtime for multi-agent applications",
   "license": "MIT",
   "type": "module",