@od-oneapp/ai-platform 0.1.0

package/dist/ai-sdk-error-integration-D0GDqrM0.d.mts

@@ -0,0 +1,553 @@
+import { ua as SDKToolSet } from "./ai-runtime-DIwOEc6g.mjs";
+import { MCPClient, OAuthClientProvider } from "@ai-sdk/mcp";
+import { Experimental_StdioMCPTransport } from "@ai-sdk/mcp/mcp-stdio";
+import "server-only";
+import { IOType } from "node:child_process";
+import { Stream } from "node:stream";
+
+//#region src/tools/mcp/client.d.ts
+interface MCPClientConfig {
+  name: string;
+  transport: MCPTransportConfig;
+  retry?: MCPRetryConfig;
+  timeoutMs?: number;
+  gracefulDegradation?: boolean;
+  healthCheck?: MCPHealthCheckConfig;
+}
+interface MCPTransportConfig {
+  type: 'stdio' | 'sse' | 'http';
+  command?: string;
+  args?: string[];
+  env?: Record<string, string>;
+  cwd?: string;
+  stderr?: IOType | Stream | number;
+  url?: string;
+  headers?: Record<string, string>;
+  httpUrl?: string;
+  sessionId?: string;
+  authProvider?: OAuthClientProvider;
+}
+type MCPClient$1 = MCPClient;
+type MCPRemoteTransport = {
+  type: 'sse' | 'http';
+  url: string;
+  headers?: Record<string, string>;
+  authProvider?: OAuthClientProvider;
+};
+type MCPTransport = Experimental_StdioMCPTransport | MCPRemoteTransport;
+interface MCPRetryConfig {
+  maxAttempts: number;
+  initialDelayMs: number;
+  maxDelayMs: number;
+  backoffMultiplier: number;
+  retryableErrors: string[];
+}
+declare const DEFAULT_RETRY_CONFIG: MCPRetryConfig;
+interface MCPHealthCheckConfig {
+  enabled: boolean;
+  intervalMs: number;
+  timeoutMs: number;
+  failureThreshold: number;
+  recoveryThreshold: number;
+}
+declare const DEFAULT_HEALTH_CHECK_CONFIG: MCPHealthCheckConfig;
+declare enum MCPHealthStatus {
+  HEALTHY = "healthy",
+  DEGRADED = "degraded",
+  UNHEALTHY = "unhealthy",
+  UNKNOWN = "unknown"
+}
+interface MCPHealthCheckResult {
+  status: MCPHealthStatus;
+  lastCheck: Date;
+  consecutiveFailures: number;
+  consecutiveSuccesses: number;
+  responseTimeMs?: number;
+  error?: string;
+}
+interface MCPClientResult {
+  client: MCPClient$1;
+  toolSet: SDKToolSet;
+  config: MCPClientConfig;
+}
+declare class MCPConnectionError extends Error {
+  readonly clientName: string;
+  readonly transportType: string;
+  readonly originalError?: Error | undefined;
+  constructor(message: string, clientName: string, transportType: string, originalError?: Error | undefined);
+}
+declare class MCPTransportError extends Error {
+  readonly transportType: string;
+  readonly originalError?: Error | undefined;
+  constructor(message: string, transportType: string, originalError?: Error | undefined);
+}
+declare class MCPRetryableError extends Error {
+  readonly attempt: number;
+  readonly maxAttempts: number;
+  readonly originalError?: Error | undefined;
+  constructor(message: string, attempt: number, maxAttempts: number, originalError?: Error | undefined);
+}
+declare function withRetryAndTimeout<T>(operation: () => Promise<T>, retryConfig?: MCPRetryConfig, timeoutMs?: number, context?: string): Promise<T>;
+declare class MCPHealthMonitor {
+  private healthStatuses;
+  private healthCheckIntervals;
+  startMonitoring(config: MCPClientConfig): void;
+  stopMonitoring(clientName: string): void;
+  getHealthStatus(clientName: string): MCPHealthCheckResult | undefined;
+  isHealthy(clientName: string): boolean;
+  shouldExclude(clientName: string): boolean;
+  private performHealthCheck;
+  getHealthSummary(): Record<string, MCPHealthCheckResult>;
+  cleanup(): void;
+}
+declare const globalMCPHealthMonitor: MCPHealthMonitor;
+declare function createTransportFromConfig(transportConfig: MCPTransportConfig): MCPTransport;
+declare class MCPRequestManager {
+  clients: MCPClient$1[];
+  private tools;
+  private errorHandlers;
+  addClient(config: MCPClientConfig): Promise<void>;
+  getTools(): SDKToolSet;
+  close(): Promise<void>;
+  getHealthSummary(): Record<string, MCPHealthCheckResult>;
+  createAISDKErrorHandlers(): {
+    onUncaughtError: (error: Error) => void;
+    onFinish: () => Promise<void>;
+    onStreamError: (error: Error) => void;
+  };
+}
+declare function createMCPToolsForRequest(configs: MCPClientConfig[]): Promise<{
+  tools: SDKToolSet;
+  clients: MCPClient$1[];
+  cleanup: () => Promise<void>;
+}>;
+declare function createMCPToolsFromConfigs(configs: MCPClientConfig[], options?: {
+  gracefulDegradation?: boolean;
+}): Promise<{
+  tools: SDKToolSet;
+  clients: MCPClient$1[];
+  closeAllClients: () => Promise<void>;
+}>;
+//#endregion
+//#region src/tools/mcp/stream-lifecycle-integration.d.ts
+declare enum StreamLifecyclePhase {
+  INITIALIZING = "initializing",
+  CONNECTED = "connected",
+  STREAMING = "streaming",
+  PAUSED = "paused",
+  COMPLETING = "completing",
+  COMPLETED = "completed",
+  ERROR = "error",
+  ABORTED = "aborted",
+  CLEANUP = "cleanup"
+}
+interface StreamLifecycleEvent {
+  phase: StreamLifecyclePhase;
+  timestamp: Date;
+  metadata: Record<string, unknown>;
+  error?: Error;
+}
+interface StreamLifecycleConfig {
+  enableHealthChecks: boolean;
+  healthCheckIntervalMs: number;
+  streamTimeoutMs: number;
+  maxRetryAttempts: number;
+  backoffStrategy: 'linear' | 'exponential';
+  enableMemoryMonitoring: boolean;
+  maxMemoryUsageMB: number;
+  enableAbortHandling: boolean;
+  gracefulShutdownTimeoutMs: number;
+}
+declare const DEFAULT_STREAM_LIFECYCLE_CONFIG: StreamLifecycleConfig;
+declare class MCPStreamLifecycleManager {
+  private clientConfigs;
+  private phase;
+  private eventHistory;
+  private config;
+  private clients;
+  private tools;
+  private closeAllClients;
+  private errorHandlers;
+  private abortController?;
+  private healthCheckInterval?;
+  private memoryMonitorInterval?;
+  private streamStartTime?;
+  constructor(clientConfigs: MCPClientConfig[], config?: Partial<StreamLifecycleConfig>);
+  initialize(): Promise<{
+    tools: SDKToolSet;
+    clients: MCPClient$1[];
+    streamCallbacks: StreamCallbacks;
+  }>;
+  private createStreamCallbacks;
+  private handleAbort;
+  private startMonitoring;
+  private performHealthCheck;
+  private checkMemoryUsage;
+  private performGracefulCleanup;
+  private performEmergencyCleanup;
+  private logEvent;
+  private getElapsedTime;
+  getStatus(): {
+    phase: StreamLifecyclePhase;
+    elapsedMs: number;
+    clientCount: number;
+    toolCount: number;
+    eventCount: number;
+    recentEvents: StreamLifecycleEvent[];
+  };
+  requestAbort(): void;
+  private performAsyncCleanup;
+}
+interface StreamFinishEvent {
+  toolResults?: unknown[];
+  usage?: unknown;
+  [key: string]: unknown;
+}
+interface StreamCallbacks {
+  onStart: () => void;
+  onProgress: (data: unknown) => void;
+  onFinish: (event: StreamFinishEvent) => Promise<void>;
+  onError: (error: Error) => Promise<void>;
+  onUncaughtError: (error: Error) => void;
+  onAbort: () => void;
+}
+declare function createMCPStreamLifecycleManager(clientConfigs: MCPClientConfig[], config?: Partial<StreamLifecycleConfig>): MCPStreamLifecycleManager;
+//#endregion
+//#region src/tools/mcp/next-pattern.d.ts
+declare function createMCPToolsForStreamText(configs: MCPClientConfig[]): Promise<{
+  tools: SDKToolSet;
+  clients: MCPClient$1[];
+  closeAllClients: () => Promise<void>;
+  onUncaughtError: (error: Error) => void;
+  onFinish: () => Promise<void>;
+}>;
+declare function createMCPToolsWithDefaults(configs: MCPClientConfig[], options?: {
+  gracefulDegradation?: boolean;
+  logErrors?: boolean;
+  includeAISDKCallbacks?: boolean;
+}): Promise<{
+  tools: SDKToolSet;
+  clients: MCPClient$1[];
+  closeAllClients: () => Promise<void>;
+  isAvailable: boolean;
+  errors: string[];
+  onUncaughtError?: (error: Error) => void;
+  onFinish?: () => Promise<void>;
+}>;
+declare function testMCPConnectivity(configs: MCPClientConfig[]): Promise<{
+  results: Array<{
+    name: string;
+    success: boolean;
+    error?: string;
+    toolCount: number;
+  }>;
+  overallSuccess: boolean;
+}>;
+declare function createMCPToolsWithStreamLifecycle(configs: MCPClientConfig[], lifecycleConfig?: Partial<StreamLifecycleConfig>): Promise<{
+  tools: SDKToolSet;
+  clients: MCPClient$1[];
+  closeAllClients: () => Promise<void>;
+  onUncaughtError: (error: Error) => void;
+  onFinish: () => Promise<void>;
+  streamCallbacks: {
+    onStart: () => void;
+    onProgress: (data: unknown) => void;
+    onFinish: (event: StreamFinishEvent) => Promise<void>;
+    onError: (error: Error) => Promise<void>;
+    onUncaughtError: (error: Error) => void;
+    onAbort: () => void;
+  };
+  lifecycleManager: {
+    getStatus: () => ReturnType<MCPStreamLifecycleManager['getStatus']>;
+    requestAbort: () => void;
+  };
+}>;
+//#endregion
+//#region src/tools/mcp/transports.d.ts
+declare const mcpTransports: {
+  filesystem: (rootPath?: string) => MCPClientConfig;
+  sqlite: (dbPath: string) => MCPClientConfig;
+  git: (repoPath?: string) => MCPClientConfig;
+  sse: (name: string, url: string) => MCPClientConfig;
+  stdio: (name: string, command: string, args?: string[]) => MCPClientConfig;
+  http: (name: string, httpUrl: string, sessionId?: string) => MCPClientConfig;
+  perplexityAsk: () => MCPClientConfig;
+};
+//#endregion
+//#region src/tools/mcp/connection-manager.d.ts
+interface ConnectionPoolConfig {
+  maxConnections: number;
+  connectionTimeout: number;
+  healthCheckInterval: number;
+  retryAttempts: number;
+  retryDelay: number;
+}
+interface ConnectionMetadata {
+  config: MCPClientConfig;
+  client: MCPClient$1;
+  tools: SDKToolSet;
+  createdAt: Date;
+  lastUsed: Date;
+  useCount: number;
+  isHealthy: boolean;
+  lastHealthCheck: Date;
+}
+interface ConnectionPoolEvents {
+  created: (config: MCPClientConfig) => void;
+  destroyed: (config: MCPClientConfig) => void;
+  error: (config: MCPClientConfig, error: Error) => void;
+  healthCheck: (config: MCPClientConfig, healthy: boolean) => void;
+}
+declare class MCPConnectionManager {
+  private connections;
+  private config;
+  private healthCheckTimer?;
+  private events;
+  constructor(config?: Partial<ConnectionPoolConfig>);
+  on<K extends keyof ConnectionPoolEvents>(event: K, listener: ConnectionPoolEvents[K]): void;
+  getConnection(config: MCPClientConfig): Promise<ConnectionMetadata>;
+  getAllTools(): Promise<SDKToolSet>;
+  getStats(): {
+    totalConnections: number;
+    healthyConnections: number;
+    totalUseCount: number;
+    oldestConnection?: Date;
+    newestConnection?: Date;
+  };
+  closeConnection(config: MCPClientConfig): Promise<void>;
+  closeAll(): Promise<void>;
+  performHealthCheck(): Promise<void>;
+  private getConnectionKey;
+  private createConnection;
+  private evictOldestConnection;
+  private startHealthChecking;
+}
+declare function getGlobalConnectionManager(config?: Partial<ConnectionPoolConfig>): MCPConnectionManager;
+declare function createPooledMCPTools(configs: MCPClientConfig[], options?: {
+  useGlobalPool?: boolean;
+  poolConfig?: Partial<ConnectionPoolConfig>;
+}): Promise<{
+  tools: SDKToolSet;
+  manager: MCPConnectionManager;
+}>;
+//#endregion
+//#region src/tools/mcp/connection-pool.d.ts
+interface MCPConnectionPoolConfig {
+  maxConnections: number;
+  minConnections: number;
+  idleTimeoutMs: number;
+  connectionTimeoutMs: number;
+  retryConfig?: typeof DEFAULT_RETRY_CONFIG;
+  healthCheckEnabled: boolean;
+}
+declare const DEFAULT_POOL_CONFIG: MCPConnectionPoolConfig;
+interface PooledConnection {
+  client: MCPClient$1;
+  config: MCPClientConfig;
+  createdAt: Date;
+  lastUsed: Date;
+  inUse: boolean;
+  id: string;
+}
+declare class MCPConnectionPool {
+  private connections;
+  private poolConfig;
+  private cleanupInterval?;
+  constructor(config?: Partial<MCPConnectionPoolConfig>);
+  getConnection(config: MCPClientConfig): Promise<PooledConnection>;
+  releaseConnection(connection: PooledConnection): void;
+  getTools(config: MCPClientConfig): Promise<SDKToolSet>;
+  private createConnection;
+  private waitForAvailableConnection;
+  private removeConnection;
+  private getPoolKey;
+  private startCleanupTask;
+  private cleanupIdleConnections;
+  getPoolStats(): Record<string, {
+    total: number;
+    inUse: number;
+    idle: number;
+  }>;
+  cleanup(): Promise<void>;
+}
+declare const globalMCPConnectionPool: MCPConnectionPool;
+//#endregion
+//#region src/tools/mcp/edge-runtime.d.ts
+interface EdgeMCPClientConfig {
+  name: string;
+  transport: EdgeMCPTransportConfig;
+}
+interface EdgeMCPTransportConfig {
+  type: 'sse' | 'http';
+  url?: string;
+  headers?: Record<string, string>;
+  httpUrl?: string;
+  sessionId?: string;
+  authProvider?: OAuthClientProvider;
+}
+declare function isEdgeRuntime(): boolean;
+declare function getEdgeCompatibleConfigs(configs: MCPClientConfig[]): EdgeMCPClientConfig[];
+declare function createEdgeMCPTools(configs: EdgeMCPClientConfig[], options?: {
+  gracefulDegradation?: boolean;
+  timeout?: number;
+}): Promise<{
+  tools: SDKToolSet;
+  clients: MCPClient$1[];
+  closeAllClients: () => Promise<void>;
+}>;
+declare const edgeMCPTransports: {
+  sse: (name: string, url: string, headers?: Record<string, string>) => EdgeMCPClientConfig;
+  http: (name: string, httpUrl: string, sessionId?: string) => EdgeMCPClientConfig;
+  zapier: (apiKey: string) => EdgeMCPClientConfig;
+  search: (baseUrl: string, apiKey?: string) => EdgeMCPClientConfig;
+};
+declare function discoverEdgeMCPServers(): EdgeMCPClientConfig[];
+declare function createSmartMCPTools(nodeConfigs?: MCPClientConfig[], edgeConfigs?: EdgeMCPClientConfig[], options?: {
+  gracefulDegradation?: boolean;
+  discoverFromEnvironment?: boolean;
+}): Promise<{
+  tools: SDKToolSet;
+  clients: MCPClient$1[];
+  closeAllClients: () => Promise<void>;
+  runtime: 'node' | 'edge';
+}>;
+//#endregion
+//#region src/tools/mcp/environment.d.ts
+interface MCPEnvironmentConfig {
+  prefix?: string;
+  includeDefaults?: boolean;
+  basePath?: string;
+}
+interface ParsedMCPServer {
+  name: string;
+  type: 'stdio' | 'sse' | 'http';
+  url?: string;
+  command?: string;
+  args?: string[];
+  enabled: boolean;
+}
+declare function discoverMCPServersFromEnvironment(config?: MCPEnvironmentConfig): MCPClientConfig[];
+declare function getMCPServers(explicitConfigs?: MCPClientConfig[], envConfig?: MCPEnvironmentConfig): MCPClientConfig[];
+declare function validateMCPEnvironment(): Promise<{
+  isValid: boolean;
+  errors: string[];
+  warnings: string[];
+  recommendations: string[];
+}>;
+//#endregion
+//#region src/tools/mcp/tool-cache.d.ts
+interface MCPToolCacheConfig {
+  enabled: boolean;
+  maxEntries: number;
+  ttlMs: number;
+  maxMemoryMB: number;
+  compressionEnabled: boolean;
+}
+declare const DEFAULT_CACHE_CONFIG: MCPToolCacheConfig;
+interface CacheStats {
+  hits: number;
+  misses: number;
+  entries: number;
+  totalSize: number;
+  hitRate: number;
+  avgAccessTime: number;
+  oldestEntry?: Date;
+  newestEntry?: Date;
+}
+declare class MCPToolCache {
+  private cache;
+  private config;
+  private stats;
+  private cleanupInterval?;
+  constructor(config?: Partial<MCPToolCacheConfig>);
+  get(clientConfig: MCPClientConfig): SDKToolSet | null;
+  set(clientConfig: MCPClientConfig, tools: SDKToolSet): void;
+  invalidate(clientConfig: MCPClientConfig): void;
+  clear(): void;
+  getStats(): CacheStats;
+  private getCacheKey;
+  private estimateSize;
+  private shouldEvictForMemory;
+  private evictLeastRecentlyUsed;
+  private evictOldestEntry;
+  private startCleanupTask;
+  private cleanupExpiredEntries;
+  private resetStats;
+  disable(): void;
+  enable(): void;
+  cleanup(): void;
+}
+declare const globalMCPToolCache: MCPToolCache;
+//#endregion
+//#region src/tools/mcp/transport-selector.d.ts
+interface TransportSelectionCriteria {
+  latencyRequirement: 'low' | 'medium' | 'high';
+  reliabilityRequirement: 'basic' | 'standard' | 'high';
+  throughputRequirement: 'low' | 'medium' | 'high';
+  networkEnvironment: 'local' | 'lan' | 'wan' | 'internet';
+  securityRequirement: 'basic' | 'standard' | 'high';
+  scalabilityRequirement: 'single' | 'multiple' | 'massive';
+}
+interface TransportSelectionResult {
+  recommendedTransport: 'stdio' | 'sse' | 'http';
+  score: number;
+  reasoningText: string[];
+  alternatives: Array<{
+    transport: 'stdio' | 'sse' | 'http';
+    score: number;
+    reason: string;
+  }>;
+}
+declare class MCPTransportSelector {
+  selectTransport(criteria: TransportSelectionCriteria, availableTransports?: Array<'stdio' | 'sse' | 'http'>): TransportSelectionResult;
+  selectForUseCase(useCase: 'real-time' | 'batch-processing' | 'high-availability' | 'development' | 'production', availableTransports?: Array<'stdio' | 'sse' | 'http'>): TransportSelectionResult;
+  recommendForClient(config: MCPClientConfig): TransportSelectionResult;
+  private calculateTransportScores;
+  private getWeightsForCriteria;
+  private generateReasoning;
+  private getTransportReason;
+  private inferCriteriaFromConfig;
+}
+declare const globalTransportSelector: MCPTransportSelector;
+declare function selectOptimalTransport(criteria: TransportSelectionCriteria, availableTransports?: Array<'stdio' | 'sse' | 'http'>): TransportSelectionResult;
+declare function selectTransportForUseCase(useCase: 'real-time' | 'batch-processing' | 'high-availability' | 'development' | 'production', availableTransports?: Array<'stdio' | 'sse' | 'http'>): TransportSelectionResult;
+//#endregion
+//#region src/tools/mcp/ai-sdk-error-integration.d.ts
+type AISDKErrorType = 'connection-error' | 'transport-error' | 'tool-execution-error' | 'timeout-error' | 'validation-error' | 'resource-exhausted' | 'unknown-error';
+declare class AISDKCompatibleMCPError extends Error {
+  readonly errorType: AISDKErrorType;
+  readonly timestamp: Date;
+  readonly recoverable: boolean;
+  readonly metadata: Record<string, unknown>;
+  constructor(message: string, errorType?: AISDKErrorType, originalError?: Error, metadata?: Record<string, unknown>, recoverable?: boolean);
+  toAISDKFormat(): {
+    name: string;
+    message: string;
+    errorType: AISDKErrorType;
+    timestamp: string;
+    recoverable: boolean;
+    metadata: Record<string, unknown>;
+    stack: string | undefined;
+  };
+}
+declare class MCPErrorHandlerFactory {
+  private clientName;
+  private operationContext;
+  constructor(clientName: string, operationContext?: string);
+  createUncaughtErrorHandler(cleanupFn: () => Promise<void>, options?: {
+    enableRecovery?: boolean;
+    maxRecoveryAttempts?: number;
+    logLevel?: 'error' | 'warn' | 'info';
+  }): (error: Error) => void;
+  createStreamErrorHandler(cleanupFn: () => Promise<void>, onStreamError?: (error: AISDKCompatibleMCPError) => void): (error: Error) => void;
+  createFinishHandler(cleanupFn: () => Promise<void>, successCallback?: () => void): () => Promise<void>;
+  private convertToAISDKError;
+}
+declare const MCPErrorUtils: {
+  createErrorContext(clientName: string, operation: string): MCPErrorHandlerFactory;
+  isRecoverableError(error: Error): boolean;
+  extractErrorMetadata(error: Error): Record<string, unknown>;
+};
+//#endregion
+export { DEFAULT_RETRY_CONFIG as $, MCPConnectionPool as A, createMCPToolsForStreamText as B, createEdgeMCPTools as C, getEdgeCompatibleConfigs as D, edgeMCPTransports as E, ConnectionPoolEvents as F, MCPStreamLifecycleManager as G, createMCPToolsWithStreamLifecycle as H, MCPConnectionManager as I, StreamLifecycleConfig as J, StreamCallbacks as K, createPooledMCPTools as L, globalMCPConnectionPool as M, ConnectionMetadata as N, isEdgeRuntime as O, ConnectionPoolConfig as P, DEFAULT_HEALTH_CHECK_CONFIG as Q, getGlobalConnectionManager as R, EdgeMCPTransportConfig as S, discoverEdgeMCPServers as T, testMCPConnectivity as U, createMCPToolsWithDefaults as V, DEFAULT_STREAM_LIFECYCLE_CONFIG as W, StreamLifecyclePhase as X, StreamLifecycleEvent as Y, createMCPStreamLifecycleManager as Z, ParsedMCPServer as _, globalMCPHealthMonitor as _t, MCPTransportSelector as a, MCPHealthCheckResult as at, validateMCPEnvironment as b, globalTransportSelector as c, MCPRequestManager as ct, CacheStats as d, MCPTransport as dt, MCPClient$1 as et, DEFAULT_CACHE_CONFIG as f, MCPTransportConfig as ft, MCPEnvironmentConfig as g, createTransportFromConfig as gt, globalMCPToolCache as h, createMCPToolsFromConfigs as ht, MCPErrorUtils as i, MCPHealthCheckConfig as it, MCPConnectionPoolConfig as j, DEFAULT_POOL_CONFIG as k, selectOptimalTransport as l, MCPRetryConfig as lt, MCPToolCacheConfig as m, createMCPToolsForRequest as mt, AISDKErrorType as n, MCPClientResult as nt, TransportSelectionCriteria as o, MCPHealthMonitor as ot, MCPToolCache as p, MCPTransportError as pt, StreamFinishEvent as q, MCPErrorHandlerFactory as r, MCPConnectionError as rt, TransportSelectionResult as s, MCPHealthStatus as st, AISDKCompatibleMCPError as t, MCPClientConfig as tt, selectTransportForUseCase as u, MCPRetryableError as ut, discoverMCPServersFromEnvironment as v, withRetryAndTimeout as vt, createSmartMCPTools as w, EdgeMCPClientConfig as x, getMCPServers as y, mcpTransports as z };
+//# sourceMappingURL=ai-sdk-error-integration-D0GDqrM0.d.mts.map

package/dist/ai-sdk-error-integration-D0GDqrM0.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-sdk-error-integration-D0GDqrM0.d.mts","names":[],"sources":["../src/tools/mcp/client.ts","../src/tools/mcp/stream-lifecycle-integration.ts","../src/tools/mcp/next-pattern.ts","../src/tools/mcp/transports.ts","../src/tools/mcp/connection-manager.ts","../src/tools/mcp/connection-pool.ts","../src/tools/mcp/edge-runtime.ts","../src/tools/mcp/environment.ts","../src/tools/mcp/tool-cache.ts","../src/tools/mcp/transport-selector.ts","../src/tools/mcp/ai-sdk-error-integration.ts"],"mappings":"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"}

package/dist/approval-queue-BcDDQ4oQ.mjs

@@ -0,0 +1,104 @@
+//#region src/hitl/approval/approval-queue.ts
+/**
+* In-memory approval queue implementation
+*
+* @example
+* ```ts
+* const queue = new InMemoryApprovalQueue();
+*
+* // Submit for approval
+* const requestId = await queue.submit({
+*   id: "req-1",
+*   type: "action",
+*   content: { action: "delete_user", userId: "123" },
+*   context: "User requested account deletion",
+*   priority: "high",
+*   createdAt: new Date(),
+* });
+*
+* // Wait for approval
+* const response = await queue.waitForApproval(requestId, 30000);
+* if (response.status === "approved") {
+*   // Proceed with action
+* }
+* ```
+*/
+var InMemoryApprovalQueue = class {
+	requests = /* @__PURE__ */ new Map();
+	responses = /* @__PURE__ */ new Map();
+	waiters = /* @__PURE__ */ new Map();
+	async submit(request) {
+		this.requests.set(request.id, request);
+		return request.id;
+	}
+	async get(requestId) {
+		return this.requests.get(requestId) || null;
+	}
+	async listPending(options = {}) {
+		const { limit = 100, priority } = options;
+		let pending = Array.from(this.requests.values()).filter((req) => !this.responses.has(req.id));
+		if (priority) pending = pending.filter((req) => req.priority === priority);
+		const priorityOrder = {
+			critical: 0,
+			high: 1,
+			medium: 2,
+			low: 3
+		};
+		pending.sort((a, b) => {
+			const priorityDiff = (priorityOrder[a.priority || "medium"] || 2) - (priorityOrder[b.priority || "medium"] || 2);
+			if (priorityDiff !== 0) return priorityDiff;
+			return a.createdAt.getTime() - b.createdAt.getTime();
+		});
+		return pending.slice(0, limit);
+	}
+	async respond(response) {
+		this.responses.set(response.requestId, response);
+		const waiters = this.waiters.get(response.requestId) || [];
+		for (const waiter of waiters) waiter.resolve(response);
+		this.waiters.delete(response.requestId);
+	}
+	async waitForApproval(requestId, timeoutMs = 3e4) {
+		const existing = this.responses.get(requestId);
+		if (existing) return existing;
+		return new Promise((resolve, reject) => {
+			const waiters = this.waiters.get(requestId) || [];
+			const timer = setTimeout(() => {
+				const idx = waiters.indexOf(waiter);
+				if (idx >= 0) waiters.splice(idx, 1);
+				reject(/* @__PURE__ */ new Error(`Approval timeout: ${requestId}`));
+			}, timeoutMs);
+			const wrappedResolve = (response) => {
+				clearTimeout(timer);
+				resolve(response);
+			};
+			const wrappedReject = (error) => {
+				clearTimeout(timer);
+				reject(error);
+			};
+			const waiter = {
+				resolve: wrappedResolve,
+				reject: wrappedReject
+			};
+			waiters.push(waiter);
+			this.waiters.set(requestId, waiters);
+		});
+	}
+	/**
+	* Get response for a request
+	*/
+	getResponse(requestId) {
+		return this.responses.get(requestId);
+	}
+	/**
+	* Clear all requests and responses
+	*/
+	clear() {
+		this.requests.clear();
+		this.responses.clear();
+		this.waiters.clear();
+	}
+};
+
+//#endregion
+export { InMemoryApprovalQueue as t };
+//# sourceMappingURL=approval-queue-BcDDQ4oQ.mjs.map