promptfoo 0.121.1 → 0.121.3

package/dist/src/{agents-B0f4HICh.cjs → agents-CAYbM7qD.cjs}

@@ -1,10 +1,43 @@
-const require_logger = require("./logger-Cp1GPUjj.cjs");
-const require_esm = require("./esm-CnNt7sI4.cjs");
-const require_fetch = require("./fetch-BxUk8odA.cjs");
-const require_openai = require("./openai-Cuif0GEt.cjs");
+const require_logger = require("./logger-D5iKBpu_.cjs");
+const require_esm = require("./esm-CipptfDu.cjs");
+const require_fetch = require("./fetch-BnR9wSnm.cjs");
+const require_openai = require("./openai-CoxGAQwn.cjs");
 let path = require("path");
 path = require_logger.__toESM(path);
 let _openai_agents = require("@openai/agents");
+//#region src/providers/openai/agents-model-settings.ts
+function resolveModelSettings(modelSettings) {
+	if (!modelSettings) return;
+	const retry = modelSettings.retry ? {
+		...modelSettings.retry,
+		policy: resolveRetryPolicy(modelSettings.retry.policy)
+	} : void 0;
+	return {
+		...modelSettings,
+		retry
+	};
+}
+function resolveRetryPolicy(policy) {
+	if (!policy) return;
+	if (typeof policy === "function") return policy;
+	if (typeof policy === "string") switch (policy) {
+		case "never": return _openai_agents.retryPolicies.never();
+		case "providerSuggested": return _openai_agents.retryPolicies.providerSuggested();
+		case "networkError": return _openai_agents.retryPolicies.networkError();
+		case "retryAfter": return _openai_agents.retryPolicies.retryAfter();
+		default: return;
+	}
+	if ("httpStatus" in policy) return _openai_agents.retryPolicies.httpStatus(policy.httpStatus);
+	if ("any" in policy) {
+		const policies = policy.any.map((nestedPolicy) => resolveRetryPolicy(nestedPolicy)).filter((nestedPolicy) => !!nestedPolicy);
+		return policies.length ? _openai_agents.retryPolicies.any(...policies) : void 0;
+	}
+	if ("all" in policy) {
+		const policies = policy.all.map((nestedPolicy) => resolveRetryPolicy(nestedPolicy)).filter((nestedPolicy) => !!nestedPolicy);
+		return policies.length ? _openai_agents.retryPolicies.all(...policies) : void 0;
+	}
+}
+//#endregion
 //#region src/providers/openai/agents-loader.ts
 /**
 * Load agent definition from file path or return inline definition
@@ -29,6 +62,82 @@ async function loadAgentDefinition(agentConfig) {
 	throw new Error("Invalid agent configuration: expected Agent instance, file:// URL, or inline definition");
 }
 /**
+* Load tools from file path or return inline definitions
+*/
+async function loadTools(toolsConfig) {
+	if (!toolsConfig) return;
+	if (typeof toolsConfig === "string" && toolsConfig.startsWith("file://")) {
+		require_logger.logger.debug("[AgentsLoader] Loading tools from file", { path: toolsConfig });
+		return await loadToolsFromFile(toolsConfig);
+	}
+	if (Array.isArray(toolsConfig)) {
+		require_logger.logger.debug("[AgentsLoader] Using inline tool definitions");
+		return normalizeTools(toolsConfig);
+	}
+	require_logger.logger.debug("[AgentsLoader] Invalid tools configuration", {
+		type: typeof toolsConfig,
+		isArray: Array.isArray(toolsConfig)
+	});
+	throw new Error("Invalid tools configuration: expected file:// URL or array");
+}
+/**
+* Load handoffs from file path or return inline definitions
+*/
+async function loadHandoffs(handoffsConfig) {
+	if (!handoffsConfig) return;
+	if (typeof handoffsConfig === "string" && handoffsConfig.startsWith("file://")) {
+		require_logger.logger.debug("[AgentsLoader] Loading handoffs from file", { path: handoffsConfig });
+		return await loadHandoffsFromFile(handoffsConfig);
+	}
+	if (Array.isArray(handoffsConfig)) {
+		require_logger.logger.debug("[AgentsLoader] Using inline handoff definitions");
+		return normalizeHandoffs(handoffsConfig);
+	}
+	require_logger.logger.debug("[AgentsLoader] Invalid handoffs configuration", {
+		type: typeof handoffsConfig,
+		isArray: Array.isArray(handoffsConfig)
+	});
+	throw new Error("Invalid handoffs configuration: expected file:// URL or array");
+}
+/**
+* Load input guardrails from file path or return inline definitions
+*/
+async function loadInputGuardrails(guardrailsConfig) {
+	if (!guardrailsConfig) return;
+	if (typeof guardrailsConfig === "string" && guardrailsConfig.startsWith("file://")) {
+		require_logger.logger.debug("[AgentsLoader] Loading input guardrails from file", { path: guardrailsConfig });
+		return await loadArrayFromFile(guardrailsConfig, "input guardrails");
+	}
+	if (Array.isArray(guardrailsConfig)) {
+		require_logger.logger.debug("[AgentsLoader] Using inline input guardrails");
+		return guardrailsConfig;
+	}
+	require_logger.logger.debug("[AgentsLoader] Invalid input guardrails configuration", {
+		type: typeof guardrailsConfig,
+		isArray: Array.isArray(guardrailsConfig)
+	});
+	throw new Error("Invalid input guardrails configuration: expected file:// URL or array");
+}
+/**
+* Load output guardrails from file path or return inline definitions
+*/
+async function loadOutputGuardrails(guardrailsConfig) {
+	if (!guardrailsConfig) return;
+	if (typeof guardrailsConfig === "string" && guardrailsConfig.startsWith("file://")) {
+		require_logger.logger.debug("[AgentsLoader] Loading output guardrails from file", { path: guardrailsConfig });
+		return await loadArrayFromFile(guardrailsConfig, "output guardrails");
+	}
+	if (Array.isArray(guardrailsConfig)) {
+		require_logger.logger.debug("[AgentsLoader] Using inline output guardrails");
+		return guardrailsConfig;
+	}
+	require_logger.logger.debug("[AgentsLoader] Invalid output guardrails configuration", {
+		type: typeof guardrailsConfig,
+		isArray: Array.isArray(guardrailsConfig)
+	});
+	throw new Error("Invalid output guardrails configuration: expected file:// URL or array");
+}
+/**
 * Load agent from file
 */
 async function loadAgentFromFile(filePath) {
@@ -48,19 +157,39 @@ async function loadAgentFromFile(filePath) {
 	}
 }
 /**
+* Load tools from file
+*/
+async function loadToolsFromFile(filePath) {
+	return await normalizeTools(await loadArrayFromFile(filePath, "tools")) ?? [];
+}
+/**
+* Load handoffs from file
+*/
+async function loadHandoffsFromFile(filePath) {
+	return await normalizeHandoffs(await loadArrayFromFile(filePath, "handoffs")) ?? [];
+}
+/**
 * Create an Agent instance from an inline definition
 */
 async function createAgentFromDefinition(definition) {
 	try {
-		const { Agent } = await import("@openai/agents");
-		return new Agent({
+		const tools = await normalizeTools(definition.tools);
+		const handoffs = await normalizeHandoffs(definition.handoffs);
+		return new _openai_agents.Agent({
 			name: definition.name,
 			instructions: definition.instructions,
+			prompt: definition.prompt,
 			model: definition.model,
+			modelSettings: resolveModelSettings(definition.modelSettings),
 			handoffDescription: definition.handoffDescription,
 			outputType: definition.outputType,
-			tools: definition.tools,
-			handoffs: definition.handoffs
+			tools,
+			handoffs,
+			inputGuardrails: definition.inputGuardrails,
+			outputGuardrails: definition.outputGuardrails,
+			mcpServers: definition.mcpServers,
+			toolUseBehavior: definition.toolUseBehavior,
+			resetToolChoice: definition.resetToolChoice
 		});
 	} catch (error) {
 		require_logger.logger.error("[AgentsLoader] Failed to create agent from definition", {
@@ -77,7 +206,52 @@ async function createAgentFromDefinition(definition) {
 * Check if a value is an Agent instance
 */
 function isAgentInstance(value) {
-	return value && typeof value === "object" && "name" in value && "instructions" in value && typeof value.name === "string";
+	return value instanceof _openai_agents.Agent;
+}
+function isToolInstance(value) {
+	return !!value && typeof value === "object" && "type" in value && typeof value.type === "string";
+}
+function isHandoffInstance(value) {
+	return !!value && typeof value === "object" && "agent" in value && "getHandoffAsFunctionTool" in value && typeof value.getHandoffAsFunctionTool === "function";
+}
+async function normalizeTools(definitions) {
+	if (!definitions?.length) return;
+	return definitions.map((definition) => {
+		if (isToolInstance(definition)) return definition;
+		return (0, _openai_agents.tool)({
+			name: definition.name,
+			description: definition.description,
+			parameters: definition.parameters,
+			strict: definition.strict ?? true,
+			deferLoading: definition.deferLoading,
+			execute: typeof definition.execute === "function" ? definition.execute : async () => definition.execute
+		});
+	});
+}
+async function normalizeHandoffs(definitions) {
+	if (!definitions?.length) return;
+	return Promise.all(definitions.map(async (definition) => {
+		if (isAgentInstance(definition) || isHandoffInstance(definition)) return definition;
+		const agent = await loadAgentDefinition(definition.agent);
+		if (!definition.description) return agent;
+		return (0, _openai_agents.handoff)(agent, { toolDescriptionOverride: definition.description });
+	}));
+}
+async function loadArrayFromFile(filePath, label) {
+	const resolvedPath = resolveFilePath(filePath);
+	require_logger.logger.debug(`[AgentsLoader] Loading ${label} from resolved path`, { path: resolvedPath });
+	try {
+		const module = await require_esm.importModule(resolvedPath);
+		const exported = module.default || module;
+		if (!Array.isArray(exported)) throw new Error(`File ${resolvedPath} does not export an array of ${label}`);
+		return exported;
+	} catch (error) {
+		require_logger.logger.error(`[AgentsLoader] Failed to load ${label} from file`, {
+			path: resolvedPath,
+			error
+		});
+		throw new Error(`Failed to load ${label} from ${resolvedPath}: ${error}`);
+	}
 }
 /**
 * Resolve file:// path to absolute file system path
@@ -329,8 +503,27 @@ var OpenAiAgentsProvider = class extends require_openai.OpenAiGenericProvider {
 		if (!this.agentConfig.agent) throw new Error("No agent configuration provided");
 		try {
 			const agent = await loadAgentDefinition(this.agentConfig.agent);
-			require_logger.logger.debug("[AgentsProvider] Agent initialized successfully", { name: agent.name });
-			return agent;
+			const [tools, handoffs, inputGuardrails, outputGuardrails] = await Promise.all([
+				loadTools(this.agentConfig.tools),
+				loadHandoffs(this.agentConfig.handoffs),
+				loadInputGuardrails(this.agentConfig.inputGuardrails),
+				loadOutputGuardrails(this.agentConfig.outputGuardrails)
+			]);
+			const configuredAgent = agent.clone({
+				tools: mergeArrays(agent.tools, tools),
+				handoffs: mergeArrays(agent.handoffs, handoffs),
+				inputGuardrails: mergeArrays(agent.inputGuardrails, inputGuardrails),
+				outputGuardrails: mergeArrays(agent.outputGuardrails, outputGuardrails)
+			});
+			const mockAwareAgent = this.wrapToolsIfNeeded(configuredAgent);
+			require_logger.logger.debug("[AgentsProvider] Agent initialized successfully", {
+				name: mockAwareAgent.name,
+				toolCount: mockAwareAgent.tools.length,
+				handoffCount: mockAwareAgent.handoffs.length,
+				inputGuardrailCount: mockAwareAgent.inputGuardrails.length,
+				outputGuardrailCount: mockAwareAgent.outputGuardrails.length
+			});
+			return mockAwareAgent;
 		} catch (error) {
 			require_logger.logger.error("[AgentsProvider] Failed to initialize agent", { error });
 			throw new Error(`Failed to initialize agent: ${error}`);
@@ -389,7 +582,7 @@ var OpenAiAgentsProvider = class extends require_openai.OpenAiGenericProvider {
 				signal: callApiOptions?.abortSignal
 			};
 			if (this.agentConfig.model || this.modelName) runOptions.model = this.agentConfig.model || this.modelName;
-			if (this.agentConfig.modelSettings) runOptions.modelSettings = this.agentConfig.modelSettings;
+			if (this.agentConfig.modelSettings) runOptions.modelSettings = resolveModelSettings(this.agentConfig.modelSettings);
 			const result = await (0, _openai_agents.getOrCreateTrace)(async () => {
 				return await (0, _openai_agents.run)(this.agent, prompt, runOptions);
 			});
@@ -424,8 +617,28 @@ var OpenAiAgentsProvider = class extends require_openai.OpenAiGenericProvider {
 	* Calculate cost from agent result
 	*/
 	calculateCost(_result) {}
+	wrapToolsIfNeeded(agent) {
+		if (this.agentConfig.executeTools !== false && this.agentConfig.executeTools !== "mock") return agent;
+		const toolMocks = this.agentConfig.toolMocks ?? {};
+		const tools = agent.tools.map((tool) => {
+			if (tool.type !== "function") return tool;
+			const mockValue = toolMocks[tool.name];
+			return {
+				...tool,
+				invoke: async () => mockValue ?? {
+					mocked: true,
+					tool: tool.name
+				}
+			};
+		});
+		return agent.clone({ tools });
+	}
 };
+function mergeArrays(existing, additions) {
+	if (!existing?.length && !additions?.length) return;
+	return [...existing ?? [], ...additions ?? []];
+}
 //#endregion
 exports.OpenAiAgentsProvider = OpenAiAgentsProvider;
 
-//# sourceMappingURL=agents-B0f4HICh.cjs.map
+//# sourceMappingURL=agents-CAYbM7qD.cjs.map

package/dist/src/{agents-CVIn-Utx.js → agents-CLQ-P15P.js}

@@ -1,9 +1,9 @@
-import { i as logger, y as getEnvInt } from "./logger-DLcq4dWf.js";
-import "./fetch-4M3YRaqL.js";
-import "./accounts-BgNJDBE6.js";
-import { a as isCacheEnabled, i as getCache } from "./cache-D3eqDYGU.js";
-import { n as telemetry } from "./telemetry-DMb2Mpfm.js";
-import { n as createBedrockRequestHandler, r as hasProxyEnv, t as AwsBedrockGenericProvider } from "./base-fEDN28WM.js";
+import { S as getEnvInt, a as logger } from "./logger-DO8_zM18.js";
+import "./fetch-CVAtKnI3.js";
+import { a as isCacheEnabled, i as getCache } from "./cache-CaT5tPgo.js";
+import "./accounts-B2XmGjty.js";
+import { t as telemetry } from "./telemetry-BugWqKiu.js";
+import { n as createBedrockRequestHandler, r as hasProxyEnv, t as AwsBedrockGenericProvider } from "./base-CqzQ4K8j.js";
 //#region src/providers/bedrock/agents.ts
 /**
 * AWS Bedrock Agents provider for invoking deployed AI agents.
@@ -230,4 +230,4 @@ var AwsBedrockAgentsProvider = class extends AwsBedrockGenericProvider {
 //#endregion
 export { AwsBedrockAgentsProvider };
 
-//# sourceMappingURL=agents-CVIn-Utx.js.map
+//# sourceMappingURL=agents-CLQ-P15P.js.map

package/dist/src/{agents-DeH4Gu94.js → agents-CgBniSlI.js}

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
-import { S as getEnvInt, o as logger } from "./logger-KkObSCzq.js";
-import "./fetch-BMv0O527.js";
-import "./accounts-CMqkzrVf.js";
-import "./cloud-Bc9526yV.js";
-import { r as telemetry } from "./telemetry-C2YDkUQH.js";
-import { o as getCache, s as isCacheEnabled } from "./cache-CG0SlR1d.js";
-import { n as createBedrockRequestHandler, r as hasProxyEnv, t as AwsBedrockGenericProvider } from "./base-B4QJRyFS.js";
+import { T as getEnvInt, s as logger } from "./logger-BcJBzSSA.js";
+import "./fetch-DoVRJZhJ.js";
+import "./accounts-CFLK3mnD.js";
+import "./cloud-z8KZpUoa.js";
+import { r as telemetry } from "./telemetry-BnH5VJAU.js";
+import { o as getCache, s as isCacheEnabled } from "./cache-DSqR6ezl.js";
+import { n as createBedrockRequestHandler, r as hasProxyEnv, t as AwsBedrockGenericProvider } from "./base-CKjwebIH.js";
 //#region src/providers/bedrock/agents.ts
 /**
 * AWS Bedrock Agents provider for invoking deployed AI agents.
@@ -232,4 +232,4 @@ var AwsBedrockAgentsProvider = class extends AwsBedrockGenericProvider {
 //#endregion
 export { AwsBedrockAgentsProvider };
 
-//# sourceMappingURL=agents-DeH4Gu94.js.map
+//# sourceMappingURL=agents-CgBniSlI.js.map

package/dist/src/{agents-CXknwsFX.js → agents-DSSTV4bv.js}

@@ -1,9 +1,42 @@
-import { i as logger, w as state } from "./logger-DLcq4dWf.js";
-import { t as fetchWithProxy } from "./fetch-4M3YRaqL.js";
-import { r as importModule } from "./esm-CaIwzWR5.js";
-import { t as OpenAiGenericProvider } from "./openai-j-sE2O7r.js";
+import { D as state, a as logger } from "./logger-BnkjG2jt.js";
+import { t as fetchWithProxy } from "./fetch-BiYv2BZc.js";
+import { r as importModule } from "./esm-CKWP3u_P.js";
+import { t as OpenAiGenericProvider } from "./openai-D6wITiVn.js";
 import path from "path";
-import { BatchTraceProcessor, addTraceProcessor, getOrCreateTrace, run, startTraceExportLoop } from "@openai/agents";
+import { Agent, BatchTraceProcessor, addTraceProcessor, getOrCreateTrace, handoff, retryPolicies, run, startTraceExportLoop, tool } from "@openai/agents";
+//#region src/providers/openai/agents-model-settings.ts
+function resolveModelSettings(modelSettings) {
+	if (!modelSettings) return;
+	const retry = modelSettings.retry ? {
+		...modelSettings.retry,
+		policy: resolveRetryPolicy(modelSettings.retry.policy)
+	} : void 0;
+	return {
+		...modelSettings,
+		retry
+	};
+}
+function resolveRetryPolicy(policy) {
+	if (!policy) return;
+	if (typeof policy === "function") return policy;
+	if (typeof policy === "string") switch (policy) {
+		case "never": return retryPolicies.never();
+		case "providerSuggested": return retryPolicies.providerSuggested();
+		case "networkError": return retryPolicies.networkError();
+		case "retryAfter": return retryPolicies.retryAfter();
+		default: return;
+	}
+	if ("httpStatus" in policy) return retryPolicies.httpStatus(policy.httpStatus);
+	if ("any" in policy) {
+		const policies = policy.any.map((nestedPolicy) => resolveRetryPolicy(nestedPolicy)).filter((nestedPolicy) => !!nestedPolicy);
+		return policies.length ? retryPolicies.any(...policies) : void 0;
+	}
+	if ("all" in policy) {
+		const policies = policy.all.map((nestedPolicy) => resolveRetryPolicy(nestedPolicy)).filter((nestedPolicy) => !!nestedPolicy);
+		return policies.length ? retryPolicies.all(...policies) : void 0;
+	}
+}
+//#endregion
 //#region src/providers/openai/agents-loader.ts
 /**
 * Load agent definition from file path or return inline definition
@@ -28,6 +61,82 @@ async function loadAgentDefinition(agentConfig) {
 	throw new Error("Invalid agent configuration: expected Agent instance, file:// URL, or inline definition");
 }
 /**
+* Load tools from file path or return inline definitions
+*/
+async function loadTools(toolsConfig) {
+	if (!toolsConfig) return;
+	if (typeof toolsConfig === "string" && toolsConfig.startsWith("file://")) {
+		logger.debug("[AgentsLoader] Loading tools from file", { path: toolsConfig });
+		return await loadToolsFromFile(toolsConfig);
+	}
+	if (Array.isArray(toolsConfig)) {
+		logger.debug("[AgentsLoader] Using inline tool definitions");
+		return normalizeTools(toolsConfig);
+	}
+	logger.debug("[AgentsLoader] Invalid tools configuration", {
+		type: typeof toolsConfig,
+		isArray: Array.isArray(toolsConfig)
+	});
+	throw new Error("Invalid tools configuration: expected file:// URL or array");
+}
+/**
+* Load handoffs from file path or return inline definitions
+*/
+async function loadHandoffs(handoffsConfig) {
+	if (!handoffsConfig) return;
+	if (typeof handoffsConfig === "string" && handoffsConfig.startsWith("file://")) {
+		logger.debug("[AgentsLoader] Loading handoffs from file", { path: handoffsConfig });
+		return await loadHandoffsFromFile(handoffsConfig);
+	}
+	if (Array.isArray(handoffsConfig)) {
+		logger.debug("[AgentsLoader] Using inline handoff definitions");
+		return normalizeHandoffs(handoffsConfig);
+	}
+	logger.debug("[AgentsLoader] Invalid handoffs configuration", {
+		type: typeof handoffsConfig,
+		isArray: Array.isArray(handoffsConfig)
+	});
+	throw new Error("Invalid handoffs configuration: expected file:// URL or array");
+}
+/**
+* Load input guardrails from file path or return inline definitions
+*/
+async function loadInputGuardrails(guardrailsConfig) {
+	if (!guardrailsConfig) return;
+	if (typeof guardrailsConfig === "string" && guardrailsConfig.startsWith("file://")) {
+		logger.debug("[AgentsLoader] Loading input guardrails from file", { path: guardrailsConfig });
+		return await loadArrayFromFile(guardrailsConfig, "input guardrails");
+	}
+	if (Array.isArray(guardrailsConfig)) {
+		logger.debug("[AgentsLoader] Using inline input guardrails");
+		return guardrailsConfig;
+	}
+	logger.debug("[AgentsLoader] Invalid input guardrails configuration", {
+		type: typeof guardrailsConfig,
+		isArray: Array.isArray(guardrailsConfig)
+	});
+	throw new Error("Invalid input guardrails configuration: expected file:// URL or array");
+}
+/**
+* Load output guardrails from file path or return inline definitions
+*/
+async function loadOutputGuardrails(guardrailsConfig) {
+	if (!guardrailsConfig) return;
+	if (typeof guardrailsConfig === "string" && guardrailsConfig.startsWith("file://")) {
+		logger.debug("[AgentsLoader] Loading output guardrails from file", { path: guardrailsConfig });
+		return await loadArrayFromFile(guardrailsConfig, "output guardrails");
+	}
+	if (Array.isArray(guardrailsConfig)) {
+		logger.debug("[AgentsLoader] Using inline output guardrails");
+		return guardrailsConfig;
+	}
+	logger.debug("[AgentsLoader] Invalid output guardrails configuration", {
+		type: typeof guardrailsConfig,
+		isArray: Array.isArray(guardrailsConfig)
+	});
+	throw new Error("Invalid output guardrails configuration: expected file:// URL or array");
+}
+/**
 * Load agent from file
 */
 async function loadAgentFromFile(filePath) {
@@ -47,19 +156,39 @@ async function loadAgentFromFile(filePath) {
 	}
 }
 /**
+* Load tools from file
+*/
+async function loadToolsFromFile(filePath) {
+	return await normalizeTools(await loadArrayFromFile(filePath, "tools")) ?? [];
+}
+/**
+* Load handoffs from file
+*/
+async function loadHandoffsFromFile(filePath) {
+	return await normalizeHandoffs(await loadArrayFromFile(filePath, "handoffs")) ?? [];
+}
+/**
 * Create an Agent instance from an inline definition
 */
 async function createAgentFromDefinition(definition) {
 	try {
-		const { Agent } = await import("@openai/agents");
+		const tools = await normalizeTools(definition.tools);
+		const handoffs = await normalizeHandoffs(definition.handoffs);
 		return new Agent({
 			name: definition.name,
 			instructions: definition.instructions,
+			prompt: definition.prompt,
 			model: definition.model,
+			modelSettings: resolveModelSettings(definition.modelSettings),
 			handoffDescription: definition.handoffDescription,
 			outputType: definition.outputType,
-			tools: definition.tools,
-			handoffs: definition.handoffs
+			tools,
+			handoffs,
+			inputGuardrails: definition.inputGuardrails,
+			outputGuardrails: definition.outputGuardrails,
+			mcpServers: definition.mcpServers,
+			toolUseBehavior: definition.toolUseBehavior,
+			resetToolChoice: definition.resetToolChoice
 		});
 	} catch (error) {
 		logger.error("[AgentsLoader] Failed to create agent from definition", {
@@ -76,7 +205,52 @@ async function createAgentFromDefinition(definition) {
 * Check if a value is an Agent instance
 */
 function isAgentInstance(value) {
-	return value && typeof value === "object" && "name" in value && "instructions" in value && typeof value.name === "string";
+	return value instanceof Agent;
+}
+function isToolInstance(value) {
+	return !!value && typeof value === "object" && "type" in value && typeof value.type === "string";
+}
+function isHandoffInstance(value) {
+	return !!value && typeof value === "object" && "agent" in value && "getHandoffAsFunctionTool" in value && typeof value.getHandoffAsFunctionTool === "function";
+}
+async function normalizeTools(definitions) {
+	if (!definitions?.length) return;
+	return definitions.map((definition) => {
+		if (isToolInstance(definition)) return definition;
+		return tool({
+			name: definition.name,
+			description: definition.description,
+			parameters: definition.parameters,
+			strict: definition.strict ?? true,
+			deferLoading: definition.deferLoading,
+			execute: typeof definition.execute === "function" ? definition.execute : async () => definition.execute
+		});
+	});
+}
+async function normalizeHandoffs(definitions) {
+	if (!definitions?.length) return;
+	return Promise.all(definitions.map(async (definition) => {
+		if (isAgentInstance(definition) || isHandoffInstance(definition)) return definition;
+		const agent = await loadAgentDefinition(definition.agent);
+		if (!definition.description) return agent;
+		return handoff(agent, { toolDescriptionOverride: definition.description });
+	}));
+}
+async function loadArrayFromFile(filePath, label) {
+	const resolvedPath = resolveFilePath(filePath);
+	logger.debug(`[AgentsLoader] Loading ${label} from resolved path`, { path: resolvedPath });
+	try {
+		const module = await importModule(resolvedPath);
+		const exported = module.default || module;
+		if (!Array.isArray(exported)) throw new Error(`File ${resolvedPath} does not export an array of ${label}`);
+		return exported;
+	} catch (error) {
+		logger.error(`[AgentsLoader] Failed to load ${label} from file`, {
+			path: resolvedPath,
+			error
+		});
+		throw new Error(`Failed to load ${label} from ${resolvedPath}: ${error}`);
+	}
 }
 /**
 * Resolve file:// path to absolute file system path
@@ -328,8 +502,27 @@ var OpenAiAgentsProvider = class extends OpenAiGenericProvider {
 		if (!this.agentConfig.agent) throw new Error("No agent configuration provided");
 		try {
 			const agent = await loadAgentDefinition(this.agentConfig.agent);
-			logger.debug("[AgentsProvider] Agent initialized successfully", { name: agent.name });
-			return agent;
+			const [tools, handoffs, inputGuardrails, outputGuardrails] = await Promise.all([
+				loadTools(this.agentConfig.tools),
+				loadHandoffs(this.agentConfig.handoffs),
+				loadInputGuardrails(this.agentConfig.inputGuardrails),
+				loadOutputGuardrails(this.agentConfig.outputGuardrails)
+			]);
+			const configuredAgent = agent.clone({
+				tools: mergeArrays(agent.tools, tools),
+				handoffs: mergeArrays(agent.handoffs, handoffs),
+				inputGuardrails: mergeArrays(agent.inputGuardrails, inputGuardrails),
+				outputGuardrails: mergeArrays(agent.outputGuardrails, outputGuardrails)
+			});
+			const mockAwareAgent = this.wrapToolsIfNeeded(configuredAgent);
+			logger.debug("[AgentsProvider] Agent initialized successfully", {
+				name: mockAwareAgent.name,
+				toolCount: mockAwareAgent.tools.length,
+				handoffCount: mockAwareAgent.handoffs.length,
+				inputGuardrailCount: mockAwareAgent.inputGuardrails.length,
+				outputGuardrailCount: mockAwareAgent.outputGuardrails.length
+			});
+			return mockAwareAgent;
 		} catch (error) {
 			logger.error("[AgentsProvider] Failed to initialize agent", { error });
 			throw new Error(`Failed to initialize agent: ${error}`);
@@ -388,7 +581,7 @@ var OpenAiAgentsProvider = class extends OpenAiGenericProvider {
 				signal: callApiOptions?.abortSignal
 			};
 			if (this.agentConfig.model || this.modelName) runOptions.model = this.agentConfig.model || this.modelName;
-			if (this.agentConfig.modelSettings) runOptions.modelSettings = this.agentConfig.modelSettings;
+			if (this.agentConfig.modelSettings) runOptions.modelSettings = resolveModelSettings(this.agentConfig.modelSettings);
 			const result = await getOrCreateTrace(async () => {
 				return await run(this.agent, prompt, runOptions);
 			});
@@ -423,8 +616,28 @@ var OpenAiAgentsProvider = class extends OpenAiGenericProvider {
 	* Calculate cost from agent result
 	*/
 	calculateCost(_result) {}
+	wrapToolsIfNeeded(agent) {
+		if (this.agentConfig.executeTools !== false && this.agentConfig.executeTools !== "mock") return agent;
+		const toolMocks = this.agentConfig.toolMocks ?? {};
+		const tools = agent.tools.map((tool) => {
+			if (tool.type !== "function") return tool;
+			const mockValue = toolMocks[tool.name];
+			return {
+				...tool,
+				invoke: async () => mockValue ?? {
+					mocked: true,
+					tool: tool.name
+				}
+			};
+		});
+		return agent.clone({ tools });
+	}
 };
+function mergeArrays(existing, additions) {
+	if (!existing?.length && !additions?.length) return;
+	return [...existing ?? [], ...additions ?? []];
+}
 //#endregion
 export { OpenAiAgentsProvider };
 
-//# sourceMappingURL=agents-CXknwsFX.js.map
+//# sourceMappingURL=agents-DSSTV4bv.js.map

package/dist/src/{agents-aF4-T121.js → agents-wg3ohknq.js}

@@ -1,9 +1,9 @@
-import { i as logger, y as getEnvInt } from "./logger-CT3IKMKA.js";
-import "./fetch-60Gzydls.js";
-import { a as isCacheEnabled, i as getCache } from "./cache-8XhNqPKW.js";
-import "./accounts-xrUGFA6n.js";
-import { t as telemetry } from "./telemetry-C15ziL8u.js";
-import { n as createBedrockRequestHandler, r as hasProxyEnv, t as AwsBedrockGenericProvider } from "./base-B0tcrnq_.js";
+import { S as getEnvInt, a as logger } from "./logger-BnkjG2jt.js";
+import "./fetch-BiYv2BZc.js";
+import "./accounts-Xatc0RYb.js";
+import { a as isCacheEnabled, i as getCache } from "./cache-HP0NP4k3.js";
+import { n as telemetry } from "./telemetry-DPXLd7UE.js";
+import { n as createBedrockRequestHandler, r as hasProxyEnv, t as AwsBedrockGenericProvider } from "./base-Cz2ZC_iA.js";
 //#region src/providers/bedrock/agents.ts
 /**
 * AWS Bedrock Agents provider for invoking deployed AI agents.
@@ -230,4 +230,4 @@ var AwsBedrockAgentsProvider = class extends AwsBedrockGenericProvider {
 //#endregion
 export { AwsBedrockAgentsProvider };
 
-//# sourceMappingURL=agents-aF4-T121.js.map
+//# sourceMappingURL=agents-wg3ohknq.js.map