@od-oneapp/ai-platform 0.1.0

package/dist/hitl-feedback.mjs

@@ -0,0 +1,137 @@
+//#region src/hitl/feedback/index.ts
+/**
+* Simple in-memory feedback store for development/testing.
+*/
+var InMemoryFeedbackStore = class {
+	feedbacks = /* @__PURE__ */ new Map();
+	async save(feedback) {
+		this.feedbacks.set(feedback.id, feedback);
+	}
+	async get(id) {
+		return this.feedbacks.get(id) ?? null;
+	}
+	async query(query) {
+		let results = Array.from(this.feedbacks.values());
+		const { minRating, maxRating, startDate, endDate, tags } = query;
+		if (query.responseId) results = results.filter((f) => f.responseId === query.responseId);
+		if (query.userId) results = results.filter((f) => f.userId === query.userId);
+		if (minRating !== void 0) results = results.filter((f) => f.rating >= minRating);
+		if (maxRating !== void 0) results = results.filter((f) => f.rating <= maxRating);
+		if (startDate) results = results.filter((f) => f.timestamp >= startDate);
+		if (endDate) results = results.filter((f) => f.timestamp <= endDate);
+		if (tags?.length) results = results.filter((f) => tags.some((tag) => f.tags?.includes(tag)));
+		results.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+		const offset = query.offset ?? 0;
+		const limit = query.limit ?? 100;
+		return results.slice(offset, offset + limit);
+	}
+	async delete(id) {
+		this.feedbacks.delete(id);
+	}
+	/** Clear all feedback (for testing) */
+	clear() {
+		this.feedbacks.clear();
+	}
+};
+/**
+* Creates a feedback collector for gathering user feedback on AI responses.
+*
+* @example
+* ```typescript
+* const collector = createFeedbackCollector({
+*   onFeedback: (feedback) => {
+*     console.log(`New feedback: ${feedback.rating}/5`);
+*   }
+* });
+*
+* await collector.collect({
+*   responseId: 'resp-123',
+*   rating: 4,
+*   comment: 'Good but could be more concise'
+* });
+* ```
+*/
+function createFeedbackCollector(config = {}) {
+	const { store = new InMemoryFeedbackStore(), validateRating = (r) => r >= 1 && r <= 5, onFeedback } = config;
+	async function collect(input) {
+		if (!validateRating(input.rating)) throw new Error(`Invalid rating: ${input.rating}. Must be between 1 and 5.`);
+		const feedback = {
+			...input,
+			id: generateId(),
+			timestamp: /* @__PURE__ */ new Date()
+		};
+		await store.save(feedback);
+		onFeedback?.(feedback);
+		return feedback;
+	}
+	async function getByResponse(responseId) {
+		return store.query({ responseId });
+	}
+	async function getByUser(userId) {
+		return store.query({ userId });
+	}
+	async function query(q) {
+		return store.query(q);
+	}
+	async function aggregate(q) {
+		const feedbacks = await store.query(q ?? {});
+		if (feedbacks.length === 0) return {
+			avgRating: 0,
+			count: 0,
+			distribution: {
+				1: 0,
+				2: 0,
+				3: 0,
+				4: 0,
+				5: 0
+			},
+			recentTrend: "stable"
+		};
+		const distribution = {
+			1: 0,
+			2: 0,
+			3: 0,
+			4: 0,
+			5: 0
+		};
+		let sum = 0;
+		for (const f of feedbacks) {
+			sum += f.rating;
+			distribution[f.rating] = (distribution[f.rating] ?? 0) + 1;
+		}
+		const avgRating = sum / feedbacks.length;
+		const trend = calculateTrend(feedbacks);
+		return {
+			avgRating: Math.round(avgRating * 100) / 100,
+			count: feedbacks.length,
+			distribution,
+			recentTrend: trend
+		};
+	}
+	return {
+		collect,
+		getByResponse,
+		getByUser,
+		query,
+		aggregate
+	};
+}
+function generateId() {
+	return `fb-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function calculateTrend(feedbacks) {
+	if (feedbacks.length < 10) return "stable";
+	const sorted = [...feedbacks].sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+	const mid = Math.floor(sorted.length / 2);
+	const firstHalf = sorted.slice(0, mid);
+	const secondHalf = sorted.slice(mid);
+	const firstAvg = firstHalf.reduce((s, f) => s + f.rating, 0) / firstHalf.length;
+	const diff = secondHalf.reduce((s, f) => s + f.rating, 0) / secondHalf.length - firstAvg;
+	if (diff > .3) return "improving";
+	if (diff < -.3) return "declining";
+	return "stable";
+}
+
+//#endregion
+export { InMemoryFeedbackStore, createFeedbackCollector };
+//# sourceMappingURL=hitl-feedback.mjs.map

package/dist/hitl-feedback.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"hitl-feedback.mjs","names":[],"sources":["../src/hitl/feedback/index.ts"],"sourcesContent":["/**\n * User Feedback Collection\n *\n * Collects and aggregates user feedback on AI responses\n * for quality monitoring and model improvement.\n *\n * @module @od-oneapp/ai-platform/hitl/feedback\n *\n * @example\n * ```typescript\n * import { createFeedbackCollector } from '@od-oneapp/ai-platform/hitl/feedback';\n *\n * const collector = createFeedbackCollector();\n *\n * // Collect feedback\n * await collector.collect({\n *   responseId: 'resp-123',\n *   rating: 5,\n *   comment: 'Very helpful response!'\n * });\n *\n * // Get aggregated stats\n * const stats = await collector.aggregate();\n * console.log(`Average rating: ${stats.avgRating}`);\n * ```\n */\n\n// -----------------------------------------------------------------------------\n// Types\n// -----------------------------------------------------------------------------\n\n/** User feedback on an AI response */\nexport interface Feedback {\n  readonly id: string;\n  readonly responseId: string;\n  readonly userId?: string;\n  readonly rating: number; // 1-5\n  readonly comment?: string;\n  readonly tags?: string[];\n  readonly metadata?: Record<string, unknown>;\n  readonly timestamp: Date;\n}\n\n/** Feedback input without auto-generated fields */\nexport type FeedbackInput = Omit<Feedback, 'id' | 'timestamp'>;\n\n/** Aggregated feedback statistics */\nexport interface FeedbackStats {\n  readonly avgRating: number;\n  readonly count: number;\n  readonly distribution: Record<number, number>;\n  readonly recentTrend: 'improving' | 'declining' | 'stable';\n}\n\n/** Feedback query options */\nexport interface FeedbackQuery {\n  readonly responseId?: string;\n  readonly userId?: string;\n  readonly minRating?: number;\n  readonly maxRating?: number;\n  readonly startDate?: Date;\n  readonly endDate?: Date;\n  readonly tags?: string[];\n  readonly limit?: number;\n  readonly offset?: number;\n}\n\n/** Feedback storage interface */\nexport interface FeedbackStore {\n  save(feedback: Feedback): Promise<void>;\n  get(id: string): Promise<Feedback | null>;\n  query(query: FeedbackQuery): Promise<Feedback[]>;\n  delete(id: string): Promise<void>;\n}\n\n/** Feedback collector interface */\nexport interface FeedbackCollector {\n  collect(input: FeedbackInput): Promise<Feedback>;\n  getByResponse(responseId: string): Promise<Feedback[]>;\n  getByUser(userId: string): Promise<Feedback[]>;\n  query(query: FeedbackQuery): Promise<Feedback[]>;\n  aggregate(query?: FeedbackQuery): Promise<FeedbackStats>;\n}\n\n// -----------------------------------------------------------------------------\n// In-Memory Store\n// -----------------------------------------------------------------------------\n\n/**\n * Simple in-memory feedback store for development/testing.\n */\nexport class InMemoryFeedbackStore implements FeedbackStore {\n  private readonly feedbacks = new Map<string, Feedback>();\n\n  async save(feedback: Feedback): Promise<void> {\n    this.feedbacks.set(feedback.id, feedback);\n  }\n\n  async get(id: string): Promise<Feedback | null> {\n    return this.feedbacks.get(id) ?? null;\n  }\n\n  async query(query: FeedbackQuery): Promise<Feedback[]> {\n    let results = Array.from(this.feedbacks.values());\n    const { minRating, maxRating, startDate, endDate, tags } = query;\n\n    if (query.responseId) {\n      results = results.filter(f => f.responseId === query.responseId);\n    }\n    if (query.userId) {\n      results = results.filter(f => f.userId === query.userId);\n    }\n    if (minRating !== undefined) {\n      results = results.filter(f => f.rating >= minRating);\n    }\n    if (maxRating !== undefined) {\n      results = results.filter(f => f.rating <= maxRating);\n    }\n    if (startDate) {\n      results = results.filter(f => f.timestamp >= startDate);\n    }\n    if (endDate) {\n      results = results.filter(f => f.timestamp <= endDate);\n    }\n    if (tags?.length) {\n      results = results.filter(f => tags.some(tag => f.tags?.includes(tag)));\n    }\n\n    // Sort by timestamp descending\n    results.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());\n\n    // Apply pagination\n    const offset = query.offset ?? 0;\n    const limit = query.limit ?? 100;\n    return results.slice(offset, offset + limit);\n  }\n\n  async delete(id: string): Promise<void> {\n    this.feedbacks.delete(id);\n  }\n\n  /** Clear all feedback (for testing) */\n  clear(): void {\n    this.feedbacks.clear();\n  }\n}\n\n// -----------------------------------------------------------------------------\n// Feedback Collector Implementation\n// -----------------------------------------------------------------------------\n\n/** Configuration for feedback collector */\nexport interface FeedbackCollectorConfig {\n  readonly store?: FeedbackStore;\n  readonly validateRating?: (rating: number) => boolean;\n  readonly onFeedback?: (feedback: Feedback) => void;\n}\n\n/**\n * Creates a feedback collector for gathering user feedback on AI responses.\n *\n * @example\n * ```typescript\n * const collector = createFeedbackCollector({\n *   onFeedback: (feedback) => {\n *     console.log(`New feedback: ${feedback.rating}/5`);\n *   }\n * });\n *\n * await collector.collect({\n *   responseId: 'resp-123',\n *   rating: 4,\n *   comment: 'Good but could be more concise'\n * });\n * ```\n */\nexport function createFeedbackCollector(config: FeedbackCollectorConfig = {}): FeedbackCollector {\n  const {\n    store = new InMemoryFeedbackStore(),\n    validateRating = r => r >= 1 && r <= 5,\n    onFeedback,\n  } = config;\n\n  async function collect(input: FeedbackInput): Promise<Feedback> {\n    // Validate rating\n    if (!validateRating(input.rating)) {\n      throw new Error(`Invalid rating: ${input.rating}. Must be between 1 and 5.`);\n    }\n\n    const feedback: Feedback = {\n      ...input,\n      id: generateId(),\n      timestamp: new Date(),\n    };\n\n    await store.save(feedback);\n    onFeedback?.(feedback);\n\n    return feedback;\n  }\n\n  async function getByResponse(responseId: string): Promise<Feedback[]> {\n    return store.query({ responseId });\n  }\n\n  async function getByUser(userId: string): Promise<Feedback[]> {\n    return store.query({ userId });\n  }\n\n  async function query(q: FeedbackQuery): Promise<Feedback[]> {\n    return store.query(q);\n  }\n\n  async function aggregate(q?: FeedbackQuery): Promise<FeedbackStats> {\n    const feedbacks = await store.query(q ?? {});\n\n    if (feedbacks.length === 0) {\n      return {\n        avgRating: 0,\n        count: 0,\n        distribution: { 1: 0, 2: 0, 3: 0, 4: 0, 5: 0 },\n        recentTrend: 'stable',\n      };\n    }\n\n    // Calculate distribution\n    const distribution: Record<number, number> = { 1: 0, 2: 0, 3: 0, 4: 0, 5: 0 };\n    let sum = 0;\n\n    for (const f of feedbacks) {\n      sum += f.rating;\n      distribution[f.rating] = (distribution[f.rating] ?? 0) + 1;\n    }\n\n    const avgRating = sum / feedbacks.length;\n\n    // Calculate trend from recent vs older feedback\n    const trend = calculateTrend(feedbacks);\n\n    return {\n      avgRating: Math.round(avgRating * 100) / 100,\n      count: feedbacks.length,\n      distribution,\n      recentTrend: trend,\n    };\n  }\n\n  return {\n    collect,\n    getByResponse,\n    getByUser,\n    query,\n    aggregate,\n  };\n}\n\n// -----------------------------------------------------------------------------\n// Utilities\n// -----------------------------------------------------------------------------\n\nfunction generateId(): string {\n  return `fb-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;\n}\n\nfunction calculateTrend(feedbacks: Feedback[]): 'improving' | 'declining' | 'stable' {\n  if (feedbacks.length < 10) return 'stable';\n\n  // Sort by timestamp\n  const sorted = [...feedbacks].sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());\n\n  // Compare first half avg vs second half avg\n  const mid = Math.floor(sorted.length / 2);\n  const firstHalf = sorted.slice(0, mid);\n  const secondHalf = sorted.slice(mid);\n\n  const firstAvg = firstHalf.reduce((s, f) => s + f.rating, 0) / firstHalf.length;\n  const secondAvg = secondHalf.reduce((s, f) => s + f.rating, 0) / secondHalf.length;\n\n  const diff = secondAvg - firstAvg;\n\n  if (diff > 0.3) return 'improving';\n  if (diff < -0.3) return 'declining';\n  return 'stable';\n}\n"],"mappings":"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"}

package/dist/hitl-review.d.mts

@@ -0,0 +1,2 @@
+import { n as ReviewContext, r as evaluateReviewTriggers, t as ReviewConditions } from "./review-trigger-DmAsiQlM.mjs";
+export { ReviewConditions, type ReviewContext, evaluateReviewTriggers };

package/dist/hitl-review.mjs

@@ -0,0 +1,3 @@
+import { n as evaluateReviewTriggers, t as ReviewConditions } from "./review-trigger-DwXfpww9.mjs";
+
+export { ReviewConditions, evaluateReviewTriggers };

package/dist/hitl.d.mts

@@ -0,0 +1,14 @@
+import { ActiveLearner, ActiveLearnerConfig, Sample, SelectionResult, SelectionStrategy, createActiveLearner, createSample, createSamples } from "./hitl-active-learning.mjs";
+import { Annotation, AnnotationInput, AnnotationStats, AnnotationStore, AnnotationTask, AnnotatorStats, TaskQuery, TaskStatus, TaskType, createAnnotationStore } from "./hitl-annotation.mjs";
+import { a as EscalationConfig, c as ReviewSession, i as ApprovalStatus, n as ApprovalRequest, o as HITLConfig, r as ApprovalResponse, s as ReviewCondition, t as ApprovalQueue } from "./types-CQ0HFd0u.mjs";
+import { t as InMemoryApprovalQueue } from "./approval-queue-CiKiFT9z.mjs";
+import { Feedback, FeedbackCollector, FeedbackCollectorConfig, FeedbackInput, FeedbackQuery, FeedbackStats, FeedbackStore, createFeedbackCollector } from "./hitl-feedback.mjs";
+import { n as ReviewContext, r as evaluateReviewTriggers, t as ReviewConditions } from "./review-trigger-DmAsiQlM.mjs";
+
+//#region src/hitl/index.d.ts
+declare namespace index_d_exports {
+  export { ActiveLearner, ActiveLearnerConfig, Annotation, AnnotationInput, AnnotationStats, AnnotationStore, AnnotationTask, AnnotatorStats, ApprovalQueue, ApprovalRequest, ApprovalResponse, ApprovalStatus, EscalationConfig, Feedback, FeedbackCollector, FeedbackCollectorConfig, FeedbackInput, FeedbackQuery, FeedbackStats, FeedbackStore, HITLConfig, InMemoryApprovalQueue, ReviewCondition, ReviewConditions, ReviewContext, ReviewSession, Sample, SelectionResult, SelectionStrategy, TaskQuery, TaskStatus, TaskType, createActiveLearner, createAnnotationStore, createFeedbackCollector, createSample, createSamples, evaluateReviewTriggers };
+}
+//#endregion
+export { type ActiveLearner, type ActiveLearnerConfig, type Annotation, type AnnotationInput, type AnnotationStats, type AnnotationStore, type AnnotationTask, type AnnotatorStats, type ApprovalQueue, type ApprovalRequest, type ApprovalResponse, type ApprovalStatus, type EscalationConfig, type Feedback, type FeedbackCollector, type FeedbackCollectorConfig, type FeedbackInput, type FeedbackQuery, type FeedbackStats, type FeedbackStore, type HITLConfig, InMemoryApprovalQueue, type ReviewCondition, ReviewConditions, type ReviewContext, type ReviewSession, type Sample, type SelectionResult, type SelectionStrategy, type TaskQuery, type TaskStatus, type TaskType, createActiveLearner, createAnnotationStore, createFeedbackCollector, createSample, createSamples, evaluateReviewTriggers, index_d_exports as t };
+//# sourceMappingURL=hitl.d.mts.map

package/dist/hitl.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hitl.d.mts","names":[],"sources":["../src/hitl/index.ts"],"mappings":""}

package/dist/hitl.mjs

@@ -0,0 +1,22 @@
+import { t as __exportAll } from "./chunk-CkzbjWQW.mjs";
+import { t as InMemoryApprovalQueue } from "./approval-queue-BcDDQ4oQ.mjs";
+import { n as evaluateReviewTriggers, t as ReviewConditions } from "./review-trigger-DwXfpww9.mjs";
+import { createFeedbackCollector } from "./hitl-feedback.mjs";
+import { createAnnotationStore } from "./hitl-annotation.mjs";
+import { createActiveLearner, createSample, createSamples } from "./hitl-active-learning.mjs";
+
+//#region src/hitl/index.ts
+var hitl_exports = /* @__PURE__ */ __exportAll({
+	InMemoryApprovalQueue: () => InMemoryApprovalQueue,
+	ReviewConditions: () => ReviewConditions,
+	createActiveLearner: () => createActiveLearner,
+	createAnnotationStore: () => createAnnotationStore,
+	createFeedbackCollector: () => createFeedbackCollector,
+	createSample: () => createSample,
+	createSamples: () => createSamples,
+	evaluateReviewTriggers: () => evaluateReviewTriggers
+});
+
+//#endregion
+export { InMemoryApprovalQueue, ReviewConditions, createActiveLearner, createAnnotationStore, createFeedbackCollector, createSample, createSamples, evaluateReviewTriggers, hitl_exports as t };
+//# sourceMappingURL=hitl.mjs.map

package/dist/hitl.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"hitl.mjs","names":[],"sources":["../src/hitl/index.ts"],"sourcesContent":["/**\n * Human-in-the-Loop (HITL) module\n *\n * Provides patterns for integrating human review and approval\n * into AI workflows, including approval queues, review triggers,\n * and escalation handling.\n *\n * @module @od-oneapp/ai-platform/hitl\n */\n\n// Types\nexport type {\n  ApprovalStatus,\n  ApprovalRequest,\n  ApprovalResponse,\n  EscalationConfig,\n  HITLConfig,\n  ReviewCondition,\n  ApprovalQueue,\n  ReviewSession,\n} from './types';\n\n// Approval\nexport { InMemoryApprovalQueue } from './approval/approval-queue';\n\n// Review\nexport {\n  evaluateReviewTriggers,\n  ReviewConditions,\n  type ReviewContext,\n} from './review/review-trigger';\n\n// Feedback collection\nexport {\n  createFeedbackCollector,\n  type Feedback,\n  type FeedbackInput,\n  type FeedbackQuery,\n  type FeedbackStats,\n  type FeedbackStore,\n  type FeedbackCollector,\n  type FeedbackCollectorConfig,\n} from \"./feedback\";\n\n// Annotation management\nexport {\n  createAnnotationStore,\n  type TaskType,\n  type TaskStatus,\n  type AnnotationTask,\n  type Annotation,\n  type AnnotationInput,\n  type TaskQuery,\n  type AnnotationStats,\n  type AnnotatorStats,\n  type AnnotationStore,\n} from \"./annotation\";\n\n// Active learning\nexport {\n  createActiveLearner,\n  createSample,\n  createSamples,\n  type SelectionStrategy,\n  type Sample,\n  type SelectionResult,\n  type ActiveLearner,\n  type ActiveLearnerConfig,\n} from \"./active-learning\";\n"],"mappings":""}

package/dist/index-B17HT-VL.d.mts

@@ -0,0 +1,285 @@
+import { A as ToolLoopAgent, Rr as SDKLanguageModelV3, Vi as SDKTelemetrySettings, ei as SDKOAuthClientProvider, qi as SDKTool, ua as SDKToolSet, xa as SDKUIMessage } from "./ai-runtime-DIwOEc6g.mjs";
+import { n as AgentStructuredOutput } from "./schemas-Dp_OCqBt.mjs";
+import { n as RiskLevel, t as ComplianceSignal } from "./schemas-DBOhxgW7.mjs";
+import { z } from "zod";
+import * as ai from "ai";
+import { z as z$1 } from "zod/v4";
+import { IOType } from "node:child_process";
+import { Stream } from "node:stream";
+
+//#region src/agents/tools/mcp.d.ts
+type McpSseTransport = {
+  type: 'sse';
+  url: string;
+  headers?: Record<string, string>;
+  authProvider?: SDKOAuthClientProvider;
+};
+type McpHttpTransport = {
+  type: 'http';
+  url: string;
+  headers?: Record<string, string>;
+  sessionId?: string;
+  authProvider?: SDKOAuthClientProvider;
+};
+type McpStdioTransport = {
+  type: 'stdio';
+  command?: string;
+  args?: string[];
+  env?: Record<string, string>;
+  cwd?: string;
+  stderr?: IOType | Stream | number;
+};
+type McpTransport = McpSseTransport | McpHttpTransport | McpStdioTransport;
+interface McpToolsetOptions {
+  transport: McpTransport;
+  approval?: boolean;
+}
+//#endregion
+//#region src/agents/tools/index.d.ts
+interface ToolCall {
+  id: string;
+  toolName: string;
+  input: unknown;
+}
+declare const createExecutionSignal: (toolCall: ToolCall, type: ComplianceSignal["type"], runId: string) => ComplianceSignal;
+//#endregion
+//#region src/agents/default-agent.d.ts
+type ToolRegistry = SDKToolSet;
+interface CreateAgentOptions {
+  model: SDKLanguageModelV3;
+  riskLevel: RiskLevel;
+  telemetry?: SDKTelemetrySettings;
+  tools?: ToolRegistry;
+  activeTools?: string[];
+  runId?: string;
+  onSignal?: (signal: ReturnType<typeof createExecutionSignal>) => void;
+  onStructuredOutput?: (output: AgentStructuredOutput) => Promise<void> | void;
+  onCleanup?: () => Promise<void> | void;
+}
+type DefaultAgentOutput = AgentStructuredOutput;
+declare class StandardAgent {
+  private agent;
+  private options;
+  private runId;
+  readonly tools: ToolRegistry;
+  constructor(options: CreateAgentOptions);
+  generate(options: Parameters<ToolLoopAgent<ToolRegistry>['generate']>[0]): Promise<ai.GenerateTextResult<{}, never>>;
+  stream(options: Parameters<ToolLoopAgent<ToolRegistry>['stream']>[0]): Promise<ai.StreamTextResult<{}, never>>;
+  getToolLoopAgent(): ToolLoopAgent<ToolRegistry>;
+}
+type DefaultAgent = StandardAgent;
+declare const createDefaultAgent: (options: CreateAgentOptions) => StandardAgent;
+declare const createDefaultAgentConfig: (options: CreateAgentOptions) => never;
+//#endregion
+//#region src/agents/governance-agent.d.ts
+interface GovernanceRules {
+  maxTokensPerIteration: number;
+  blockedTools: string[];
+  requireApproval: string[];
+  maxTotalTokens?: number;
+  iterationTimeoutMs?: number;
+}
+interface GovernanceIteration {
+  index: number;
+  status: 'running' | 'success' | 'error' | 'timeout';
+  output?: string;
+  error?: string;
+  tokenUsage: {
+    input: number;
+    output: number;
+  };
+  durationMs: number;
+  toolCalls?: Array<{
+    name: string;
+    args: unknown;
+  }>;
+}
+interface GovernanceResult {
+  success: boolean;
+  iterations: number;
+  iterationHistory: GovernanceIteration[];
+  finalOutput?: string;
+  error?: string;
+  totalTokens: {
+    input: number;
+    output: number;
+  };
+  totalDurationMs: number;
+  signals: ComplianceSignal[];
+}
+interface GovernanceAgentOptions {
+  task: string;
+  completionSignal: string;
+  maxIterations?: number;
+  feedbackErrors?: boolean;
+  iterationDelay?: number;
+  governance: GovernanceRules;
+  model: SDKLanguageModelV3;
+  tools?: Record<string, SDKTool>;
+  onIteration?: (iteration: GovernanceIteration) => void;
+  onSignal?: (signal: ComplianceSignal) => void;
+  systemPrompt?: string;
+  runId?: string;
+}
+declare function executeGovernanceLoop(options: GovernanceAgentOptions): Promise<GovernanceResult>;
+declare class GovernanceAgent {
+  private options;
+  constructor(options: GovernanceAgentOptions);
+  generate(): Promise<GovernanceResult>;
+  static create(options: GovernanceAgentOptions): GovernanceAgent;
+}
+declare function createGovernanceAgent(options: GovernanceAgentOptions): GovernanceAgent;
+declare const DEFAULT_GOVERNANCE_RULES: GovernanceRules;
+declare const ralphLoop: typeof executeGovernanceLoop;
+type RalphLoopResult = GovernanceResult;
+type RalphLoopOptions = GovernanceAgentOptions;
+type RalphGovernance = GovernanceRules;
+declare const DEFAULT_RALPH_GOVERNANCE: GovernanceRules;
+//#endregion
+//#region src/agents/orchestrator.d.ts
+interface OrchestratorOptions {
+  modelFactory: () => SDKLanguageModelV3;
+  onSignal?: (signal: ComplianceSignal) => void;
+  onStructuredOutput?: (output: AgentStructuredOutput) => Promise<void> | void;
+  mcp?: McpToolsetOptions;
+}
+declare class PlatformOrchestrator {
+  readonly version: "agent-v1";
+  readonly id = "platform-orchestrator";
+  private readonly options;
+  private readonly agents;
+  constructor(options: OrchestratorOptions);
+  get tools(): {};
+  getTools(): Promise<SDKToolSet>;
+  generate(options: Parameters<DefaultAgent['generate']>[0]): Promise<ai.GenerateTextResult<{}, never>>;
+  stream(options: Parameters<DefaultAgent['stream']>[0]): Promise<ai.StreamTextResult<{}, never>>;
+  respond({
+    messages
+  }: {
+    messages: SDKUIMessage[];
+  }): Promise<Response>;
+  private extractTextContent;
+  private agentForMessages;
+  private ensureAgent;
+}
+type PlatformAgent = PlatformOrchestrator;
+//#endregion
+//#region src/agents/evaluator-optimizer/schema.d.ts
+declare const EvaluationResultSchema: z.ZodObject<{
+  qualityScore: z.ZodNumber;
+  preservesTone: z.ZodBoolean;
+  preservesNuance: z.ZodBoolean;
+  culturallyAccurate: z.ZodBoolean;
+  technicallyCorrect: z.ZodBoolean;
+  specificIssues: z.ZodArray<z.ZodString>;
+  improvementSuggestions: z.ZodArray<z.ZodString>;
+  strengths: z.ZodArray<z.ZodString>;
+  overallAssessment: z.ZodString;
+  meetsThreshold: z.ZodBoolean;
+}, z.core.$strip>;
+type EvaluationResult = z.infer<typeof EvaluationResultSchema>;
+declare const OptimizerInputSchema: z.ZodObject<{
+  content: z.ZodString;
+  evaluationFeedback: z.ZodObject<{
+    qualityScore: z.ZodNumber;
+    preservesTone: z.ZodBoolean;
+    preservesNuance: z.ZodBoolean;
+    culturallyAccurate: z.ZodBoolean;
+    technicallyCorrect: z.ZodBoolean;
+    specificIssues: z.ZodArray<z.ZodString>;
+    improvementSuggestions: z.ZodArray<z.ZodString>;
+    strengths: z.ZodArray<z.ZodString>;
+    overallAssessment: z.ZodString;
+    meetsThreshold: z.ZodBoolean;
+  }, z.core.$strip>;
+  originalRequest: z.ZodString;
+  iterationNumber: z.ZodOptional<z.ZodNumber>;
+  previousVersions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+type OptimizerInput = z.infer<typeof OptimizerInputSchema>;
+declare const EvaluatorInputSchema: z.ZodObject<{
+  content: z.ZodString;
+  originalRequest: z.ZodString;
+  criteria: z.ZodOptional<z.ZodObject<{
+    threshold: z.ZodDefault<z.ZodNumber>;
+    focusAreas: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    maxAllowedIssues: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>>;
+  iterationNumber: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type EvaluatorInput = z.infer<typeof EvaluatorInputSchema>;
+declare const FeedbackLoopConfigSchema: z.ZodObject<{
+  maxIterations: z.ZodDefault<z.ZodNumber>;
+  targetScore: z.ZodDefault<z.ZodNumber>;
+  enableLogging: z.ZodDefault<z.ZodBoolean>;
+  stopOnThreshold: z.ZodDefault<z.ZodBoolean>;
+  diminishingReturnThreshold: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+type FeedbackLoopConfig = z.infer<typeof FeedbackLoopConfigSchema>;
+declare const OptimizedResultSchema: z.ZodObject<{
+  finalContent: z.ZodString;
+  finalEvaluation: z.ZodObject<{
+    qualityScore: z.ZodNumber;
+    preservesTone: z.ZodBoolean;
+    preservesNuance: z.ZodBoolean;
+    culturallyAccurate: z.ZodBoolean;
+    technicallyCorrect: z.ZodBoolean;
+    specificIssues: z.ZodArray<z.ZodString>;
+    improvementSuggestions: z.ZodArray<z.ZodString>;
+    strengths: z.ZodArray<z.ZodString>;
+    overallAssessment: z.ZodString;
+    meetsThreshold: z.ZodBoolean;
+  }, z.core.$strip>;
+  cyclesCompleted: z.ZodNumber;
+  meetsThreshold: z.ZodBoolean;
+  scoreHistory: z.ZodArray<z.ZodNumber>;
+  contentHistory: z.ZodArray<z.ZodString>;
+  terminationReason: z.ZodEnum<{
+    error: "error";
+    threshold_met: "threshold_met";
+    max_iterations: "max_iterations";
+    diminishing_returns: "diminishing_returns";
+  }>;
+  error: z.ZodOptional<z.ZodString>;
+  metadata: z.ZodOptional<z.ZodObject<{
+    startTime: z.ZodString;
+    endTime: z.ZodString;
+    processingTimeMs: z.ZodNumber;
+    averageScoreImprovement: z.ZodNumber;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type OptimizedResult = z.infer<typeof OptimizedResultSchema>;
+interface Evaluator {
+  evaluate(input: EvaluatorInput): Promise<EvaluationResult>;
+}
+interface Optimizer {
+  optimize(input: OptimizerInput): Promise<string>;
+}
+declare namespace index_d_exports {
+  export { EvaluationResult, EvaluationResultSchema, Evaluator, EvaluatorInput, EvaluatorOptimizer, FeedbackLoopConfig, FeedbackLoopConfigSchema, OptimizedResult, Optimizer, OptimizerConfig, createEvaluatorOptimizer, runFeedbackLoop };
+}
+interface OptimizerConfig {
+  maxIterations: number;
+  targetScore: number;
+  evaluator: Evaluator;
+  optimizer: Optimizer;
+  enableLogging?: boolean;
+  stopOnThreshold?: boolean;
+  diminishingReturnThreshold?: number;
+}
+declare class EvaluatorOptimizer {
+  private config;
+  private logger;
+  constructor(config: OptimizerConfig);
+  getEvaluator(): Evaluator;
+  getOptimizer(): Optimizer;
+  runFeedbackLoop(initialContent: string, originalRequest: string, loopConfig?: Partial<FeedbackLoopConfig>): Promise<OptimizedResult>;
+  private evaluateContent;
+  private optimizeContent;
+  private buildResult;
+}
+declare function createEvaluatorOptimizer(config: OptimizerConfig): EvaluatorOptimizer;
+declare function runFeedbackLoop(initialContent: string, originalRequest: string, config?: Partial<OptimizerConfig>): Promise<OptimizedResult>;
+//#endregion
+export { createDefaultAgentConfig as S, CreateAgentOptions as _, DEFAULT_GOVERNANCE_RULES as a, StandardAgent as b, GovernanceAgentOptions as c, GovernanceRules as d, RalphGovernance as f, ralphLoop as g, createGovernanceAgent as h, PlatformOrchestrator as i, GovernanceIteration as l, RalphLoopResult as m, OrchestratorOptions as n, DEFAULT_RALPH_GOVERNANCE as o, RalphLoopOptions as p, PlatformAgent as r, GovernanceAgent as s, index_d_exports as t, GovernanceResult as u, DefaultAgent as v, createDefaultAgent as x, DefaultAgentOutput as y };
+//# sourceMappingURL=index-B17HT-VL.d.mts.map

package/dist/index-B17HT-VL.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-B17HT-VL.d.mts","names":[],"sources":["../src/agents/tools/mcp.ts","../src/agents/tools/index.ts","../src/agents/default-agent.ts","../src/agents/governance-agent.ts","../src/agents/orchestrator.ts","../src/agents/evaluator-optimizer/schema.ts","../src/agents/evaluator-optimizer/index.ts"],"mappings":"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"}

package/dist/index-BDwgsK9B.d.mts

@@ -0,0 +1,101 @@
+import { t as ModelRef } from "./ai-runtime-DIwOEc6g.mjs";
+
+//#region src/sdk/middleware/circuit-breaker.d.ts
+type CircuitState$1 = 'closed' | 'open' | 'half-open';
+type FallbackBehavior = 'error' | 'default' | 'partial' | 'cache';
+interface CircuitBreakerConfig$1<TDefault = unknown> {
+  name: string;
+  failureThreshold?: number;
+  resetTimeout?: number;
+  halfOpenRequests?: number;
+  fallbackBehavior?: FallbackBehavior;
+  defaultValue?: TDefault;
+  onStateChange?: (from: CircuitState$1, to: CircuitState$1) => void;
+  onMetrics?: (metrics: CircuitMetrics) => void;
+}
+interface CircuitMetrics {
+  name: string;
+  state: CircuitState$1;
+  failureCount: number;
+  successCount: number;
+  lastFailureTime?: number;
+  lastSuccessTime?: number;
+  totalRequests: number;
+  totalFailures: number;
+  totalSuccesses: number;
+}
+declare class CircuitBreaker<TDefault = unknown> {
+  private state;
+  private failureCount;
+  private successCount;
+  private lastFailureTime?;
+  private lastSuccessTime?;
+  private totalRequests;
+  private totalFailures;
+  private totalSuccesses;
+  private halfOpenSuccessCount;
+  private resetTimer?;
+  private readonly config;
+  constructor(config: CircuitBreakerConfig$1<TDefault>);
+  getState(): CircuitState$1;
+  getMetrics(): CircuitMetrics;
+  private transitionTo;
+  private recordFailure;
+  private recordSuccess;
+  private openCircuit;
+  private closeCircuit;
+  canRequest(): boolean;
+  getResetTime(): number;
+  execute<T extends TDefault>(fn: () => Promise<T>): Promise<T>;
+  reportFailure(error: Error): void;
+  reset(): void;
+  destroy(): void;
+}
+declare class CircuitBreakerRegistry {
+  private circuits;
+  getOrCreate<T = unknown>(config: CircuitBreakerConfig$1<T>): CircuitBreaker<T>;
+  get(name: string): CircuitBreaker | undefined;
+  getAllMetrics(): CircuitMetrics[];
+  resetAll(): void;
+  destroy(): void;
+}
+declare const circuitBreakerRegistry: CircuitBreakerRegistry;
+declare function withCircuitBreaker<T>(name: string, config?: Partial<Omit<CircuitBreakerConfig$1, 'name'>>): (fn: () => Promise<T>) => Promise<T>;
+//#endregion
+//#region src/sdk/middleware/index.d.ts
+type MiddlewareFn<TContext = unknown> = (ctx: MiddlewareContext<TContext>, next: () => Promise<MiddlewareResult>) => Promise<MiddlewareResult>;
+interface ModelCallOptions {
+  readonly prompt?: string;
+  readonly messages?: unknown[];
+  readonly maxOutputTokens?: number;
+  readonly temperature?: number;
+  readonly [key: string]: unknown;
+}
+interface MiddlewareContext<TContext = unknown> {
+  readonly model: ModelRef;
+  readonly options: ModelCallOptions;
+  readonly custom: TContext | undefined;
+  readonly attempt: number;
+  readonly startTime: number;
+}
+interface MiddlewareResult {
+  readonly success: boolean;
+  readonly response?: unknown;
+  readonly error?: Error;
+  readonly duration: number;
+  readonly metadata?: Record<string, unknown>;
+}
+type CircuitState = 'closed' | 'open' | 'half-open';
+interface CircuitBreakerConfig {
+  readonly failureThreshold: number;
+  readonly successThreshold: number;
+  readonly timeout: number;
+  readonly onStateChange?: (state: CircuitState, provider?: string) => void;
+}
+declare function createCircuitBreaker(config: CircuitBreakerConfig): MiddlewareFn & {
+  getState: (key?: string) => CircuitState;
+  reset: (key?: string) => void;
+};
+//#endregion
+export { CircuitBreakerRegistry as a, CircuitBreaker as i, CircuitState as n, circuitBreakerRegistry as o, createCircuitBreaker as r, withCircuitBreaker as s, CircuitBreakerConfig as t };
+//# sourceMappingURL=index-BDwgsK9B.d.mts.map

package/dist/index-BDwgsK9B.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-BDwgsK9B.d.mts","names":[],"sources":["../src/sdk/middleware/circuit-breaker.ts","../src/sdk/middleware/index.ts"],"mappings":";;;KAaY,cAAA;AAAA,KAKA,gBAAA;AAAA,UAKK,sBAAA;EAEf,IAAA;EAEA,gBAAA;EAEA,YAAA;EAEA,gBAAA;EAEA,gBAAA,GAAmB,gBAAA;EAEnB,YAAA,GAAe,QAAA;EAEf,aAAA,IAAiB,IAAA,EAAM,cAAA,EAAc,EAAA,EAAI,cAAA;EAEzC,SAAA,IAAa,OAAA,EAAS,cAAA;AAAA;AAAA,UAMP,cAAA;EACf,IAAA;EACA,KAAA,EAAO,cAAA;EACP,YAAA;EACA,YAAA;EACA,eAAA;EACA,eAAA;EACA,aAAA;EACA,aAAA;EACA,cAAA;AAAA;AAAA,cAsBW,cAAA;EAAA,QACH,KAAA;EAAA,QACA,YAAA;EAAA,QACA,YAAA;EAAA,QACA,eAAA;EAAA,QACA,eAAA;EAAA,QACA,aAAA;EAAA,QACA,aAAA;EAAA,QACA,cAAA;EAAA,QACA,oBAAA;EAAA,QACA,UAAA;EAAA,iBAES,MAAA;cAEL,MAAA,EAAQ,sBAAA,CAAqB,QAAA;EAgBzC,QAAA,CAAA,GAAY,cAAA;EAOZ,UAAA,CAAA,GAAc,cAAA;EAAA,QAiBN,YAAA;EAAA,QAaA,aAAA;EAAA,QAgBA,aAAA;EAAA,QAmBA,WAAA;EAAA,QAkBA,YAAA;EAcR,UAAA,CAAA;EAQA,YAAA,CAAA;EAeM,OAAA,WAAkB,QAAA,CAAA,CAAU,EAAA,QAAU,OAAA,CAAQ,CAAA,IAAK,OAAA,CAAQ,CAAA;EAmCjE,aAAA,CAAc,KAAA,EAAO,KAAA;EAQrB,KAAA,CAAA;EAqBA,OAAA,CAAA;AAAA;AAAA,cAWW,sBAAA;EAAA,QACH,QAAA;EAKR,WAAA,aAAA,CAAyB,MAAA,EAAQ,sBAAA,CAAqB,CAAA,IAAK,cAAA,CAAe,CAAA;EAY1E,GAAA,CAAI,IAAA,WAAe,cAAA;EAOnB,aAAA,CAAA,GAAiB,cAAA;EAOjB,QAAA,CAAA;EASA,OAAA,CAAA;AAAA;AAAA,cAWW,sBAAA,EAAsB,sBAAA;AAAA,iBAqBnB,kBAAA,GAAA,CACd,IAAA,UACA,MAAA,GAAS,OAAA,CAAQ,IAAA,CAAK,sBAAA,cACpB,EAAA,QAAU,OAAA,CAAQ,CAAA,MAAO,OAAA,CAAQ,CAAA;;;KC/WzB,YAAA,wBACV,GAAA,EAAK,iBAAA,CAAkB,QAAA,GACvB,IAAA,QAAY,OAAA,CAAQ,gBAAA,MACjB,OAAA,CAAQ,gBAAA;AAAA,UAGI,gBAAA;EAAA,SACN,MAAA;EAAA,SACA,QAAA;EAAA,SACA,eAAA;EAAA,SACA,WAAA;EAAA,UACC,GAAA;AAAA;AAAA,UAIK,iBAAA;EAAA,SACN,KAAA,EAAO,QAAA;EAAA,SACP,OAAA,EAAS,gBAAA;EAAA,SACT,MAAA,EAAQ,QAAA;EAAA,SACR,OAAA;EAAA,SACA,SAAA;AAAA;AAAA,UAIM,gBAAA;EAAA,SACN,OAAA;EAAA,SACA,QAAA;EAAA,SACA,KAAA,GAAQ,KAAA;EAAA,SACR,QAAA;EAAA,SACA,QAAA,GAAW,MAAA;AAAA;AAAA,KAIV,YAAA;AAAA,UAGK,oBAAA;EAAA,SACN,gBAAA;EAAA,SACA,gBAAA;EAAA,SACA,OAAA;EAAA,SACA,aAAA,IAAiB,KAAA,EAAO,YAAA,EAAc,QAAA;AAAA;AAAA,iBA2CjC,oBAAA,CACd,MAAA,EAAQ,oBAAA,GACP,YAAA;EAAiB,QAAA,GAAW,GAAA,cAAiB,YAAA;EAAc,KAAA,GAAQ,GAAA;AAAA"}