@botbotgo/agent-harness 0.0.298 → 0.0.299

package/dist/request-events.js

@@ -0,0 +1,400 @@
+function createEmptyPlanSummary() {
+    return {
+        total: 0,
+        pending: 0,
+        inProgress: 0,
+        completed: 0,
+        failed: 0,
+        cancelled: 0,
+        blocked: 0,
+    };
+}
+function resolveTodoKey(content, id, index) {
+    if (typeof id === "string" && id.length > 0) {
+        return id;
+    }
+    return `${index}:${content}`;
+}
+function resolveActiveTodoKey(items) {
+    const active = items.find((item) => item.status === "in_progress");
+    return active?.key;
+}
+function countStructuredTodoIds(items) {
+    return items.filter((item) => typeof item.id === "string" && item.id.length > 0).length;
+}
+function shouldReplacePlanItems(currentItems, nextItems) {
+    if (currentItems.length === 0) {
+        return true;
+    }
+    if (nextItems.length === 0) {
+        return false;
+    }
+    const currentStructuredIds = countStructuredTodoIds(currentItems);
+    const nextStructuredIds = countStructuredTodoIds(nextItems);
+    if (currentStructuredIds > 0
+        && nextStructuredIds === 0
+        && nextItems.length < currentItems.length) {
+        return false;
+    }
+    return true;
+}
+function cloneSteps(steps) {
+    return steps.map((step) => ({
+        ...step,
+        ...(step.detail ? { detail: { ...step.detail } } : {}),
+    }));
+}
+function buildPlanItems(snapshot, planItems) {
+    const previousSteps = new Map(snapshot.plan.items.map((item) => [item.key, cloneSteps(item.events)]));
+    return planItems.map((item, index) => {
+        const key = resolveTodoKey(item.content, item.id, index);
+        return {
+            ...item,
+            key,
+            events: previousSteps.get(key) ?? [],
+        };
+    });
+}
+function buildStepEventKey(input) {
+    return `${input.kind}:${input.id}`;
+}
+function applyPlanState(snapshot, planState) {
+    if (!shouldReplacePlanItems(snapshot.plan.items, planState.items)) {
+        return {
+            ...snapshot,
+            sessionId: planState.sessionId,
+            requestId: planState.requestId,
+            updatedAt: planState.updatedAt,
+        };
+    }
+    const items = buildPlanItems(snapshot, planState.items);
+    return {
+        ...snapshot,
+        sessionId: planState.sessionId,
+        requestId: planState.requestId,
+        updatedAt: planState.updatedAt,
+        plan: {
+            version: planState.version,
+            updatedAt: planState.updatedAt,
+            summary: planState.summary,
+            items,
+        },
+        activeTodoKey: resolveActiveTodoKey(items),
+    };
+}
+function appendStep(steps, nextStep, timestamp) {
+    return [
+        ...steps,
+        {
+            ...nextStep,
+            ...(timestamp ? { occurredAt: nextStep.occurredAt ?? timestamp } : {}),
+        },
+    ];
+}
+function applySurfaceItem(snapshot, surfaceItem, timestamp) {
+    const nextStep = {
+        id: surfaceItem.id,
+        kind: surfaceItem.kind,
+        name: surfaceItem.name,
+        action: surfaceItem.action,
+        status: surfaceItem.status,
+        ...(surfaceItem.agentId ? { agentId: surfaceItem.agentId } : {}),
+        ...(surfaceItem.agentName ? { agentName: surfaceItem.agentName } : {}),
+        ...(surfaceItem.ownerAgentId ? { ownerAgentId: surfaceItem.ownerAgentId } : {}),
+        ...(surfaceItem.ownerAgentName ? { ownerAgentName: surfaceItem.ownerAgentName } : {}),
+        ...(surfaceItem.sourceEventId ? { sourceEventId: surfaceItem.sourceEventId } : {}),
+        ...(surfaceItem.detail ? { detail: surfaceItem.detail } : {}),
+    };
+    const targetTodoKey = snapshot.activeTodoKey;
+    if (!targetTodoKey) {
+        const activeEventKey = buildStepEventKey(nextStep);
+        return {
+            ...snapshot,
+            updatedAt: timestamp,
+            events: appendStep(snapshot.events, nextStep, timestamp),
+            activeEventId: surfaceItem.status === "started" ? activeEventKey : snapshot.activeEventId,
+        };
+    }
+    const activeEventKey = buildStepEventKey(nextStep);
+    return {
+        ...snapshot,
+        updatedAt: timestamp,
+        plan: {
+            ...snapshot.plan,
+            items: snapshot.plan.items.map((item) => item.key === targetTodoKey
+                ? {
+                    ...item,
+                    events: appendStep(item.events, nextStep, timestamp),
+                }
+                : item),
+        },
+        activeEventId: surfaceItem.status === "started" ? activeEventKey : snapshot.activeEventId,
+    };
+}
+function applyToolResult(snapshot, item, timestamp) {
+    const summary = typeof item.output === "object" && item.output !== null
+        ? item.output.summary
+        : undefined;
+    const hasStructuredSummary = typeof summary === "object"
+        && summary !== null
+        && Array.isArray(summary.items)
+        && typeof summary.summary === "object"
+        && summary.summary !== null;
+    if (hasStructuredSummary) {
+        const typedSummary = summary;
+        if (!shouldReplacePlanItems(snapshot.plan.items, typedSummary.items)) {
+            return {
+                ...snapshot,
+                sessionId: item.sessionId,
+                requestId: item.requestId,
+                agentId: item.agentId,
+                updatedAt: timestamp,
+            };
+        }
+        const items = buildPlanItems(snapshot, typedSummary.items);
+        return {
+            ...snapshot,
+            sessionId: item.sessionId,
+            requestId: item.requestId,
+            agentId: item.agentId,
+            updatedAt: timestamp,
+            plan: {
+                version: snapshot.plan.version + 1,
+                updatedAt: timestamp,
+                summary: typedSummary.summary,
+                items,
+            },
+            activeTodoKey: resolveActiveTodoKey(items),
+        };
+    }
+    return {
+        ...snapshot,
+        sessionId: item.sessionId,
+        requestId: item.requestId,
+        agentId: item.agentId,
+        updatedAt: timestamp,
+    };
+}
+function applyLifecycleEvent(snapshot, event) {
+    const next = {
+        ...snapshot,
+        sessionId: event.sessionId,
+        requestId: event.requestId,
+        updatedAt: event.timestamp,
+    };
+    if (event.eventType === "request.created") {
+        return {
+            ...next,
+            state: "running",
+            ...(typeof event.payload.selectedAgentId === "string" ? { agentId: event.payload.selectedAgentId } : {}),
+        };
+    }
+    if (event.eventType === "request.state.changed") {
+        return {
+            ...next,
+            state: typeof event.payload.state === "string" ? event.payload.state : next.state,
+        };
+    }
+    if (event.eventType === "request.resumed") {
+        return {
+            ...next,
+            state: typeof event.payload.state === "string" ? event.payload.state : "resuming",
+        };
+    }
+    if (event.eventType === "approval.requested") {
+        const approval = {
+            ...(typeof event.payload.approvalId === "string" ? { approvalId: event.payload.approvalId } : {}),
+            ...(typeof event.payload.pendingActionId === "string" ? { pendingActionId: event.payload.pendingActionId } : {}),
+            ...(typeof event.payload.toolName === "string" ? { toolName: event.payload.toolName } : {}),
+            status: "pending",
+            ...(Array.isArray(event.payload.allowedDecisions) ? { allowedDecisions: event.payload.allowedDecisions } : {}),
+        };
+        return {
+            ...next,
+            state: "waiting_for_approval",
+            approval,
+        };
+    }
+    if (event.eventType === "approval.resolved") {
+        const decision = typeof event.payload.decision === "string" ? event.payload.decision : undefined;
+        const approvalStatus = decision === "approve" ? "approved"
+            : decision === "edit" ? "edited"
+                : decision === "reject" ? "rejected"
+                    : snapshot.approval?.status;
+        return {
+            ...next,
+            approval: {
+                ...(snapshot.approval ?? {}),
+                ...(typeof event.payload.approvalId === "string" ? { approvalId: event.payload.approvalId } : {}),
+                ...(typeof event.payload.pendingActionId === "string" ? { pendingActionId: event.payload.pendingActionId } : {}),
+                ...(typeof event.payload.toolName === "string" ? { toolName: event.payload.toolName } : {}),
+                ...(approvalStatus ? { status: approvalStatus } : {}),
+            },
+        };
+    }
+    return next;
+}
+export function createInitialRequestEventSnapshot() {
+    const now = new Date().toISOString();
+    return {
+        sessionId: "",
+        requestId: "",
+        updatedAt: now,
+        state: "running",
+        plan: {
+            version: 0,
+            updatedAt: now,
+            summary: createEmptyPlanSummary(),
+            items: [],
+        },
+        output: "",
+        events: [],
+    };
+}
+export function applyRequestStreamItemToSnapshot(snapshot, item) {
+    const now = new Date().toISOString();
+    switch (item.type) {
+        case "event":
+            return applyLifecycleEvent(snapshot, item.event);
+        case "content":
+            return {
+                ...snapshot,
+                sessionId: item.sessionId,
+                requestId: item.requestId,
+                updatedAt: now,
+                agentId: item.agentId,
+                output: snapshot.output + item.content,
+            };
+        case "commentary":
+            return {
+                ...snapshot,
+                sessionId: item.sessionId,
+                requestId: item.requestId,
+                updatedAt: now,
+                agentId: item.agentId,
+            };
+        case "content-blocks":
+            return {
+                ...snapshot,
+                sessionId: item.sessionId,
+                requestId: item.requestId,
+                updatedAt: now,
+                agentId: item.agentId,
+                contentBlocks: item.contentBlocks,
+            };
+        case "tool-result":
+            return applyToolResult({
+                ...snapshot,
+                sessionId: item.sessionId,
+                requestId: item.requestId,
+                agentId: item.agentId,
+            }, item, now);
+        case "plan-state":
+            return applyPlanState({
+                ...snapshot,
+                agentId: item.agentId,
+            }, item.planState);
+        case "upstream-event":
+            return item.surfaceItem
+                ? applySurfaceItem({
+                    ...snapshot,
+                    sessionId: item.sessionId,
+                    requestId: item.requestId,
+                }, item.surfaceItem, now)
+                : {
+                    ...snapshot,
+                    sessionId: item.sessionId,
+                    requestId: item.requestId,
+                    updatedAt: now,
+                };
+        case "profile-step":
+            const activeEventKey = buildStepEventKey(item.step);
+            return {
+                ...snapshot,
+                sessionId: item.sessionId,
+                requestId: item.requestId,
+                updatedAt: now,
+                events: appendStep(snapshot.events, item.step, now),
+                activeEventId: item.step.status === "started"
+                    ? activeEventKey
+                    : snapshot.activeEventId,
+            };
+        case "result":
+            return {
+                ...snapshot,
+                sessionId: item.result.sessionId,
+                requestId: item.result.requestId,
+                updatedAt: now,
+                state: item.result.state,
+                agentId: item.result.agentId ?? snapshot.agentId,
+                output: item.result.output || snapshot.output,
+                ...(item.result.contentBlocks ? { contentBlocks: item.result.contentBlocks } : {}),
+                ...(item.result.structuredResponse !== undefined ? { structuredResponse: item.result.structuredResponse } : {}),
+                ...(item.result.interruptContent !== undefined ? { interruptContent: item.result.interruptContent } : {}),
+                ...(item.result.approvalId || item.result.pendingActionId
+                    ? {
+                        approval: {
+                            ...(snapshot.approval ?? {}),
+                            ...(item.result.approvalId ? { approvalId: item.result.approvalId } : {}),
+                            ...(item.result.pendingActionId ? { pendingActionId: item.result.pendingActionId } : {}),
+                        },
+                    }
+                    : {}),
+            };
+    }
+}
+export function toRequestDataEvent(item) {
+    switch (item.type) {
+        case "commentary":
+            return {
+                type: "progress.commentary",
+                sessionId: item.sessionId,
+                requestId: item.requestId,
+                agentId: item.agentId,
+                text: item.content,
+            };
+        case "content":
+            return {
+                type: "output.text.delta",
+                sessionId: item.sessionId,
+                requestId: item.requestId,
+                agentId: item.agentId,
+                text: item.content,
+            };
+        case "content-blocks":
+            return {
+                type: "output.content-blocks",
+                sessionId: item.sessionId,
+                requestId: item.requestId,
+                agentId: item.agentId,
+                contentBlocks: item.contentBlocks,
+            };
+        case "tool-result":
+            return {
+                type: "tool.result",
+                sessionId: item.sessionId,
+                requestId: item.requestId,
+                agentId: item.agentId,
+                toolName: item.toolName,
+                output: item.output,
+                ...(item.isError !== undefined ? { isError: item.isError } : {}),
+            };
+        case "upstream-event":
+            return {
+                type: "debug.upstream",
+                sessionId: item.sessionId,
+                requestId: item.requestId,
+                ...(item.surfaceItem ? { surfaceItem: item.surfaceItem } : {}),
+                event: item.event,
+            };
+        case "profile-step":
+            return {
+                type: "debug.profile",
+                sessionId: item.sessionId,
+                requestId: item.requestId,
+                step: item.step,
+            };
+        default:
+            return null;
+    }
+}

package/dist/resource/isolation.js

@@ -4,6 +4,8 @@ import path from "node:path";
 import { createHash, randomUUID } from "node:crypto";
 import { existsSync } from "node:fs";
 import { cp, mkdir, readFile, stat, symlink } from "node:fs/promises";
+const HARNESS_PACKAGE_NAME = "@botbotgo/agent-harness";
+const HARNESS_PACKAGE_ROOT = path.resolve(import.meta.dirname, "..", "..");
 const isolatedResourceRootCache = new Map();
 const isolatedResourceRootBuilds = new Map();
 function isolationCacheRoot() {
@@ -81,6 +83,14 @@ async function linkDeclaredDependencies(isolatedRoot, packageRoot, manifest) {
         await symlink(resolved, targetPath, "junction");
     }
 }
+async function linkHarnessPackage(isolatedRoot) {
+    const targetPath = dependencyLinkPath(isolatedRoot, HARNESS_PACKAGE_NAME);
+    if (existsSync(targetPath)) {
+        return;
+    }
+    await mkdir(path.dirname(targetPath), { recursive: true });
+    await symlink(HARNESS_PACKAGE_ROOT, targetPath, "junction");
+}
 async function buildIsolatedResourceRoot(packageRoot) {
     const packageJsonPath = path.join(packageRoot, "package.json");
     const manifest = JSON.parse(await readFile(packageJsonPath, "utf8"));
@@ -93,6 +103,7 @@ async function buildIsolatedResourceRoot(packageRoot) {
     });
     await mkdir(path.join(isolatedRoot, "node_modules"), { recursive: true });
     await linkDeclaredDependencies(isolatedRoot, packageRoot, manifest);
+    await linkHarnessPackage(isolatedRoot);
     return isolatedRoot;
 }
 async function rebuildIsolatedResourcePackageRoot(packageRoot) {

package/dist/resource/resource-impl.d.ts

@@ -1,6 +1,7 @@
 import type { RuntimeAdapterOptions, WorkspaceBundle } from "../contracts/types.js";
 export { getOrCreateMcpClient, listRemoteMcpTools, readMcpServerConfig, type McpServerConfig, type McpToolDescriptor, } from "./mcp-tool-support.js";
 export declare function resolveLocalResourceProviderEntry(currentResourceDir: string, resolveInstalledEntry?: () => string | null): string;
+export declare function normalizeWorkspaceScopedPath(rootDir: string, inputPath: string): string;
 export type ResourceToolInfo = {
     toolPath: string;
     backendOperation: string;

package/dist/resource/resource-impl.js

@@ -6,6 +6,7 @@ import { stat } from "node:fs/promises";
 import { readFile } from "node:fs/promises";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { CompositeBackend, LangSmithSandbox, LocalShellBackend, StateBackend, StoreBackend } from "deepagents";
+import { UPSTREAM_REQUEST_CONFIG_KEY, UPSTREAM_SESSION_CONFIG_KEY } from "../runtime/adapter/upstream-configurable-keys.js";
 import { getBindingBackendConfig, getBindingExecutionView, getBindingPrimaryModel } from "../runtime/support/compiled-binding.js";
 import { resolveCompiledEmbeddingModelRef } from "../runtime/support/embedding-models.js";
 import { createRuntimeEnv } from "../runtime/support/runtime-env.js";
@@ -65,6 +66,82 @@ function normalizeVirtualExecuteCommand(command, rootDir) {
         return `${prefix}${quote}${translatedPath}${quote}`;
     });
 }
+export function normalizeWorkspaceScopedPath(rootDir, inputPath) {
+    if (typeof inputPath !== "string" || inputPath.length === 0 || !path.isAbsolute(inputPath)) {
+        return inputPath;
+    }
+    if (inputPath === "/") {
+        return ".";
+    }
+    const virtualSegments = inputPath.replace(/\/+/g, "/").split("/").filter((segment) => segment.length > 0);
+    if (virtualSegments.length > 0) {
+        const rootEntries = listVirtualRootEntries(rootDir);
+        const firstSegment = virtualSegments[0];
+        if (rootEntries.has(firstSegment)) {
+            return path.join(...virtualSegments);
+        }
+    }
+    const normalizedRootDir = path.resolve(rootDir);
+    const normalizedInputPath = path.resolve(inputPath);
+    if (normalizedInputPath === normalizedRootDir || normalizedInputPath.startsWith(`${normalizedRootDir}${path.sep}`)) {
+        return path.relative(normalizedRootDir, normalizedInputPath) || ".";
+    }
+    throw new Error(`Path '${inputPath}' is outside the workspace root '${normalizedRootDir}'. Use a workspace-relative path instead.`);
+}
+function normalizeWorkspaceScopedNullablePath(rootDir, inputPath) {
+    return typeof inputPath === "string" ? normalizeWorkspaceScopedPath(rootDir, inputPath) : inputPath;
+}
+class WorkspaceScopedBackend {
+    backend;
+    id;
+    cwd;
+    rootDir;
+    root;
+    virtualMode;
+    execute;
+    constructor(backend, rootDir) {
+        this.backend = backend;
+        this.rootDir = path.resolve(rootDir);
+        this.root = this.rootDir;
+        this.cwd = this.rootDir;
+        this.id = typeof backend.id === "string" ? backend.id : undefined;
+        this.virtualMode = backend.virtualMode === true;
+        this.execute = typeof backend.execute === "function"
+            ? (command) => backend.execute(command)
+            : undefined;
+    }
+    ls(filePath) {
+        return this.backend.ls(normalizeWorkspaceScopedPath(this.rootDir, filePath));
+    }
+    read(filePath, offset, limit) {
+        return this.backend.read(normalizeWorkspaceScopedPath(this.rootDir, filePath), offset, limit);
+    }
+    readRaw(filePath) {
+        return this.backend.readRaw(normalizeWorkspaceScopedPath(this.rootDir, filePath));
+    }
+    grep(pattern, filePath, glob) {
+        return this.backend.grep(pattern, normalizeWorkspaceScopedNullablePath(this.rootDir, filePath), glob);
+    }
+    grepRaw(pattern, filePath, glob) {
+        return this.backend.grepRaw(pattern, normalizeWorkspaceScopedNullablePath(this.rootDir, filePath), glob);
+    }
+    glob(pattern, filePath) {
+        return this.backend.glob(pattern, typeof filePath === "string" ? normalizeWorkspaceScopedPath(this.rootDir, filePath) : filePath);
+    }
+    write(filePath, content) {
+        return this.backend.write(normalizeWorkspaceScopedPath(this.rootDir, filePath), content);
+    }
+    edit(filePath, oldString, newString, replaceAll) {
+        return this.backend.edit(normalizeWorkspaceScopedPath(this.rootDir, filePath), oldString, newString, replaceAll);
+    }
+    uploadFiles(files) {
+        return this.backend.uploadFiles(files);
+    }
+    downloadFiles(paths) {
+        const normalizedPaths = Array.isArray(paths) ? paths.map((currentPath) => normalizeWorkspaceScopedPath(this.rootDir, currentPath)) : paths;
+        return this.backend.downloadFiles(normalizedPaths);
+    }
+}
 async function loadLocalResource(entry) {
     if (!existsSync(entry)) {
         return null;
@@ -202,14 +279,14 @@ function createLocalShellStyleBackend(workspaceRoot, config, options) {
     const rootDir = resolveInlineBackendRootDir(workspaceRoot, config?.rootDir);
     mkdirSync(rootDir, { recursive: true });
     const inheritedEnv = config?.inheritEnv === false ? {} : process.env;
-    return new LocalShellBackend({
+    return new WorkspaceScopedBackend(new LocalShellBackend({
         rootDir,
         virtualMode: options.virtualMode,
         timeout: typeof config?.timeout === "number" ? config.timeout : undefined,
         maxOutputBytes: typeof config?.maxOutputBytes === "number" ? config.maxOutputBytes : undefined,
         env: createRuntimeEnv(readStringRecord(config?.env), inheritedEnv),
         inheritEnv: config?.inheritEnv !== false,
-    });
+    }), rootDir);
 }
 function createInlineBackendInstance(workspaceRoot, kind, config, runtimeLike) {
     switch (kind) {
@@ -262,7 +339,7 @@ function createInlineBackendResolver(workspace) {
                         const routeKind = typeof routeConfig?.kind === "string" ? routeConfig.kind : "StoreBackend";
                         return [route, createInlineBackendInstance(workspace.workspaceRoot, routeKind, routeConfig, runtimeLike)];
                     }));
-                    return new CompatibleCompositeBackend(createInlineBackendInstance(workspace.workspaceRoot, defaultBackendKind, stateConfig, runtimeLike), mappedRoutes);
+                    return new WorkspaceScopedBackend(new CompatibleCompositeBackend(createInlineBackendInstance(workspace.workspaceRoot, defaultBackendKind, stateConfig, runtimeLike), mappedRoutes), workspace.workspaceRoot);
                 }
                 default:
                     return unsupportedInlineBackend(kind);
@@ -504,7 +581,7 @@ function createFunctionToolResolver(workspace) {
                 description: tool.description,
                 schema: tool.modelSchema,
                 modelSchema: tool.modelSchema,
-                async invoke(input) {
+                async invoke(input, config) {
                     const loaded = await loadFunctionToolModule(tool);
                     const parsedInput = loaded.schema.parse(input ?? {});
                     const toolPackageRoot = await findPackageRoot(tool.sourcePath);
@@ -520,7 +597,13 @@ function createFunctionToolResolver(workspace) {
                         ? resolveCompiledEmbeddingModelRef(workspace, effectiveEmbeddingModelRef)
                         : undefined;
                     const model = binding ? getBindingPrimaryModel(binding) : undefined;
-                    const toolContext = {
+                    const configurable = typeof config?.configurable === "object" && config.configurable !== null
+                        ? config.configurable
+                        : {};
+                    const dynamicToolRuntimeContext = typeof config?.toolRuntimeContext === "object" && config.toolRuntimeContext !== null
+                        ? config.toolRuntimeContext
+                        : {};
+                    const baseToolContext = {
                         appRoot: workspace.workspaceRoot,
                         toolId: tool.id,
                         toolPath: tool.sourcePath,
@@ -530,6 +613,12 @@ function createFunctionToolResolver(workspace) {
                         runtime: {
                             workspaceRoot: workspace.workspaceRoot,
                             runtimeRoot: binding?.harnessRuntime.runtimeRoot,
+                            ...(typeof configurable[UPSTREAM_SESSION_CONFIG_KEY] === "string"
+                                ? { sessionId: configurable[UPSTREAM_SESSION_CONFIG_KEY] }
+                                : {}),
+                            ...(typeof configurable[UPSTREAM_REQUEST_CONFIG_KEY] === "string"
+                                ? { requestId: configurable[UPSTREAM_REQUEST_CONFIG_KEY] }
+                                : {}),
                         },
                         agent: binding
                             ? {
@@ -562,9 +651,16 @@ function createFunctionToolResolver(workspace) {
                         subprocess: effectiveSubprocess,
                     }, workspace.workspaceRoot, loaded.isolatedSourcePath);
                     if (subprocessConfig) {
-                        return runFunctionToolInSubprocess(subprocessConfig, parsedInput, toolContext);
+                        return runFunctionToolInSubprocess(subprocessConfig, parsedInput, baseToolContext);
                     }
-                    return loaded.invoke(parsedInput, toolContext);
+                    return loaded.invoke(parsedInput, {
+                        ...baseToolContext,
+                        ...dynamicToolRuntimeContext,
+                        runtime: {
+                            ...(typeof baseToolContext.runtime === "object" && baseToolContext.runtime ? baseToolContext.runtime : {}),
+                            ...(typeof dynamicToolRuntimeContext.runtime === "object" && dynamicToolRuntimeContext.runtime ? dynamicToolRuntimeContext.runtime : {}),
+                        },
+                    });
                 },
             },
         ];
@@ -662,9 +758,6 @@ export function defaultResourceConfigRoot() {
 export async function listResourceTools(sources = [], workspaceRoot = process.cwd()) {
     await ensureResourceSources(sources, workspaceRoot);
     const deduped = new Map();
-    for (const tool of listProviderTools(localResource)) {
-        deduped.set(tool.toolPath, tool);
-    }
     for (const source of sources) {
         for (const tool of listProviderTools(remoteResourceCache.get(source) ?? undefined)) {
             deduped.set(tool.toolPath, tool);
@@ -689,13 +782,11 @@ export function createResourceBackendResolver(workspace) {
 export function createResourceToolResolver(workspace, options = {}) {
     const functionResolver = createFunctionToolResolver(workspace);
     const mcpResolver = createMcpToolResolver(workspace);
-    const localResolver = createProviderToolResolver(localResource, workspace, options);
     const remoteResolvers = createWorkspaceProviderResolvers(workspace, (provider) => createProviderToolResolver(provider, workspace, options));
     return (toolIds, binding) => {
         const resolved = [
             ...functionResolver(toolIds, binding),
             ...mcpResolver(toolIds, binding),
-            ...(localResolver?.(toolIds, binding) ?? []),
             ...remoteResolvers.flatMap((resolver) => resolver(toolIds, binding)),
         ];
         const deduped = new Map();

package/dist/resources/init-templates/agent-context/deep-research.md

@@ -0,0 +1,5 @@
+# Deep Research Workspace Context
+
+- This workspace is a starter for product-oriented research applications.
+{{webSearchGuidance}}
+- Synthesize findings clearly, call out uncertainty, and separate facts from inference.

package/dist/resources/init-templates/prompts/research-analyst-basic.md

@@ -0,0 +1 @@
+Break down the problem, compare alternatives carefully, extract the most decision-relevant facts, and return clean notes the host agent can synthesize.

package/dist/resources/init-templates/prompts/research-analyst-web-search.md

@@ -0,0 +1 @@
+Gather current sources, compare claims carefully, extract the most decision-relevant facts, and return clean notes the host agent can synthesize.

package/dist/resources/init-templates/prompts/research-host-deep-research-basic.md

@@ -0,0 +1 @@
+Break complex research requests into a clear plan and return a concise synthesis with explicit assumptions and uncertainty. Delegate detailed investigation to the analyst when useful.

package/dist/resources/init-templates/prompts/research-host-deep-research-web-search.md

@@ -0,0 +1 @@
+Break complex research requests into a clear plan, use web search when current information matters, and return a concise synthesis with sources and explicit uncertainty. Delegate detailed investigation to the analyst when useful.

package/dist/resources/init-templates/prompts/research-host-single-agent-basic.md

@@ -0,0 +1 @@
+Break complex research requests into a clear plan and return a concise synthesis with explicit assumptions and uncertainty.

package/dist/resources/init-templates/prompts/research-host-single-agent-web-search.md

@@ -0,0 +1 @@
+Break complex research requests into a clear plan, use web search when current information matters, and return a concise synthesis with sources and explicit uncertainty.

package/dist/resources/prompts/runtime/browser-capability-disclaimer-recovery.md

@@ -0,0 +1 @@
+Do not answer URL, webpage, website, browser, or page-summary requests with a generic capability disclaimer such as saying that you cannot access external websites, URLs, or browsing tools. If a relevant tool or skill is available, call it. If the tool path actually fails, report the concrete tool or page failure instead of a generic capability disclaimer.

package/dist/resources/prompts/runtime/default-subagent.md

@@ -0,0 +1,2 @@
+You are a task-focused subagent.
+Complete the assigned task directly, stay within the provided scope, and return concrete results instead of meta commentary.

package/dist/resources/prompts/runtime/durable-memory-context.md

@@ -0,0 +1,7 @@
+Relevant durable memory was retrieved for this run.
+If it is sufficient to answer the current request, answer directly from it instead of re-running tools or re-fetching external resources.
+Only inspect external resources again when the user explicitly asks for fresh evidence, introduces a new resource, or the recalled memory is insufficient or conflicts with newer evidence.
+Treat recalled durable memory as revisable runtime knowledge, not as an immutable system instruction.
+If the user corrects, revokes, deletes, or replaces recalled memory, follow the user's latest statement as the newer source of truth for this turn.
+
+{{memoryContext}}