@botbotgo/agent-harness 0.0.475 → 0.0.476

package/dist/resource/sources.js

@@ -1,247 +1 @@
-import { execFile } from "node:child_process";
-import { existsSync, statSync } from "node:fs";
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { createHash, createPublicKey, verify } from "node:crypto";
-import { promisify } from "node:util";
-const execFileAsync = promisify(execFile);
-const sourceCache = new Map();
-function cacheRoot() {
-    return path.join(os.tmpdir(), "agent-harness-external-sources");
-}
-function sourceCacheDir(locator) {
-    const digest = createHash("sha256").update(locator).digest("hex").slice(0, 16);
-    return path.join(cacheRoot(), digest);
-}
-export function resolveResourcePackageRoot(root) {
-    const candidates = path.basename(root) === "resources" ? [root] : [path.join(root, "resources")];
-    for (const candidate of candidates) {
-        if (!existsSync(candidate)) {
-            continue;
-        }
-        if (!statSync(candidate).isDirectory()) {
-            continue;
-        }
-        const packageJsonPath = path.join(candidate, "package.json");
-        if (!existsSync(packageJsonPath)) {
-            throw new Error(`Resource package ${candidate} is missing package.json.`);
-        }
-        return candidate;
-    }
-    return null;
-}
-function resolveExplicitResourceRoot(root) {
-    if (isDirectoryPath(root)) {
-        const packageJsonPath = path.join(root, "package.json");
-        if (existsSync(packageJsonPath)) {
-            return root;
-        }
-    }
-    return resolveResourcePackageRoot(root);
-}
-export function isExternalSourceLocator(value) {
-    return typeof value === "string" && /^(npm|tgz|file):/.test(value);
-}
-export function parseExternalSourceLocator(locator) {
-    const separator = locator.indexOf("::");
-    const rawBase = separator >= 0 ? locator.slice(0, separator) : locator;
-    const subpath = separator >= 0 ? locator.slice(separator + 2) : undefined;
-    const [baseWithoutQuery, rawQuery = ""] = rawBase.split("?", 2);
-    const query = new URLSearchParams(rawQuery);
-    const shared = {
-        subpath,
-        integrity: query.get("integrity") ?? undefined,
-        signature: query.get("signature") ?? undefined,
-        publicKey: query.get("publicKey") ?? query.get("key") ?? undefined,
-    };
-    if (baseWithoutQuery.startsWith("npm:")) {
-        return { kind: "npm", spec: baseWithoutQuery.slice(4), ...shared };
-    }
-    if (baseWithoutQuery.startsWith("tgz:")) {
-        return { kind: "tgz", spec: baseWithoutQuery.slice(4), ...shared };
-    }
-    if (baseWithoutQuery.startsWith("file:")) {
-        return { kind: "file", spec: baseWithoutQuery.slice(5), ...shared };
-    }
-    throw new Error(`Unsupported external source locator ${locator}. Use npm:, tgz:, or file:.`);
-}
-function resolveFileSpec(spec, workspaceRoot) {
-    if (path.isAbsolute(spec)) {
-        return spec;
-    }
-    return path.resolve(workspaceRoot, spec);
-}
-async function packAndExtract(packageSpec, cacheKey) {
-    const root = sourceCacheDir(cacheKey);
-    const extractRoot = path.join(root, "extract");
-    const packageRoot = path.join(extractRoot, "package");
-    const npmCacheRoot = path.join(root, ".npm-cache");
-    const tarballMarker = path.join(root, ".tarball-path");
-    if (existsSync(path.join(packageRoot, "package.json"))) {
-        const tarballPath = existsSync(tarballMarker) ? (await readFile(tarballMarker, "utf8")).trim() : undefined;
-        return {
-            basePath: packageRoot,
-            tarballPath: tarballPath || undefined,
-        };
-    }
-    await mkdir(root, { recursive: true });
-    await mkdir(extractRoot, { recursive: true });
-    await mkdir(npmCacheRoot, { recursive: true });
-    const packed = await execFileAsync("npm", ["pack", packageSpec, "--silent"], {
-        cwd: root,
-        maxBuffer: 1024 * 1024 * 10,
-        env: {
-            ...process.env,
-            NPM_CONFIG_CACHE: npmCacheRoot,
-        },
-    });
-    const tarballName = packed.stdout.trim().split(/\r?\n/).filter(Boolean).at(-1);
-    if (!tarballName) {
-        throw new Error(`Failed to pack external source ${cacheKey}`);
-    }
-    const tarballPath = path.join(root, tarballName);
-    await execFileAsync("tar", ["-xzf", tarballName, "-C", extractRoot], {
-        cwd: root,
-        maxBuffer: 1024 * 1024 * 10,
-    });
-    await writeFile(tarballMarker, tarballPath, "utf8");
-    return {
-        basePath: packageRoot,
-        tarballPath,
-    };
-}
-function decodeIntegrity(integrity) {
-    const trimmed = integrity.trim();
-    if (!trimmed) {
-        throw new Error("External source integrity must not be empty.");
-    }
-    const [algorithm, encoded] = trimmed.includes("-")
-        ? trimmed.split("-", 2)
-        : trimmed.includes(":")
-            ? trimmed.split(":", 2)
-            : [trimmed, ""];
-    if (!encoded) {
-        throw new Error(`External source integrity ${integrity} must use <algorithm>-<digest> or <algorithm>:<digest>.`);
-    }
-    const normalizedAlgorithm = algorithm.toLowerCase();
-    const encoding = /^[a-f0-9]+$/i.test(encoded) ? "hex" : "base64";
-    return {
-        algorithm: normalizedAlgorithm,
-        expected: Buffer.from(encoded, encoding),
-    };
-}
-async function readVerificationPublicKey(publicKey, workspaceRoot) {
-    const trimmed = publicKey.trim();
-    if (trimmed.startsWith("-----BEGIN")) {
-        return trimmed;
-    }
-    const resolved = trimmed.startsWith("file:")
-        ? resolveFileSpec(trimmed.slice("file:".length), workspaceRoot)
-        : resolveFileSpec(trimmed, workspaceRoot);
-    return readFile(resolved);
-}
-async function verifyExternalSource(locator, parsed, cached, workspaceRoot) {
-    if (!parsed.integrity && !parsed.signature) {
-        return;
-    }
-    if (!cached.tarballPath) {
-        throw new Error(`External source ${locator} does not provide a tarball to verify.`);
-    }
-    const tarball = await readFile(cached.tarballPath);
-    if (parsed.integrity) {
-        const { algorithm, expected } = decodeIntegrity(parsed.integrity);
-        const actual = createHash(algorithm).update(tarball).digest();
-        if (!actual.equals(expected)) {
-            throw new Error(`External source ${locator} failed integrity verification.`);
-        }
-    }
-    if (parsed.signature) {
-        if (!parsed.publicKey) {
-            throw new Error(`External source ${locator} signature verification requires publicKey=.`);
-        }
-        const key = createPublicKey(await readVerificationPublicKey(parsed.publicKey, workspaceRoot));
-        const signature = Buffer.from(parsed.signature, "base64");
-        const verified = verify(null, tarball, key, signature) ||
-            verify("sha256", tarball, key, signature);
-        if (!verified) {
-            throw new Error(`External source ${locator} failed signature verification.`);
-        }
-    }
-}
-export async function ensureExternalSource(locator, workspaceRoot) {
-    const parsed = parseExternalSourceLocator(locator);
-    const cacheKey = `${parsed.kind}:${parsed.spec}`;
-    const cached = sourceCache.get(cacheKey);
-    if (cached) {
-        await verifyExternalSource(locator, parsed, cached, workspaceRoot);
-        return parsed.subpath ? path.join(cached.basePath, parsed.subpath) : cached.basePath;
-    }
-    let resolved;
-    if (parsed.kind === "npm") {
-        resolved = await packAndExtract(parsed.spec, cacheKey);
-    }
-    else if (parsed.kind === "tgz") {
-        const tgzPath = resolveFileSpec(parsed.spec, workspaceRoot);
-        resolved = await packAndExtract(tgzPath, cacheKey);
-        resolved.tarballPath ??= tgzPath;
-    }
-    else {
-        const filePath = resolveFileSpec(parsed.spec, workspaceRoot);
-        if (!existsSync(filePath)) {
-            throw new Error(`External file source ${locator} does not exist`);
-        }
-        if (filePath.endsWith(".tgz") || filePath.endsWith(".tar.gz")) {
-            resolved = await packAndExtract(filePath, cacheKey);
-            resolved.tarballPath ??= filePath;
-        }
-        else {
-            resolved = { basePath: filePath };
-        }
-    }
-    sourceCache.set(cacheKey, resolved);
-    await verifyExternalSource(locator, parsed, resolved, workspaceRoot);
-    return parsed.subpath ? path.join(resolved.basePath, parsed.subpath) : resolved.basePath;
-}
-export async function ensureExternalResourceSource(locator, workspaceRoot) {
-    const parsed = parseExternalSourceLocator(locator);
-    const baseLocator = `${parsed.kind}:${parsed.spec}`;
-    const packageRoot = await ensureExternalSource(baseLocator, workspaceRoot);
-    const resourcePackageRoot = resolveExplicitResourceRoot(packageRoot);
-    if (!resourcePackageRoot) {
-        throw new Error(`External source ${baseLocator} is missing a resource package root or resources/package.json.`);
-    }
-    return parsed.subpath ? path.join(resourcePackageRoot, parsed.subpath) : resourcePackageRoot;
-}
-export async function ensureExternalSources(locators, workspaceRoot) {
-    await Promise.all(Array.from(new Set(locators)).map((locator) => ensureExternalSource(locator, workspaceRoot)));
-}
-export function resolveExternalSourcePath(locator, workspaceRoot) {
-    const parsed = parseExternalSourceLocator(locator);
-    const cacheKey = `${parsed.kind}:${parsed.spec}`;
-    const cached = sourceCache.get(cacheKey);
-    if (cached) {
-        return parsed.subpath ? path.join(cached.basePath, parsed.subpath) : cached.basePath;
-    }
-    if (parsed.kind === "file") {
-        const resolved = resolveFileSpec(parsed.spec, workspaceRoot);
-        if (resolved.endsWith(".tgz") || resolved.endsWith(".tar.gz")) {
-            throw new Error(`External source ${locator} must be preloaded before synchronous resolution`);
-        }
-        return parsed.subpath ? path.join(resolved, parsed.subpath) : resolved;
-    }
-    throw new Error(`External source ${locator} must be preloaded before synchronous resolution`);
-}
-export function resolveExternalResourcePath(locator, workspaceRoot) {
-    const parsed = parseExternalSourceLocator(locator);
-    const baseLocator = `${parsed.kind}:${parsed.spec}`;
-    const packageRoot = resolveExternalSourcePath(baseLocator, workspaceRoot);
-    const resourcePackageRoot = resolveExplicitResourceRoot(packageRoot);
-    if (!resourcePackageRoot) {
-        throw new Error(`External source ${baseLocator} is missing a resource package root or resources/package.json.`);
-    }
-    return parsed.subpath ? path.join(resourcePackageRoot, parsed.subpath) : resourcePackageRoot;
-}
-export function isDirectoryPath(candidate) {
-    return existsSync(candidate) && statSync(candidate).isDirectory();
-}
+import{execFile as $}from"node:child_process";import{existsSync as c,statSync as w}from"node:fs";import{mkdir as h,readFile as d,writeFile as z}from"node:fs/promises";import R from"node:os";import o from"node:path";import{createHash as x,createPublicKey as S,verify as y}from"node:crypto";import{promisify as W}from"node:util";const E=W($),g=new Map;function C(){return o.join(R.tmpdir(),"agent-harness-external-sources")}function K(t){const r=x("sha256").update(t).digest("hex").slice(0,16);return o.join(C(),r)}function B(t){const r=o.basename(t)==="resources"?[t]:[o.join(t,"resources")];for(const e of r){if(!c(e)||!w(e).isDirectory())continue;const i=o.join(e,"package.json");if(!c(i))throw new Error(`Resource package ${e} is missing package.json.`);return e}return null}function k(t){if(D(t)){const r=o.join(t,"package.json");if(c(r))return t}return B(t)}function J(t){return typeof t=="string"&&/^(npm|tgz|file):/.test(t)}function f(t){const r=t.indexOf("::"),e=r>=0?t.slice(0,r):t,i=r>=0?t.slice(r+2):void 0,[a,n=""]=e.split("?",2),s=new URLSearchParams(n),u={subpath:i,integrity:s.get("integrity")??void 0,signature:s.get("signature")??void 0,publicKey:s.get("publicKey")??s.get("key")??void 0};if(a.startsWith("npm:"))return{kind:"npm",spec:a.slice(4),...u};if(a.startsWith("tgz:"))return{kind:"tgz",spec:a.slice(4),...u};if(a.startsWith("file:"))return{kind:"file",spec:a.slice(5),...u};throw new Error(`Unsupported external source locator ${t}. Use npm:, tgz:, or file:.`)}function l(t,r){return o.isAbsolute(t)?t:o.resolve(r,t)}async function m(t,r){const e=K(r),i=o.join(e,"extract"),a=o.join(i,"package"),n=o.join(e,".npm-cache"),s=o.join(e,".tarball-path");if(c(o.join(a,"package.json"))){const v=c(s)?(await d(s,"utf8")).trim():void 0;return{basePath:a,tarballPath:v||void 0}}await h(e,{recursive:!0}),await h(i,{recursive:!0}),await h(n,{recursive:!0});const p=(await E("npm",["pack",t,"--silent"],{cwd:e,maxBuffer:1024*1024*10,env:{...process.env,NPM_CONFIG_CACHE:n}})).stdout.trim().split(/\r?\n/).filter(Boolean).at(-1);if(!p)throw new Error(`Failed to pack external source ${r}`);const b=o.join(e,p);return await E("tar",["-xzf",p,"-C",i],{cwd:e,maxBuffer:1024*1024*10}),await z(s,b,"utf8"),{basePath:a,tarballPath:b}}function F(t){const r=t.trim();if(!r)throw new Error("External source integrity must not be empty.");const[e,i]=r.includes("-")?r.split("-",2):r.includes(":")?r.split(":",2):[r,""];if(!i)throw new Error(`External source integrity ${t} must use <algorithm>-<digest> or <algorithm>:<digest>.`);const a=e.toLowerCase(),n=/^[a-f0-9]+$/i.test(i)?"hex":"base64";return{algorithm:a,expected:Buffer.from(i,n)}}async function A(t,r){const e=t.trim();if(e.startsWith("-----BEGIN"))return e;const i=e.startsWith("file:")?l(e.slice(5),r):l(e,r);return d(i)}async function P(t,r,e,i){if(!r.integrity&&!r.signature)return;if(!e.tarballPath)throw new Error(`External source ${t} does not provide a tarball to verify.`);const a=await d(e.tarballPath);if(r.integrity){const{algorithm:n,expected:s}=F(r.integrity);if(!x(n).update(a).digest().equals(s))throw new Error(`External source ${t} failed integrity verification.`)}if(r.signature){if(!r.publicKey)throw new Error(`External source ${t} signature verification requires publicKey=.`);const n=S(await A(r.publicKey,i)),s=Buffer.from(r.signature,"base64");if(!(y(null,a,n,s)||y("sha256",a,n,s)))throw new Error(`External source ${t} failed signature verification.`)}}async function j(t,r){const e=f(t),i=`${e.kind}:${e.spec}`,a=g.get(i);if(a)return await P(t,e,a,r),e.subpath?o.join(a.basePath,e.subpath):a.basePath;let n;if(e.kind==="npm")n=await m(e.spec,i);else if(e.kind==="tgz"){const s=l(e.spec,r);n=await m(s,i),n.tarballPath??=s}else{const s=l(e.spec,r);if(!c(s))throw new Error(`External file source ${t} does not exist`);s.endsWith(".tgz")||s.endsWith(".tar.gz")?(n=await m(s,i),n.tarballPath??=s):n={basePath:s}}return g.set(i,n),await P(t,e,n,r),e.subpath?o.join(n.basePath,e.subpath):n.basePath}async function O(t,r){const e=f(t),i=`${e.kind}:${e.spec}`,a=await j(i,r),n=k(a);if(!n)throw new Error(`External source ${i} is missing a resource package root or resources/package.json.`);return e.subpath?o.join(n,e.subpath):n}async function Q(t,r){await Promise.all(Array.from(new Set(t)).map(e=>j(e,r)))}function L(t,r){const e=f(t),i=`${e.kind}:${e.spec}`,a=g.get(i);if(a)return e.subpath?o.join(a.basePath,e.subpath):a.basePath;if(e.kind==="file"){const n=l(e.spec,r);if(n.endsWith(".tgz")||n.endsWith(".tar.gz"))throw new Error(`External source ${t} must be preloaded before synchronous resolution`);return e.subpath?o.join(n,e.subpath):n}throw new Error(`External source ${t} must be preloaded before synchronous resolution`)}function _(t,r){const e=f(t),i=`${e.kind}:${e.spec}`,a=L(i,r),n=k(a);if(!n)throw new Error(`External source ${i} is missing a resource package root or resources/package.json.`);return e.subpath?o.join(n,e.subpath):n}function D(t){return c(t)&&w(t).isDirectory()}export{O as ensureExternalResourceSource,j as ensureExternalSource,Q as ensureExternalSources,D as isDirectoryPath,J as isExternalSourceLocator,f as parseExternalSourceLocator,_ as resolveExternalResourcePath,L as resolveExternalSourcePath,B as resolveResourcePackageRoot};

package/dist/resource/tools/function-tool-resolver.js

@@ -1,65 +1,4 @@
-import { spawn } from "node:child_process";
-import path from "node:path";
-import { stat } from "node:fs/promises";
-import { pathToFileURL } from "node:url";
-import { UPSTREAM_REQUEST_CONFIG_KEY, UPSTREAM_SESSION_CONFIG_KEY } from "../../runtime/adapter/upstream-configurable-keys.js";
-import { getBindingExecutionView, getBindingPrimaryModel } from "../../runtime/support/compiled-binding.js";
-import { resolveCompiledEmbeddingModelRef } from "../../runtime/support/embedding-models.js";
-import { createRuntimeEnv } from "../../runtime/env/runtime-env.js";
-import { isSupportedToolModulePath, loadToolModuleDefinition } from "../../tooling/module-loader.js";
-import { resolveIsolatedResourceModulePath } from "../isolation.js";
-import { resolveResourcePackageRoot } from "../sources.js";
-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));
-}
-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 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{spawn as _}from"node:child_process";import m from"node:path";import{stat as I}from"node:fs/promises";import{pathToFileURL as k}from"node:url";import{UPSTREAM_REQUEST_CONFIG_KEY as M,UPSTREAM_SESSION_CONFIG_KEY as N}from"../../runtime/adapter/upstream-configurable-keys.js";import{getBindingExecutionView as C,getBindingPrimaryModel as F}from"../../runtime/support/compiled-binding.js";import{resolveCompiledEmbeddingModelRef as j}from"../../runtime/support/embedding-models.js";import{createRuntimeEnv as U}from"../../runtime/env/runtime-env.js";import{isSupportedToolModulePath as A,loadToolModuleDefinition as $}from"../../tooling/module-loader.js";import{resolveIsolatedResourceModulePath as D}from"../isolation.js";import{resolveResourcePackageRoot as L}from"../sources.js";function K(e){let n=m.dirname(e);for(;;){const o=L(n);if(o&&B(e,o))return o;const r=m.dirname(n);if(r===n)return null;n=r}}function B(e,n){const o=m.relative(n,e);return o===""||!o.startsWith("..")&&!m.isAbsolute(o)}async function w(e){const n=K(e);if(n)return n;let o=m.dirname(e);for(;;){try{return await I(m.join(o,"package.json")),o}catch{}const r=m.dirname(o);if(r===o)return m.dirname(e);o=r}}function E(e){return typeof e=="object"&&e!==null?e:void 0}function G(e){const n=E(e);if(n)return Object.fromEntries(Object.entries(n).filter(o=>typeof o[1]=="string"))}function J(e){return Array.isArray(e)?e.filter(n=>typeof n=="string"):[]}const q=`
 import { pathToFileURL } from "node:url";
 
 const TOOL_DEFINITION_MARKER = "__agent_harness_tool_definition__";
@@ -94,213 +33,4 @@ const input = tool.schema && typeof tool.schema.parse === "function"
   : (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 }));
-    });
-}
-const functionToolModuleCache = new Map();
-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;
-}
-export 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 W(e,n,o){const r=E(e.config?.execution);if(e.subprocess!==!0)return null;const i=r??{},t=typeof i.entry=="string"&&i.entry.trim()?m.resolve(n,i.entry):void 0,u=typeof i.command=="string"&&i.command.trim()?i.command:process.execPath;if(!u)throw new Error(`Tool ${e.id} subprocess execution requires config.execution.command or config.execution.entry`);const a=[...t?[t]:["--input-type=module","--eval",q,o,e.implementationName??e.id],...J(i.args)],c=typeof i.cwd=="string"&&i.cwd.trim()?m.resolve(n,i.cwd):n,d=Number.isFinite(i.timeoutMs)?Number(i.timeoutMs):void 0;return{command:u,args:a,cwd:c,env:G(i.env),timeoutMs:d}}async function Y(e,n,o){return await new Promise((r,i)=>{const t=_(e.command,e.args,{cwd:e.cwd,env:U(e.env,process.env),stdio:["pipe","pipe","pipe"]});let u="",a="",c=!1,d;const f=s=>{c||(c=!0,d&&clearTimeout(d),s())};e.timeoutMs&&e.timeoutMs>0&&(d=setTimeout(()=>{t.kill("SIGTERM"),f(()=>i(new Error(`Subprocess tool timed out after ${e.timeoutMs}ms`)))},e.timeoutMs)),t.stdout.setEncoding("utf8"),t.stderr.setEncoding("utf8"),t.stdout.on("data",s=>{u+=s}),t.stderr.on("data",s=>{a+=s}),t.on("error",s=>{f(()=>i(s))}),t.on("close",(s,l)=>{f(()=>{if(s===0){r(u.trim());return}const R=a.trim()||u.trim()||`Subprocess tool exited with code ${s??"unknown"}${l?` (${l})`:""}`;i(new Error(R))})}),t.stdin.end(JSON.stringify({input:n,context:o}))})}const P=new Map;async function H(e){const n=`${e.sourcePath}:${e.implementationName??e.id}`,o=P.get(n);if(o)return o;const r=(async()=>{const i=await w(e.sourcePath),t=await D(i,e.sourcePath),u=await import(k(t).href),a=e.implementationName??e.id,c=$(u,a);return{invoke:c.invoke,schema:c.schema,modelSchema:c.modelSchema,description:c.description,isolatedSourcePath:t,implementationName:a}})();return P.set(n,r),r}function se(e){const n=new Map(Array.from(e.tools.values()).filter(o=>o.type==="function"&&A(o.sourcePath)).map(o=>[o.id,o]));return(o,r)=>o.flatMap(i=>{const t=n.get(i);return t?[{name:t.name,description:t.description,schema:t.modelSchema,modelSchema:t.modelSchema,async invoke(u,a){const c=await H(t),d=c.schema.parse(u??{}),f=await w(t.sourcePath),s=r?C(r).primaryTools.find(S=>S.id===t.id||S.name===t.name):void 0,l=s?.embeddingModelRef??t.embeddingModelRef,R=s?.subprocess??t.subprocess,g=s?.config??t.config,v=s?.hitl??t.hitl,b=s?.retryable??t.retryable,x=l?j(e,l):void 0,O=r?F(r):void 0,h=typeof a?.configurable=="object"&&a.configurable!==null?a.configurable:{},y=typeof a?.toolRuntimeContext=="object"&&a.toolRuntimeContext!==null?a.toolRuntimeContext:{},p={appRoot:e.workspaceRoot,toolId:t.id,toolPath:t.sourcePath,toolPackageRoot:f,embeddingModel:x,model:O,runtime:{workspaceRoot:e.workspaceRoot,runtimeRoot:r?.harnessRuntime.runtimeRoot,...typeof h[N]=="string"?{sessionId:h[N]}:{},...typeof h[M]=="string"?{requestId:h[M]}:{}},agent:r?{id:r.agent.id,executionMode:r.agent.executionMode,description:r.agent.description,sourcePath:r.agent.sourcePath}:void 0,tool:{id:t.id,name:t.name,type:t.type,description:t.description,sourcePath:t.sourcePath,packageRoot:f,config:g,embeddingModelRef:l,inputSchemaRef:t.inputSchemaRef,retryable:b,hitl:v}},T=W({...t,config:g,embeddingModelRef:l,hitl:v,retryable:b,subprocess:R},e.workspaceRoot,c.isolatedSourcePath);return T?Y(T,d,p):c.invoke(d,{...p,...y,runtime:{...typeof p.runtime=="object"&&p.runtime?p.runtime:{},...typeof y.runtime=="object"&&y.runtime?y.runtime:{}}})}}]:[]})}export{se as createFunctionToolResolver};

package/dist/runtime/adapter/compat/deepagent-compat.js

@@ -1,29 +1 @@
-import path from "node:path";
-export function relativizeDeepAgentSkillSourcePaths(workspaceRoot, skillPaths) {
-    if (!workspaceRoot || !skillPaths) {
-        return skillPaths;
-    }
-    return skillPaths.map((skillPath) => {
-        if (!path.isAbsolute(skillPath)) {
-            return skillPath;
-        }
-        const relative = path.relative(workspaceRoot, skillPath);
-        if (!relative || relative.startsWith("..")) {
-            return skillPath;
-        }
-        return relative.split(path.sep).join("/");
-    });
-}
-export async function materializeDeepAgentSkillSourcePaths(options) {
-    return Promise.resolve(resolveDeepAgentSkillSourcePaths(options));
-}
-export function resolveDeepAgentSkillSourcePaths(options) {
-    const { workspaceRoot, skillPaths } = options;
-    if (!skillPaths) {
-        return skillPaths;
-    }
-    return relativizeDeepAgentSkillSourcePaths(workspaceRoot, skillPaths) ?? skillPaths;
-}
-export function resolveDeepAgentSkillSourceRootPaths(options) {
-    return resolveDeepAgentSkillSourcePaths(options);
-}
+import o from"node:path";function u(r,t){return!r||!t?t:t.map(e=>{if(!o.isAbsolute(e))return e;const n=o.relative(r,e);return!n||n.startsWith("..")?e:n.split(o.sep).join("/")})}async function s(r){return Promise.resolve(i(r))}function i(r){const{workspaceRoot:t,skillPaths:e}=r;return e&&(u(t,e)??e)}function c(r){return i(r)}export{s as materializeDeepAgentSkillSourcePaths,u as relativizeDeepAgentSkillSourcePaths,i as resolveDeepAgentSkillSourcePaths,c as resolveDeepAgentSkillSourceRootPaths};

package/dist/runtime/adapter/compat/openai-compatible.js

@@ -1,55 +1 @@
-function asObject(value) {
-    return typeof value === "object" && value ? value : undefined;
-}
-function isPlaceholderApiKey(value) {
-    return typeof value === "string" && value.trim().toLowerCase() === "dummy";
-}
-export function buildAuthOmittingFetch(baseFetch = fetch) {
-    return async (input, init) => {
-        const sanitizedHeaders = new Headers(input instanceof Request ? input.headers : undefined);
-        const initHeaders = new Headers(init?.headers);
-        initHeaders.forEach((value, key) => {
-            sanitizedHeaders.set(key, value);
-        });
-        sanitizedHeaders.delete("authorization");
-        if (input instanceof Request) {
-            return baseFetch(new Request(input, {
-                ...init,
-                headers: sanitizedHeaders,
-            }));
-        }
-        return baseFetch(input, {
-            ...init,
-            headers: sanitizedHeaders,
-        });
-    };
-}
-export function normalizeOpenAICompatibleInit(init) {
-    const normalized = { ...init };
-    const configuration = asObject(init.configuration) ?? {};
-    const modelKwargs = asObject(init.modelKwargs) ?? {};
-    const baseUrl = typeof init.baseUrl === "string" && init.baseUrl.trim() ? init.baseUrl.trim() : undefined;
-    const omitAuthHeader = init.omitAuthHeader === true || isPlaceholderApiKey(init.apiKey);
-    const nextConfiguration = { ...configuration };
-    if (baseUrl && typeof nextConfiguration.baseURL !== "string") {
-        nextConfiguration.baseURL = baseUrl;
-    }
-    if (omitAuthHeader) {
-        nextConfiguration.fetch = buildAuthOmittingFetch(typeof configuration.fetch === "function" ? configuration.fetch : fetch);
-    }
-    if (typeof init.numPredict === "number" && typeof normalized.maxTokens !== "number") {
-        normalized.maxTokens = init.numPredict;
-    }
-    if (typeof init.numCtx === "number" && typeof modelKwargs.num_ctx !== "number") {
-        normalized.modelKwargs = {
-            ...modelKwargs,
-            num_ctx: init.numCtx,
-        };
-    }
-    normalized.configuration = nextConfiguration;
-    delete normalized.baseUrl;
-    delete normalized.omitAuthHeader;
-    delete normalized.numPredict;
-    delete normalized.numCtx;
-    return normalized;
-}
+function d(e){return typeof e=="object"&&e?e:void 0}function f(e){return typeof e=="string"&&e.trim().toLowerCase()==="dummy"}function u(e=fetch){return async(t,r)=>{const n=new Headers(t instanceof Request?t.headers:void 0);return new Headers(r?.headers).forEach((a,o)=>{n.set(o,a)}),n.delete("authorization"),t instanceof Request?e(new Request(t,{...r,headers:n})):e(t,{...r,headers:n})}}function c(e){const t={...e},r=d(e.configuration)??{},n=d(e.modelKwargs)??{},s=typeof e.baseUrl=="string"&&e.baseUrl.trim()?e.baseUrl.trim():void 0,a=e.omitAuthHeader===!0||f(e.apiKey),o={...r};return s&&typeof o.baseURL!="string"&&(o.baseURL=s),a&&(o.fetch=u(typeof r.fetch=="function"?r.fetch:fetch)),typeof e.numPredict=="number"&&typeof t.maxTokens!="number"&&(t.maxTokens=e.numPredict),typeof e.numCtx=="number"&&typeof n.num_ctx!="number"&&(t.modelKwargs={...n,num_ctx:e.numCtx}),t.configuration=o,delete t.baseUrl,delete t.omitAuthHeader,delete t.numPredict,delete t.numCtx,t}export{u as buildAuthOmittingFetch,c as normalizeOpenAICompatibleInit};