@defai.digital/discussion-domain 13.0.3

package/src/provider-bridge.ts

@@ -0,0 +1,346 @@
+/**
+ * Discussion Provider Bridge
+ *
+ * Bridges the discussion-domain's DiscussionProviderExecutor interface
+ * to the provider-adapters' ProviderRegistry.
+ *
+ * This adapter pattern allows the discussion domain to remain decoupled
+ * from the concrete provider implementation details.
+ */
+
+import type {
+  DiscussionProviderExecutor,
+  ProviderExecuteRequest,
+  ProviderExecuteResult,
+} from './types.js';
+
+/**
+ * Minimal LLMProvider interface (mirrors provider-adapters without importing)
+ */
+interface LLMProviderLike {
+  providerId: string;
+  complete(request: CompletionRequestLike): Promise<CompletionResponseLike>;
+  checkHealth(): Promise<HealthCheckResultLike>;
+  isAvailable(): Promise<boolean>;
+}
+
+/**
+ * Minimal CompletionRequest interface
+ */
+interface CompletionRequestLike {
+  requestId: string;
+  model: string;
+  messages: { role: 'system' | 'user' | 'assistant'; content: string }[];
+  maxTokens?: number | undefined;
+  temperature?: number | undefined;
+  timeout?: number | undefined;
+  systemPrompt?: string | undefined;
+}
+
+/**
+ * Minimal CompletionResponse interface (discriminated union)
+ */
+type CompletionResponseLike =
+  | {
+      success: true;
+      requestId: string;
+      content: string;
+      model: string;
+      usage: { inputTokens: number; outputTokens: number; totalTokens: number };
+      latencyMs: number;
+    }
+  | {
+      success: false;
+      requestId: string;
+      error: {
+        category: string;
+        message: string;
+        shouldRetry: boolean;
+      };
+      latencyMs: number;
+    };
+
+/**
+ * Minimal HealthCheckResult interface
+ */
+interface HealthCheckResultLike {
+  healthy: boolean;
+  message?: string | undefined;
+  latencyMs: number;
+}
+
+/**
+ * Minimal ProviderRegistry interface
+ */
+export interface ProviderRegistryLike {
+  get(providerId: string): LLMProviderLike | undefined;
+  getAll(): LLMProviderLike[];
+  has(providerId: string): boolean;
+}
+
+/**
+ * Options for creating the provider bridge
+ */
+export interface ProviderBridgeOptions {
+  /**
+   * Default timeout per provider call in milliseconds
+   */
+  defaultTimeoutMs?: number | undefined;
+
+  /**
+   * Default max tokens per response
+   */
+  defaultMaxTokens?: number | undefined;
+
+  /**
+   * Whether to perform health checks before considering a provider available
+   */
+  performHealthChecks?: boolean | undefined;
+
+  /**
+   * Cache health check results for this many milliseconds
+   */
+  healthCheckCacheMs?: number | undefined;
+}
+
+/**
+ * Creates a DiscussionProviderExecutor that bridges to a ProviderRegistry
+ *
+ * @param registry - The provider registry to bridge to
+ * @param options - Bridge configuration options
+ * @returns A DiscussionProviderExecutor implementation
+ */
+export function createProviderBridge(
+  registry: ProviderRegistryLike,
+  options: ProviderBridgeOptions = {}
+): DiscussionProviderExecutor {
+  const {
+    defaultTimeoutMs = 120000,
+    defaultMaxTokens = 4000,
+    performHealthChecks = true,
+    healthCheckCacheMs = 60000,
+  } = options;
+
+  // Cache for health check results
+  const healthCache = new Map<string, { healthy: boolean; timestamp: number }>();
+
+  return {
+    async execute(request: ProviderExecuteRequest): Promise<ProviderExecuteResult> {
+      const startTime = Date.now();
+      const { providerId, prompt, systemPrompt, temperature, maxTokens, timeoutMs } = request;
+
+      // Get provider from registry
+      const provider = registry.get(providerId);
+
+      if (!provider) {
+        return {
+          success: false,
+          error: `Provider ${providerId} not found in registry`,
+          retryable: false,
+          durationMs: Date.now() - startTime,
+        };
+      }
+
+      try {
+        // Check abort signal
+        if (request.abortSignal?.aborted) {
+          return {
+            success: false,
+            error: 'Request aborted',
+            retryable: false,
+            durationMs: Date.now() - startTime,
+          };
+        }
+
+        // Build messages array
+        const messages: CompletionRequestLike['messages'] = [];
+
+        if (systemPrompt) {
+          messages.push({ role: 'system', content: systemPrompt });
+        }
+
+        messages.push({ role: 'user', content: prompt });
+
+        // Build completion request
+        const completionRequest: CompletionRequestLike = {
+          requestId: `discuss-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
+          model: 'default',
+          messages,
+          maxTokens: maxTokens ?? defaultMaxTokens,
+          temperature: temperature ?? 0.7,
+          timeout: timeoutMs ?? defaultTimeoutMs,
+        };
+
+        // Execute the completion
+        const response = await provider.complete(completionRequest);
+
+        if (response.success) {
+          return {
+            success: true,
+            content: response.content,
+            durationMs: response.latencyMs,
+            tokenCount: response.usage.totalTokens,
+          };
+        } else {
+          return {
+            success: false,
+            error: response.error.message,
+            retryable: response.error.shouldRetry,
+            durationMs: response.latencyMs,
+          };
+        }
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+
+        return {
+          success: false,
+          error: errorMessage,
+          retryable: true, // Assume retryable for unexpected errors
+          durationMs: Date.now() - startTime,
+        };
+      }
+    },
+
+    async isAvailable(providerId: string): Promise<boolean> {
+      const provider = registry.get(providerId);
+
+      if (!provider) {
+        return false;
+      }
+
+      // Check cache first
+      const cached = healthCache.get(providerId);
+      if (cached && Date.now() - cached.timestamp < healthCheckCacheMs) {
+        return cached.healthy;
+      }
+
+      // Perform health check if enabled
+      if (performHealthChecks) {
+        try {
+          const health = await provider.checkHealth();
+          healthCache.set(providerId, {
+            healthy: health.healthy,
+            timestamp: Date.now(),
+          });
+          return health.healthy;
+        } catch {
+          healthCache.set(providerId, {
+            healthy: false,
+            timestamp: Date.now(),
+          });
+          return false;
+        }
+      }
+
+      // If health checks disabled, just check if provider exists
+      return true;
+    },
+
+    async getAvailableProviders(): Promise<string[]> {
+      const allProviders = registry.getAll();
+      const available: string[] = [];
+
+      // Check each provider's availability
+      for (const provider of allProviders) {
+        // Check cache first
+        const cached = healthCache.get(provider.providerId);
+        if (cached && Date.now() - cached.timestamp < healthCheckCacheMs) {
+          if (cached.healthy) {
+            available.push(provider.providerId);
+          }
+          continue;
+        }
+
+        // Perform health check if enabled
+        if (performHealthChecks) {
+          try {
+            const health = await provider.checkHealth();
+            healthCache.set(provider.providerId, {
+              healthy: health.healthy,
+              timestamp: Date.now(),
+            });
+            if (health.healthy) {
+              available.push(provider.providerId);
+            }
+          } catch {
+            healthCache.set(provider.providerId, {
+              healthy: false,
+              timestamp: Date.now(),
+            });
+          }
+        } else {
+          // If health checks disabled, assume available
+          available.push(provider.providerId);
+        }
+      }
+
+      return available;
+    },
+  };
+}
+
+/**
+ * Creates a provider bridge with a custom provider map (for testing)
+ *
+ * @param providers - Map of provider ID to execute function
+ * @returns A DiscussionProviderExecutor implementation
+ */
+export function createSimpleProviderBridge(
+  providers: Map<
+    string,
+    (prompt: string, systemPrompt?: string) => Promise<{ content: string; tokenCount?: number }>
+  >
+): DiscussionProviderExecutor {
+  return {
+    async execute(request: ProviderExecuteRequest): Promise<ProviderExecuteResult> {
+      const startTime = Date.now();
+      const { providerId, prompt, systemPrompt } = request;
+
+      const executeFunc = providers.get(providerId);
+
+      if (!executeFunc) {
+        return {
+          success: false,
+          error: `Provider ${providerId} not available`,
+          retryable: false,
+          durationMs: Date.now() - startTime,
+        };
+      }
+
+      try {
+        if (request.abortSignal?.aborted) {
+          return {
+            success: false,
+            error: 'Request aborted',
+            retryable: false,
+            durationMs: Date.now() - startTime,
+          };
+        }
+
+        const result = await executeFunc(prompt, systemPrompt);
+
+        return {
+          success: true,
+          content: result.content,
+          durationMs: Date.now() - startTime,
+          tokenCount: result.tokenCount,
+        };
+      } catch (error) {
+        return {
+          success: false,
+          error: error instanceof Error ? error.message : String(error),
+          retryable: true,
+          durationMs: Date.now() - startTime,
+        };
+      }
+    },
+
+    async isAvailable(providerId: string): Promise<boolean> {
+      return providers.has(providerId);
+    },
+
+    async getAvailableProviders(): Promise<string[]> {
+      return Array.from(providers.keys());
+    },
+  };
+}

package/src/types.ts

@@ -0,0 +1,375 @@
+/**
+ * Discussion Domain Types
+ *
+ * Core types and interfaces for multi-model discussion orchestration.
+ */
+
+import type {
+  DiscussionPattern,
+  DiscussStepConfig,
+  DiscussionRound,
+  ConsensusResult,
+  ConsensusMethod,
+  VotingResults,
+} from '@defai.digital/contracts';
+
+// ============================================================================
+// Provider Executor Interface
+// ============================================================================
+
+/**
+ * Interface for executing prompts against LLM providers.
+ *
+ * This is a port interface that will be implemented by the provider adapters.
+ * The discussion domain depends on this abstraction, not concrete providers.
+ *
+ * Invariants:
+ * - INV-DISC-100: Provider availability must be checked before discussions
+ * - INV-DISC-102: Provider timeout must be enforced
+ */
+export interface DiscussionProviderExecutor {
+  /**
+   * Execute a prompt against a specific provider
+   */
+  execute(request: ProviderExecuteRequest): Promise<ProviderExecuteResult>;
+
+  /**
+   * Check if a provider is available/healthy
+   */
+  isAvailable(providerId: string): Promise<boolean>;
+
+  /**
+   * Get list of available providers
+   */
+  getAvailableProviders(): Promise<string[]>;
+}
+
+/**
+ * Request to execute a prompt against a provider
+ */
+export interface ProviderExecuteRequest {
+  /** Provider to use (e.g., 'claude', 'glm', 'qwen', 'gemini') */
+  providerId: string;
+
+  /** The prompt to send */
+  prompt: string;
+
+  /** System prompt/context */
+  systemPrompt?: string | undefined;
+
+  /** Temperature (0-2) */
+  temperature?: number | undefined;
+
+  /** Max tokens for response */
+  maxTokens?: number | undefined;
+
+  /** Timeout in milliseconds */
+  timeoutMs?: number | undefined;
+
+  /** Abort signal for cancellation */
+  abortSignal?: AbortSignal | undefined;
+}
+
+/**
+ * Result from provider execution
+ */
+export interface ProviderExecuteResult {
+  /** Whether execution succeeded */
+  success: boolean;
+
+  /** Response content */
+  content?: string | undefined;
+
+  /** Error message if failed */
+  error?: string | undefined;
+
+  /** Whether error is retryable */
+  retryable?: boolean | undefined;
+
+  /** Duration in milliseconds */
+  durationMs: number;
+
+  /** Token count if available */
+  tokenCount?: number | undefined;
+
+  /** Whether response was truncated */
+  truncated?: boolean | undefined;
+}
+
+// ============================================================================
+// Pattern Executor Interface
+// ============================================================================
+
+/**
+ * Context passed to pattern executors
+ */
+export interface PatternExecutionContext {
+  /** The discussion configuration */
+  config: DiscussStepConfig;
+
+  /** Provider executor for making calls */
+  providerExecutor: DiscussionProviderExecutor;
+
+  /** Providers that are available */
+  availableProviders: string[];
+
+  /** Abort signal for cancellation */
+  abortSignal?: AbortSignal | undefined;
+
+  /** Trace ID for debugging */
+  traceId?: string | undefined;
+
+  /** Callback for progress updates */
+  onProgress?: ((event: DiscussionProgressEvent) => void) | undefined;
+}
+
+/**
+ * Progress event during discussion execution
+ */
+export interface DiscussionProgressEvent {
+  type: 'round_start' | 'provider_start' | 'provider_complete' | 'round_complete' | 'synthesis_start' | 'synthesis_complete';
+  round?: number | undefined;
+  provider?: string | undefined;
+  message?: string | undefined;
+  timestamp: string;
+}
+
+/**
+ * Result from pattern execution
+ */
+export interface PatternExecutionResult {
+  /** All discussion rounds */
+  rounds: DiscussionRound[];
+
+  /** Providers that participated successfully */
+  participatingProviders: string[];
+
+  /** Providers that failed */
+  failedProviders: string[];
+
+  /** Total duration in milliseconds */
+  totalDurationMs: number;
+
+  /** Whether execution succeeded (enough providers participated) */
+  success: boolean;
+
+  /** Error if execution failed */
+  error?: string | undefined;
+}
+
+/**
+ * Interface for discussion pattern executors
+ */
+export interface PatternExecutor {
+  /** Pattern type this executor handles */
+  readonly pattern: DiscussionPattern;
+
+  /**
+   * Execute the discussion pattern
+   */
+  execute(context: PatternExecutionContext): Promise<PatternExecutionResult>;
+}
+
+// ============================================================================
+// Consensus Executor Interface
+// ============================================================================
+
+/**
+ * Context for consensus execution
+ */
+export interface ConsensusExecutionContext {
+  /** Original topic/prompt */
+  topic: string;
+
+  /** All discussion rounds */
+  rounds: DiscussionRound[];
+
+  /** Providers that participated */
+  participatingProviders: string[];
+
+  /** Consensus configuration */
+  config: DiscussStepConfig['consensus'];
+
+  /** Provider executor for synthesis calls */
+  providerExecutor: DiscussionProviderExecutor;
+
+  /** Abort signal */
+  abortSignal?: AbortSignal | undefined;
+
+  /** Progress callback */
+  onProgress?: ((event: DiscussionProgressEvent) => void) | undefined;
+}
+
+/**
+ * Result from consensus execution
+ */
+export interface ConsensusExecutionResult {
+  /** Synthesized final output */
+  synthesis: string;
+
+  /** Consensus details */
+  consensus: ConsensusResult;
+
+  /** Voting results if applicable */
+  votingResults?: VotingResults | undefined;
+
+  /** Duration in milliseconds */
+  durationMs: number;
+
+  /** Whether consensus was reached */
+  success: boolean;
+
+  /** Error if failed */
+  error?: string | undefined;
+}
+
+/**
+ * Interface for consensus mechanism executors
+ */
+export interface ConsensusExecutor {
+  /** Consensus method this executor handles */
+  readonly method: ConsensusMethod;
+
+  /**
+   * Execute consensus mechanism
+   */
+  execute(context: ConsensusExecutionContext): Promise<ConsensusExecutionResult>;
+}
+
+// ============================================================================
+// Discussion Executor Options
+// ============================================================================
+
+/**
+ * Options for creating a discussion executor
+ */
+export interface DiscussionExecutorOptions {
+  /** Provider executor implementation */
+  providerExecutor: DiscussionProviderExecutor;
+
+  /** Default timeout per provider in milliseconds */
+  defaultTimeoutMs?: number | undefined;
+
+  /** Whether to check provider health before starting */
+  checkProviderHealth?: boolean | undefined;
+
+  /** Trace ID for debugging */
+  traceId?: string | undefined;
+}
+
+// ============================================================================
+// Stub Provider Executor (for testing/development)
+// ============================================================================
+
+/**
+ * Stub provider executor that returns mock responses.
+ * Used for testing and development when real providers aren't available.
+ */
+export class StubProviderExecutor implements DiscussionProviderExecutor {
+  private availableProviders: Set<string>;
+  private responseDelay: number;
+
+  constructor(
+    providers: string[] = ['claude', 'glm', 'qwen', 'gemini'],
+    responseDelayMs = 100
+  ) {
+    this.availableProviders = new Set(providers);
+    this.responseDelay = responseDelayMs;
+  }
+
+  async execute(request: ProviderExecuteRequest): Promise<ProviderExecuteResult> {
+    const start = Date.now();
+
+    // Simulate network delay
+    await new Promise(resolve => setTimeout(resolve, this.responseDelay));
+
+    if (!this.availableProviders.has(request.providerId)) {
+      return {
+        success: false,
+        error: `Provider ${request.providerId} not available`,
+        retryable: false,
+        durationMs: Date.now() - start,
+      };
+    }
+
+    // Generate mock response based on provider
+    const content = this.generateMockResponse(request.providerId, request.prompt);
+
+    return {
+      success: true,
+      content,
+      durationMs: Date.now() - start,
+      tokenCount: content.length / 4, // Rough estimate
+    };
+  }
+
+  async isAvailable(providerId: string): Promise<boolean> {
+    return this.availableProviders.has(providerId);
+  }
+
+  async getAvailableProviders(): Promise<string[]> {
+    return Array.from(this.availableProviders);
+  }
+
+  private generateMockResponse(providerId: string, prompt: string): string {
+    const providerStyles: Record<string, string> = {
+      claude: 'From a nuanced reasoning perspective',
+      glm: 'From a practical implementation standpoint',
+      qwen: 'Considering multilingual and mathematical aspects',
+      gemini: 'Based on extensive research and analysis',
+      codex: 'From a code-centric viewpoint',
+      grok: 'With real-time context in mind',
+    };
+
+    const style = providerStyles[providerId] || 'In my analysis';
+    const topicPreview = prompt.slice(0, 100).replace(/\n/g, ' ');
+
+    // Check if this is a voting prompt
+    if (prompt.includes('Your Vote:') || prompt.includes('evaluating options')) {
+      // Extract options from prompt - try numbered list format first (1. Option)
+      const numberedPattern = /^\d+\.\s*(.+)$/gm;
+      const matches = [...prompt.matchAll(numberedPattern)];
+      let options: string[];
+
+      if (matches.length >= 2) {
+        options = matches.map(m => m[1] ? m[1].trim() : '').filter(Boolean);
+      } else {
+        // Try comma-separated format
+        const optionsMatch = /Options:\s*([^\n]+)/i.exec(prompt);
+        options = optionsMatch?.[1]
+          ? optionsMatch[1].split(/[,;]/).map(o => o.trim()).filter(Boolean)
+          : ['Yes', 'No'];
+      }
+
+      const chosenOption = options[Math.floor(Math.random() * options.length)] || 'Yes';
+      const confidence = 70 + Math.floor(Math.random() * 25); // 70-94%
+
+      return `${style}, evaluating the options:\n\n` +
+        `After careful consideration of each option:\n\n` +
+        `Your Vote: [${chosenOption}]\n` +
+        `Confidence: [${confidence}%]\n\n` +
+        `Reasoning: This option best aligns with the requirements because ` +
+        `it offers the most balanced approach. ${providerId} recommends this ` +
+        `based on practical experience and technical merit.\n`;
+    }
+
+    return `${style}, regarding "${topicPreview}...":\n\n` +
+      `This is a mock response from ${providerId}. ` +
+      `In a real discussion, this would contain the provider's unique perspective ` +
+      `based on its strengths and training.\n\n` +
+      `Key points:\n` +
+      `1. First consideration from ${providerId}\n` +
+      `2. Second insight unique to this provider\n` +
+      `3. Practical recommendation\n`;
+  }
+
+  /** Add a provider to available set (for testing) */
+  addProvider(providerId: string): void {
+    this.availableProviders.add(providerId);
+  }
+
+  /** Remove a provider from available set (for testing) */
+  removeProvider(providerId: string): void {
+    this.availableProviders.delete(providerId);
+  }
+}