@botbotgo/agent-harness 0.0.134 → 0.0.135

package/dist/resource/resource-impl.js

@@ -1,11 +1,13 @@
 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, LocalShellBackend, StateBackend, StoreBackend } from "deepagents";
-import { getBindingBackendConfig } from "../runtime/support/compiled-binding.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";
@@ -273,6 +275,142 @@ function createWorkspaceProviderResolvers(workspace, factory) {
         .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: {
+                ...process.env,
+                ...(config.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);
@@ -285,7 +423,7 @@ async function loadFunctionToolModule(tool) {
         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, description: loaded.description };
+        return { invoke: loaded.invoke, schema: loaded.schema, description: loaded.description, isolatedSourcePath, implementationName };
     })();
     functionToolModuleCache.set(cacheKey, loading);
     return loading;
@@ -294,7 +432,7 @@ 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) => toolIds.flatMap((toolId) => {
+    return (toolIds, binding) => toolIds.flatMap((toolId) => {
         const tool = functionTools.get(toolId);
         if (!tool) {
             return [];
@@ -307,12 +445,63 @@ function createFunctionToolResolver(workspace) {
                     const loaded = await loadFunctionToolModule(tool);
                     const parsedInput = loaded.schema.parse(input ?? {});
                     const toolPackageRoot = await findPackageRoot(tool.sourcePath);
-                    return loaded.invoke(parsedInput, {
+                    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 toolContext = {
                         appRoot: workspace.workspaceRoot,
                         toolId: tool.id,
                         toolPath: tool.sourcePath,
                         toolPackageRoot,
-                    });
+                        embeddingModel,
+                        model,
+                        runtime: {
+                            workspaceRoot: workspace.workspaceRoot,
+                            runRoot: binding?.harnessRuntime.runRoot,
+                        },
+                        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, toolContext);
+                    }
+                    return loaded.invoke(parsedInput, toolContext);
                 },
             },
         ];
@@ -431,7 +620,10 @@ export function createResourceToolResolver(workspace, options = {}) {
         ];
         const deduped = new Map();
         for (const tool of resolved) {
-            deduped.set(String(tool.name), tool);
+            const name = String(tool.name);
+            if (!deduped.has(name)) {
+                deduped.set(name, tool);
+            }
         }
         return Array.from(deduped.values());
     };

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

@@ -5,7 +5,9 @@ export declare class RuntimeOperationTimeoutError extends Error {
     readonly stage: "stream" | "invoke";
     constructor(operation: string, timeoutMs: number, stage?: "stream" | "invoke");
 }
-export declare function invokeWithProviderRetry<T>(binding: CompiledAgentBinding, operation: () => Promise<T>): Promise<T>;
+export declare function invokeWithProviderRetry<T>(binding: CompiledAgentBinding, operation: () => Promise<T>, options?: {
+    onRetry?: (attempt: number, error: unknown) => void | Promise<void>;
+}): Promise<T>;
 export declare function withRuntimeTimeout<T>(producer: () => T | Promise<T>, timeoutMs: number | undefined, operation: string, stage?: "stream" | "invoke"): Promise<T>;
 export declare function iterateWithTimeout<T>(iterable: AsyncIterable<T>, timeoutMs: number | undefined, operation: string, deadlineAt?: number, deadlineTimeoutMs?: number): AsyncGenerator<T>;
 export declare function materializeModelStream(streamFactory: (input: unknown, config?: Record<string, unknown>) => Promise<AsyncIterable<unknown>>, input: unknown, config?: Record<string, unknown>): Promise<{

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

@@ -15,7 +15,7 @@ export class RuntimeOperationTimeoutError extends Error {
         this.name = "RuntimeOperationTimeoutError";
     }
 }
-export async function invokeWithProviderRetry(binding, operation) {
+export async function invokeWithProviderRetry(binding, operation, options = {}) {
     const retryPolicy = resolveProviderRetryPolicy(binding);
     let lastError;
     for (let attempt = 1; attempt <= retryPolicy.maxAttempts; attempt += 1) {
@@ -27,6 +27,7 @@ export async function invokeWithProviderRetry(binding, operation) {
             if (attempt >= retryPolicy.maxAttempts || !isRetryableProviderError(binding, error)) {
                 throw error;
             }
+            await options.onRetry?.(attempt, error);
             if (retryPolicy.backoffMs > 0) {
                 await sleep(retryPolicy.backoffMs);
             }

package/dist/runtime/adapter/tool/tool-arguments.js

@@ -37,6 +37,7 @@ export function normalizeToolArgsForSchema(args, schema) {
     const aliasesByExpected = {
         city: ["location", "locality", "place"],
         location: ["city", "city_name"],
+        query: ["question", "prompt", "text", "request"],
     };
     const aliases = aliasesByExpected[expectedKey] ?? [];
     const aliasKey = aliases.find((candidate) => candidate in args);

package/dist/runtime/adapter/tool/tool-hitl.js

@@ -107,6 +107,9 @@ function wrapToolWithDedupe(resolvedTool, compiledTool) {
     });
 }
 function shouldConstrainWorkspacePaths(compiledTool) {
+    if (compiledTool.type === "mcp") {
+        return false;
+    }
     const normalized = `${compiledTool.name} ${compiledTool.description}`.toLowerCase();
     if (/(web[_ .-]?search|fetch[_ .-]?url|https?:\/\/|\burl\b)/.test(normalized)) {
         return false;

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

@@ -26,6 +26,11 @@ export declare function buildLangChainCreateParams(input: {
     passthroughOverride?: Record<string, unknown>;
     systemPromptOverride?: string;
 }): Record<string, unknown>;
+export declare function resolveLangChainInvocationConfig(binding: CompiledAgentBinding, options: {
+    threadId: string;
+    runId: string;
+    context?: Record<string, unknown>;
+}): Record<string, unknown>;
 export declare function buildDeepAgentCreateParams(input: {
     binding: CompiledAgentBinding;
     resolvedModel: unknown;
@@ -54,6 +59,7 @@ export declare class AgentRuntimeAdapter {
     private createModelFallbackRunnable;
     private applyStrictToolJsonInstruction;
     private resolveModel;
+    private invalidateBindingRuntimeCaches;
     private resolveTools;
     private getToolNameMapping;
     private resolveFilesystemBackend;

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

@@ -89,6 +89,24 @@ export function buildLangChainCreateParams(input) {
         store: input.resolvedStore,
     };
 }
+export function resolveLangChainInvocationConfig(binding, options) {
+    const langchainPassthrough = typeof binding.harnessRuntime.langchain?.passthrough === "object" && binding.harnessRuntime.langchain?.passthrough
+        ? binding.harnessRuntime.langchain.passthrough
+        : undefined;
+    const config = {
+        configurable: {
+            thread_id: options.threadId,
+            run_id: options.runId,
+        },
+    };
+    if (typeof langchainPassthrough?.recursionLimit === "number") {
+        config.recursionLimit = langchainPassthrough.recursionLimit;
+    }
+    if (options.context) {
+        config.context = options.context;
+    }
+    return config;
+}
 export function buildDeepAgentCreateParams(input) {
     const executionKind = getBindingExecutionKind(input.binding);
     if (executionKind !== "deepagent" || !getBindingExecutionParams(input.binding)) {
@@ -155,7 +173,11 @@ export class AgentRuntimeAdapter {
         });
     }
     async invokeWithProviderRetry(binding, operation) {
-        return invokeWithProviderRetryHelper(binding, operation);
+        return invokeWithProviderRetryHelper(binding, operation, {
+            onRetry: async () => {
+                this.invalidateBindingRuntimeCaches(binding);
+            },
+        });
     }
     async withTimeout(producer, timeoutMs, operation, stage = operation.includes("stream") ? "stream" : "invoke") {
         return withRuntimeTimeout(producer, timeoutMs, operation, stage);
@@ -190,6 +212,10 @@ export class AgentRuntimeAdapter {
             throw error;
         }
     }
+    invalidateBindingRuntimeCaches(binding) {
+        this.runnableCache.delete(binding);
+        this.modelCache.clear();
+    }
     resolveTools(tools, binding) {
         return resolveAdapterTools({
             tools,
@@ -418,7 +444,11 @@ export class AgentRuntimeAdapter {
         const callRuntime = async (activeBinding, activeRequest) => {
             return this.invokeWithProviderRetry(activeBinding, async () => {
                 const runnable = await this.create(activeBinding);
-                return (await this.withTimeout(() => runnable.invoke(activeRequest, { configurable: { thread_id: threadId, run_id: runId }, ...(options.context ? { context: options.context } : {}) }), resolveBindingTimeout(activeBinding), "agent invoke", "invoke"));
+                return (await this.withTimeout(() => runnable.invoke(activeRequest, resolveLangChainInvocationConfig(activeBinding, {
+                    threadId,
+                    runId,
+                    context: options.context,
+                })), resolveBindingTimeout(activeBinding), "agent invoke", "invoke"));
             });
         };
         const callRuntimeWithToolParseRecovery = async (activeRequest) => {

package/dist/runtime/harness.js

@@ -21,6 +21,7 @@ import { dropPendingRunSlot, enqueuePendingRunSlot } from "./harness/run/run-que
 import { getDefaultRuntimeEntryAgentId, resolveSelectedAgentId, routeAgentId } from "./harness/run/routing.js";
 import { resolveStoreFromConfig, } from "./harness/run/resources.js";
 import { createToolMcpServerFromTools, serveToolsOverStdioFromHarness } from "../mcp.js";
+import { closeMcpClientsForWorkspace } from "../resource/mcp-tool-support.js";
 import { getBindingRuntimeExecutionMode, } from "./support/compiled-binding.js";
 import { bindingSupportsRunningReplay, getWorkspaceBinding, resolveWorkspaceAgentTools, } from "./harness/bindings.js";
 import { describeWorkspaceInventory, getAgentInventoryRecord, listAgentSkills as listWorkspaceAgentSkills, } from "./harness/system/inventory.js";
@@ -584,6 +585,7 @@ export class AgentHarnessRuntime {
         await Promise.allSettled(Array.from(this.backgroundTasks));
         await this.threadMemorySync?.close();
         await this.mem0IngestionSync?.close();
+        await closeMcpClientsForWorkspace(this.workspace);
         this.initialized = false;
     }
     async stop() {

package/dist/workspace/agent-binding-compiler.d.ts

@@ -1,4 +1,4 @@
-import type { CompiledAgentBinding, CompiledTool, ParsedAgentObject, ParsedModelObject, ParsedToolObject, WorkspaceObject } from "../contracts/types.js";
+import type { CompiledAgentBinding, CompiledTool, ParsedAgentObject, ParsedAgentToolBinding, ParsedModelObject, ParsedToolObject, WorkspaceObject } from "../contracts/types.js";
 export declare function compileAgentSkills(workspaceRoot: string, agent: ParsedAgentObject, parentSkills?: string[]): string[];
-export declare function requireTools(tools: Map<string, ParsedToolObject>, refs: string[], ownerId: string): CompiledTool[];
+export declare function requireTools(tools: Map<string, ParsedToolObject>, bindings: ParsedAgentToolBinding[], ownerId: string): CompiledTool[];
 export declare function compileBinding(workspaceRoot: string, agent: ParsedAgentObject, agents: Map<string, ParsedAgentObject>, referencedSubagentIds: Set<string>, refs: Map<string, WorkspaceObject | ParsedAgentObject>, models: Map<string, ParsedModelObject>, tools: Map<string, ParsedToolObject>): CompiledAgentBinding;

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

@@ -74,13 +74,85 @@ function resolveAgentRuntimeName(agent) {
     }
     return baseName;
 }
-export function requireTools(tools, refs, ownerId) {
-    const compiled = refs.flatMap((ref) => {
-        const targets = resolveToolTargets(tools, ref);
+function asObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function mergeConfigValue(base, override) {
+    if (override === undefined) {
+        return base;
+    }
+    if (Array.isArray(base) && Array.isArray(override)) {
+        return override;
+    }
+    if (typeof base === "object" && base && typeof override === "object" && override && !Array.isArray(base) && !Array.isArray(override)) {
+        const merged = { ...base };
+        for (const [key, value] of Object.entries(override)) {
+            merged[key] = key in merged ? mergeConfigValue(merged[key], value) : value;
+        }
+        return merged;
+    }
+    return override;
+}
+function mergeConfigObjects(base, override) {
+    const merged = mergeConfigValue(base, override);
+    return typeof merged === "object" && merged && !Array.isArray(merged)
+        ? merged
+        : undefined;
+}
+function parseHitlOverride(value) {
+    const record = asObject(value);
+    if (!record) {
+        return undefined;
+    }
+    const enabled = record.enabled === true;
+    const allow = Array.isArray(record.allow)
+        ? record.allow.filter((item) => item === "approve" || item === "edit" || item === "reject")
+        : undefined;
+    return {
+        enabled,
+        allow: allow && allow.length > 0 ? allow : undefined,
+    };
+}
+function applyToolBindingOverrides(tool, binding) {
+    const overrides = binding.overrides;
+    if (!overrides || Object.keys(overrides).length === 0) {
+        return tool;
+    }
+    const overrideConfig = mergeConfigObjects(asObject(overrides.config), asObject(overrides.execution)
+        ? {
+            execution: asObject(overrides.execution),
+        }
+        : undefined);
+    return {
+        ...tool,
+        ...(typeof overrides.name === "string" ? { name: overrides.name } : {}),
+        ...(typeof overrides.description === "string" ? { description: overrides.description } : {}),
+        ...(typeof overrides.implementationName === "string" ? { implementationName: overrides.implementationName } : {}),
+        ...(typeof overrides.inputSchemaRef === "string" ? { inputSchemaRef: overrides.inputSchemaRef } : {}),
+        ...(typeof overrides.embeddingModelRef === "string" ? { embeddingModelRef: overrides.embeddingModelRef } : {}),
+        ...(typeof overrides.backendOperation === "string" ? { backendOperation: overrides.backendOperation } : {}),
+        ...(typeof overrides.mcpRef === "string" ? { mcpRef: overrides.mcpRef } : {}),
+        ...(typeof overrides.subprocess === "boolean" ? { subprocess: overrides.subprocess } : {}),
+        ...(typeof overrides.retryable === "boolean" ? { retryable: overrides.retryable } : {}),
+        ...(overrides.hitl !== undefined ? { hitl: parseHitlOverride(overrides.hitl) } : {}),
+        ...(overrideConfig ? { config: mergeConfigObjects(tool.config, overrideConfig) } : {}),
+    };
+}
+function getAgentToolBindings(agent) {
+    if (agent.toolBindings && agent.toolBindings.length > 0) {
+        return agent.toolBindings;
+    }
+    return agent.toolRefs.map((ref) => ({ ref }));
+}
+export function requireTools(tools, bindings, ownerId) {
+    const compiled = bindings.flatMap((binding) => {
+        const targets = resolveToolTargets(tools, binding.ref);
         if (targets.length === 0) {
-            throw new Error(`Agent ${ownerId} references missing tool ${ref}`);
+            throw new Error(`Agent ${ownerId} references missing tool ${binding.ref}`);
         }
-        return targets.flatMap((tool) => compileTool(tool, tools));
+        return targets.flatMap((tool) => compileTool(applyToolBindingOverrides(tool, binding), tools));
     });
     const deduped = new Map();
     for (const tool of compiled) {
@@ -138,7 +210,7 @@ function compileSubagents(agent, agents, workspaceRoot, models, tools, compiledA
 function compileExecutionCore(agent, models, tools) {
     return {
         model: requireModel(models, agent.modelRef, agent.id),
-        tools: requireTools(tools, agent.toolRefs, agent.id),
+        tools: requireTools(tools, getAgentToolBindings(agent), agent.id),
         systemPrompt: resolveSystemPrompt(agent),
         responseFormat: resolveResponseFormat(agent),
         contextSchema: resolveContextSchema(agent),

package/dist/workspace/compile.js

@@ -42,6 +42,17 @@ function validateWorkspaceResources(embeddings, mcpServers, models, vectorStores
     models.forEach((model) => validateModelObject(model, models));
     vectorStores.forEach((vectorStore) => validateVectorStoreObject(vectorStore));
     tools.forEach((tool) => validateToolObject(tool, tools));
+    tools.forEach((tool) => {
+        if (!tool.embeddingModelRef) {
+            return;
+        }
+        const embeddingModelId = tool.embeddingModelRef.startsWith("embedding-model/")
+            ? tool.embeddingModelRef.slice("embedding-model/".length)
+            : tool.embeddingModelRef;
+        if (!embeddings.has(embeddingModelId)) {
+            throw new Error(`Tool ${tool.id} references missing embedding model ${tool.embeddingModelRef}`);
+        }
+    });
     agents.forEach(validateAgent);
     validateTopology(agents);
     tools.forEach((tool) => {
@@ -91,6 +102,11 @@ export async function loadWorkspace(workspaceRoot, options = {}) {
         loaded.refs.set(`agent/${agent.id}`, agent);
     }
     const { embeddings, mcpServers, models, vectorStores, tools } = collectParsedResources(loaded.refs);
+    for (const agent of loaded.agents) {
+        for (const tool of agent.inlineTools ?? []) {
+            tools.set(tool.id, tool);
+        }
+    }
     await hydrateAgentMcpTools(loaded.agents, mcpServers, tools);
     const toolSourceRefs = collectToolSourceRefs(tools, loaded.agents, options);
     await ensureResourceSources(toolSourceRefs, workspaceRoot);