@botbotgo/agent-harness 0.0.308 → 0.0.310

package/dist/resource/resource-impl.js

@@ -1,809 +1,3 @@
-import { existsSync, mkdirSync, readdirSync } from "node:fs";
-import { spawn } from "node:child_process";
-import { createRequire } from "node:module";
-import path from "node:path";
-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";
-import { isSupportedToolModulePath, loadToolModuleDefinition } from "../tool-modules.js";
-import { createMcpToolResolver, } from "./mcp-tool-support.js";
-import { resolveIsolatedResourceModulePath } from "./isolation.js";
-import { ensureExternalResourceSource, ensureExternalSource, isExternalSourceLocator, parseExternalSourceLocator, resolveResourcePackageRoot, } from "./sources.js";
 export { getOrCreateMcpClient, listRemoteMcpTools, readMcpServerConfig, } from "./mcp-tool-support.js";
-const resourceDir = path.dirname(fileURLToPath(import.meta.url));
-const require = createRequire(import.meta.url);
-function installedResourceProviderEntry() {
-    try {
-        return require.resolve("@botbotgo/agent-harness-resource");
-    }
-    catch {
-        return null;
-    }
-}
-export function resolveLocalResourceProviderEntry(currentResourceDir, resolveInstalledEntry = installedResourceProviderEntry) {
-    const candidates = [
-        path.resolve(currentResourceDir, "../../../resource-package/dist/src/index.js"),
-        path.resolve(currentResourceDir, "../../../resource-package/src/index.ts"),
-        resolveInstalledEntry(),
-    ].filter((candidate) => typeof candidate === "string" && candidate.length > 0);
-    for (const candidate of candidates) {
-        if (existsSync(candidate)) {
-            return candidate;
-        }
-    }
-    return candidates.at(-1) ?? path.resolve(currentResourceDir, "../../../resource-package/dist/src/index.js");
-}
-const resourceProviderEntry = resolveLocalResourceProviderEntry(resourceDir);
-function listVirtualRootEntries(rootDir) {
-    try {
-        return new Set(readdirSync(rootDir, { withFileTypes: true }).map((entry) => entry.name));
-    }
-    catch {
-        return new Set();
-    }
-}
-function normalizeVirtualExecuteCommand(command, rootDir) {
-    if (typeof command !== "string" || command.length === 0) {
-        return command;
-    }
-    const rootEntries = listVirtualRootEntries(rootDir);
-    if (rootEntries.size === 0) {
-        return command;
-    }
-    return command.replace(/(^|[\s=:(\[{,;|&])(?<quote>["']?)(?<virtualPath>\/(?:[^\s"'`;|&()<>]+))(?:\k<quote>)/g, (match, prefix, quote = "", virtualPath) => {
-        const normalizedVirtualPath = virtualPath.replace(/\/+/g, "/");
-        const segments = normalizedVirtualPath.split("/").filter((segment) => segment.length > 0);
-        const firstSegment = segments[0];
-        if (!firstSegment || !rootEntries.has(firstSegment)) {
-            return match;
-        }
-        const translatedPath = path.resolve(rootDir, ...segments);
-        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;
-    }
-    const imported = await import(pathToFileURL(entry).href);
-    return (imported.default ?? imported);
-}
-const localResource = await loadLocalResource(resourceProviderEntry);
-function listProviderTools(provider) {
-    const rawTools = provider?.listResourceTools?.() ?? provider?.listBuiltinTools?.() ?? [];
-    return rawTools.map((tool) => ({
-        ...tool,
-        toolPath: tool.toolPath ?? tool.builtinPath ?? "",
-    }));
-}
-function preferProviderValue(provider, primary, fallback) {
-    return provider ? (primary(provider) ?? fallback(provider)) : undefined;
-}
-function createProviderToolResolver(provider, workspace, options) {
-    return preferProviderValue(provider, (candidate) => candidate.createResourceToolResolver?.(workspace, options), (candidate) => candidate.createBuiltinToolResolver?.(workspace, options));
-}
-function createProviderBackendResolver(provider, workspace) {
-    return preferProviderValue(provider, (candidate) => candidate.createResourceBackendResolver?.(workspace), (candidate) => candidate.createBuiltinBackendResolver?.(workspace));
-}
-class CompatibleCompositeBackend {
-    id;
-    execute;
-    composite;
-    constructor(defaultBackend, routes) {
-        this.composite = new CompositeBackend(defaultBackend, routes);
-        const sandboxLike = defaultBackend;
-        if (typeof sandboxLike.id === "string" && typeof sandboxLike.execute === "function") {
-            this.id = sandboxLike.id;
-            const virtualCwd = typeof sandboxLike.cwd === "string" && sandboxLike.virtualMode === true ? sandboxLike.cwd : null;
-            this.execute =
-                virtualCwd
-                    ? (command) => this.composite.execute(normalizeVirtualExecuteCommand(command, virtualCwd))
-                    : (command) => this.composite.execute(command);
-        }
-    }
-    ls(filePath) {
-        return this.composite.ls(filePath);
-    }
-    read(filePath, offset, limit) {
-        return this.composite.read(filePath, offset, limit);
-    }
-    readRaw(filePath) {
-        return this.composite.readRaw(filePath);
-    }
-    grep(pattern, filePath, glob) {
-        return this.composite.grep(pattern, filePath ?? undefined, glob ?? undefined);
-    }
-    glob(pattern, filePath) {
-        return this.composite.glob(pattern, filePath);
-    }
-    write(filePath, content) {
-        return this.composite.write(filePath, content);
-    }
-    edit(filePath, oldString, newString, replaceAll) {
-        return this.composite.edit(filePath, oldString, newString, replaceAll);
-    }
-    uploadFiles(files) {
-        return this.composite.uploadFiles(files);
-    }
-    downloadFiles(paths) {
-        return this.composite.downloadFiles(paths);
-    }
-}
-function omitKind(config) {
-    const { kind: _kind, ...rest } = config ?? {};
-    return rest;
-}
-class LazyLangSmithSandbox {
-    config;
-    sandboxPromise = null;
-    constructor(config) {
-        this.config = config;
-    }
-    get id() {
-        return "langsmith-pending";
-    }
-    get isRunning() {
-        return this.sandboxPromise !== null;
-    }
-    getSandbox() {
-        if (!this.sandboxPromise) {
-            this.sandboxPromise = LangSmithSandbox.create(omitKind(this.config));
-        }
-        return this.sandboxPromise;
-    }
-    async read(filePath, offset, limit) {
-        return (await this.getSandbox()).read(filePath, offset, limit);
-    }
-    async edit(filePath, oldString, newString, replaceAll) {
-        return (await this.getSandbox()).edit(filePath, oldString, newString, replaceAll);
-    }
-    async ls(dirPath) {
-        return (await this.getSandbox()).ls(dirPath);
-    }
-    async glob(pattern, searchPath) {
-        return (await this.getSandbox()).glob(pattern, searchPath);
-    }
-    async write(filePath, content) {
-        return (await this.getSandbox()).write(filePath, content);
-    }
-    async execute(command) {
-        return (await this.getSandbox()).execute(command);
-    }
-    async uploadFiles(files) {
-        return (await this.getSandbox()).uploadFiles(files);
-    }
-    async downloadFiles(paths) {
-        return (await this.getSandbox()).downloadFiles(paths);
-    }
-    async close() {
-        if (!this.sandboxPromise) {
-            return;
-        }
-        await (await this.sandboxPromise).close();
-    }
-}
-const INLINE_BACKEND_ERROR = 'Unsupported DeepAgent backend kind "%s". Supported inline kinds: LocalShellBackend, VfsSandbox, StateBackend, StoreBackend, CompositeBackend, LangSmithSandbox.';
-function unsupportedInlineBackend(kind) {
-    throw new Error(INLINE_BACKEND_ERROR.replace("%s", kind));
-}
-function resolveInlineBackendRootDir(workspaceRoot, configuredRootDir) {
-    if (typeof configuredRootDir === "string" && configuredRootDir.trim().length > 0) {
-        return path.isAbsolute(configuredRootDir)
-            ? configuredRootDir
-            : path.resolve(workspaceRoot, configuredRootDir);
-    }
-    return workspaceRoot;
-}
-function createLocalShellStyleBackend(workspaceRoot, config, options) {
-    const rootDir = resolveInlineBackendRootDir(workspaceRoot, config?.rootDir);
-    mkdirSync(rootDir, { recursive: true });
-    const inheritedEnv = config?.inheritEnv === false ? {} : process.env;
-    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) {
-        case "LocalShellBackend":
-            return createLocalShellStyleBackend(workspaceRoot, config, {
-                virtualMode: config?.virtualMode === true,
-            });
-        case "VfsSandbox":
-            return createLocalShellStyleBackend(workspaceRoot, config, {
-                virtualMode: config?.virtualMode === false ? false : true,
-            });
-        case "StateBackend":
-            return new StateBackend(runtimeLike);
-        case "StoreBackend":
-            return new StoreBackend(runtimeLike);
-        case "LangSmithSandbox":
-            return new LazyLangSmithSandbox(config);
-        default:
-            return unsupportedInlineBackend(kind);
-    }
-}
-function createInlineBackendResolver(workspace) {
-    return (binding) => {
-        const backendConfig = getBindingBackendConfig(binding);
-        if (!backendConfig || typeof backendConfig !== "object") {
-            return undefined;
-        }
-        return (runtimeLike) => {
-            const kind = typeof backendConfig.kind === "string" ? backendConfig.kind : "CompositeBackend";
-            switch (kind) {
-                case "LocalShellBackend":
-                    return createInlineBackendInstance(workspace.workspaceRoot, "LocalShellBackend", backendConfig, runtimeLike);
-                case "VfsSandbox":
-                    return createInlineBackendInstance(workspace.workspaceRoot, "VfsSandbox", backendConfig, runtimeLike);
-                case "StateBackend":
-                    return createInlineBackendInstance(workspace.workspaceRoot, "StateBackend", backendConfig, runtimeLike);
-                case "StoreBackend":
-                    return createInlineBackendInstance(workspace.workspaceRoot, "StoreBackend", backendConfig, runtimeLike);
-                case "LangSmithSandbox":
-                    return createInlineBackendInstance(workspace.workspaceRoot, "LangSmithSandbox", backendConfig, runtimeLike);
-                case "CompositeBackend": {
-                    const stateConfig = typeof backendConfig.state === "object" && backendConfig.state
-                        ? backendConfig.state
-                        : { kind: "StateBackend" };
-                    const defaultBackendKind = typeof stateConfig.kind === "string" ? stateConfig.kind : "StateBackend";
-                    const routes = typeof backendConfig.routes === "object" && backendConfig.routes
-                        ? backendConfig.routes
-                        : { "/memories/": { kind: "StoreBackend" } };
-                    const mappedRoutes = Object.fromEntries(Object.entries(routes).map(([route, routeConfig]) => {
-                        const routeKind = typeof routeConfig?.kind === "string" ? routeConfig.kind : "StoreBackend";
-                        return [route, createInlineBackendInstance(workspace.workspaceRoot, routeKind, routeConfig, runtimeLike)];
-                    }));
-                    return new WorkspaceScopedBackend(new CompatibleCompositeBackend(createInlineBackendInstance(workspace.workspaceRoot, defaultBackendKind, stateConfig, runtimeLike), mappedRoutes), workspace.workspaceRoot);
-                }
-                default:
-                    return unsupportedInlineBackend(kind);
-            }
-        };
-    };
-}
-function requireLocalResource(feature) {
-    if (localResource) {
-        return localResource;
-    }
-    throw new Error(`agent-harness optional tool bundle support is unavailable for ${feature}. Install the matching provider package or provide a local sibling checkout.`);
-}
-const remoteResourceCache = new Map();
-async function findPackageRoot(startPath) {
-    const resourcePackageRoot = findEnclosingResourcePackageRoot(startPath);
-    if (resourcePackageRoot) {
-        return resourcePackageRoot;
-    }
-    let current = path.dirname(startPath);
-    for (;;) {
-        try {
-            await stat(path.join(current, "package.json"));
-            return current;
-        }
-        catch { }
-        const parent = path.dirname(current);
-        if (parent === current) {
-            return path.dirname(startPath);
-        }
-        current = parent;
-    }
-}
-function findEnclosingResourcePackageRoot(startPath) {
-    let current = path.dirname(startPath);
-    for (;;) {
-        const resourcePackageRoot = resolveResourcePackageRoot(current);
-        if (resourcePackageRoot && isPathWithinRoot(startPath, resourcePackageRoot)) {
-            return resourcePackageRoot;
-        }
-        const parent = path.dirname(current);
-        if (parent === current) {
-            return null;
-        }
-        current = parent;
-    }
-}
-function isPathWithinRoot(targetPath, rootPath) {
-    const relative = path.relative(rootPath, targetPath);
-    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
-}
-const functionToolModuleCache = new Map();
-function readStringRecord(value) {
-    if (typeof value !== "object" || !value) {
-        return undefined;
-    }
-    const entries = Object.entries(value).filter((entry) => typeof entry[1] === "string");
-    return entries.length > 0 ? Object.fromEntries(entries) : undefined;
-}
-function listWorkspaceResourceProviders(workspace) {
-    return (workspace.resources ?? [])
-        .map((source) => remoteResourceCache.get(source))
-        .filter((provider) => Boolean(provider));
-}
-function createWorkspaceProviderResolvers(workspace, factory) {
-    return listWorkspaceResourceProviders(workspace)
-        .map((provider) => factory(provider))
-        .filter((resolver) => Boolean(resolver));
-}
-function asObject(value) {
-    return typeof value === "object" && value !== null ? value : undefined;
-}
-function asStringRecord(value) {
-    const record = asObject(value);
-    if (!record) {
-        return undefined;
-    }
-    return Object.fromEntries(Object.entries(record).filter((entry) => typeof entry[1] === "string"));
-}
-function asStringArray(value) {
-    return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
-}
-const FUNCTION_TOOL_SUBPROCESS_RUNNER_SOURCE = `
-import { pathToFileURL } from "node:url";
-
-const TOOL_DEFINITION_MARKER = "__agent_harness_tool_definition__";
-
-function isToolDefinitionObject(value) {
-  return typeof value === "object" && value !== null && value[TOOL_DEFINITION_MARKER] === true;
-}
-
-function loadToolDefinition(imported, implementationName) {
-  for (const [exportName, value] of Object.entries(imported)) {
-    if (exportName === "default" || !isToolDefinitionObject(value)) {
-      continue;
-    }
-    const resolvedName = typeof value.name === "string" && value.name.trim() ? value.name.trim() : exportName;
-    if (resolvedName === implementationName) {
-      return value;
-    }
-  }
-  throw new Error(\`Tool module must export a tool({...}) definition named \${implementationName}.\`);
-}
-
-const [modulePath, implementationName] = process.argv.slice(1);
-const imported = await import(pathToFileURL(modulePath).href);
-const tool = loadToolDefinition(imported, implementationName);
-let stdin = "";
-for await (const chunk of process.stdin) {
-  stdin += String(chunk);
-}
-const payload = stdin.trim() ? JSON.parse(stdin) : {};
-const input = tool.schema && typeof tool.schema.parse === "function"
-  ? tool.schema.parse(payload.input ?? {})
-  : (payload.input ?? {});
-const result = await tool.invoke(input, payload.context ?? {});
-process.stdout.write(typeof result === "string" ? result : JSON.stringify(result));
-`;
-function resolveFunctionToolSubprocessConfig(tool, workspaceRoot, isolatedSourcePath) {
-    const execution = asObject(tool.config?.execution);
-    if (tool.subprocess !== true) {
-        return null;
-    }
-    const resolvedExecution = execution ?? {};
-    const entry = typeof resolvedExecution.entry === "string" && resolvedExecution.entry.trim()
-        ? path.resolve(workspaceRoot, resolvedExecution.entry)
-        : undefined;
-    const command = typeof resolvedExecution.command === "string" && resolvedExecution.command.trim()
-        ? resolvedExecution.command
-        : entry
-            ? process.execPath
-            : process.execPath;
-    if (!command) {
-        throw new Error(`Tool ${tool.id} subprocess execution requires config.execution.command or config.execution.entry`);
-    }
-    const args = [
-        ...(entry ? [entry] : ["--input-type=module", "--eval", FUNCTION_TOOL_SUBPROCESS_RUNNER_SOURCE, isolatedSourcePath, tool.implementationName ?? tool.id]),
-        ...asStringArray(resolvedExecution.args),
-    ];
-    const cwd = typeof resolvedExecution.cwd === "string" && resolvedExecution.cwd.trim()
-        ? path.resolve(workspaceRoot, resolvedExecution.cwd)
-        : workspaceRoot;
-    const timeoutMs = Number.isFinite(resolvedExecution.timeoutMs) ? Number(resolvedExecution.timeoutMs) : undefined;
-    return {
-        command,
-        args,
-        cwd,
-        env: asStringRecord(resolvedExecution.env),
-        timeoutMs,
-    };
-}
-async function runFunctionToolInSubprocess(config, input, context) {
-    return await new Promise((resolve, reject) => {
-        const child = spawn(config.command, config.args, {
-            cwd: config.cwd,
-            env: createRuntimeEnv(config.env, process.env),
-            stdio: ["pipe", "pipe", "pipe"],
-        });
-        let stdout = "";
-        let stderr = "";
-        let settled = false;
-        let timeout;
-        const finish = (fn) => {
-            if (settled) {
-                return;
-            }
-            settled = true;
-            if (timeout) {
-                clearTimeout(timeout);
-            }
-            fn();
-        };
-        if (config.timeoutMs && config.timeoutMs > 0) {
-            timeout = setTimeout(() => {
-                child.kill("SIGTERM");
-                finish(() => reject(new Error(`Subprocess tool timed out after ${config.timeoutMs}ms`)));
-            }, config.timeoutMs);
-        }
-        child.stdout.setEncoding("utf8");
-        child.stderr.setEncoding("utf8");
-        child.stdout.on("data", (chunk) => {
-            stdout += chunk;
-        });
-        child.stderr.on("data", (chunk) => {
-            stderr += chunk;
-        });
-        child.on("error", (error) => {
-            finish(() => reject(error));
-        });
-        child.on("close", (code, signal) => {
-            finish(() => {
-                if (code === 0) {
-                    resolve(stdout.trim());
-                    return;
-                }
-                const message = stderr.trim() || stdout.trim() || `Subprocess tool exited with code ${code ?? "unknown"}${signal ? ` (${signal})` : ""}`;
-                reject(new Error(message));
-            });
-        });
-        child.stdin.end(JSON.stringify({ input, context }));
-    });
-}
-async function loadFunctionToolModule(tool) {
-    const cacheKey = `${tool.sourcePath}:${tool.implementationName ?? tool.id}`;
-    const cached = functionToolModuleCache.get(cacheKey);
-    if (cached) {
-        return cached;
-    }
-    const loading = (async () => {
-        const packageRoot = await findPackageRoot(tool.sourcePath);
-        const isolatedSourcePath = await resolveIsolatedResourceModulePath(packageRoot, tool.sourcePath);
-        const imported = await import(pathToFileURL(isolatedSourcePath).href);
-        const implementationName = tool.implementationName ?? tool.id;
-        const loaded = loadToolModuleDefinition(imported, implementationName);
-        return {
-            invoke: loaded.invoke,
-            schema: loaded.schema,
-            modelSchema: loaded.modelSchema,
-            description: loaded.description,
-            isolatedSourcePath,
-            implementationName,
-        };
-    })();
-    functionToolModuleCache.set(cacheKey, loading);
-    return loading;
-}
-function createFunctionToolResolver(workspace) {
-    const functionTools = new Map(Array.from(workspace.tools.values())
-        .filter((tool) => tool.type === "function" && isSupportedToolModulePath(tool.sourcePath))
-        .map((tool) => [tool.id, tool]));
-    return (toolIds, binding) => toolIds.flatMap((toolId) => {
-        const tool = functionTools.get(toolId);
-        if (!tool) {
-            return [];
-        }
-        return [
-            {
-                name: tool.name,
-                description: tool.description,
-                schema: tool.modelSchema,
-                modelSchema: tool.modelSchema,
-                async invoke(input, config) {
-                    const loaded = await loadFunctionToolModule(tool);
-                    const parsedInput = loaded.schema.parse(input ?? {});
-                    const toolPackageRoot = await findPackageRoot(tool.sourcePath);
-                    const bindingTool = binding
-                        ? getBindingExecutionView(binding).primaryTools.find((candidate) => candidate.id === tool.id || candidate.name === tool.name)
-                        : undefined;
-                    const effectiveEmbeddingModelRef = bindingTool?.embeddingModelRef ?? tool.embeddingModelRef;
-                    const effectiveSubprocess = bindingTool?.subprocess ?? tool.subprocess;
-                    const effectiveConfig = bindingTool?.config ?? tool.config;
-                    const effectiveHitl = bindingTool?.hitl ?? tool.hitl;
-                    const effectiveRetryable = bindingTool?.retryable ?? tool.retryable;
-                    const embeddingModel = effectiveEmbeddingModelRef
-                        ? resolveCompiledEmbeddingModelRef(workspace, effectiveEmbeddingModelRef)
-                        : undefined;
-                    const model = binding ? getBindingPrimaryModel(binding) : undefined;
-                    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,
-                        toolPackageRoot,
-                        embeddingModel,
-                        model,
-                        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
-                            ? {
-                                id: binding.agent.id,
-                                executionMode: binding.agent.executionMode,
-                                description: binding.agent.description,
-                                sourcePath: binding.agent.sourcePath,
-                            }
-                            : undefined,
-                        tool: {
-                            id: tool.id,
-                            name: tool.name,
-                            type: tool.type,
-                            description: tool.description,
-                            sourcePath: tool.sourcePath,
-                            packageRoot: toolPackageRoot,
-                            config: effectiveConfig,
-                            embeddingModelRef: effectiveEmbeddingModelRef,
-                            inputSchemaRef: tool.inputSchemaRef,
-                            retryable: effectiveRetryable,
-                            hitl: effectiveHitl,
-                        },
-                    };
-                    const subprocessConfig = resolveFunctionToolSubprocessConfig({
-                        ...tool,
-                        config: effectiveConfig,
-                        embeddingModelRef: effectiveEmbeddingModelRef,
-                        hitl: effectiveHitl,
-                        retryable: effectiveRetryable,
-                        subprocess: effectiveSubprocess,
-                    }, workspace.workspaceRoot, loaded.isolatedSourcePath);
-                    if (subprocessConfig) {
-                        return runFunctionToolInSubprocess(subprocessConfig, parsedInput, baseToolContext);
-                    }
-                    return loaded.invoke(parsedInput, {
-                        ...baseToolContext,
-                        ...dynamicToolRuntimeContext,
-                        runtime: {
-                            ...(typeof baseToolContext.runtime === "object" && baseToolContext.runtime ? baseToolContext.runtime : {}),
-                            ...(typeof dynamicToolRuntimeContext.runtime === "object" && dynamicToolRuntimeContext.runtime ? dynamicToolRuntimeContext.runtime : {}),
-                        },
-                    });
-                },
-            },
-        ];
-    });
-}
-function resolvePackageEntry(packageRoot, pkg) {
-    const exportsField = pkg.exports;
-    if (typeof exportsField === "string") {
-        return path.resolve(packageRoot, exportsField);
-    }
-    if (exportsField && typeof exportsField === "object" && "." in exportsField) {
-        const rootExport = exportsField["."];
-        if (typeof rootExport === "string") {
-            return path.resolve(packageRoot, rootExport);
-        }
-        if (rootExport && typeof rootExport === "object") {
-            const importEntry = rootExport.import ?? rootExport.default;
-            if (typeof importEntry === "string") {
-                return path.resolve(packageRoot, importEntry);
-            }
-        }
-    }
-    if (typeof pkg.module === "string") {
-        return path.resolve(packageRoot, pkg.module);
-    }
-    if (typeof pkg.main === "string") {
-        return path.resolve(packageRoot, pkg.main);
-    }
-    return path.resolve(packageRoot, "index.js");
-}
-async function loadRemoteResource(source, workspaceRoot) {
-    const cached = remoteResourceCache.get(source);
-    if (cached !== undefined) {
-        return cached;
-    }
-    if (!isExternalSourceLocator(source)) {
-        throw new Error(`Unsupported resource source ${source}. Use npm:, tgz:, or file:.`);
-    }
-    const parsed = parseExternalSourceLocator(source);
-    if (parsed.subpath) {
-        throw new Error(`Resource source ${source} must point at a package root, not a subpath`);
-    }
-    await ensureExternalResourceSource(source, workspaceRoot);
-    const packageRoot = await ensureExternalSource(source, workspaceRoot);
-    const pkg = JSON.parse(await readFile(path.join(packageRoot, "package.json"), "utf8"));
-    const entry = resolvePackageEntry(packageRoot, pkg);
-    if (!existsSync(entry)) {
-        remoteResourceCache.set(source, null);
-        return null;
-    }
-    const imported = await import(pathToFileURL(entry).href);
-    const provider = (imported.default ?? imported);
-    if (listProviderTools(provider).length === 0 &&
-        !provider.listResourceTools &&
-        !provider.listBuiltinTools) {
-        remoteResourceCache.set(source, null);
-        return null;
-    }
-    if (!provider.createResourceToolResolver && !provider.createBuiltinToolResolver) {
-        remoteResourceCache.set(source, null);
-        return null;
-    }
-    const typedProvider = provider;
-    remoteResourceCache.set(source, typedProvider);
-    return typedProvider;
-}
-export async function ensureResourceSources(sources = [], workspaceRoot = process.cwd()) {
-    await Promise.all(sources.map((source) => loadRemoteResource(source, workspaceRoot)));
-}
-function resolveBundledFallbackRoot(kind) {
-    const suffix = kind === "skills" ? ["resources", "skills"] : ["config"];
-    const candidates = [
-        path.resolve(resourceDir, "..", ...suffix),
-        path.resolve(resourceDir, "..", "..", ...suffix),
-    ];
-    for (const candidate of candidates) {
-        if (existsSync(candidate)) {
-            return candidate;
-        }
-    }
-    return null;
-}
-export function defaultResourceSkillsRoot() {
-    if (localResource) {
-        return preferProviderValue(localResource, (candidate) => candidate.defaultResourceSkillsRoot?.(), (candidate) => candidate.builtinSkillsRoot?.()) ?? "";
-    }
-    return resolveBundledFallbackRoot("skills") ?? requireLocalResource("default resource skill resolution").defaultResourceSkillsRoot?.() ?? "";
-}
-export function defaultResourceConfigRoot() {
-    if (localResource) {
-        return (preferProviderValue(localResource, (candidate) => candidate.defaultResourceConfigRoot?.(), (candidate) => candidate.builtinConfigRoot?.() ?? candidate.builtinDefaultsRoot?.()) ?? "");
-    }
-    return resolveBundledFallbackRoot("config") ?? requireLocalResource("default resource config resolution").defaultResourceConfigRoot?.() ?? "";
-}
-export async function listResourceTools(sources = [], workspaceRoot = process.cwd()) {
-    await ensureResourceSources(sources, workspaceRoot);
-    const deduped = new Map();
-    for (const source of sources) {
-        for (const tool of listProviderTools(remoteResourceCache.get(source) ?? undefined)) {
-            deduped.set(tool.toolPath, tool);
-        }
-    }
-    return Array.from(deduped.values());
-}
-export async function listResourceToolsForSource(source, workspaceRoot = process.cwd()) {
-    await ensureResourceSources([source], workspaceRoot);
-    return listProviderTools(remoteResourceCache.get(source) ?? undefined);
-}
-export function createResourceBackendResolver(workspace) {
-    const localResolver = createProviderBackendResolver(localResource, workspace);
-    const remoteResolvers = createWorkspaceProviderResolvers(workspace, (provider) => createProviderBackendResolver(provider, workspace));
-    const inlineResolver = createInlineBackendResolver(workspace);
-    return (binding) => {
-        const providerResolved = localResolver?.(binding) ??
-            remoteResolvers.map((resolver) => resolver(binding)).find((resolved) => resolved !== undefined);
-        return providerResolved ?? inlineResolver(binding);
-    };
-}
-export function createResourceToolResolver(workspace, options = {}) {
-    const functionResolver = createFunctionToolResolver(workspace);
-    const mcpResolver = createMcpToolResolver(workspace);
-    const remoteResolvers = createWorkspaceProviderResolvers(workspace, (provider) => createProviderToolResolver(provider, workspace, options));
-    return (toolIds, binding) => {
-        const resolved = [
-            ...functionResolver(toolIds, binding),
-            ...mcpResolver(toolIds, binding),
-            ...remoteResolvers.flatMap((resolver) => resolver(toolIds, binding)),
-        ];
-        const deduped = new Map();
-        for (const tool of resolved) {
-            const name = String(tool.name);
-            if (!deduped.has(name)) {
-                deduped.set(name, tool);
-            }
-        }
-        return Array.from(deduped.values());
-    };
-}
-export const ensureBuiltinSources = ensureResourceSources;
-export const builtinSkillsRoot = defaultResourceSkillsRoot;
-export const builtinConfigRoot = defaultResourceConfigRoot;
-export const listBuiltinTools = listResourceTools;
-export const listBuiltinToolsForSource = listResourceToolsForSource;
-export const createBuiltinBackendResolver = createResourceBackendResolver;
-export const createBuiltinToolResolver = createResourceToolResolver;
-export const resolveLocalBuiltinsEntry = resolveLocalResourceProviderEntry;
+export { ensureResourceSources, defaultResourceSkillsRoot, defaultResourceConfigRoot, listResourceTools, listResourceToolsForSource, createResourceBackendResolver, createResourceToolResolver, ensureBuiltinSources, builtinSkillsRoot, builtinConfigRoot, listBuiltinTools, listBuiltinToolsForSource, createBuiltinBackendResolver, createBuiltinToolResolver, resolveLocalResourceProviderEntry, resolveLocalBuiltinsEntry, } from "./providers/resource-provider.js";
+export { normalizeWorkspaceScopedPath } from "./backend/workspace-scoped-backend.js";