promptfoo 0.125.0 → 0.125.1

package/dist/src/claude-agent-sdk-Cr-jqJZl.js

@@ -0,0 +1,1000 @@
+#!/usr/bin/env node
+import { Q as getEnvString, c as logger, lt as state, tt as getProcessEnv } from "./logger-pCNnmVuz.js";
+import { a as importModule, c as safeResolve, o as resolvePackageEntryPoint, r as getDirectory } from "./esm-B4NX_h4K.js";
+import { t as getPackageVersion } from "./packageVersion-CVhzH1IZ.js";
+import { n as PROMPTFOO_RESOURCE_ATTR_TRACE_ID, t as PROMPTFOO_RESOURCE_ATTR_PARENT_SPAN_ID } from "./resourceAttributes-Cixq2go1.js";
+import { h as withGenAISpan, l as getGenAITracer, o as emitTurnMarkerSpan, p as sanitizeBody, r as addActiveSpanRoleAttribute, t as GenAIAttributes, u as getTraceparent } from "./genaiTracer-j8OXa5Va.js";
+import { i as initializeAgenticCache, o as resolveAgenticWorkingDir, r as getCachedResponse, t as cacheResponse } from "./agentic-utils-D8wyQwPG.js";
+import { n as clearRepositoryEnv, t as assertIsolatedWorkingDir } from "./agentWorkspace-DPtMLrlI.js";
+import { a as isActiveTracingExport, o as waitForNativeTraceExport, t as getConfiguredTracingExport } from "./tracing-Eev_7A4e.js";
+import { a as validateMCPConfigForClaudeCode, t as transformMCPConfigToClaudeCode } from "./transform-DAED8imp.js";
+import { t as ANTHROPIC_MODELS } from "./util-TfpE49TI.js";
+import path from "node:path";
+import os from "node:os";
+import fsPromises from "node:fs/promises";
+import dedent from "dedent";
+import { SpanStatusCode, trace } from "@opentelemetry/api";
+import semverSatisfies from "semver/functions/satisfies.js";
+//#region src/providers/claude-agent-sdk.ts
+/** Hard cap for attribute body length on synthesized tool spans. */
+const TOOL_SPAN_BODY_LIMIT = 4096;
+const REDACTED_SUBAGENT_TRANSCRIPT = "[Subagent transcript omitted; set forward_subagent_text: true to include it]";
+/** Returned when cancellation is observed at any checkpoint before the SDK query starts. */
+const ABORTED_BEFORE_START_ERROR = "Claude Agent SDK call aborted before it started";
+const USAGE_BASELINE_TIMEOUT_MS = 5e3;
+const MODEL_USAGE_COUNTERS = [
+	"inputTokens",
+	"outputTokens",
+	"thinkingTokens",
+	"cacheReadInputTokens",
+	"cacheCreationInputTokens",
+	"webSearchRequests",
+	"costUSD"
+];
+function subtractSessionUsage(current, baseline) {
+	return Object.fromEntries(Object.entries(current).map(([model, usage]) => {
+		const delta = { ...usage };
+		for (const key of MODEL_USAGE_COUNTERS) if (typeof usage[key] === "number") delta[key] = Math.max(0, usage[key] - (baseline[model]?.[key] ?? 0));
+		return [model, delta];
+	}));
+}
+/**
+* Append promptfoo-specific resource-attribute kvs to a W3C-style
+* `OTEL_RESOURCE_ATTRIBUTES` string, removing trailing whitespace/commas from
+* the existing value and stripping any previous occurrence of our keys so the
+* producer can't double-up. Returns the new string. Exported for tests.
+*/
+function appendPromptfooResourceAttrs(existing, traceId, parentSpanId) {
+	const incoming = `${PROMPTFOO_RESOURCE_ATTR_TRACE_ID}=${traceId},${PROMPTFOO_RESOURCE_ATTR_PARENT_SPAN_ID}=${parentSpanId}`;
+	if (!existing) return incoming;
+	const cleaned = existing.split(",").map((pair) => pair.trim()).filter((pair) => pair.length > 0 && !pair.startsWith(`promptfoo.trace_id=`) && !pair.startsWith(`promptfoo.parent_span_id=`)).join(",");
+	return cleaned.length > 0 ? `${cleaned},${incoming}` : incoming;
+}
+function stringifyForSpan(value) {
+	if (value === void 0 || value === null) return;
+	let raw;
+	if (typeof value === "string") raw = value;
+	else try {
+		raw = JSON.stringify(value);
+	} catch {
+		return "<unserializable>";
+	}
+	if (raw === void 0) return;
+	const sanitized = sanitizeBody(raw);
+	return sanitized.length > TOOL_SPAN_BODY_LIMIT ? `${sanitized.slice(0, 4081)}... [truncated]` : sanitized;
+}
+/**
+* Emit a child span for a single tool call. Parents to the currently active
+* span (the provider's GenAI wrapper) so the UI shows an agent → tool hierarchy
+* similar to the OpenAI Agents SDK.
+*
+* When `incomplete` is true the call never produced a matching `tool_result`
+* (aborted run, stop hook, or the stream ended mid-tool). Such spans are
+* flagged via `tool.incomplete` and marked ERROR so traces surface the gap
+* instead of silently dropping the tool.
+*/
+function emitToolSpan(entry, startTimeMs, endTimeMs, isError, incomplete = false, turnIndex) {
+	try {
+		const tracer = getGenAITracer();
+		const attributes = {
+			"gen_ai.operation.name": "execute_tool",
+			"gen_ai.tool.call.id": entry.id,
+			"gen_ai.tool.name": entry.name,
+			"tool.name": entry.name,
+			"tool.is_error": isError
+		};
+		if (incomplete) attributes["tool.incomplete"] = true;
+		const input = stringifyForSpan(entry.input);
+		if (input !== void 0) attributes["tool.input"] = input;
+		const output = stringifyForSpan(entry.output);
+		if (output !== void 0) attributes["tool.output"] = output;
+		if (entry.parentToolUseId) attributes["tool.parent_id"] = entry.parentToolUseId;
+		if (typeof turnIndex === "number") attributes["gen_ai.turn.index"] = turnIndex;
+		const span = tracer.startSpan(`tool ${entry.name}`, {
+			startTime: startTimeMs,
+			attributes: addActiveSpanRoleAttribute(attributes)
+		});
+		span.setStatus({ code: isError || incomplete ? SpanStatusCode.ERROR : SpanStatusCode.OK });
+		span.end(endTimeMs);
+	} catch (err) {
+		logger.warn(`[ClaudeAgentSDK] Failed to emit tool span for ${entry.name}: ${err}`);
+	}
+}
+function isRawSubagentTranscript(result) {
+	if (typeof result !== "object" || result === null) return false;
+	if ("content" in result && "_meta" in result) return isRawSubagentTranscript(result.content);
+	if ("isRawTranscript" in result && result.isRawTranscript === true) return true;
+	return "task" in result && typeof result.task === "object" && result.task !== null && "isRawTranscript" in result.task && result.task.isRawTranscript === true;
+}
+function redactRawSubagentToolOutput(result) {
+	if (!isRawSubagentTranscript(result)) return result;
+	const output = result;
+	if ("content" in output && "_meta" in output) return {
+		...output,
+		content: redactRawSubagentToolOutput(output.content)
+	};
+	const nestedTask = "task" in output && typeof output.task === "object" && output.task !== null;
+	const task = nestedTask ? output.task : output;
+	const redactedTask = {
+		...task,
+		output: REDACTED_SUBAGENT_TRANSCRIPT,
+		..."result" in task ? { result: REDACTED_SUBAGENT_TRANSCRIPT } : {},
+		isRawTranscript: false
+	};
+	return nestedTask ? {
+		...output,
+		task: redactedTask
+	} : redactedTask;
+}
+function createTaskOutputTranscriptRedactionHook() {
+	return {
+		matcher: "TaskOutput",
+		hooks: [async (input) => {
+			if (input.hook_event_name !== "PostToolUse" || input.tool_name !== "TaskOutput" || !isRawSubagentTranscript(input.tool_response)) return {};
+			return { hookSpecificOutput: {
+				hookEventName: "PostToolUse",
+				updatedToolOutput: redactRawSubagentToolOutput(input.tool_response)
+			} };
+		}]
+	};
+}
+function deriveSkillCalls(toolCalls) {
+	return toolCalls.filter((toolCall) => toolCall.name === "Skill").flatMap((toolCall) => {
+		const skillName = toolCall.input && typeof toolCall.input === "object" && typeof toolCall.input.skill === "string" ? toolCall.input.skill.trim() : "";
+		if (!skillName) return [];
+		return [{
+			name: skillName,
+			input: toolCall.input,
+			is_error: toolCall.is_error,
+			source: "tool"
+		}];
+	});
+}
+/**
+* Claude Agent SDK Provider
+*
+* This provider requires the @anthropic-ai/claude-agent-sdk package to be installed separately:
+*   npm install promptfoo @anthropic-ai/claude-agent-sdk@^0.3.273
+*
+* Two default configurations:
+* - No working_dir: Runs in temp directory with no tools - behaves like plain chat API
+* - With working_dir: Runs in specified directory with read-only file tools (Read/Grep/Glob/LS)
+*
+* User can override tool permissions with 'custom_allowed_tools', 'append_allowed_tools', 'disallowed_tools', and 'permission_mode'.
+*
+* For side effects (file writes, system calls, etc.), user can override permissions and use a custom working directory. They're then responsible for setup/teardown and security considerations.
+*
+* MCP server connection details are passed through from config. strict_mcp_config is true by default to only allow explicitly configured MCP servers.
+*/
+const FS_READONLY_ALLOWED_TOOLS = [
+	"Read",
+	"Grep",
+	"Glob",
+	"LS"
+].sort();
+const CLAUDE_CODE_MODEL_ALIASES = [
+	"default",
+	"best",
+	"fable",
+	"fable[1m]",
+	"sonnet",
+	"opus",
+	"haiku",
+	"sonnet[1m]",
+	"opus[1m]",
+	"opusplan",
+	"opusplan[1m]"
+];
+const CLAUDE_AGENT_SDK_RANGE = "^0.3.273";
+/**
+* Helper to load the Claude Agent SDK ESM module
+* Uses resolvePackageEntryPoint to handle ESM-only packages with restrictive exports
+*/
+async function loadClaudeCodeSDK() {
+	const basePath = state.basePath && path.isAbsolute(state.basePath) ? state.basePath : process.cwd();
+	const basePaths = /* @__PURE__ */ new Set([
+		basePath,
+		process.cwd(),
+		path.resolve(getDirectory(), ".."),
+		path.resolve(getDirectory(), "../..")
+	]);
+	let claudeCodePath = null;
+	for (const candidate of basePaths) {
+		claudeCodePath = resolvePackageEntryPoint("@anthropic-ai/claude-agent-sdk", candidate);
+		if (claudeCodePath) break;
+	}
+	if (!claudeCodePath) throw new Error(dedent`The @anthropic-ai/claude-agent-sdk package could not be resolved from ${basePath}.
+
+      To use the Claude Agent SDK provider, install it with:
+        npm install promptfoo @anthropic-ai/claude-agent-sdk@${CLAUDE_AGENT_SDK_RANGE}
+
+      If the package is already installed elsewhere, run promptfoo from the
+      project root (or point the config at that root) so node_modules is on
+      the resolution path.
+
+      For more information, see: https://www.promptfoo.dev/docs/providers/claude-agent-sdk/`);
+	const version = getPackageVersion("@anthropic-ai/claude-agent-sdk", claudeCodePath);
+	if (!version || !semverSatisfies(version, CLAUDE_AGENT_SDK_RANGE)) throw new Error(`The Claude Agent SDK provider requires @anthropic-ai/claude-agent-sdk@${CLAUDE_AGENT_SDK_RANGE} (found ${version ?? "unknown"}). Install it with: npm install promptfoo @anthropic-ai/claude-agent-sdk@${CLAUDE_AGENT_SDK_RANGE}`);
+	try {
+		return await importModule(claudeCodePath);
+	} catch (err) {
+		logger.error(`Failed to load Claude Agent SDK: ${err}`);
+		if (err.stack) logger.error(err.stack);
+		throw new Error(dedent`Failed to load @anthropic-ai/claude-agent-sdk.
+
+      The package was found but could not be loaded. This may be due to:
+      - Incompatible Node.js version (requires Node.js >=22.22.0)
+      - Corrupted installation
+
+      Try reinstalling:
+        npm install promptfoo @anthropic-ai/claude-agent-sdk@${CLAUDE_AGENT_SDK_RANGE}
+
+      For more information, see: https://www.promptfoo.dev/docs/providers/claude-agent-sdk/`);
+	}
+}
+/**
+* Creates a canUseTool callback for handling AskUserQuestion tool in automated evaluations.
+* This provides automated responses to questions that would normally require user input.
+*
+* The callback wraps an optional user-provided canUseTool and handles AskUserQuestion specifically,
+* deferring to the wrapped callback for all other tools.
+*/
+function createAskUserQuestionCanUseTool(behavior = "first_option", wrappedCanUseTool) {
+	return async (toolName, input, options) => {
+		if (toolName !== "AskUserQuestion") {
+			if (wrappedCanUseTool) return wrappedCanUseTool(toolName, input, options);
+			return {
+				behavior: "deny",
+				message: "Tool permission request is not handled by ask_user_question automation"
+			};
+		}
+		if (behavior === "deny") return {
+			behavior: "deny",
+			message: "AskUserQuestion is disabled in automated evaluation mode"
+		};
+		if (!isAskUserQuestionToolInput(input)) return {
+			behavior: "deny",
+			message: "AskUserQuestion received malformed question input"
+		};
+		const toolInput = input;
+		const answers = Object.create(null);
+		for (const question of toolInput.questions) {
+			if (!question.options || question.options.length === 0) continue;
+			let selectedLabels;
+			if (behavior === "random") {
+				const randomIndex = Math.floor(Math.random() * question.options.length);
+				selectedLabels = [question.options[randomIndex].label];
+			} else selectedLabels = [question.options[0].label];
+			answers[question.question] = selectedLabels.join(", ");
+		}
+		return {
+			behavior: "allow",
+			updatedInput: {
+				questions: toolInput.questions,
+				answers
+			}
+		};
+	};
+}
+/**
+* Assemble the hook set actually handed to the SDK.
+*
+* Two independent concerns layer here, on different hook events, so both apply:
+* a PostToolUse hook that redacts raw background-agent transcripts, and a
+* PreToolUse hook that answers AskUserQuestion under `dontAsk`. In both cases
+* promptfoo's hook goes first and the user's configured matchers stay installed
+* behind it, so an explicit user denial still wins.
+*/
+function buildClaudeHooks(config) {
+	let hooks = config.hooks;
+	if (!config.forward_subagent_text) hooks = {
+		...hooks,
+		PostToolUse: [createTaskOutputTranscriptRedactionHook(), ...hooks?.PostToolUse ?? []]
+	};
+	if (config.permission_mode !== "dontAsk" || !config.ask_user_question) return hooks;
+	const questionHandler = createAskUserQuestionCanUseTool(config.ask_user_question.behavior);
+	const askUserQuestionHook = {
+		matcher: "AskUserQuestion",
+		hooks: [async (input, toolUseID, { signal }) => {
+			if (input.hook_event_name !== "PreToolUse" || input.tool_name !== "AskUserQuestion") return {};
+			const resolvedToolUseID = toolUseID ?? input.tool_use_id;
+			const result = await questionHandler(input.tool_name, input.tool_input, {
+				signal,
+				toolUseID: resolvedToolUseID,
+				requestId: resolvedToolUseID
+			});
+			if (result?.behavior !== "allow") return { hookSpecificOutput: {
+				hookEventName: "PreToolUse",
+				permissionDecision: "deny",
+				permissionDecisionReason: result?.message ?? "ask_user_question automation returned no decision"
+			} };
+			return { hookSpecificOutput: {
+				hookEventName: "PreToolUse",
+				permissionDecision: "allow",
+				updatedInput: result.updatedInput
+			} };
+		}]
+	};
+	return {
+		...hooks,
+		PreToolUse: [askUserQuestionHook, ...hooks?.PreToolUse ?? []]
+	};
+}
+function validateAskUserQuestionConfig(config) {
+	if (!config || typeof config !== "object" || Array.isArray(config)) throw new Error("ask_user_question must be an object");
+	const behavior = config.behavior;
+	if (behavior !== void 0 && behavior !== "first_option" && behavior !== "random" && behavior !== "deny") throw new Error("ask_user_question.behavior must be first_option, random, or deny");
+}
+const RESERVED_POLICY_EXTRA_ARGS = /* @__PURE__ */ new Set([
+	"adddir",
+	"agent",
+	"agents",
+	"allowdangerouslyskippermissions",
+	"allowedtools",
+	"bare",
+	"brief",
+	"chrome",
+	"dangerouslyskippermissions",
+	"disallowedtools",
+	"ide",
+	"managedsettings",
+	"mcpconfig",
+	"permissionmode",
+	"permissionprompttool",
+	"plugindir",
+	"plugindirnomcp",
+	"pluginurl",
+	"remotecontrol",
+	"safemode",
+	"settings",
+	"settingsources",
+	"strictmcpconfig",
+	"tools"
+]);
+function normalizeClaudeCliArgumentName(name) {
+	return name.split(/[=:]/, 1)[0].replace(/^--/, "").replace(/[-_]/g, "").toLowerCase();
+}
+function validateClaudeToolPolicyConfig(config) {
+	for (const option of ["allow_all_tools", "allow_dangerously_skip_permissions"]) if (config[option] !== void 0 && typeof config[option] !== "boolean") throw new Error(`${option} must be a boolean`);
+	for (const option of [
+		"custom_allowed_tools",
+		"append_allowed_tools",
+		"disallowed_tools"
+	]) {
+		const value = config[option];
+		if (value !== void 0 && (!Array.isArray(value) || value.some((tool) => typeof tool !== "string"))) throw new Error(`${option} must be an array of tool-name strings`);
+	}
+	const permissionModes = [
+		"default",
+		"plan",
+		"acceptEdits",
+		"bypassPermissions",
+		"dontAsk",
+		"auto",
+		"manual"
+	];
+	if (config.permission_mode !== void 0 && !permissionModes.includes(config.permission_mode)) throw new Error(`permission_mode must be one of ${permissionModes.join(", ")}`);
+	if (config.tools !== void 0) {
+		const validArray = Array.isArray(config.tools) && config.tools.every((tool) => typeof tool === "string");
+		const validPreset = !!config.tools && typeof config.tools === "object" && !Array.isArray(config.tools) && config.tools.type === "preset" && config.tools.preset === "claude_code";
+		if (!validArray && !validPreset) throw new Error("tools must be an array of tool-name strings or the claude_code preset");
+	}
+	if (config.extra_args !== void 0 && (!config.extra_args || typeof config.extra_args !== "object" || Array.isArray(config.extra_args) || Object.values(config.extra_args).some((value) => value !== null && typeof value !== "string"))) throw new Error("extra_args must be an object with string or null values");
+	const reservedExtraArg = Object.keys(config.extra_args ?? {}).find((name) => RESERVED_POLICY_EXTRA_ARGS.has(normalizeClaudeCliArgumentName(name)));
+	if (reservedExtraArg) throw new Error(`extra_args cannot override Claude runtime policy (${reservedExtraArg}); use supported structured provider options instead`);
+}
+function mcpServerContainsCacheSensitiveData(server) {
+	if (server.auth || Object.keys(server.headers ?? {}).length > 0 || Object.keys(server.env ?? {}).length > 0 || (server.args?.length ?? 0) > 0) return true;
+	if (!server.url) return false;
+	try {
+		const url = new URL(server.url);
+		return Boolean(url.username || url.password || url.search);
+	} catch {
+		return server.url.includes("?") || server.url.includes("@");
+	}
+}
+function mcpConfigContainsCacheSensitiveData(config) {
+	if (!config || config.enabled === false) return false;
+	return [...config.servers ?? [], ...config.server ? [config.server] : []].some(mcpServerContainsCacheSensitiveData);
+}
+function isAskUserQuestionToolInput(input) {
+	if (!input || typeof input !== "object" || !Array.isArray(input.questions)) return false;
+	return input.questions.every((question) => !!question && typeof question === "object" && typeof question.question === "string" && typeof question.header === "string" && typeof question.multiSelect === "boolean" && Array.isArray(question.options) && question.options.every((option) => !!option && typeof option === "object" && typeof option.label === "string" && typeof option.description === "string"));
+}
+var ClaudeCodeSDKProvider = class ClaudeCodeSDKProvider {
+	static ANTHROPIC_MODELS = ANTHROPIC_MODELS;
+	static ANTHROPIC_MODELS_NAMES = ANTHROPIC_MODELS.map((model) => model.id);
+	config;
+	env;
+	apiKey;
+	providerId = "anthropic:claude-agent-sdk";
+	claudeCodeModule;
+	credentialCacheScope = crypto.randomUUID();
+	constructor(options = {}) {
+		const { config, env, id } = options;
+		this.config = config ?? {};
+		this.env = env;
+		this.apiKey = this.getApiKey();
+		this.providerId = id ?? this.providerId;
+		if (this.config.model && !ClaudeCodeSDKProvider.ANTHROPIC_MODELS_NAMES.includes(this.config.model) && !CLAUDE_CODE_MODEL_ALIASES.includes(this.config.model)) logger.warn(`Using unknown model for Claude Agent SDK: ${this.config.model}`);
+		for (const fallbackModel of (this.config.fallback_model ?? "").split(",").map((m) => m.trim()).filter(Boolean)) if (!ClaudeCodeSDKProvider.ANTHROPIC_MODELS_NAMES.includes(fallbackModel) && !CLAUDE_CODE_MODEL_ALIASES.includes(fallbackModel)) logger.warn(`Using unknown model for Claude Agent SDK fallback: ${fallbackModel}`);
+	}
+	id() {
+		return this.providerId;
+	}
+	async callApi(prompt, context, callOptions) {
+		if (callOptions?.abortSignal?.aborted) return { error: ABORTED_BEFORE_START_ERROR };
+		const config = {
+			...this.config,
+			...context?.prompt?.config
+		};
+		const inIsolatedWorkspace = assertIsolatedWorkingDir(config);
+		if (config.ask_user_question !== void 0) validateAskUserQuestionConfig(config.ask_user_question);
+		if (config.mcp !== void 0) validateMCPConfigForClaudeCode(config.mcp);
+		validateClaudeToolPolicyConfig(config);
+		const env = {};
+		const processEnv = getProcessEnv();
+		for (const key of Object.keys(processEnv).sort()) if (processEnv[key] !== void 0) env[key] = processEnv[key];
+		if (config.env) for (const key of Object.keys(config.env).sort()) {
+			const value = config.env[key];
+			if (value !== void 0) env[key] = value;
+		}
+		if (this.env) for (const key of Object.keys(this.env).sort()) {
+			const value = this.env[key];
+			if (value !== void 0) env[key] = value;
+		}
+		if (inIsolatedWorkspace) clearRepositoryEnv(env);
+		if (config.deep_tracing) {
+			const receiverExport = getConfiguredTracingExport();
+			env.CLAUDE_CODE_ENABLE_TELEMETRY ??= "1";
+			env.CLAUDE_CODE_ENHANCED_TELEMETRY_BETA ??= "1";
+			env.OTEL_TRACES_EXPORTER ??= "otlp";
+			env.OTEL_EXPORTER_OTLP_ENDPOINT ??= receiverExport?.endpoint ?? "http://127.0.0.1:4318";
+			env.OTEL_EXPORTER_OTLP_PROTOCOL ??= receiverExport?.format === "json" ? "http/json" : "http/protobuf";
+			env.OTEL_TRACES_EXPORT_INTERVAL ??= "1000";
+		}
+		const sdkExportsNativeSpans = env.CLAUDE_CODE_ENABLE_TELEMETRY === "1" && (env.CLAUDE_CODE_ENHANCED_TELEMETRY_BETA === "1" || env.ENABLE_ENHANCED_TELEMETRY_BETA === "1") && env.OTEL_TRACES_EXPORTER?.split(",").some((exporter) => exporter.trim() === "otlp") && isActiveTracingExport(env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT ?? env.OTEL_EXPORTER_OTLP_ENDPOINT, env.OTEL_EXPORTER_OTLP_TRACES_PROTOCOL ?? env.OTEL_EXPORTER_OTLP_PROTOCOL);
+		for (const [option, environmentVariable] of [["max_subagent_spawn_depth", "CLAUDE_CODE_MAX_SUBAGENT_SPAWN_DEPTH"], ["max_concurrent_subagents", "CLAUDE_CODE_MAX_CONCURRENT_SUBAGENTS"]]) {
+			const value = config[option];
+			if (value === void 0) continue;
+			if (!Number.isSafeInteger(value) || value < 1) throw new Error(`${option} must be a positive safe integer`);
+			env[environmentVariable] = String(value);
+		}
+		env.CLAUDE_CODE_MAX_SUBAGENT_SPAWN_DEPTH ??= "5";
+		if (config.allow_all_tools) env.CLAUDE_CODE_ENABLE_TODO_TOOLS ??= "1";
+		const effectiveApiKey = config.apiKey || this.apiKey;
+		if (effectiveApiKey) env.ANTHROPIC_API_KEY = effectiveApiKey;
+		const credentialCacheScope = this.credentialCacheScope;
+		if (!effectiveApiKey && !(config.apiKeyRequired === false || env.CLAUDE_CODE_USE_BEDROCK || env.CLAUDE_CODE_USE_VERTEX)) throw new Error(dedent`Anthropic API key is not set. Set the ANTHROPIC_API_KEY environment variable or add "apiKey" to the provider config.
+
+        Use CLAUDE_CODE_USE_BEDROCK or CLAUDE_CODE_USE_VERTEX environment variables to use Bedrock or Vertex instead.`);
+		if (config.allow_all_tools === true && ("custom_allowed_tools" in config || "append_allowed_tools" in config || config.tools !== void 0)) throw new Error("Cannot specify allow_all_tools together with tools, custom_allowed_tools, or append_allowed_tools");
+		if ("custom_allowed_tools" in config && "append_allowed_tools" in config) throw new Error("Cannot specify both custom_allowed_tools and append_allowed_tools");
+		if (config.permission_mode === "bypassPermissions" && config.allow_dangerously_skip_permissions !== true) throw new Error("permission_mode 'bypassPermissions' requires allow_dangerously_skip_permissions: true as a safety measure");
+		if (config.title && (config.resume || config.continue)) logger.warn("[ClaudeAgentSDK] `title` is ignored when `resume` or `continue` is set; the persisted session title is used instead.");
+		const defaultAllowedTools = config.working_dir ? FS_READONLY_ALLOWED_TOOLS : [];
+		let allowedTools = config.allow_all_tools ? void 0 : defaultAllowedTools;
+		if ("custom_allowed_tools" in config) allowedTools = Array.from(new Set(config.custom_allowed_tools ?? [])).sort();
+		else if (config.append_allowed_tools) allowedTools = Array.from(/* @__PURE__ */ new Set([...defaultAllowedTools, ...config.append_allowed_tools])).sort();
+		if (config.ask_user_question) allowedTools = allowedTools?.filter((tool) => tool !== "AskUserQuestion");
+		const disallowedTools = config.disallowed_tools ? Array.from(new Set(config.disallowed_tools)).sort() : void 0;
+		let tools = config.tools;
+		if (tools === void 0) {
+			if (config.allow_all_tools === true) tools = {
+				type: "preset",
+				preset: "claude_code"
+			};
+			else {
+				const derivedTools = new Set(allowedTools);
+				if (config.ask_user_question) derivedTools.add("AskUserQuestion");
+				if (config.skills === "all" || Array.isArray(config.skills) && config.skills.length > 0) derivedTools.add("Skill");
+				if (config.agents && Object.keys(config.agents).length > 0) derivedTools.add("Task");
+				if (config.permission_mode === "plan") derivedTools.add("ExitPlanMode");
+				tools = Array.from(derivedTools).sort();
+			}
+		}
+		const basePath = state.basePath ? path.resolve(state.basePath) : process.cwd();
+		let isTempDir = false;
+		let workingDir;
+		if (config.working_dir) workingDir = resolveAgenticWorkingDir(config.working_dir, basePath);
+		else isTempDir = true;
+		let canUseTool = config.can_use_tool;
+		if (config.ask_user_question) canUseTool = createAskUserQuestionCanUseTool(config.ask_user_question.behavior, config.can_use_tool);
+		const hooks = buildClaudeHooks(config);
+		const cacheKeyQueryOptions = {
+			maxTurns: config.max_turns,
+			model: config.model,
+			fallbackModel: config.fallback_model,
+			strictMcpConfig: config.strict_mcp_config ?? true,
+			permissionMode: config.permission_mode === "manual" ? "default" : config.permission_mode ?? "default",
+			planModeInstructions: config.plan_mode_instructions,
+			systemPrompt: config.custom_system_prompt == null ? {
+				type: "preset",
+				preset: "claude_code",
+				append: config.append_system_prompt,
+				snapshot: false,
+				...config.exclude_dynamic_sections ? { excludeDynamicSections: true } : {}
+			} : {
+				type: "custom",
+				prompt: config.custom_system_prompt,
+				snapshot: false
+			},
+			maxThinkingTokens: config.max_thinking_tokens,
+			allowedTools,
+			disallowedTools,
+			plugins: config.plugins?.map((plugin) => ({
+				...plugin,
+				path: safeResolve(basePath, plugin.path)
+			})),
+			skills: config.skills,
+			maxBudgetUsd: config.max_budget_usd,
+			additionalDirectories: config.additional_directories?.map((dir) => safeResolve(basePath, dir)),
+			resume: config.resume,
+			forkSession: config.fork_session,
+			resumeSessionAt: config.resume_session_at,
+			continue: config.continue,
+			agents: config.agents,
+			outputFormat: config.output_format,
+			hooks,
+			includePartialMessages: config.include_partial_messages,
+			includeHookEvents: config.include_hook_events,
+			forwardSubagentText: config.forward_subagent_text,
+			toolConfig: config.tool_config,
+			promptSuggestions: config.prompt_suggestions,
+			agentProgressSummaries: config.agent_progress_summaries,
+			settings: typeof config.settings === "string" && config.settings ? safeResolve(basePath, config.settings) : config.settings,
+			managedSettings: config.managed_settings,
+			betas: config.betas,
+			thinking: config.thinking,
+			effort: config.effort,
+			agent: config.agent,
+			sessionId: config.session_id,
+			debug: config.debug,
+			debugFile: config.debug_file ? safeResolve(basePath, config.debug_file) : void 0,
+			sandbox: config.sandbox,
+			allowDangerouslySkipPermissions: config.allow_dangerously_skip_permissions,
+			permissionPromptToolName: config.permission_prompt_tool_name,
+			executable: config.executable,
+			executableArgs: config.executable_args,
+			extraArgs: config.extra_args,
+			pathToClaudeCodeExecutable: config.path_to_claude_code_executable ? safeResolve(basePath, config.path_to_claude_code_executable) : void 0,
+			settingSources: config.setting_sources ?? [],
+			tools,
+			enableFileCheckpointing: config.enable_file_checkpointing,
+			persistSession: config.persist_session,
+			taskBudget: config.task_budget,
+			env: {}
+		};
+		const runtimeCallbackBypassesCache = Boolean(config.can_use_tool) || Boolean(config.on_elicitation) || Boolean(config.hooks) || Boolean(config.spawn_claude_code_process) || config.ask_user_question?.behavior === "random";
+		const activeMcpConfig = config.mcp?.enabled !== false && (config.mcp?.server || (config.mcp?.servers?.length ?? 0) > 0) ? config.mcp : void 0;
+		const sensitiveMcpBypassesCache = mcpConfigContainsCacheSensitiveData(activeMcpConfig);
+		const settingsConfigurationBypassesCache = config.settings !== void 0 || config.managed_settings !== void 0;
+		const extraArgsBypassCache = Object.keys(config.extra_args ?? {}).length > 0;
+		const promptCredentialOverrideBypassesCache = config.env !== this.config.env || config.apiKey !== this.config.apiKey;
+		const statefulSessionBypassesCache = Boolean(config.continue || config.resume || config.session_id);
+		const externalCredentialProviderBypassesCache = config.apiKeyRequired === false || Boolean(env.CLAUDE_CODE_USE_BEDROCK || env.CLAUDE_CODE_USE_VERTEX);
+		if (runtimeCallbackBypassesCache) logger.debug("[ClaudeCodeSDKProvider] Bypassing cache: runtime callback is not cache-stable");
+		if (sensitiveMcpBypassesCache) logger.debug("[ClaudeCodeSDKProvider] Bypassing cache: MCP configuration contains secrets");
+		if (credentialCacheScope) logger.debug("[ClaudeCodeSDKProvider] Scoping cache to in-memory credential identity");
+		if (settingsConfigurationBypassesCache) logger.debug("[ClaudeCodeSDKProvider] Bypassing cache: SDK settings are externally mutable");
+		if (extraArgsBypassCache) logger.debug("[ClaudeCodeSDKProvider] Bypassing cache: extra_args is open-ended");
+		if (promptCredentialOverrideBypassesCache) logger.debug("[ClaudeCodeSDKProvider] Bypassing cache: prompt config overrides credentials or environment");
+		if (statefulSessionBypassesCache) logger.debug("[ClaudeCodeSDKProvider] Bypassing cache: session history is mutable");
+		if (externalCredentialProviderBypassesCache) logger.debug("[ClaudeCodeSDKProvider] Bypassing cache: external credential identity is not cache-stable");
+		const cacheResult = inIsolatedWorkspace || runtimeCallbackBypassesCache || sensitiveMcpBypassesCache || settingsConfigurationBypassesCache || extraArgsBypassCache || promptCredentialOverrideBypassesCache || statefulSessionBypassesCache || externalCredentialProviderBypassesCache ? {
+			shouldReadCache: false,
+			shouldWriteCache: false
+		} : await initializeAgenticCache({
+			cacheKeyPrefix: "anthropic:claude-agent-sdk",
+			workingDir,
+			bustCache: context?.bustCache,
+			mcp: activeMcpConfig,
+			cacheMcp: config.cache_mcp
+		}, {
+			prompt,
+			cacheKeyQueryOptions,
+			...credentialCacheScope ? { credentialCacheScope } : {},
+			...config.ask_user_question ? { ask_user_question: config.ask_user_question } : {}
+		});
+		const cachedResponse = await getCachedResponse(cacheResult, "Claude Agent SDK");
+		if (callOptions?.abortSignal?.aborted) return { error: ABORTED_BEFORE_START_ERROR };
+		if (cachedResponse) return cachedResponse;
+		const mcpServers = config.mcp ? await transformMCPConfigToClaudeCode(config.mcp) : {};
+		if (workingDir) {
+			let stats;
+			try {
+				stats = await fsPromises.stat(workingDir);
+			} catch (err) {
+				throw new Error(`Working dir ${config.working_dir} does not exist or isn't accessible: ${err.message}`);
+			}
+			if (!stats.isDirectory()) throw new Error(`Working dir ${config.working_dir} is not a directory`);
+		} else if (isTempDir) workingDir = await fsPromises.mkdtemp(path.join(os.tmpdir(), "promptfoo-claude-agent-sdk-"));
+		if (callOptions?.abortSignal?.aborted) {
+			if (isTempDir && workingDir) await fsPromises.rm(workingDir, {
+				recursive: true,
+				force: true
+			});
+			return { error: ABORTED_BEFORE_START_ERROR };
+		}
+		const abortController = new AbortController();
+		let abortHandler;
+		if (callOptions?.abortSignal) {
+			abortHandler = () => {
+				abortController.abort(callOptions.abortSignal.reason);
+			};
+			callOptions.abortSignal.addEventListener("abort", abortHandler);
+		}
+		const options = {
+			...cacheKeyQueryOptions,
+			env,
+			abortController,
+			mcpServers,
+			cwd: workingDir,
+			stderr: config.stderr,
+			spawnClaudeCodeProcess: config.spawn_claude_code_process,
+			canUseTool,
+			hooks,
+			onElicitation: config.on_elicitation,
+			title: config.title
+		};
+		const queryParams = {
+			prompt,
+			options
+		};
+		const needsUsageBaseline = Boolean(config.resume || config.continue || config.fork_session || [
+			"resume",
+			"r",
+			"continue",
+			"c",
+			"fork-session"
+		].some((key) => Object.prototype.hasOwnProperty.call(config.extra_args ?? {}, key)));
+		let query;
+		let usageBaseline;
+		let captureUsageBaseline;
+		if (needsUsageBaseline) options.hooks = {
+			...hooks,
+			UserPromptSubmit: [{ hooks: [async () => {
+				captureUsageBaseline ??= (async () => {
+					let timer;
+					let cancelSnapshot;
+					try {
+						const snapshot = query?.usage_EXPERIMENTAL_MAY_CHANGE_DO_NOT_RELY_ON_THIS_API_YET;
+						if (!snapshot) return;
+						const session = (await Promise.race([snapshot.call(query, { skipBehaviors: true }), new Promise((_, reject) => {
+							cancelSnapshot = () => reject(/* @__PURE__ */ new Error("Usage baseline cancelled"));
+							if (abortController.signal.aborted) {
+								cancelSnapshot();
+								return;
+							}
+							abortController.signal.addEventListener("abort", cancelSnapshot, { once: true });
+							timer = setTimeout(() => reject(/* @__PURE__ */ new Error("Usage baseline timed out")), USAGE_BASELINE_TIMEOUT_MS);
+						})]))?.session;
+						if (session && Number.isFinite(session.total_cost_usd) && session.total_cost_usd >= 0 && session.model_usage && typeof session.model_usage === "object" && !Array.isArray(session.model_usage) && Object.values(session.model_usage).every((usage) => usage && typeof usage === "object" && MODEL_USAGE_COUNTERS.every((key) => usage[key] === void 0 || Number.isFinite(usage[key]) && usage[key] >= 0))) usageBaseline = session;
+					} catch {} finally {
+						clearTimeout(timer);
+						if (cancelSnapshot) abortController.signal.removeEventListener("abort", cancelSnapshot);
+					}
+				})();
+				await captureUsageBaseline;
+				return {};
+			}] }, ...hooks?.UserPromptSubmit ?? []]
+		};
+		logger.debug(`Calling Claude Agent SDK: ${JSON.stringify({
+			prompt,
+			options: {
+				...options,
+				mcpServers: options.mcpServers ? Object.keys(options.mcpServers) : void 0,
+				env: Object.keys(env).length > 0 ? Object.keys(env) : void 0
+			}
+		})}`);
+		try {
+			return await withGenAISpan({
+				system: "anthropic",
+				operationName: "invoke_agent",
+				model: config.model || "Claude Code",
+				agentName: "Claude Code",
+				providerId: this.providerId,
+				traceparent: context?.traceparent,
+				maxTokens: config.max_thinking_tokens,
+				requestBody: prompt
+			}, async () => {
+				const ZERO_TRACE_ID = "00000000000000000000000000000000";
+				const active = getTraceparent();
+				const traceparent = (active && !active.includes(ZERO_TRACE_ID) ? active : void 0) ?? context?.traceparent;
+				if (traceparent && !env.TRACEPARENT) env.TRACEPARENT = traceparent;
+				const [, tpTraceId, tpSpanId] = traceparent ? traceparent.split("-") : [];
+				if (tpTraceId && tpSpanId) env.OTEL_RESOURCE_ATTRIBUTES = appendPromptfooResourceAttrs(env.OTEL_RESOURCE_ATTRIBUTES, tpTraceId, tpSpanId);
+				if (!this.claudeCodeModule) this.claudeCodeModule = await loadClaudeCodeSDK();
+				const res = await this.claudeCodeModule.query(queryParams);
+				query = res;
+				const toolCallsMap = /* @__PURE__ */ new Map();
+				const assistantErrors = [];
+				const toolStartTimes = /* @__PURE__ */ new Map();
+				let turnCount = 0;
+				const toolTurnIndex = /* @__PURE__ */ new Map();
+				const deferredSyntheticSpans = [];
+				const emitOrDeferSyntheticSpan = (emit) => {
+					if (sdkExportsNativeSpans) deferredSyntheticSpans.push(emit);
+					else emit();
+				};
+				const emitTurnSpan = (msg) => {
+					const index = turnCount + 1;
+					turnCount = index;
+					const attributes = {
+						"gen_ai.turn.index": index,
+						[GenAIAttributes.PROVIDER_NAME]: "anthropic"
+					};
+					if (msg.parent_tool_use_id) {
+						attributes["gen_ai.turn.parent_tool_use_id"] = msg.parent_tool_use_id;
+						attributes["gen_ai.turn.is_subagent"] = true;
+					}
+					if (msg.subagent_type) attributes["gen_ai.turn.subagent_type"] = msg.subagent_type;
+					if (msg.message?.model) attributes["gen_ai.response.model"] = msg.message.model;
+					const usage = msg.message?.usage;
+					if (usage) {
+						if (typeof usage.input_tokens === "number") attributes["gen_ai.usage.input_tokens"] = usage.input_tokens;
+						if (typeof usage.output_tokens === "number") attributes["gen_ai.usage.output_tokens"] = usage.output_tokens;
+					}
+					if (msg.error) attributes["gen_ai.turn.error"] = msg.error;
+					const now = Date.now();
+					emitOrDeferSyntheticSpan(() => {
+						emitTurnMarkerSpan({
+							tracer: getGenAITracer(),
+							index,
+							startTime: now,
+							endTime: now,
+							attributes,
+							errorMessage: msg.error,
+							logLabel: "ClaudeAgentSDK"
+						});
+					});
+					return index;
+				};
+				const drainOrphans = () => {
+					if (toolStartTimes.size === 0) return;
+					const endedAt = Date.now();
+					for (const [toolUseId, startMs] of toolStartTimes) {
+						const entry = toolCallsMap.get(toolUseId);
+						if (entry) {
+							const turnIndex = toolTurnIndex.get(toolUseId);
+							emitOrDeferSyntheticSpan(() => {
+								emitToolSpan(entry, startMs, endedAt, false, true, turnIndex);
+							});
+						}
+					}
+					toolStartTimes.clear();
+					toolTurnIndex.clear();
+				};
+				let lastResultMsg;
+				let lastMainResultMsg;
+				let resultMsgCount = 0;
+				for await (const msg of res) if (msg.type === "assistant") {
+					const turnIndex = emitTurnSpan(msg);
+					for (const block of msg.message.content) if (block.type === "tool_use") {
+						toolCallsMap.set(block.id, {
+							id: block.id,
+							name: block.name,
+							input: block.input,
+							output: void 0,
+							is_error: false,
+							parentToolUseId: msg.parent_tool_use_id
+						});
+						toolStartTimes.set(block.id, Date.now());
+						toolTurnIndex.set(block.id, turnIndex);
+					}
+					if (msg.error) assistantErrors.push({
+						error: msg.error,
+						uuid: msg.uuid,
+						parentToolUseId: msg.parent_tool_use_id,
+						...msg.request_id ? { request_id: msg.request_id } : {},
+						...msg.subagent_type ? { subagent_type: msg.subagent_type } : {},
+						...msg.task_description ? { task_description: msg.task_description } : {}
+					});
+				} else if (msg.type === "user") {
+					const content = msg.message?.content;
+					if (Array.isArray(content)) {
+						for (const block of content) if (block.type === "tool_result") {
+							const entry = toolCallsMap.get(block.tool_use_id);
+							if (entry) {
+								entry.output = entry.name === "TaskOutput" && isRawSubagentTranscript(msg.tool_use_result) && !config.forward_subagent_text ? REDACTED_SUBAGENT_TRANSCRIPT : block.content;
+								entry.is_error = block.is_error ?? false;
+								const startMs = toolStartTimes.get(block.tool_use_id);
+								if (startMs !== void 0) {
+									const endedAt = Date.now();
+									const turnIndex = toolTurnIndex.get(block.tool_use_id);
+									emitOrDeferSyntheticSpan(() => {
+										emitToolSpan(entry, startMs, endedAt, entry.is_error, false, turnIndex);
+									});
+									toolStartTimes.delete(block.tool_use_id);
+									toolTurnIndex.delete(block.tool_use_id);
+								}
+							}
+						}
+					}
+				} else if (msg.type === "result") {
+					lastResultMsg = msg;
+					resultMsgCount++;
+					if (!(msg.origin?.kind === "task-notification" && !("subkind" in msg.origin && msg.origin.subkind === "scheduled-trigger"))) lastMainResultMsg = msg;
+				}
+				drainOrphans();
+				const finalMsg = lastMainResultMsg ?? lastResultMsg;
+				if (!finalMsg) return { error: "Claude Agent SDK call didn't return a result" };
+				if (sdkExportsNativeSpans && tpTraceId && tpSpanId) {
+					let nativeSpansArrived = false;
+					try {
+						nativeSpansArrived = await waitForNativeTraceExport(tpTraceId, tpSpanId, env, callOptions?.abortSignal);
+					} catch (error) {
+						logger.debug("[ClaudeAgentSDK] Unable to inspect native trace export", { error: error instanceof Error ? error.message : String(error) });
+					}
+					if (!nativeSpansArrived && !callOptions?.abortSignal?.aborted) {
+						logger.warn("[ClaudeAgentSDK] Native trace spans did not reach the receiver before grading; emitting synthetic turn and tool spans.");
+						for (const emit of deferredSyntheticSpans) emit();
+					}
+				}
+				if ((!lastMainResultMsg || lastMainResultMsg.origin === void 0) && resultMsgCount > 1 && finalMsg.subtype === "success" && finalMsg.terminal_reason === void 0) {
+					logger.warn(`[ClaudeAgentSDK] Stream produced ${resultMsgCount} result messages and the last had no terminal_reason; returning it as the main-agent result, but the stream may have been truncated.`);
+					trace.getActiveSpan()?.setStatus({
+						code: SpanStatusCode.ERROR,
+						message: "stream closed without terminal_reason after multiple result messages"
+					});
+				}
+				const raw = JSON.stringify(finalMsg);
+				const usageUnavailable = needsUsageBaseline && !usageBaseline;
+				if (usageUnavailable) logger.warn("[ClaudeAgentSDK] Could not measure resumed-session usage before inference; per-call cost and token usage are unavailable. Raw session totals are preserved.");
+				const counterReset = usageBaseline && (finalMsg.total_cost_usd < usageBaseline.total_cost_usd || Object.entries(finalMsg.modelUsage ?? {}).some(([model, usage]) => MODEL_USAGE_COUNTERS.some((key) => typeof usage[key] === "number" && usage[key] < (usageBaseline?.model_usage[model]?.[key] ?? 0))));
+				const modelUsage = usageUnavailable ? void 0 : usageBaseline && !counterReset ? subtractSessionUsage(finalMsg.modelUsage ?? {}, usageBaseline.model_usage) : finalMsg.modelUsage;
+				const usageSources = Object.values(modelUsage ?? {});
+				if (!usageUnavailable && usageSources.length === 0 && finalMsg.usage) usageSources.push({
+					inputTokens: finalMsg.usage.input_tokens,
+					outputTokens: finalMsg.usage.output_tokens,
+					thinkingTokens: finalMsg.usage.output_tokens_details?.thinking_tokens,
+					cacheReadInputTokens: finalMsg.usage.cache_read_input_tokens,
+					cacheCreationInputTokens: finalMsg.usage.cache_creation_input_tokens
+				});
+				const usage = usageSources.reduce((total, source) => ({
+					inputTokens: total.inputTokens + (source.inputTokens ?? 0),
+					outputTokens: total.outputTokens + (source.outputTokens ?? 0),
+					thinkingTokens: source.thinkingTokens == null ? total.thinkingTokens : (total.thinkingTokens ?? 0) + source.thinkingTokens,
+					cacheReadInputTokens: total.cacheReadInputTokens + (source.cacheReadInputTokens ?? 0),
+					cacheCreationInputTokens: total.cacheCreationInputTokens + (source.cacheCreationInputTokens ?? 0)
+				}), {
+					inputTokens: 0,
+					outputTokens: 0,
+					cacheReadInputTokens: 0,
+					cacheCreationInputTokens: 0
+				});
+				const promptTokens = usage.inputTokens + usage.cacheReadInputTokens + usage.cacheCreationInputTokens;
+				const tokenUsage = usageSources.length ? {
+					prompt: promptTokens,
+					completion: usage.outputTokens,
+					total: promptTokens + usage.outputTokens,
+					...usage.thinkingTokens != null || usage.cacheReadInputTokens > 0 || usage.cacheCreationInputTokens > 0 ? { completionDetails: {
+						...usage.thinkingTokens != null && { reasoning: usage.thinkingTokens },
+						cacheReadInputTokens: usage.cacheReadInputTokens,
+						cacheCreationInputTokens: usage.cacheCreationInputTokens
+					} } : {}
+				} : {};
+				const cost = usageUnavailable ? void 0 : Math.max(0, (finalMsg.total_cost_usd ?? 0) - (counterReset ? 0 : usageBaseline?.total_cost_usd ?? 0));
+				const usageMetadata = needsUsageBaseline ? {
+					usageAccounting: usageUnavailable ? "unavailable" : "query",
+					sessionCost: finalMsg.total_cost_usd,
+					sessionModelUsage: finalMsg.modelUsage
+				} : {};
+				const sessionId = finalMsg.session_id;
+				const toolCallsArray = Array.from(toolCallsMap.values());
+				const skillCalls = deriveSkillCalls(toolCallsArray);
+				const abortedTerminalReason = typeof finalMsg.terminal_reason === "string" && (finalMsg.terminal_reason.startsWith("aborted_") || finalMsg.terminal_reason === "hook_stopped") ? finalMsg.terminal_reason : void 0;
+				if (abortedTerminalReason) trace.getActiveSpan()?.setStatus({
+					code: SpanStatusCode.ERROR,
+					message: `aborted: ${abortedTerminalReason}`
+				});
+				const apiErrorStatus = "api_error_status" in finalMsg ? finalMsg.api_error_status : void 0;
+				if (finalMsg.subtype === "success") {
+					logger.debug(`Claude Agent SDK response: ${raw}`);
+					const response = {
+						output: finalMsg.structured_output === void 0 ? finalMsg.result : finalMsg.structured_output,
+						tokenUsage,
+						cost,
+						raw,
+						sessionId,
+						metadata: {
+							skillCalls,
+							toolCalls: toolCallsArray,
+							numTurns: finalMsg.num_turns,
+							durationMs: finalMsg.duration_ms,
+							durationApiMs: finalMsg.duration_api_ms,
+							modelUsage,
+							...usageMetadata,
+							permissionDenials: finalMsg.permission_denials,
+							...finalMsg.terminal_reason === void 0 ? {} : { terminalReason: finalMsg.terminal_reason },
+							...finalMsg.structured_output === void 0 ? {} : { structuredOutput: finalMsg.structured_output },
+							...apiErrorStatus === void 0 || apiErrorStatus === null ? {} : { apiErrorStatus },
+							...assistantErrors.length > 0 ? { assistantErrors } : {}
+						}
+					};
+					await cacheResponse(cacheResult, response, "Claude Agent SDK");
+					return response;
+				}
+				const lastAssistantError = assistantErrors.length > 0 ? assistantErrors[assistantErrors.length - 1].error : void 0;
+				return {
+					error: lastAssistantError ? `Claude Agent SDK call failed: ${finalMsg.subtype} (${lastAssistantError})` : `Claude Agent SDK call failed: ${finalMsg.subtype}`,
+					tokenUsage,
+					cost,
+					raw,
+					sessionId,
+					metadata: {
+						skillCalls,
+						toolCalls: toolCallsArray,
+						numTurns: finalMsg.num_turns,
+						durationMs: finalMsg.duration_ms,
+						durationApiMs: finalMsg.duration_api_ms,
+						modelUsage,
+						...usageMetadata,
+						permissionDenials: finalMsg.permission_denials,
+						...finalMsg.terminal_reason === void 0 ? {} : { terminalReason: finalMsg.terminal_reason },
+						...apiErrorStatus === void 0 || apiErrorStatus === null ? {} : { apiErrorStatus },
+						...assistantErrors.length > 0 ? { assistantErrors } : {}
+					}
+				};
+			}, (response) => {
+				const metadata = response.metadata ?? {};
+				const additional = {};
+				if (typeof metadata.numTurns === "number") additional["promptfoo.agent.num_turns"] = metadata.numTurns;
+				if (typeof metadata.durationApiMs === "number") additional["promptfoo.agent.duration_api_ms"] = metadata.durationApiMs;
+				if (typeof response.cost === "number" && response.cost > 0) additional["promptfoo.agent.cost_usd"] = response.cost;
+				const toolCalls = metadata.toolCalls;
+				if (Array.isArray(toolCalls) && toolCalls.length > 0) additional["promptfoo.agent.tool_call_count"] = toolCalls.length;
+				let responseModel;
+				const modelUsage = metadata.modelUsage;
+				if (modelUsage && typeof modelUsage === "object" && !Array.isArray(modelUsage)) {
+					let topUsage = -1;
+					for (const [key, usage] of Object.entries(modelUsage)) {
+						if (typeof key !== "string" || key.length === 0 || key === "undefined") continue;
+						const total = (usage?.inputTokens ?? 0) + (usage?.outputTokens ?? 0);
+						if (total > topUsage) {
+							topUsage = total;
+							responseModel = key;
+						}
+					}
+				}
+				const finishReasons = typeof metadata.terminalReason === "string" ? [metadata.terminalReason] : void 0;
+				return {
+					tokenUsage: response.tokenUsage,
+					responseModel,
+					responseId: response.sessionId,
+					finishReasons,
+					cacheHit: response.cached,
+					responseBody: typeof response.output === "string" ? response.output : response.output === void 0 ? void 0 : JSON.stringify(response.output),
+					additionalAttributes: Object.keys(additional).length > 0 ? additional : void 0
+				};
+			});
+		} catch (error) {
+			if (error?.name === "AbortError" || callOptions?.abortSignal?.aborted) {
+				logger.warn("Claude Agent SDK call aborted");
+				return { error: "Claude Agent SDK call aborted" };
+			}
+			logger.error(`Error calling Claude Agent SDK: ${error}`);
+			return { error: `Error calling Claude Agent SDK: ${error}` };
+		} finally {
+			if (isTempDir && workingDir) await fsPromises.rm(workingDir, {
+				recursive: true,
+				force: true
+			});
+			if (callOptions?.abortSignal && abortHandler) callOptions.abortSignal.removeEventListener("abort", abortHandler);
+		}
+	}
+	toString() {
+		return "[Anthropic Claude Agent SDK Provider]";
+	}
+	requiresApiKey() {
+		return false;
+	}
+	getApiKey() {
+		return this.config?.apiKey || this.env?.ANTHROPIC_API_KEY || getEnvString("ANTHROPIC_API_KEY");
+	}
+	async cleanup() {}
+};
+//#endregion
+export { ClaudeCodeSDKProvider };
+
+//# sourceMappingURL=claude-agent-sdk-Cr-jqJZl.js.map