@botbotgo/agent-harness 0.0.156 → 0.0.158

package/dist/runtime/agent-runtime-adapter.js

@@ -159,7 +159,7 @@ function shouldAttachMinimalDeepAgentBackend(binding) {
 export class AgentRuntimeAdapter {
     options;
     modelCache = new Map();
-    runnableCache = new WeakMap();
+    runnableCache = new Map();
     toolNameMappingCache = new WeakMap();
     constructor(options = {}) {
         this.options = options;
@@ -213,7 +213,12 @@ export class AgentRuntimeAdapter {
         }
     }
     invalidateBindingRuntimeCaches(binding) {
-        this.runnableCache.delete(binding);
+        const prefix = `${binding.agent.sourcePath}::`;
+        for (const key of Array.from(this.runnableCache.keys())) {
+            if (key.startsWith(prefix)) {
+                this.runnableCache.delete(key);
+            }
+        }
         this.modelCache.clear();
     }
     resolveTools(tools, binding) {
@@ -232,15 +237,19 @@ export class AgentRuntimeAdapter {
         this.toolNameMappingCache.set(binding, resolved);
         return resolved;
     }
-    resolveFilesystemBackend(binding) {
+    resolveFilesystemBackend(binding, options = {}) {
         const filesystemConfig = getBindingFilesystemConfig(binding);
+        const sessionStorage = typeof filesystemConfig?.sessionStorage === "object" && filesystemConfig.sessionStorage
+            ? filesystemConfig.sessionStorage
+            : undefined;
         const configuredRootDir = typeof filesystemConfig?.rootDir === "string" && filesystemConfig.rootDir.trim().length > 0
             ? filesystemConfig.rootDir
             : undefined;
         const workspaceRoot = binding.harnessRuntime.workspaceRoot;
-        const rootDir = configuredRootDir
+        const baseRootDir = configuredRootDir
             ? (path.isAbsolute(configuredRootDir) ? configuredRootDir : path.resolve(workspaceRoot ?? process.cwd(), configuredRootDir))
             : workspaceRoot ?? process.cwd();
+        const rootDir = this.resolveFilesystemRootDir(baseRootDir, binding, sessionStorage, options.threadId);
         return new FilesystemBackend({
             rootDir,
             virtualMode: filesystemConfig?.virtualMode === true,
@@ -249,6 +258,25 @@ export class AgentRuntimeAdapter {
                 : 10,
         });
     }
+    resolveFilesystemRootDir(baseRootDir, binding, sessionStorage, threadId) {
+        const enabled = sessionStorage?.enabled === true;
+        if (!enabled || !threadId) {
+            return baseRootDir;
+        }
+        const workspaceRoot = binding.harnessRuntime.workspaceRoot ?? process.cwd();
+        const runRoot = binding.harnessRuntime.runRoot;
+        const configuredRootDir = typeof sessionStorage.rootDir === "string" && sessionStorage.rootDir.trim().length > 0
+            ? sessionStorage.rootDir.trim()
+            : "{runRoot}/threads/{threadId}/filesystem";
+        const rendered = configuredRootDir
+            .replaceAll("{threadId}", threadId)
+            .replaceAll("{sessionId}", threadId)
+            .replaceAll("{agentId}", binding.agent.id)
+            .replaceAll("{runRoot}", runRoot)
+            .replaceAll("{workspaceRoot}", workspaceRoot)
+            .replaceAll("{baseRootDir}", baseRootDir);
+        return path.isAbsolute(rendered) ? rendered : path.resolve(workspaceRoot, rendered);
+    }
     resolveBuiltinMiddlewareBackend(binding, options = {}) {
         return resolveBuiltinMiddlewareBackendHelper({
             binding,
@@ -257,7 +285,7 @@ export class AgentRuntimeAdapter {
             options,
         });
     }
-    createDeclaredMiddlewareResolverOptions(binding) {
+    createDeclaredMiddlewareResolverOptions(binding, options = {}) {
         return {
             resolveModel: (model) => this.resolveModel(model),
             resolveBackend: (resolvedBinding) => {
@@ -266,7 +294,7 @@ export class AgentRuntimeAdapter {
             },
             resolveFilesystemBackend: (resolvedBinding) => {
                 const targetBinding = resolvedBinding ?? binding;
-                return targetBinding ? this.resolveFilesystemBackend(targetBinding) : undefined;
+                return targetBinding ? this.resolveFilesystemBackend(targetBinding, { threadId: options.threadId }) : undefined;
             },
             resolveCustom: this.options.declaredMiddlewareResolver,
             binding,
@@ -276,8 +304,8 @@ export class AgentRuntimeAdapter {
         return {
             resolveModel: (model) => this.resolveModel(model),
             resolveTools: (tools, currentBinding) => this.resolveTools(tools, currentBinding),
-            resolveFilesystemBackend: (currentBinding) => this.resolveFilesystemBackend(currentBinding),
-            createDeclaredMiddlewareResolverOptions: (currentBinding) => this.createDeclaredMiddlewareResolverOptions(currentBinding),
+            resolveFilesystemBackend: (currentBinding) => this.resolveFilesystemBackend(currentBinding, { threadId: options.threadId }),
+            createDeclaredMiddlewareResolverOptions: (currentBinding) => this.createDeclaredMiddlewareResolverOptions(currentBinding, options),
             resolveBuiltinMiddlewareBackend: (currentBinding, currentOptions = {}) => this.resolveBuiltinMiddlewareBackend(currentBinding, currentOptions),
             resolveSubagents: (subagents, currentBinding) => this.resolveSubagents(subagents, currentBinding),
             invokeBuiltinTaskTool: (currentBinding, toolInput, currentOptions = {}) => this.invokeBuiltinTaskTool(currentBinding, toolInput, currentOptions),
@@ -313,8 +341,8 @@ export class AgentRuntimeAdapter {
             createDeclaredMiddlewareResolverOptions: assembly.createDeclaredMiddlewareResolverOptions,
         });
     }
-    async resolveLangChainRuntimeExtensionMiddleware(binding) {
-        const assembly = this.createAssemblyResolvers(binding);
+    async resolveLangChainRuntimeExtensionMiddleware(binding, options = {}) {
+        const assembly = this.createAssemblyResolvers(binding, options);
         return resolveLangChainRuntimeExtensionMiddlewareHelper({
             binding,
             materializeAutomaticSummarizationMiddleware: (currentBinding) => this.materializeAutomaticSummarizationMiddleware(currentBinding),
@@ -324,14 +352,14 @@ export class AgentRuntimeAdapter {
             resolveSubagents: assembly.resolveSubagents,
         });
     }
-    async resolveMiddleware(binding, interruptOn) {
-        const assembly = this.createAssemblyResolvers(binding);
+    async resolveMiddleware(binding, interruptOn, options = {}) {
+        const assembly = this.createAssemblyResolvers(binding, options);
         return resolveMiddlewareHelper({
             binding,
             interruptOn,
             runtimeAdapterOptions: this.options,
             createDeclaredMiddlewareResolverOptions: assembly.createDeclaredMiddlewareResolverOptions,
-            resolveLangChainRuntimeExtensionMiddleware: (currentBinding) => this.resolveLangChainRuntimeExtensionMiddleware(currentBinding),
+            resolveLangChainRuntimeExtensionMiddleware: (currentBinding) => this.resolveLangChainRuntimeExtensionMiddleware(currentBinding, options),
         });
     }
     async resolveSubagents(subagents, binding) {
@@ -354,7 +382,7 @@ export class AgentRuntimeAdapter {
         const interruptOn = resolveRunnableInterruptOn(binding);
         const resolvedModel = await this.resolveModel(primaryModel);
         const resolvedTools = this.resolveTools(primaryTools, binding);
-        const resolvedMiddleware = await this.resolveMiddleware(binding, interruptOn);
+        const resolvedMiddleware = await this.resolveMiddleware(binding, interruptOn, { threadId: options.threadId });
         const resolvedCheckpointer = resolveRunnableCheckpointer(this.options, binding);
         const resolvedStore = this.options.storeResolver?.(binding);
         const model = resolvedModel;
@@ -372,12 +400,12 @@ export class AgentRuntimeAdapter {
             systemPromptOverride: options.systemPromptOverride,
         }));
     }
-    async createRunnable(binding) {
+    async createRunnable(binding, options = {}) {
         if (getBindingAdapterKind(binding) === "langgraph") {
             throw new Error(`Agent ${binding.agent.id} uses removed backend langgraph; use langchain-v1 or deepagent`);
         }
         if (isLangChainBinding(binding)) {
-            return this.createLangChainRunnable(binding);
+            return this.createLangChainRunnable(binding, { threadId: options.threadId });
         }
         return this.createDeepAgentRunnable(binding);
     }
@@ -425,25 +453,34 @@ export class AgentRuntimeAdapter {
         });
         return createDeepAgent(deepAgentConfig);
     }
-    async create(binding) {
-        const cached = this.runnableCache.get(binding);
+    buildRunnableCacheKey(binding, threadId) {
+        const filesystemConfig = getBindingFilesystemConfig(binding);
+        const sessionStorage = typeof filesystemConfig?.sessionStorage === "object" && filesystemConfig.sessionStorage
+            ? filesystemConfig.sessionStorage
+            : undefined;
+        const sessionScoped = sessionStorage?.enabled === true;
+        return `${binding.agent.sourcePath}::${sessionScoped ? (threadId ?? "__default__") : "__binding__"}`;
+    }
+    async create(binding, options = {}) {
+        const cacheKey = this.buildRunnableCacheKey(binding, options.threadId);
+        const cached = this.runnableCache.get(cacheKey);
         if (cached) {
             return cached;
         }
-        const pending = this.createRunnable(binding);
-        this.runnableCache.set(binding, pending);
+        const pending = this.createRunnable(binding, options);
+        this.runnableCache.set(cacheKey, pending);
         try {
             return await pending;
         }
         catch (error) {
-            this.runnableCache.delete(binding);
+            this.runnableCache.delete(cacheKey);
             throw error;
         }
     }
     async invoke(binding, input, threadId, runId, resumePayload, history = [], options = {}) {
         const callRuntime = async (activeBinding, activeRequest) => {
             return this.invokeWithProviderRetry(activeBinding, async () => {
-                const runnable = await this.create(activeBinding);
+                const runnable = await this.create(activeBinding, { threadId });
                 return (await this.withTimeout(() => runnable.invoke(activeRequest, resolveLangChainInvocationConfig(activeBinding, {
                     threadId,
                     runId,
@@ -469,7 +506,7 @@ export class AgentRuntimeAdapter {
             invokeOptions: options,
             resolveTools: (tools, currentBinding) => this.resolveTools(tools, currentBinding),
             getToolNameMapping: (currentBinding) => this.getToolNameMapping(currentBinding),
-            resolveBuiltinMiddlewareTools: (currentBinding, currentOptions) => this.resolveBuiltinMiddlewareTools(currentBinding, currentOptions),
+            resolveBuiltinMiddlewareTools: (currentBinding, currentOptions) => this.resolveBuiltinMiddlewareTools(currentBinding, { ...currentOptions, threadId }),
             callRuntimeWithToolParseRecovery,
         });
     }
@@ -494,7 +531,7 @@ export class AgentRuntimeAdapter {
             forceInvokeFallback,
             canUseDirectModelStream,
             langChainStreamModel,
-            createRunnable: () => this.create(binding),
+            createRunnable: () => this.create(binding, { threadId }),
             withTimeout: (producer, timeoutMs, operation, stage) => this.withTimeout(producer, timeoutMs, operation, stage),
             iterateWithTimeout: (iterable, timeoutMs, operation, deadlineAt, deadlineTimeoutMs) => this.iterateWithTimeout(iterable, timeoutMs, operation, deadlineAt, deadlineTimeoutMs),
             invokeTimeoutMs: computeRemainingTimeoutMs(streamDeadlineAt, invokeTimeoutMs),

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

@@ -42,6 +42,12 @@ export async function dispatchRunListeners(stream, listeners, options) {
         }
         if (item.type === "upstream-event") {
             await options.notifyListener(listeners.onUpstreamEvent, item.event);
+            await options.notifyListener(listeners.onUpstreamItem, {
+                threadId: item.threadId,
+                runId: item.runId,
+                agentId: item.agentId,
+                event: item.event,
+            });
             continue;
         }
         if (item.type === "result") {

package/dist/runtime/harness/run/governance.d.ts

@@ -0,0 +1,2 @@
+import type { CompiledAgentBinding, RuntimeGovernanceBundle } from "../../../contracts/types.js";
+export declare function buildRuntimeGovernanceBundles(binding: CompiledAgentBinding): RuntimeGovernanceBundle[];

package/dist/runtime/harness/run/governance.js

@@ -0,0 +1,76 @@
+import { getBindingPrimaryTools } from "../../support/compiled-binding.js";
+import { toolRequiresRuntimeApproval } from "../../adapter/tool/tool-hitl.js";
+const WRITE_LIKE_PATTERN = /\b(write|edit|delete|create|update|append|insert|push|commit|publish|send|post|apply|merge|sync|upload|save)\b/i;
+function inputHints(binding, tool) {
+    const hints = new Set();
+    const target = `${tool.name} ${tool.description}`.toLowerCase();
+    if (/(path|file|dir|directory|folder|workspace|repo|repository)/.test(target)) {
+        hints.add("filesystem-scope");
+    }
+    if (/(memory|knowledge|store|recall)/.test(target)) {
+        hints.add("memory-scope");
+    }
+    if (tool.config?.mcp) {
+        hints.add("remote-mcp");
+    }
+    if (binding.agent.executionMode === "deepagent") {
+        hints.add("delegated-runtime");
+    }
+    return Array.from(hints);
+}
+function classifyRisk(policy) {
+    if (policy.requiresApproval) {
+        return "high";
+    }
+    const target = `${policy.toolName} ${policy.description}`;
+    if (policy.toolType === "mcp" && WRITE_LIKE_PATTERN.test(target)) {
+        return "high";
+    }
+    if (policy.toolType === "backend" || policy.toolType === "mcp") {
+        return "medium";
+    }
+    return "low";
+}
+function toCategory(toolType) {
+    if (toolType === "mcp") {
+        return "mcp";
+    }
+    if (toolType === "backend") {
+        return "backend";
+    }
+    if (toolType === "provider") {
+        return "provider-native";
+    }
+    return "local";
+}
+export function buildRuntimeGovernanceBundles(binding) {
+    const toolPolicies = getBindingPrimaryTools(binding).map((tool) => {
+        const requiresApproval = toolRequiresRuntimeApproval(tool);
+        return {
+            toolName: tool.name,
+            toolId: tool.id,
+            toolType: tool.type,
+            category: toCategory(tool.type),
+            risk: classifyRisk({
+                toolType: tool.type,
+                requiresApproval,
+                toolName: tool.name,
+                description: tool.description,
+                config: tool.config,
+            }),
+            requiresApproval,
+            approvalPolicy: tool.hitl?.enabled === true ? "explicit-hitl" : requiresApproval ? "runtime-default" : "none",
+            hasInputSchema: typeof tool.inputSchemaRef === "string" && tool.inputSchemaRef.trim().length > 0,
+            inputRiskHints: inputHints(binding, tool),
+        };
+    });
+    if (toolPolicies.length === 0) {
+        return [];
+    }
+    return [{
+            bundleId: `governance/${binding.agent.id}`,
+            title: "Runtime tool governance",
+            summary: `${toolPolicies.filter((tool) => tool.requiresApproval).length} of ${toolPolicies.length} tool(s) require approval`,
+            toolPolicies,
+        }];
+}

package/dist/runtime/harness/run/inspection.js

@@ -1,5 +1,6 @@
 import { readSkillMetadata } from "../../support/skill-metadata.js";
 import { getBindingMemorySources, getBindingPrimaryModel, getBindingPrimaryTools, getBindingSkills, getBindingSubagents, } from "../../support/compiled-binding.js";
+import { buildRuntimeGovernanceBundles } from "./governance.js";
 function asObject(value) {
     return typeof value === "object" && value !== null ? value : null;
 }
@@ -67,6 +68,9 @@ export function buildRunRuntimeSnapshot(binding, options) {
             };
         }),
         memory: getBindingMemorySources(binding),
+        governance: {
+            bundles: buildRuntimeGovernanceBundles(binding),
+        },
         ...(tracing ? { tracing } : {}),
     };
 }

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

@@ -85,7 +85,7 @@ export async function* streamHarnessRun(options) {
                     type: "upstream-event",
                     threadId: options.threadId,
                     runId: options.runId,
-                    agentId: options.selectedAgentId,
+                    agentId: currentAgentId,
                     event: normalizedChunk.event,
                 };
                 continue;

package/dist/runtime/harness/system/policy-engine.d.ts

@@ -1,7 +1,8 @@
-import type { CompiledAgentBinding } from "../../../contracts/types.js";
+import type { CompiledAgentBinding, RuntimeGovernanceBundle } from "../../../contracts/types.js";
 export type PolicyEngineDecision = {
     allowed: boolean;
     reasons: string[];
+    bundles?: RuntimeGovernanceBundle[];
 };
 export declare class PolicyEngine {
     /**

package/dist/runtime/harness/system/policy-engine.js

@@ -7,6 +7,7 @@ export class PolicyEngine {
      */
     evaluate(binding) {
         const reasons = [];
+        const bundles = [];
         let allowed = true;
         for (const evaluator of getPolicyEvaluators()) {
             const decision = evaluator.evaluate(binding);
@@ -17,8 +18,11 @@ export class PolicyEngine {
                 allowed = false;
             }
             reasons.push(...decision.reasons);
+            if (Array.isArray(decision.bundles)) {
+                bundles.push(...decision.bundles);
+            }
         }
-        return { allowed, reasons };
+        return bundles.length > 0 ? { allowed, reasons, bundles } : { allowed, reasons };
     }
 }
 export { PolicyEngine as GovernanceEngine, };

package/dist/runtime/harness.d.ts

@@ -1,4 +1,4 @@
-import type { ApprovalRecord, CancelOptions, HarnessEvent, HarnessStreamItem, RuntimeHealthSnapshot, ListMemoriesInput, ListMemoriesResult, MessageContent, RemoveMemoryInput, RunRecord, RunStartOptions, RestartConversationOptions, RuntimeAdapterOptions, ResumeOptions, RunOptions, RunResult, RunSummary, MemoryRecord, MemorizeInput, MemorizeResult, RecallInput, RecallResult, UpdateMemoryInput, ThreadSummary, ThreadRecord, WorkspaceBundle } from "../contracts/types.js";
+import type { ApprovalRecord, ArtifactListing, CancelOptions, HarnessEvent, HarnessStreamItem, RuntimeHealthSnapshot, ListMemoriesInput, ListMemoriesResult, MessageContent, RemoveMemoryInput, RunRecord, RunStartOptions, RestartConversationOptions, RuntimeAdapterOptions, RuntimeEvaluationExport, RuntimeEvaluationExportInput, ResumeOptions, RunOptions, RunResult, RunSummary, MemoryRecord, MemorizeInput, MemorizeResult, RecallInput, RecallResult, UpdateMemoryInput, ThreadSummary, ThreadRecord, WorkspaceBundle } from "../contracts/types.js";
 import { type ToolMcpServerOptions } from "../mcp.js";
 import { type InventoryAgentRecord, type InventorySkillRecord } from "./harness/system/inventory.js";
 import type { RequirementAssessmentOptions } from "./harness/system/skill-requirements.js";
@@ -82,6 +82,10 @@ export declare class AgentHarnessRuntime {
         runId?: string;
     }): Promise<ApprovalRecord[]>;
     getApproval(approvalId: string): Promise<ApprovalRecord | null>;
+    listArtifacts(threadId: string, runId: string): Promise<ArtifactListing>;
+    readArtifact(threadId: string, runId: string, artifactPath: string): Promise<unknown>;
+    listRunEvents(threadId: string, runId: string): Promise<HarnessEvent[]>;
+    exportEvaluationBundle(input: RuntimeEvaluationExportInput): Promise<RuntimeEvaluationExport>;
     listAgentSkills(agentId: string, options?: RequirementAssessmentOptions): InventorySkillRecord[];
     getAgent(agentId: string, options?: RequirementAssessmentOptions): InventoryAgentRecord | null;
     describeWorkspaceInventory(options?: RequirementAssessmentOptions): {

package/dist/runtime/harness.js

@@ -475,6 +475,51 @@ export class AgentHarnessRuntime {
             persistence: this.persistence,
         }, approvalId);
     }
+    async listArtifacts(threadId, runId) {
+        return this.persistence.listArtifacts(threadId, runId);
+    }
+    async readArtifact(threadId, runId, artifactPath) {
+        return this.persistence.readArtifact(threadId, runId, artifactPath);
+    }
+    async listRunEvents(threadId, runId) {
+        return this.persistence.listRunEvents(threadId, runId);
+    }
+    async exportEvaluationBundle(input) {
+        const thread = await this.getThread(input.sessionId);
+        const run = await this.getRun(input.requestId);
+        const approvals = await this.listApprovals({ threadId: input.sessionId, runId: input.requestId });
+        const transcript = await this.persistence.listThreadMessages(input.sessionId, 500);
+        const events = await this.persistence.listRunEvents(input.sessionId, input.requestId);
+        const runtimeHealth = await this.getHealth();
+        const artifactsListing = input.includeArtifacts === false
+            ? { items: [] }
+            : await this.persistence.listArtifacts(input.sessionId, input.requestId);
+        const artifacts = await Promise.all(artifactsListing.items.map(async (artifact) => ({
+            ...artifact,
+            ...(input.includeArtifactContents === true
+                ? { content: await this.persistence.readArtifact(input.sessionId, input.requestId, artifact.path) }
+                : {}),
+        })));
+        return {
+            session: thread ? toSessionRecord(thread) : null,
+            request: run ? toRequestRecord(run) : null,
+            approvals,
+            transcript,
+            events,
+            artifacts,
+            runtimeHealth,
+            ...(typeof input.expectedOutput === "string" && input.expectedOutput.trim().length > 0
+                ? { expectedOutput: input.expectedOutput.trim() }
+                : {}),
+            rubric: Array.isArray(input.rubric)
+                ? input.rubric.filter((item) => typeof item === "string" && item.trim().length > 0).map((item) => item.trim())
+                : [],
+            tags: Array.isArray(input.tags)
+                ? input.tags.filter((item) => typeof item === "string" && item.trim().length > 0).map((item) => item.trim())
+                : [],
+            ...(input.metadata ? { metadata: { ...input.metadata } } : {}),
+        };
+    }
     listAgentSkills(agentId, options = {}) {
         return listWorkspaceAgentSkills(this.workspace, agentId, {
             assessRequirements: isInventoryEnabled(this.workspace),
@@ -1393,3 +1438,40 @@ export class AgentHarnessRuntime {
         }, thread, nowMs);
     }
 }
+function toRequestSummary(summary) {
+    return {
+        requestId: summary.runId,
+        sessionId: summary.threadId,
+        agentId: summary.agentId,
+        executionMode: summary.executionMode,
+        adapterKind: summary.adapterKind,
+        createdAt: summary.createdAt,
+        updatedAt: summary.updatedAt,
+        state: summary.state,
+        checkpointRef: summary.checkpointRef,
+        resumable: summary.resumable,
+        startedAt: summary.startedAt,
+        endedAt: summary.endedAt,
+        lastActivityAt: summary.lastActivityAt,
+        currentAgentId: summary.currentAgentId,
+        delegationChain: summary.delegationChain,
+        runtimeSnapshot: summary.runtimeSnapshot,
+    };
+}
+function toSessionRecord(record) {
+    return {
+        sessionId: record.threadId,
+        entryAgentId: record.entryAgentId,
+        currentAgentId: record.currentAgentId,
+        currentState: record.currentState,
+        latestRequestId: record.latestRunId,
+        createdAt: record.createdAt,
+        updatedAt: record.updatedAt,
+        messages: record.messages,
+        requests: record.runs.map(toRequestSummary),
+        pendingDecision: record.pendingDecision,
+    };
+}
+function toRequestRecord(record) {
+    return toRequestSummary(record);
+}

package/dist/workspace/agent-binding-compiler.js

@@ -337,6 +337,12 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
     const store = resolveStoreConfig(agent, refs);
     const checkpointer = resolveCheckpointerConfig(agent, refs);
     const runtimeMemory = resolveRuntimeMemoryConfig(agent, refs);
+    const runtimeFilesystemDefaults = agent.executionMode === "langchain-v1"
+        ? asObject(runtimeDefaults?.filesystem)
+        : undefined;
+    const compiledFilesystemConfig = agent.executionMode === "langchain-v1"
+        ? mergeConfigObjects(runtimeFilesystemDefaults, getAgentExecutionObject(agent, "filesystem", { executionMode: "langchain-v1" }))
+        : undefined;
     const runRoot = typeof agent.runRoot === "string" && agent.runRoot.trim().length > 0
         ? path.resolve(workspaceRoot, agent.runRoot)
         : typeof runtimeDefaults?.runRoot === "string" && runtimeDefaults.runRoot.trim().length > 0
@@ -362,7 +368,7 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
                     langchain: {
                         passthrough,
                         interruptOn: resolveInterruptOn(agent),
-                        filesystem: getAgentExecutionObject(agent, "filesystem", { executionMode: "langchain-v1" }),
+                        filesystem: compiledFilesystemConfig,
                         subagents: compileSubagents(agent, agents, workspaceRoot, models, tools, compiledAgentSkills, compiledAgentModel),
                         memory: compiledAgentMemory,
                         skills: compiledAgentSkills,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.156",
+  "version": "0.0.158",
   "description": "Workspace runtime for multi-agent applications",
   "type": "module",
   "packageManager": "npm@10.9.2",
@@ -28,6 +28,11 @@
       "import": "./dist/index.js",
       "default": "./dist/index.js"
     },
+    "./acp": {
+      "types": "./dist/acp.d.ts",
+      "import": "./dist/acp.js",
+      "default": "./dist/acp.js"
+    },
     "./tools": {
       "types": "./dist/tools.d.ts",
       "import": "./dist/tools.js",
@@ -54,7 +59,7 @@
     "mem0ai": "^2.4.4",
     "mustache": "^4.2.0",
     "yaml": "^2.8.1",
-    "zod": "^3.25.67"
+    "zod": "^4.3.6"
   },
   "scripts": {
     "build": "rm -rf dist tsconfig.tsbuildinfo && tsc -p tsconfig.json && cp -R config dist/",
@@ -70,5 +75,9 @@
     "@types/node": "^24.6.0",
     "typescript": "^5.9.3",
     "vitest": "^3.2.4"
+  },
+  "overrides": {
+    "@browserbasehq/stagehand": "3.2.0",
+    "openai": "6.33.0"
   }
 }