@od-oneapp/ai-platform 0.1.0

package/dist/evaluator-optimizer-De67_mJC.mjs

@@ -0,0 +1,1086 @@
+import { t as __exportAll } from "./chunk-CkzbjWQW.mjs";
+import { Et as rerank, Ft as tool, et as generateText, f as ToolLoopAgent, k as createMCPClient, s as Experimental_StdioMCPTransport, w as createAgentUIStreamResponse } from "./ai-runtime-CDzQztTt.mjs";
+import { t as complianceSignalSchema } from "./schemas-CxQtxIga.mjs";
+import { c as detectRiskFromMessages, i as resolveLoopPolicy, n as defaultTelemetry, o as applyDefaultGuardrails, r as mergeActiveTools } from "./telemetry-2eKMojIb.mjs";
+import { n as FeedbackLoopConfigSchema, t as EvaluationResultSchema } from "./schema-CwFvuCnA.mjs";
+import { randomUUID } from "node:crypto";
+import { z } from "zod/v4";
+import { logInfo } from "@od-oneapp/shared/logs";
+
+//#region src/agents/tools/mcp.ts
+/**
+* @fileoverview Model Context Protocol (MCP) tool integration
+*
+* Provides utilities for connecting to MCP servers and integrating their tools
+* into AI agents. Supports SSE, HTTP, and stdio transport types.
+*
+* @module @od-oneapp/ai-platform/agents/tools/mcp
+*/
+/**
+* Connects to an MCP server and returns its tools.
+* Uses createMCPClient from the AI SDK MCP package.
+*
+* @param options - MCP connection options.
+* @returns Connected toolset with tools and close function.
+* @example
+* ```ts
+* const toolset = await connectMcpToolset({
+*   transport: { type: 'sse', url: 'https://mcp.example.com/sse' },
+*   approval: true
+* });
+*
+* // Use tools
+* const result = await toolset.tools.myTool.execute({ input: 'data' });
+*
+* // Cleanup
+* await toolset.close();
+* ```
+* @example
+* ```ts
+* const stdioToolset = await connectMcpToolset({
+*   transport: { type: 'stdio', command: 'mcp-server', args: ['--profile', 'prod'] },
+* });
+* ```
+*/
+const connectMcpToolset = async (options) => {
+	const baseEnv = Object.entries(process.env).reduce((acc, [key, value]) => {
+		if (typeof value === "string") acc[key] = value;
+		return acc;
+	}, {});
+	const client = await createMCPClient({ transport: options.transport.type === "stdio" ? new Experimental_StdioMCPTransport({
+		command: options.transport.command ?? "node",
+		args: options.transport.args ?? [],
+		env: options.transport.env ? {
+			...baseEnv,
+			...options.transport.env
+		} : baseEnv,
+		cwd: options.transport.cwd,
+		stderr: options.transport.stderr
+	}) : {
+		type: options.transport.type,
+		url: options.transport.url,
+		headers: options.transport.type === "http" && options.transport.sessionId ? {
+			...options.transport.headers,
+			"x-mcp-session-id": options.transport.sessionId
+		} : options.transport.headers,
+		authProvider: options.transport.authProvider
+	} });
+	let tools;
+	try {
+		tools = await client.tools();
+	} catch (error) {
+		await client.close();
+		throw new Error(`Failed to retrieve tools from MCP server: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	const processedTools = {};
+	try {
+		for (const name of Object.keys(tools)) {
+			const toolDefinition = tools[name];
+			if (!toolDefinition) continue;
+			processedTools[name] = {
+				...toolDefinition,
+				needsApproval: options.approval ?? toolDefinition.needsApproval
+			};
+		}
+	} catch (error) {
+		await client.close();
+		throw error;
+	}
+	return {
+		tools: processedTools,
+		close: async () => {
+			await client.close();
+		}
+	};
+};
+
+//#endregion
+//#region src/agents/tools/index.ts
+/**
+* @fileoverview Default agent tools
+*
+* Provides default tools for AI agents including knowledge base search,
+* escalation, and audit logging. Also includes utilities for creating
+* execution signals.
+*
+* @module @od-oneapp/ai-platform/agents/tools
+*/
+/**
+* Internal knowledge base for compliance and best practices.
+* Used by the knowledgeBaseTool for searching compliance guidelines.
+* @internal
+*/
+const KNOWLEDGE_BASE = [
+	{
+		id: "kb-guardrails",
+		title: "Guardrail Playbook",
+		snippet: "All high risk guardrail violations must be escalated to compliance within 1 hour."
+	},
+	{
+		id: "kb-telemetry",
+		title: "Telemetry Standards",
+		snippet: "Every AI call must include telemetry metadata including risk levels and tool names."
+	},
+	{
+		id: "kb-rag",
+		title: "RAG Quality Checks",
+		snippet: "Use rerank() with topN <= 5 to keep prompts small and latency predictable."
+	}
+];
+/**
+* Schema for knowledge base search input.
+*/
+const knowledgeBaseInputSchema = z.object({
+	query: z.string().min(2),
+	topN: z.number().min(1).max(5).default(3)
+});
+/**
+* Knowledge base search tool.
+* Searches the internal compliance knowledge base using reranking.
+* Falls back to simple text matching if reranking fails.
+* @example
+* ```ts
+* const result = await knowledgeBaseTool.execute({ query: 'guardrail', topN: 2 });
+* console.log(result.results[0].text);
+* ```
+*/
+const knowledgeBaseTool = tool({
+	description: "Searches the internal compliance knowledge base and returns ranked snippets.",
+	inputSchema: knowledgeBaseInputSchema,
+	execute: async ({ query, topN }) => {
+		try {
+			return {
+				query,
+				results: (await rerank({
+					model: "openai:rerank-v1",
+					documents: KNOWLEDGE_BASE.map((document) => ({
+						id: document.id,
+						text: `${document.title}: ${document.snippet}`
+					})),
+					query,
+					topN,
+					experimental_telemetry: {
+						isEnabled: true,
+						functionId: "knowledge-base-rerank",
+						metadata: { queryLength: query.length }
+					}
+				})).rerankedDocuments.slice(0, topN).map((entry, index) => ({
+					id: entry.id ?? `kb-${index}`,
+					score: typeof entry.score === "number" ? entry.score : 0,
+					text: entry.text
+				}))
+			};
+		} catch (error) {
+			return {
+				query,
+				results: KNOWLEDGE_BASE.filter((document) => document.snippet.toLowerCase().includes(query.toLowerCase())).slice(0, topN).map((document, index) => ({
+					id: document.id ?? `fallback-${index}`,
+					score: 0,
+					text: `${document.title}: ${document.snippet}`
+				})),
+				warning: error instanceof Error ? error.message : String(error)
+			};
+		}
+	}
+});
+/**
+* Schema for escalation ticket input.
+*/
+const escalateInputSchema = z.object({
+	summary: z.string().min(10),
+	ticketSystem: z.enum([
+		"jira",
+		"pagerduty",
+		"service-now"
+	]).default("jira"),
+	severity: z.enum([
+		"low",
+		"medium",
+		"high"
+	]).default("medium")
+});
+/**
+* Escalation tool for creating compliance tickets.
+* Requires human approval for medium and high severity tickets.
+* @example
+* ```ts
+* const ticket = await escalateTool.execute({
+*   summary: 'User requested PII export',
+*   ticketSystem: 'jira',
+*   severity: 'high',
+* });
+* ```
+*/
+const escalateTool = tool({
+	description: "Creates a compliance escalation ticket that requires human approval.",
+	inputSchema: escalateInputSchema,
+	needsApproval: (input) => input.severity !== "low",
+	execute: async (input) => ({
+		ticketId: `${input.ticketSystem}-${randomUUID().slice(0, 8)}`,
+		...input,
+		createdAt: (/* @__PURE__ */ new Date()).toISOString()
+	})
+});
+/**
+* Schema for audit log input.
+*/
+const auditLogInputSchema = z.object({
+	runId: z.string(),
+	toolCalls: z.array(z.object({
+		id: z.string(),
+		toolName: z.string(),
+		approved: z.boolean().optional(),
+		payload: z.record(z.string(), z.unknown()).optional()
+	}))
+});
+/**
+* Audit logging tool for compliance tracking.
+* Writes structured audit log entries and returns compliance receipts.
+* @example
+* ```ts
+* const receipt = await auditLogTool.execute({
+*   runId: 'run-1',
+*   toolCalls: [{ id: 'call-1', toolName: 'knowledgeBase' }],
+* });
+* ```
+*/
+const auditLogTool = tool({
+	description: "Writes a structured audit log entry and returns a compliance receipt.",
+	inputSchema: auditLogInputSchema,
+	execute: async ({ runId, toolCalls }) => ({
+		receiptId: randomUUID(),
+		runId,
+		totalTools: toolCalls.length,
+		createdAt: (/* @__PURE__ */ new Date()).toISOString()
+	})
+});
+/**
+* Default tools available to all agents.
+* Includes knowledge base search, escalation, and audit logging.
+* @example
+* ```ts
+* const tools = Object.keys(defaultTools);
+* // ['knowledgeBase', 'escalate', 'auditLog']
+* ```
+*/
+const defaultTools = {
+	knowledgeBase: knowledgeBaseTool,
+	escalate: escalateTool,
+	auditLog: auditLogTool
+};
+/**
+* Creates a compliance signal for tool execution events.
+* Used to track tool calls throughout agent execution for audit purposes.
+*
+* @param toolCall - Tool call information.
+* @param type - Signal type (tool.executed, tool.awaiting-approval, or tool.denied).
+* @param runId - Agent run identifier.
+* @returns Compliance signal object.
+* @example
+* ```ts
+* const signal = createExecutionSignal(
+*   { id: 'call-123', toolName: 'escalate', input: { summary: 'Issue' } },
+*   'tool.executed',
+*   'run-456'
+* );
+* ```
+*/
+const createExecutionSignal = (toolCall, type, runId) => complianceSignalSchema.parse({
+	id: randomUUID(),
+	type,
+	message: `${toolCall.toolName} (${toolCall.id}) ${type.replace("tool.", "")}`,
+	runId,
+	timestamp: (/* @__PURE__ */ new Date()).toISOString()
+});
+
+//#endregion
+//#region src/agents/default-agent.ts
+/**
+* @fileoverview Agent creation utilities
+*
+* Provides functions for creating AI agents with default configurations including
+* guardrails, loop policies, telemetry, and structured output support.
+*
+* THIS FILE IMPLEMENTS THE STANDARD AGENT TRACK (Experimental_Agent).
+*
+* @module @od-oneapp/ai-platform/agents/default-agent
+*/
+/**
+* Standard Agent type (Experimental_Agent instance).
+* Wrapper class to maintain compatibility with legacy DefaultAgent interface
+* while using Experimental_Agent internally.
+*/
+var StandardAgent = class {
+	agent;
+	options;
+	runId;
+	tools;
+	constructor(options) {
+		this.options = options;
+		this.runId = options.runId ?? randomUUID();
+		const wrappedModel = applyDefaultGuardrails(options.model);
+		const loopPolicy = resolveLoopPolicy({
+			riskLevel: options.riskLevel,
+			activeTools: options.activeTools
+		});
+		this.tools = {
+			...defaultTools,
+			...options.tools
+		};
+		const activeToolNames = mergeActiveTools(loopPolicy, options.activeTools);
+		this.agent = new ToolLoopAgent({
+			model: wrappedModel,
+			tools: activeToolNames ? Object.keys(this.tools).filter((key) => activeToolNames.includes(key)).reduce((obj, key) => {
+				const tool = this.tools[key];
+				if (tool) obj[key] = tool;
+				return obj;
+			}, {}) : this.tools,
+			instructions: "You are a compliance co-pilot. Obey guardrails, honour human approvals, and document every decision in the structured output.",
+			experimental_telemetry: options.telemetry ?? defaultTelemetry,
+			stopWhen: loopPolicy.stopCondition
+		});
+	}
+	/**
+	* Generates a response using the agent.
+	* Wraps the internal generate call to provide signal emission and structured output handling.
+	*/
+	async generate(options) {
+		const result = await this.agent.generate(options);
+		if (this.options.onSignal && result.steps) {
+			for (const step of result.steps) if (step.toolCalls) for (const toolCall of step.toolCalls) this.options.onSignal(createExecutionSignal({
+				id: toolCall.toolCallId,
+				toolName: toolCall.toolName,
+				input: toolCall.input
+			}, "tool.executed", this.runId));
+		}
+		await this.options.onCleanup?.();
+		return result;
+	}
+	async stream(options) {
+		return this.agent.stream(options);
+	}
+	/**
+	* Access the underlying ToolLoopAgent instance.
+	* Intended for SDK helpers that require the raw agent type.
+	*/
+	getToolLoopAgent() {
+		return this.agent;
+	}
+};
+/**
+* Creates a default agent (Standard Track).
+* Uses Experimental_Agent under the hood.
+*/
+const createDefaultAgent = (options) => {
+	return new StandardAgent(options);
+};
+const createDefaultAgentConfig = (options) => {
+	throw new Error("createDefaultAgentConfig is deprecated. Use createDefaultAgent directly.");
+};
+
+//#endregion
+//#region src/agents/governance-agent.ts
+/**
+* @fileoverview Governance Agent
+*
+* Implements the "Governance Track" agent strategy using the Ralph Wiggum autonomous retry loop.
+* This agent prioritizes RELIABILITY and COMPLIANCE over raw speed.
+*
+* Features:
+* - Autonomous Retry Loop (keeps trying until completion signal)
+* - "Principal Skinner" Governance (fine-grained token budgets per iteration)
+* - Audit Signals (loop.approval_required, loop.budget_exceeded)
+* - Feedback Loops (feeds errors back into context)
+*
+* @module @od-oneapp/ai-platform/agents/governance-agent
+*/
+/**
+* Creates a delay promise.
+* @internal
+*/
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/**
+* Filters tools based on blocked list.
+* @internal
+*/
+const filterTools = (tools, blockedTools) => {
+	if (!tools) return void 0;
+	const filtered = {};
+	for (const [name, tool] of Object.entries(tools)) if (!blockedTools.includes(name)) filtered[name] = tool;
+	return Object.keys(filtered).length > 0 ? filtered : void 0;
+};
+/**
+* Checks if output contains completion signal.
+* Uses word boundary matching to avoid false positives.
+* @internal
+*/
+const detectCompletion = (output, signal) => {
+	const escapedSignal = signal.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	return new RegExp(`\\b${escapedSignal}\\b`, "i").test(output);
+};
+/**
+* Creates a compliance signal.
+* @internal
+*/
+const createSignal = (type, message, runId, riskLevel, metadata) => {
+	return complianceSignalSchema.parse({
+		id: randomUUID(),
+		type,
+		message,
+		runId,
+		riskLevel,
+		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+		metadata
+	});
+};
+/**
+* Executes the Governance Loop.
+* @internal
+*/
+async function executeGovernanceLoop(options) {
+	const { task, completionSignal, maxIterations = 10, feedbackErrors = true, iterationDelay = 0, governance, model, tools, onIteration, onSignal, systemPrompt, runId = randomUUID() } = options;
+	const signals = [];
+	const iterationHistory = [];
+	let iteration = 0;
+	const context = task;
+	let lastError;
+	let totalInputTokens = 0;
+	let totalOutputTokens = 0;
+	const startTime = Date.now();
+	const allowedTools = filterTools(tools, governance.blockedTools);
+	const startSignal = createSignal("loop.started", `Governance Agent started: ${task.slice(0, 50)}...`, runId, "low", {
+		maxIterations,
+		completionSignal
+	});
+	signals.push(startSignal);
+	onSignal?.(startSignal);
+	while (iteration < maxIterations) {
+		iteration++;
+		const iterationStart = Date.now();
+		if (governance.maxTotalTokens && totalInputTokens + totalOutputTokens >= governance.maxTotalTokens) {
+			const budgetSignal = createSignal("loop.budget_exceeded", `Total token budget exhausted after ${iteration - 1} iterations`, runId, "medium", {
+				totalInputTokens,
+				totalOutputTokens
+			});
+			signals.push(budgetSignal);
+			onSignal?.(budgetSignal);
+			return {
+				success: false,
+				iterations: iteration - 1,
+				iterationHistory,
+				error: `Token budget exceeded (${totalInputTokens + totalOutputTokens} / ${governance.maxTotalTokens})`,
+				totalTokens: {
+					input: totalInputTokens,
+					output: totalOutputTokens
+				},
+				totalDurationMs: Date.now() - startTime,
+				signals
+			};
+		}
+		const prompt = feedbackErrors && lastError ? `${context}\n\n[Previous attempt failed with error: ${lastError}]\n\nPlease try again and address the error.` : context;
+		try {
+			const result = await generateText({
+				model,
+				prompt,
+				system: systemPrompt,
+				tools: allowedTools,
+				maxOutputTokens: governance.maxTokensPerIteration,
+				abortSignal: governance.iterationTimeoutMs ? AbortSignal.timeout(governance.iterationTimeoutMs) : void 0
+			});
+			const iterationDuration = Date.now() - iterationStart;
+			const inputTokens = result.usage?.inputTokens ?? 0;
+			const outputTokens = result.usage?.outputTokens ?? 0;
+			totalInputTokens += inputTokens;
+			totalOutputTokens += outputTokens;
+			const toolCalls = result.toolCalls?.map((tc) => ({
+				name: tc.toolName,
+				args: tc.input ?? tc.args
+			}));
+			if (toolCalls) {
+				const approvalRequired = toolCalls.filter((tc) => governance.requireApproval.includes(tc.name));
+				if (approvalRequired.length > 0) {
+					const approvalSignal = createSignal("loop.approval_required", `Audit: Tools executed that require approval: ${approvalRequired.map((t) => t.name).join(", ")}`, runId, "medium", {
+						tools: approvalRequired,
+						note: "Post-execution audit signal"
+					});
+					signals.push(approvalSignal);
+					onSignal?.(approvalSignal);
+				}
+			}
+			const iterationResult = {
+				index: iteration,
+				status: "running",
+				output: result.text,
+				tokenUsage: {
+					input: inputTokens,
+					output: outputTokens
+				},
+				durationMs: iterationDuration,
+				toolCalls
+			};
+			if (detectCompletion(result.text, completionSignal)) {
+				iterationResult.status = "success";
+				iterationHistory.push(iterationResult);
+				onIteration?.(iterationResult);
+				const successSignal = createSignal("loop.completed", `Governance Agent completed successfully after ${iteration} iterations`, runId, "low", {
+					iterations: iteration,
+					totalTokens: totalInputTokens + totalOutputTokens
+				});
+				signals.push(successSignal);
+				onSignal?.(successSignal);
+				return {
+					success: true,
+					iterations: iteration,
+					iterationHistory,
+					finalOutput: result.text,
+					totalTokens: {
+						input: totalInputTokens,
+						output: totalOutputTokens
+					},
+					totalDurationMs: Date.now() - startTime,
+					signals
+				};
+			}
+			iterationHistory.push(iterationResult);
+			onIteration?.(iterationResult);
+			lastError = void 0;
+			if (iterationDelay > 0 && iteration < maxIterations) await sleep(iterationDelay);
+		} catch (error) {
+			const iterationDuration = Date.now() - iterationStart;
+			lastError = error instanceof Error ? error.message : String(error);
+			const isTimeout = error instanceof Error && error.name === "TimeoutError";
+			const iterationResult = {
+				index: iteration,
+				status: isTimeout ? "timeout" : "error",
+				error: lastError,
+				tokenUsage: {
+					input: 0,
+					output: 0
+				},
+				durationMs: iterationDuration
+			};
+			iterationHistory.push(iterationResult);
+			onIteration?.(iterationResult);
+			const errorSignal = createSignal(isTimeout ? "loop.timeout" : "loop.error", `Iteration ${iteration} ${isTimeout ? "timed out" : "failed"}: ${lastError}`, runId, "medium", {
+				iteration,
+				error: lastError
+			});
+			signals.push(errorSignal);
+			onSignal?.(errorSignal);
+			if (!feedbackErrors) return {
+				success: false,
+				iterations: iteration,
+				iterationHistory,
+				error: `Iteration ${iteration} failed: ${lastError}`,
+				totalTokens: {
+					input: totalInputTokens,
+					output: totalOutputTokens
+				},
+				totalDurationMs: Date.now() - startTime,
+				signals
+			};
+		}
+	}
+	const exhaustedSignal = createSignal("loop.exhausted", `Max iterations (${maxIterations}) reached without completion signal`, runId, "high", {
+		iterations: maxIterations,
+		completionSignal
+	});
+	signals.push(exhaustedSignal);
+	onSignal?.(exhaustedSignal);
+	return {
+		success: false,
+		iterations: iteration,
+		iterationHistory,
+		error: `Max iterations (${maxIterations}) reached without completion signal "${completionSignal}"`,
+		totalTokens: {
+			input: totalInputTokens,
+			output: totalOutputTokens
+		},
+		totalDurationMs: Date.now() - startTime,
+		signals
+	};
+}
+/**
+* Governance Agent class.
+* Wraps the autonomous retry loop in an interface compatible with StandardAgent.
+*/
+var GovernanceAgent = class GovernanceAgent {
+	options;
+	constructor(options) {
+		this.options = options;
+	}
+	/**
+	* Generates a response using the governance retry loop.
+	* Maps the result to a format compatible with StandardAgent results where possible,
+	* or returns the specific GovernanceResult.
+	*/
+	async generate() {
+		return executeGovernanceLoop(this.options);
+	}
+	/**
+	* Creates a new instance with merged options.
+	*/
+	static create(options) {
+		return new GovernanceAgent(options);
+	}
+};
+/**
+* Factory for creating a Governance Agent with defaults.
+*/
+function createGovernanceAgent(options) {
+	return new GovernanceAgent(options);
+}
+/**
+* Default governance rules.
+*/
+const DEFAULT_GOVERNANCE_RULES = {
+	maxTokensPerIteration: 4096,
+	blockedTools: [
+		"deleteFile",
+		"formatDisk",
+		"dropTable",
+		"truncateTable",
+		"deleteDatabase"
+	],
+	requireApproval: [
+		"executeShell",
+		"runCommand",
+		"modifyPermissions",
+		"deployProduction"
+	],
+	maxTotalTokens: 1e5,
+	iterationTimeoutMs: 6e4
+};
+const ralphLoop = executeGovernanceLoop;
+const DEFAULT_RALPH_GOVERNANCE = DEFAULT_GOVERNANCE_RULES;
+
+//#endregion
+//#region src/agents/orchestrator.ts
+/**
+* @fileoverview Platform Orchestrator
+*
+* Provides risk-aware agent orchestration with intelligent caching and dynamic
+* agent selection based on message risk analysis. Supports MCP toolset integration
+* and compliance signal emission.
+*
+* @module @od-oneapp/ai-platform/agents/orchestrator
+*/
+/**
+* Risk-aware agent orchestrator with intelligent caching and dynamic agent selection.
+* Automatically selects the appropriate agent based on message risk analysis and
+* caches agents per risk level for performance optimization.
+*/
+var PlatformOrchestrator = class {
+	/** Orchestrator version identifier. */
+	version = "agent-v1";
+	/** Orchestrator ID. */
+	id = "platform-orchestrator";
+	/** Orchestrator configuration options. */
+	options;
+	/** Cached agents per risk level. */
+	agents = {};
+	/**
+	* Constructs a new PlatformOrchestrator instance.
+	* @param options - Orchestrator configuration options.
+	*/
+	constructor(options) {
+		this.options = options;
+	}
+	/**
+	* Gets the tools available to the orchestrator.
+	* Returns empty object as tools are managed per agent instance.
+	*/
+	get tools() {
+		return {};
+	}
+	/**
+	* Gets tools from a medium-risk agent (default).
+	*/
+	async getTools() {
+		return (await this.ensureAgent("medium")).tools;
+	}
+	/**
+	* Generates a response using the appropriate agent based on message risk.
+	*/
+	async generate(options) {
+		return (await this.agentForMessages(options.messages ?? [])).generate(options);
+	}
+	/**
+	* Streams a response using the appropriate agent based on message risk.
+	*/
+	async stream(options) {
+		return (await this.agentForMessages(options.messages ?? [])).stream(options);
+	}
+	/**
+	* Creates a UI stream response for the given messages.
+	* Uses the StandardAgent (Experimental_Agent) interface.
+	*/
+	async respond({ messages }) {
+		return createAgentUIStreamResponse({
+			agent: (await this.agentForMessages(messages)).getToolLoopAgent(),
+			uiMessages: messages
+		});
+	}
+	extractTextContent(content) {
+		if (typeof content === "string") return content;
+		if (Array.isArray(content)) return content.filter((part) => typeof part === "object" && part !== null && "type" in part && part.type === "text" && "text" in part).map((part) => part.text).join(" ");
+		return "";
+	}
+	async agentForMessages(messages) {
+		const risk = detectRiskFromMessages(messages.map((message) => {
+			if (!message || typeof message !== "object") return null;
+			const record = message;
+			if (typeof record.role !== "string") return null;
+			const source = typeof record.content !== "undefined" ? record.content : record.parts;
+			return {
+				role: record.role,
+				content: this.extractTextContent(source)
+			};
+		}).filter((value) => value !== null));
+		return this.ensureAgent(risk);
+	}
+	async ensureAgent(riskLevel) {
+		const cachedAgent = this.agents[riskLevel];
+		if (cachedAgent) return cachedAgent;
+		if (!this.agents[riskLevel]) {
+			const model = this.options.modelFactory();
+			let cleanup;
+			let dynamicTools;
+			if (this.options.mcp) {
+				const connection = await connectMcpToolset(this.options.mcp);
+				dynamicTools = connection.tools;
+				cleanup = async () => {
+					await connection.close();
+					delete this.agents[riskLevel];
+				};
+			}
+			const agent = createDefaultAgent({
+				model,
+				riskLevel,
+				runId: randomUUID(),
+				onSignal: this.options.onSignal,
+				onStructuredOutput: this.options.onStructuredOutput,
+				tools: dynamicTools,
+				onCleanup: cleanup
+			});
+			this.agents[riskLevel] = agent;
+		}
+		return this.agents[riskLevel];
+	}
+};
+
+//#endregion
+//#region src/agents/evaluator-optimizer/index.ts
+/**
+* @fileoverview Evaluator-Optimizer Feedback Loop.
+* @module @od-oneapp/ai-platform/agents/evaluator-optimizer
+*
+* Main orchestration module implementing the 5-step workflow.
+* Based on VERCEL_AI_SDK_V6_PATTERNS.md section 4.2
+*
+* WORKFLOW:
+* 1. Generate initial content based on user request
+* 2. Evaluate quality against criteria
+* 3. If quality < threshold, optimize the content
+* 4. Re-evaluate optimized content
+* 5. Repeat steps 3-4 until threshold met or max iterations reached
+*/
+var evaluator_optimizer_exports = /* @__PURE__ */ __exportAll({
+	EvaluationResultSchema: () => EvaluationResultSchema,
+	EvaluatorOptimizer: () => EvaluatorOptimizer,
+	FeedbackLoopConfigSchema: () => FeedbackLoopConfigSchema,
+	createEvaluatorOptimizer: () => createEvaluatorOptimizer,
+	runFeedbackLoop: () => runFeedbackLoop
+});
+/** Default maximum iterations for feedback loop. */
+const DEFAULT_MAX_ITERATIONS = 5;
+/** Default target quality score. */
+const DEFAULT_TARGET_SCORE = 8;
+/** Default diminishing return threshold. */
+const DEFAULT_DIMINISHING_RETURN_THRESHOLD = 2;
+/** Minimum allowed iterations. */
+const MIN_ITERATIONS = 1;
+/** Maximum allowed iterations. */
+const MAX_ITERATIONS = 10;
+/** Minimum target score. */
+const MIN_TARGET_SCORE = 1;
+/** Maximum target score. */
+const MAX_TARGET_SCORE = 10;
+/**
+* Validates OptimizerConfig bounds at runtime
+* @throws Error if config values are out of valid ranges
+*/
+function validateOptimizerConfig(config) {
+	if (config.maxIterations < MIN_ITERATIONS || config.maxIterations > MAX_ITERATIONS) throw new Error(`maxIterations must be between ${MIN_ITERATIONS} and ${MAX_ITERATIONS}, got ${config.maxIterations}`);
+	if (config.targetScore < MIN_TARGET_SCORE || config.targetScore > MAX_TARGET_SCORE) throw new Error(`targetScore must be between ${MIN_TARGET_SCORE} and ${MAX_TARGET_SCORE}, got ${config.targetScore}`);
+}
+/**
+* Main EvaluatorOptimizer class
+* Orchestrates the iterative evaluation-optimization feedback loop
+*/
+var EvaluatorOptimizer = class {
+	config;
+	logger;
+	constructor(config) {
+		validateOptimizerConfig(config);
+		this.config = config;
+		this.logger = config.enableLogging ? logInfo : () => {};
+	}
+	/**
+	* Get the evaluator instance.
+	* @returns The configured evaluator.
+	*/
+	getEvaluator() {
+		return this.config.evaluator;
+	}
+	/**
+	* Get the optimizer instance.
+	* @returns The configured optimizer.
+	*/
+	getOptimizer() {
+		return this.config.optimizer;
+	}
+	/**
+	* Execute 5-step feedback loop workflow
+	*
+	* STEP 1: Generate initial content (provided as input)
+	* STEP 2: Evaluate initial content
+	* STEP 3: If score < threshold, optimize
+	* STEP 4: Re-evaluate optimized content
+	* STEP 5: Repeat until threshold or max iterations
+	*
+	* @param initialContent - Initial content to optimize
+	* @param originalRequest - Original user request context
+	* @param config - Optional loop configuration overrides
+	* @returns Optimized result with full history and metadata
+	*
+	* @example
+	* ```typescript
+	* const optimizer = new EvaluatorOptimizer({
+	*   maxIterations: 5,
+	*   targetScore: 8,
+	*   evaluator: createLLMEvaluator(),
+	*   optimizer: createPromptOptimizer(),
+	*   enableLogging: true
+	* });
+	*
+	* const result = await optimizer.runFeedbackLoop(
+	*   "Generated content",
+	*   "Original user request"
+	* );
+	*
+	* console.log(`Final score: ${result.finalEvaluation.qualityScore}/10`);
+	* console.log(`Cycles: ${result.cyclesCompleted}`);
+	* ```
+	*/
+	async runFeedbackLoop(initialContent, originalRequest, loopConfig) {
+		const startTime = (/* @__PURE__ */ new Date()).toISOString();
+		const config = {
+			maxIterations: this.config.maxIterations,
+			targetScore: this.config.targetScore,
+			enableLogging: this.config.enableLogging ?? false,
+			stopOnThreshold: this.config.stopOnThreshold ?? true,
+			diminishingReturnThreshold: this.config.diminishingReturnThreshold ?? 2,
+			...loopConfig
+		};
+		const scoreHistory = [];
+		const contentHistory = [initialContent];
+		let currentContent = initialContent;
+		let currentEvaluation = null;
+		let cyclesCompleted = 0;
+		let consecutiveNonImprovingCycles = 0;
+		this.logger(`\n${"=".repeat(60)}`);
+		this.logger("Evaluator-Optimizer Feedback Loop Started");
+		this.logger(`Target Score: ${config.targetScore}/10`);
+		this.logger(`Max Iterations: ${config.maxIterations}`);
+		this.logger(`${"=".repeat(60)}\n`);
+		try {
+			this.logger(`STEP 2: Initial Evaluation`);
+			currentEvaluation = await this.evaluateContent(currentContent, originalRequest, 1);
+			scoreHistory.push(currentEvaluation.qualityScore);
+			this.logger(`Quality Score: ${currentEvaluation.qualityScore}/10`);
+			this.logger(`Meets Threshold: ${currentEvaluation.meetsThreshold}\n`);
+			while (cyclesCompleted < config.maxIterations && !currentEvaluation.meetsThreshold) {
+				cyclesCompleted += 1;
+				this.logger(`${"─".repeat(60)}`);
+				this.logger(`STEP 3: Optimization (Cycle ${cyclesCompleted})`);
+				if (cyclesCompleted > 1 && scoreHistory.length >= 2) {
+					const previousScore = scoreHistory[scoreHistory.length - 2];
+					if (currentEvaluation.qualityScore === previousScore) {
+						consecutiveNonImprovingCycles += 1;
+						this.logger(`⚠ No improvement (${consecutiveNonImprovingCycles} consecutive)`);
+						if (consecutiveNonImprovingCycles >= config.diminishingReturnThreshold) {
+							this.logger(`Diminishing returns detected. Stopping optimization.`);
+							return this.buildResult(currentContent, currentEvaluation, cyclesCompleted, scoreHistory, contentHistory, "diminishing_returns", startTime, void 0);
+						}
+					} else consecutiveNonImprovingCycles = 0;
+				}
+				const optimizedContent = await this.optimizeContent(currentContent, currentEvaluation, originalRequest, cyclesCompleted);
+				currentContent = optimizedContent;
+				contentHistory.push(optimizedContent);
+				this.logger(`Content optimized`);
+				this.logger(`STEP 4: Re-evaluation`);
+				currentEvaluation = await this.evaluateContent(currentContent, originalRequest, cyclesCompleted + 1);
+				scoreHistory.push(currentEvaluation.qualityScore);
+				this.logger(`Quality Score: ${currentEvaluation.qualityScore}/10`);
+				this.logger(`Meets Threshold: ${currentEvaluation.meetsThreshold}`);
+				this.logger(`Issues: ${currentEvaluation.specificIssues.length}\n`);
+				if (currentEvaluation.meetsThreshold && config.stopOnThreshold) {
+					this.logger(`✓ Threshold reached! Quality: ${currentEvaluation.qualityScore}/10`);
+					return this.buildResult(currentContent, currentEvaluation, cyclesCompleted, scoreHistory, contentHistory, "threshold_met", startTime, void 0);
+				}
+			}
+			if (currentEvaluation.meetsThreshold) {
+				this.logger(`✓ Threshold reached after ${cyclesCompleted} cycles`);
+				return this.buildResult(currentContent, currentEvaluation, cyclesCompleted, scoreHistory, contentHistory, "threshold_met", startTime, void 0);
+			} else {
+				this.logger(`⚠ Max iterations (${config.maxIterations}) reached without meeting threshold`);
+				return this.buildResult(currentContent, currentEvaluation, cyclesCompleted, scoreHistory, contentHistory, "max_iterations", startTime, void 0);
+			}
+		} catch (error) {
+			const errorMessage = error instanceof Error ? error.message : String(error);
+			this.logger(`✗ Error in feedback loop: ${errorMessage}`);
+			const errorEvaluation = currentEvaluation || {
+				qualityScore: 0,
+				preservesTone: false,
+				preservesNuance: false,
+				culturallyAccurate: false,
+				technicallyCorrect: false,
+				specificIssues: [`Error during evaluation: ${errorMessage}`],
+				improvementSuggestions: [],
+				strengths: [],
+				overallAssessment: `Evaluation failed: ${errorMessage}`,
+				meetsThreshold: false
+			};
+			return this.buildResult(currentContent, errorEvaluation, cyclesCompleted, scoreHistory, contentHistory, "error", startTime, errorMessage);
+		}
+	}
+	/**
+	* Evaluate content
+	*/
+	async evaluateContent(content, originalRequest, iterationNumber) {
+		const evaluatorInput = {
+			content,
+			originalRequest,
+			criteria: { threshold: this.config.targetScore },
+			iterationNumber
+		};
+		return this.config.evaluator.evaluate(evaluatorInput);
+	}
+	/**
+	* Optimize content
+	*/
+	async optimizeContent(content, evaluationFeedback, originalRequest, iterationNumber) {
+		return this.config.optimizer.optimize({
+			content,
+			evaluationFeedback,
+			originalRequest,
+			iterationNumber
+		});
+	}
+	/**
+	* Build final result object
+	*/
+	buildResult(finalContent, finalEvaluation, cyclesCompleted, scoreHistory, contentHistory, terminationReason, startTime, error) {
+		const endTime = (/* @__PURE__ */ new Date()).toISOString();
+		const startMs = new Date(startTime).getTime();
+		const endMs = new Date(endTime).getTime();
+		const firstScore = scoreHistory[0] ?? 0;
+		const lastScore = scoreHistory[scoreHistory.length - 1] ?? firstScore;
+		const averageScoreImprovement = scoreHistory.length > 1 ? (lastScore - firstScore) / (scoreHistory.length - 1) : 0;
+		this.logger(`\n${"=".repeat(60)}`);
+		this.logger("Feedback Loop Complete");
+		this.logger(`Cycles: ${cyclesCompleted}`);
+		this.logger(`Final Score: ${finalEvaluation.qualityScore}/10`);
+		this.logger(`Average Improvement: ${averageScoreImprovement.toFixed(2)}/cycle`);
+		this.logger(`Time: ${endMs - startMs}ms`);
+		this.logger(`Reason: ${terminationReason}`);
+		this.logger(`${"=".repeat(60)}\n`);
+		return {
+			finalContent,
+			finalEvaluation,
+			cyclesCompleted,
+			meetsThreshold: finalEvaluation.meetsThreshold,
+			scoreHistory,
+			contentHistory,
+			terminationReason,
+			error,
+			metadata: {
+				startTime,
+				endTime,
+				processingTimeMs: endMs - startMs,
+				averageScoreImprovement
+			}
+		};
+	}
+};
+/**
+* Factory function to create evaluator-optimizer
+*
+* @param config - Configuration object
+* @returns EvaluatorOptimizer instance
+*
+* @example
+* ```typescript
+* const loop = createEvaluatorOptimizer({
+*   maxIterations: 5,
+*   targetScore: 8,
+*   evaluator: createLLMEvaluator(),
+*   optimizer: createPromptOptimizer(),
+*   enableLogging: true
+* });
+* ```
+*/
+function createEvaluatorOptimizer(config) {
+	return new EvaluatorOptimizer(config);
+}
+/**
+* Helper function to run feedback loop with sensible defaults
+*
+* @param initialContent - Content to optimize
+* @param originalRequest - Original request context
+* @param config - Optional configuration
+* @returns Optimized result
+*
+* @example
+* ```typescript
+* const result = await runFeedbackLoop(
+*   "Generated content",
+*   "User request",
+*   {
+*     maxIterations: 5,
+*     targetScore: 8,
+*     enableLogging: true
+*   }
+* );
+* ```
+*/
+async function runFeedbackLoop(initialContent, originalRequest, config) {
+	let createLLMEvaluator;
+	let createPromptOptimizer;
+	try {
+		const { createLLMEvaluator: importedEvaluator } = await import("./evaluator-Cs84qkr8.mjs");
+		createLLMEvaluator = importedEvaluator;
+	} catch (error) {
+		throw new Error(`Failed to import evaluator module: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	try {
+		const { createPromptOptimizer: importedOptimizer } = await import("./optimizer-DhXXpci6.mjs");
+		createPromptOptimizer = importedOptimizer;
+	} catch (error) {
+		throw new Error(`Failed to import optimizer module: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	return createEvaluatorOptimizer({
+		maxIterations: config?.maxIterations ?? DEFAULT_MAX_ITERATIONS,
+		targetScore: config?.targetScore ?? DEFAULT_TARGET_SCORE,
+		evaluator: config?.evaluator ?? createLLMEvaluator(),
+		optimizer: config?.optimizer ?? createPromptOptimizer(),
+		enableLogging: config?.enableLogging ?? false,
+		stopOnThreshold: config?.stopOnThreshold ?? true,
+		diminishingReturnThreshold: config?.diminishingReturnThreshold ?? DEFAULT_DIMINISHING_RETURN_THRESHOLD
+	}).runFeedbackLoop(initialContent, originalRequest);
+}
+
+//#endregion
+export { GovernanceAgent as a, StandardAgent as c, DEFAULT_RALPH_GOVERNANCE as i, createDefaultAgent as l, PlatformOrchestrator as n, createGovernanceAgent as o, DEFAULT_GOVERNANCE_RULES as r, ralphLoop as s, evaluator_optimizer_exports as t, createDefaultAgentConfig as u };
+//# sourceMappingURL=evaluator-optimizer-De67_mJC.mjs.map