@botbotgo/agent-harness 0.0.309 → 0.0.310

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

@@ -0,0 +1,33 @@
+import type { RuntimeAdapterOptions, WorkspaceBundle } from "../contracts/types.js";
+export type ResourceToolInfo = {
+    toolPath: string;
+    backendOperation: string;
+    name: string;
+    description: string;
+    retryable?: boolean;
+    hitl?: {
+        enabled: boolean;
+        allow: Array<"approve" | "edit" | "reject">;
+    };
+};
+export type ResourceProvider = {
+    listResourceTools?: () => ResourceToolInfo[];
+    listBuiltinTools?: () => ResourceToolInfo[];
+    createResourceToolResolver?: (workspace: WorkspaceBundle, options?: {
+        getStore?: (_binding?: WorkspaceBundle["bindings"] extends Map<any, infer T> ? T : never) => unknown;
+        getEmbeddingModel?: (embeddingModelRef?: string, _binding?: WorkspaceBundle["bindings"] extends Map<any, infer T> ? T : never) => Promise<unknown>;
+        getVectorStore?: (vectorStoreRef?: string, _binding?: WorkspaceBundle["bindings"] extends Map<any, infer T> ? T : never) => Promise<unknown>;
+    }) => NonNullable<RuntimeAdapterOptions["toolResolver"]>;
+    createBuiltinToolResolver?: (workspace: WorkspaceBundle, options?: {
+        getStore?: (_binding?: WorkspaceBundle["bindings"] extends Map<any, infer T> ? T : never) => unknown;
+        getEmbeddingModel?: (embeddingModelRef?: string, _binding?: WorkspaceBundle["bindings"] extends Map<any, infer T> ? T : never) => Promise<unknown>;
+        getVectorStore?: (vectorStoreRef?: string, _binding?: WorkspaceBundle["bindings"] extends Map<any, infer T> ? T : never) => Promise<unknown>;
+    }) => NonNullable<RuntimeAdapterOptions["toolResolver"]>;
+    createResourceBackendResolver?: (workspace: WorkspaceBundle) => NonNullable<RuntimeAdapterOptions["backendResolver"]>;
+    createBuiltinBackendResolver?: (workspace: WorkspaceBundle) => NonNullable<RuntimeAdapterOptions["backendResolver"]>;
+    defaultResourceSkillsRoot?: () => string;
+    builtinSkillsRoot?: () => string;
+    defaultResourceConfigRoot?: () => string;
+    builtinConfigRoot?: () => string;
+    builtinDefaultsRoot?: () => string;
+};

package/dist/resource/resource-types.js

@@ -0,0 +1 @@
+export {};

package/dist/resource/tools/function-tool-resolver.d.ts

@@ -0,0 +1,2 @@
+import type { RuntimeAdapterOptions, WorkspaceBundle } from "../../contracts/types.js";
+export declare function createFunctionToolResolver(workspace: WorkspaceBundle): NonNullable<RuntimeAdapterOptions["toolResolver"]>;

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

@@ -0,0 +1,306 @@
+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 { 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 }));
+    });
+}
+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 : {}),
+                        },
+                    });
+                },
+            },
+        ];
+    });
+}

package/dist/runtime/adapter/middleware-assembly.js

@@ -9,7 +9,7 @@ import { resolveDeclaredMiddleware } from "./tool/declared-middleware.js";
 import { UPSTREAM_SESSION_CONFIG_KEY } from "./upstream-configurable-keys.js";
 import { bindingHasLangChainSubagentSupport, bindingHasMiddlewareKind, getBindingExecutionKind, getBindingGeneralPurposeAgent, getBindingInterruptCompatibilityRules, getBindingMiddlewareConfigs, getBindingMemorySources, getBindingPrimaryModel, getBindingPrimaryTools, getBindingSkills, getBindingSubagents, getBindingTaskDescription, isDeepAgentBinding, isLangChainBinding, } from "../support/compiled-binding.js";
 import { applyDeepAgentDelegationPromptCompatibility, materializeDeepAgentSkillSourcePaths } from "./compat/deepagent-compat.js";
-import { DEFAULT_SUBAGENT_PROMPT } from "../support/runtime-prompts.js";
+import { DEFAULT_SUBAGENT_PROMPT } from "../prompts/runtime-prompts.js";
 export function buildBuiltinTaskSubagentMiddleware(input) {
     const { selectedSubagent, builtinBackend, summarizationModel } = input;
     const defaultSubagentMiddleware = [

package/dist/runtime/adapter/model/invocation-request.js

@@ -1,8 +1,8 @@
 import { getBindingSkills } from "../../support/compiled-binding.js";
 import { extractMessageText, normalizeMessageContent } from "../../../utils/message-content.js";
-import { readSkillMetadata } from "../../support/skill-metadata.js";
+import { readSkillMetadata } from "../../skills/skill-metadata.js";
 import { summarizeAssistantText } from "../direct-builtin-utility.js";
-import { renderDurableMemoryContextPrompt, renderSlashCommandSkillInstruction } from "../../support/runtime-prompts.js";
+import { renderDurableMemoryContextPrompt, renderSlashCommandSkillInstruction } from "../../prompts/runtime-prompts.js";
 import { hasExplicitResourceReference, } from "../../harness/system/runtime-memory-policy.js";
 const MAX_HISTORY_ASSISTANT_CHARS = 1600;
 const MAX_HISTORY_ASSISTANT_LINES = 40;

package/dist/runtime/adapter/model/message-assembly.js

@@ -1,5 +1,5 @@
 import { buildAgentMessages, buildSlashCommandSkillInstruction } from "./invocation-request.js";
-import { renderDurableMemoryContextPrompt } from "../../support/runtime-prompts.js";
+import { renderDurableMemoryContextPrompt } from "../../prompts/runtime-prompts.js";
 export function buildStateSnapshot(result) {
     const snapshot = { ...result };
     delete snapshot.messages;

package/dist/runtime/agent-runtime-adapter.d.ts

@@ -1,8 +1,7 @@
-import type { CompiledAgentBinding, CompiledAsyncSubAgent, MessageContent, RequestResult, RuntimeAdapterOptions, TranscriptMessage } from "../contracts/types.js";
+import type { CompiledAgentBinding, MessageContent, RequestResult, RuntimeAdapterOptions, TranscriptMessage } from "../contracts/types.js";
 import { type RuntimeStreamChunk } from "./parsing/stream-event-parsing.js";
-import type { ExecutableTool } from "./adapter/flow/invoke-runtime.js";
+import { AGENT_INTERRUPT_SENTINEL_PREFIX, buildDeepAgentCreateParams, buildLangChainCreateParams, buildMinimalDeepAgentCreateParams, materializeModelExposedBuiltinMiddlewareTools, resolveLangChainInvocationConfig, resolveRunnableCheckpointer, resolveRunnableInterruptOn, shouldUseMinimalDeepAgentAssembly } from "./agent-runtime-assembly.js";
 import { RuntimeOperationTimeoutError } from "./adapter/runtime-shell.js";
-import { type UpstreamSubagentConfig } from "./adapter/middleware-assembly.js";
 export { applyDeepAgentDelegationPromptCompatibility, materializeDeepAgentSkillSourcePaths, resolveDeepAgentSkillSourcePaths, relativizeDeepAgentSkillSourcePaths, shouldRelaxDeepAgentDelegationPrompt, } from "./adapter/compat/deepagent-compat.js";
 export { buildAuthOmittingFetch, normalizeOpenAICompatibleInit } from "./adapter/compat/openai-compatible.js";
 export { buildToolNameMapping, createModelFacingToolNameCandidates, createModelFacingToolNameLookupCandidates, resolveModelFacingToolName, sanitizeToolNameForModel, } from "./adapter/tool/tool-name-mapping.js";
@@ -12,65 +11,6 @@ type RunnableLike = {
     stream?: (input: unknown, config?: Record<string, unknown>) => Promise<AsyncIterable<unknown>>;
     streamEvents?: (input: unknown, config?: Record<string, unknown>) => Promise<AsyncIterable<unknown>>;
 };
-declare const AGENT_INTERRUPT_SENTINEL_PREFIX = "__agent_harness_interrupt__:";
-export declare function materializeModelExposedBuiltinMiddlewareTools(input: {
-    builtinTools: Map<string, ExecutableTool>;
-    explicitToolNames?: string[];
-}): unknown[];
-export declare function resolveRunnableCheckpointer(options: RuntimeAdapterOptions, binding: CompiledAgentBinding): unknown;
-export declare function resolveRunnableInterruptOn(binding: CompiledAgentBinding): Record<string, {
-    allowedDecisions: import("./adapter/tool/interrupt-policy.js").InterruptDecision[];
-}> | undefined;
-export declare function buildLangChainCreateParams(input: {
-    binding: CompiledAgentBinding;
-    resolvedModel: unknown;
-    resolvedTools: unknown[];
-    resolvedMiddleware: unknown[];
-    resolvedCheckpointer: unknown;
-    resolvedStore: unknown;
-    passthroughOverride?: Record<string, unknown>;
-    systemPromptOverride?: string;
-}): Record<string, unknown>;
-export declare function resolveLangChainInvocationConfig(binding: CompiledAgentBinding, options: {
-    sessionId: string;
-    requestId: string;
-    legacySessionId?: string;
-    legacyRequestId?: string;
-    context?: Record<string, unknown>;
-    toolRuntimeContext?: Record<string, unknown>;
-}): Record<string, unknown>;
-export declare function buildDeepAgentCreateParams(input: {
-    binding: CompiledAgentBinding;
-    resolvedModel: unknown;
-    resolvedTools: unknown[];
-    resolvedMiddleware: unknown[];
-    resolvedSubagents: Array<UpstreamSubagentConfig | CompiledAsyncSubAgent>;
-    resolvedCheckpointer?: unknown;
-    resolvedStore?: unknown;
-    resolvedBackend?: unknown;
-    resolvedInterruptOn?: Record<string, {
-        allowedDecisions: Array<"approve" | "edit" | "reject">;
-    }>;
-    resolvedSkills: string[];
-}): Record<string, unknown>;
-export declare function shouldUseMinimalDeepAgentAssembly(input: {
-    binding: CompiledAgentBinding;
-    resolvedMiddleware: unknown[];
-    resolvedSubagents: Array<UpstreamSubagentConfig | CompiledAsyncSubAgent>;
-    resolvedInterruptOn?: Record<string, {
-        allowedDecisions: Array<"approve" | "edit" | "reject">;
-    }>;
-    resolvedSkills: string[];
-    resolvedBackend?: unknown;
-}): boolean;
-export declare function buildMinimalDeepAgentCreateParams(input: {
-    binding: CompiledAgentBinding;
-    resolvedModel: unknown;
-    resolvedTools: unknown[];
-    resolvedCheckpointer?: unknown;
-    resolvedStore?: unknown;
-    resolvedBackend: unknown;
-}): Record<string, unknown>;
 export declare class AgentRuntimeAdapter {
     private readonly options;
     private readonly modelCache;
@@ -125,4 +65,4 @@ export declare class AgentRuntimeAdapter {
         toolRuntimeContext?: Record<string, unknown>;
     }): AsyncGenerator<RuntimeStreamChunk | string>;
 }
-export { AgentRuntimeAdapter as RuntimeAdapter, AGENT_INTERRUPT_SENTINEL_PREFIX, AGENT_INTERRUPT_SENTINEL_PREFIX as INTERRUPT_SENTINEL_PREFIX, RuntimeOperationTimeoutError, };
+export { AgentRuntimeAdapter as RuntimeAdapter, AGENT_INTERRUPT_SENTINEL_PREFIX, AGENT_INTERRUPT_SENTINEL_PREFIX as INTERRUPT_SENTINEL_PREFIX, buildDeepAgentCreateParams, buildLangChainCreateParams, buildMinimalDeepAgentCreateParams, materializeModelExposedBuiltinMiddlewareTools, resolveLangChainInvocationConfig, resolveRunnableCheckpointer, resolveRunnableInterruptOn, shouldUseMinimalDeepAgentAssembly, RuntimeOperationTimeoutError, };