@use-lattice/litmus 0.121.3

package/dist/src/agentic-utils-Dh7xaMQM.cjs

@@ -0,0 +1,180 @@
+const require_logger = require("./logger-DyfK9PBt.cjs");
+const require_cache = require("./cache-DsCxFlsZ.cjs");
+let fs = require("fs");
+fs = require_logger.__toESM(fs);
+let path = require("path");
+path = require_logger.__toESM(path);
+let dedent = require("dedent");
+dedent = require_logger.__toESM(dedent);
+let crypto = require("crypto");
+crypto = require_logger.__toESM(crypto);
+//#region src/providers/agentic-utils.ts
+/**
+* Shared utilities for agentic providers (Claude Agent SDK, OpenCode SDK, etc.)
+*
+* These utilities handle common functionality needed by coding agent providers:
+* - Working directory fingerprinting for cache key generation
+* - Response caching with fingerprint support
+*/
+/**
+* Timeout for working directory fingerprint generation (ms)
+* Prevents hanging on extremely large directories
+*/
+const FINGERPRINT_TIMEOUT_MS = 2e3;
+/**
+* Get a fingerprint for a working directory to use as a cache key.
+* Checks directory mtime and descendant file mtimes recursively.
+*
+* This allows for caching prompts that use the same working directory
+* when the files haven't changed.
+*
+* @param workingDir - Absolute path to the working directory
+* @returns SHA-256 hash fingerprint of the directory state
+* @throws Error if fingerprinting times out or directory is inaccessible
+*/
+async function getWorkingDirFingerprint(workingDir) {
+	const dirMtime = fs.default.statSync(workingDir).mtimeMs;
+	const startTime = Date.now();
+	const getAllFiles = (dir, files = []) => {
+		if (Date.now() - startTime > FINGERPRINT_TIMEOUT_MS) throw new Error("Working directory fingerprint timed out");
+		const entries = fs.default.readdirSync(dir, { withFileTypes: true });
+		for (const entry of entries) {
+			const fullPath = path.default.join(dir, entry.name);
+			if (entry.isDirectory()) getAllFiles(fullPath, files);
+			else if (entry.isFile()) files.push(fullPath);
+		}
+		return files;
+	};
+	const fingerprintData = `dir:${dirMtime};files:${getAllFiles(workingDir).map((file) => {
+		const stat = fs.default.statSync(file);
+		return `${path.default.relative(workingDir, file)}:${stat.mtimeMs}`;
+	}).sort().join(",")}`;
+	return crypto.default.createHash("sha256").update(fingerprintData).digest("hex");
+}
+/**
+* Generate a cache key from arbitrary data using SHA-256 hash
+*
+* @param prefix - Cache key prefix (provider identifier)
+* @param data - Data to hash for the cache key
+* @returns Prefixed SHA-256 hash cache key
+*/
+function generateCacheKey(prefix, data) {
+	const stringified = JSON.stringify(data);
+	return `${prefix}:${crypto.default.createHash("sha256").update(stringified).digest("hex")}`;
+}
+/**
+* Initialize cache and check for cached response
+*
+* This handles the common caching pattern used by agentic providers:
+* 1. Check if caching is enabled
+* 2. Generate working directory fingerprint if needed
+* 3. Generate cache key
+* 4. Return cache configuration for use by the provider
+*
+* @param options - Cache options including prefix and working directory
+* @param cacheKeyData - Data to include in the cache key
+* @returns Cache configuration and optional cached response
+*/
+async function initializeAgenticCache(options, cacheKeyData) {
+	if (!require_cache.isCacheEnabled()) return {
+		shouldCache: false,
+		shouldReadCache: false,
+		shouldWriteCache: false
+	};
+	if (options.mcp && !options.cacheMcp) return {
+		shouldCache: false,
+		shouldReadCache: false,
+		shouldWriteCache: false
+	};
+	let workingDirFingerprint = null;
+	if (options.workingDir) try {
+		workingDirFingerprint = await getWorkingDirFingerprint(options.workingDir);
+	} catch (error) {
+		require_logger.logger.error(dedent.default`Error getting working directory fingerprint for cache key - ${options.workingDir}: ${String(error)}
+
+        Caching is disabled.`);
+		return {
+			shouldCache: false,
+			shouldReadCache: false,
+			shouldWriteCache: false
+		};
+	}
+	const cache = await require_cache.getCache();
+	const cacheKey = generateCacheKey(options.cacheKeyPrefix, {
+		...cacheKeyData,
+		workingDirFingerprint,
+		...options.mcp ? { mcp: options.mcp } : {}
+	});
+	return {
+		shouldCache: true,
+		shouldReadCache: !options.bustCache,
+		shouldWriteCache: true,
+		cache,
+		cacheKey,
+		workingDirFingerprint
+	};
+}
+/**
+* Try to get a cached response
+*
+* @param cacheResult - Result from initializeAgenticCache
+* @param debugContext - Context for debug logging (e.g., prompt preview)
+* @returns Cached ProviderResponse if found, undefined otherwise
+*/
+async function getCachedResponse(cacheResult, debugContext) {
+	if (!cacheResult.shouldReadCache || !cacheResult.cache || !cacheResult.cacheKey) return;
+	try {
+		const cachedResponse = await cacheResult.cache.get(cacheResult.cacheKey);
+		if (cachedResponse) {
+			require_logger.logger.debug(`Returning cached response${debugContext ? ` for ${debugContext}` : ""} (cache key: ${cacheResult.cacheKey})`);
+			return {
+				...JSON.parse(cachedResponse),
+				cached: true
+			};
+		}
+	} catch (error) {
+		require_logger.logger.error(`Error getting cached response: ${String(error)}`);
+	}
+}
+/**
+* Cache a provider response
+*
+* @param cacheResult - Result from initializeAgenticCache
+* @param response - The ProviderResponse to cache
+* @param debugContext - Context for debug logging
+*/
+async function cacheResponse(cacheResult, response, debugContext) {
+	if (!cacheResult.shouldWriteCache || !cacheResult.cache || !cacheResult.cacheKey) return;
+	try {
+		await cacheResult.cache.set(cacheResult.cacheKey, JSON.stringify(response));
+	} catch (error) {
+		require_logger.logger.error(`Error caching response${debugContext ? ` for ${debugContext}` : ""}: ${String(error)}`);
+	}
+}
+//#endregion
+Object.defineProperty(exports, "cacheResponse", {
+	enumerable: true,
+	get: function() {
+		return cacheResponse;
+	}
+});
+Object.defineProperty(exports, "generateCacheKey", {
+	enumerable: true,
+	get: function() {
+		return generateCacheKey;
+	}
+});
+Object.defineProperty(exports, "getCachedResponse", {
+	enumerable: true,
+	get: function() {
+		return getCachedResponse;
+	}
+});
+Object.defineProperty(exports, "initializeAgenticCache", {
+	enumerable: true,
+	get: function() {
+		return initializeAgenticCache;
+	}
+});
+
+//# sourceMappingURL=agentic-utils-Dh7xaMQM.cjs.map

package/dist/src/agents-C6BIMlZa.js

@@ -0,0 +1,231 @@
+import { b as getEnvInt, r as logger } from "./logger-C40ZGil9.js";
+import { a as isCacheEnabled, i as getCache } from "./cache-BkrqU5Ba.js";
+import { t as telemetry } from "./telemetry-Bg2WqF79.js";
+import { n as createBedrockRequestHandler, r as hasProxyEnv, t as AwsBedrockGenericProvider } from "./base-C451JQfq.js";
+//#region src/providers/bedrock/agents.ts
+/**
+* AWS Bedrock Agents provider for invoking deployed AI agents.
+* Supports all Bedrock Agents features including memory, knowledge bases, action groups,
+* guardrails, and session management.
+*
+* @example Basic usage
+* ```yaml
+* providers:
+*   - bedrock-agent:AGENT_ID
+*     config:
+*       agentAliasId: PROD_ALIAS
+*       region: us-east-1
+* ```
+*
+* @example With memory and session
+* ```yaml
+* providers:
+*   - bedrock-agent:AGENT_ID
+*     config:
+*       agentAliasId: PROD_ALIAS
+*       sessionId: user-session-123
+*       memoryId: LONG_TERM_MEMORY
+*       enableTrace: true
+* ```
+*
+* @example With guardrails and inference config
+* ```yaml
+* providers:
+*   - bedrock-agent:AGENT_ID
+*     config:
+*       agentAliasId: PROD_ALIAS
+*       guardrailConfiguration:
+*         guardrailId: GUARDRAIL_ID
+*         guardrailVersion: "1"
+*       temperature: 0.7  # Can be specified at root level for convenience
+*         topP: 0.9
+*         maximumLength: 2048
+* ```
+*/
+var AwsBedrockAgentsProvider = class extends AwsBedrockGenericProvider {
+	agentRuntimeClient;
+	config;
+	constructor(agentId, options = {}) {
+		super(agentId, options);
+		if (!agentId && !options.config?.agentId) throw new Error("Agent ID is required. Provide it in the provider path (bedrock-agent:AGENT_ID) or config.");
+		this.config = {
+			...options.config,
+			agentId: options.config?.agentId || agentId
+		};
+		telemetry.record("feature_used", {
+			feature: "bedrock-agents",
+			provider: "bedrock"
+		});
+	}
+	id() {
+		return `bedrock-agent:${this.config.agentId}`;
+	}
+	toString() {
+		return `[AWS Bedrock Agents Provider ${this.config.agentId}]`;
+	}
+	/**
+	* Get or create the Bedrock Agent Runtime client
+	*/
+	async getAgentRuntimeClient() {
+		if (!this.agentRuntimeClient) {
+			const handler = hasProxyEnv() ? await createBedrockRequestHandler() : void 0;
+			try {
+				const { BedrockAgentRuntimeClient } = await import("@aws-sdk/client-bedrock-agent-runtime");
+				const credentials = await this.getCredentials();
+				this.agentRuntimeClient = new BedrockAgentRuntimeClient({
+					region: this.getRegion(),
+					maxAttempts: getEnvInt("AWS_BEDROCK_MAX_RETRIES", 10),
+					retryMode: "adaptive",
+					...handler ? { requestHandler: handler } : {},
+					...credentials ? { credentials } : {}
+				});
+			} catch (err) {
+				logger.error(`Error creating BedrockAgentRuntimeClient: ${err}`);
+				throw new Error("The @aws-sdk/client-bedrock-agent-runtime package is required. Please install it: npm install @aws-sdk/client-bedrock-agent-runtime");
+			}
+		}
+		return this.agentRuntimeClient;
+	}
+	/**
+	* Build the session state from configuration
+	*/
+	buildSessionState() {
+		if (!this.config.sessionState) return;
+		const sessionState = {
+			sessionAttributes: this.config.sessionState.sessionAttributes,
+			promptSessionAttributes: this.config.sessionState.promptSessionAttributes,
+			invocationId: this.config.sessionState.invocationId
+		};
+		if (this.config.sessionState.returnControlInvocationResults) sessionState.returnControlInvocationResults = this.config.sessionState.returnControlInvocationResults;
+		return sessionState;
+	}
+	/**
+	* Build inference configuration from both root-level and nested parameters
+	* Root-level parameters take precedence over nested ones for convenience
+	*/
+	buildInferenceConfig() {
+		const hasRootConfig = this.config.temperature !== void 0 || this.config.topP !== void 0 || this.config.topK !== void 0 || this.config.maximumLength !== void 0 || this.config.stopSequences !== void 0;
+		const hasNestedConfig = this.config.inferenceConfig !== void 0;
+		if (!hasRootConfig && !hasNestedConfig) return;
+		const inferenceConfig = {};
+		if (this.config.inferenceConfig) {
+			if (this.config.inferenceConfig.maximumLength !== void 0) inferenceConfig.maximumLength = this.config.inferenceConfig.maximumLength;
+			if (this.config.inferenceConfig.stopSequences !== void 0) inferenceConfig.stopSequences = this.config.inferenceConfig.stopSequences;
+			if (this.config.inferenceConfig.temperature !== void 0) inferenceConfig.temperature = this.config.inferenceConfig.temperature;
+			if (this.config.inferenceConfig.topP !== void 0) inferenceConfig.topP = this.config.inferenceConfig.topP;
+			if (this.config.inferenceConfig.topK !== void 0) inferenceConfig.topK = this.config.inferenceConfig.topK;
+		}
+		if (this.config.temperature !== void 0) inferenceConfig.temperature = this.config.temperature;
+		if (this.config.topP !== void 0) inferenceConfig.topP = this.config.topP;
+		if (this.config.topK !== void 0) inferenceConfig.topK = this.config.topK;
+		if (this.config.maximumLength !== void 0) inferenceConfig.maximumLength = this.config.maximumLength;
+		if (this.config.stopSequences !== void 0) inferenceConfig.stopSequences = this.config.stopSequences;
+		return inferenceConfig;
+	}
+	/**
+	* Process the streaming response from the agent
+	*/
+	async processResponse(response) {
+		let output = "";
+		const traces = [];
+		if (response.completion) {
+			const decoder = new TextDecoder();
+			try {
+				for await (const event of response.completion) {
+					if (event.chunk?.bytes) output += decoder.decode(event.chunk.bytes, { stream: true });
+					if (this.config.enableTrace && event.trace) traces.push(event.trace);
+				}
+				output += decoder.decode();
+			} catch (error) {
+				logger.error(`Error processing agent response stream: ${error}`);
+				throw error;
+			}
+		}
+		return {
+			output,
+			trace: traces.length > 0 ? traces : void 0,
+			sessionId: response.sessionId
+		};
+	}
+	/**
+	* Invoke the agent with the given prompt
+	*/
+	async callApi(prompt) {
+		if (!this.config.agentAliasId) return { error: "Agent Alias ID is required. Set agentAliasId in the provider config." };
+		const client = await this.getAgentRuntimeClient();
+		const sessionId = this.config.sessionId || (typeof crypto !== "undefined" && "randomUUID" in crypto ? `session-${crypto.randomUUID()}` : `session-${Date.now()}-${process.hrtime.bigint().toString(36)}`);
+		const input = {
+			agentId: this.config.agentId,
+			agentAliasId: this.config.agentAliasId,
+			sessionId,
+			inputText: prompt,
+			enableTrace: this.config.enableTrace,
+			endSession: this.config.endSession,
+			sessionState: this.buildSessionState(),
+			memoryId: this.config.memoryId,
+			...this.buildInferenceConfig() && { inferenceConfig: this.buildInferenceConfig() },
+			...this.config.guardrailConfiguration && { guardrailConfiguration: this.config.guardrailConfiguration },
+			...this.config.promptOverrideConfiguration && { promptOverrideConfiguration: this.config.promptOverrideConfiguration },
+			...this.config.knowledgeBaseConfigurations && { knowledgeBaseConfigurations: this.config.knowledgeBaseConfigurations },
+			...this.config.actionGroups && { actionGroups: this.config.actionGroups },
+			...this.config.inputDataConfig && { inputDataConfig: this.config.inputDataConfig }
+		};
+		logger.debug(`Invoking Bedrock agent ${this.config.agentId} with session ${sessionId}`);
+		const cache = await getCache();
+		const cacheKey = `bedrock-agent:${this.config.agentId}:${JSON.stringify({
+			prompt,
+			inferenceConfig: this.buildInferenceConfig(),
+			knowledgeBaseConfigurations: this.config.knowledgeBaseConfigurations
+		})}`;
+		if (isCacheEnabled()) {
+			const cached = await cache.get(cacheKey);
+			if (cached) {
+				logger.debug("Returning cached Bedrock Agents response");
+				try {
+					const parsed = JSON.parse(cached);
+					if (parsed && typeof parsed === "object") return {
+						...parsed,
+						cached: true
+					};
+				} catch {
+					logger.warn("Failed to parse cached Bedrock Agents response, ignoring cache");
+				}
+			}
+		}
+		try {
+			const { InvokeAgentCommand } = await import("@aws-sdk/client-bedrock-agent-runtime");
+			const response = await client.send(new InvokeAgentCommand(input));
+			const { output, trace, sessionId: responseSessionId } = await this.processResponse(response);
+			const result = {
+				output,
+				metadata: {
+					...responseSessionId && { sessionId: responseSessionId },
+					...trace && { trace },
+					...this.config.memoryId && { memoryId: this.config.memoryId },
+					...this.config.guardrailConfiguration && { guardrails: {
+						applied: true,
+						guardrailId: this.config.guardrailConfiguration.guardrailId,
+						guardrailVersion: this.config.guardrailConfiguration.guardrailVersion
+					} }
+				}
+			};
+			if (isCacheEnabled()) try {
+				await cache.set(cacheKey, JSON.stringify(result));
+			} catch (err) {
+				logger.error(`Failed to cache response: ${err}`);
+			}
+			return result;
+		} catch (error) {
+			logger.error(`Bedrock Agents invocation failed: ${error}`);
+			if (error.name === "ResourceNotFoundException") return { error: `Agent or alias not found. Verify agentId: ${this.config.agentId} and agentAliasId: ${this.config.agentAliasId}` };
+			else if (error.name === "AccessDeniedException") return { error: "Access denied. Check IAM permissions for bedrock:InvokeAgent" };
+			else if (error.name === "ValidationException") return { error: `Invalid configuration: ${error.message}` };
+			else if (error.name === "ThrottlingException") return { error: "Rate limit exceeded. Please retry later." };
+			return { error: `Failed to invoke agent: ${error.message || String(error)}` };
+		}
+	}
+};
+//#endregion
+export { AwsBedrockAgentsProvider };
+
+//# sourceMappingURL=agents-C6BIMlZa.js.map