nova-terminal-assistant 0.1.0

package/src/core/model/ModelValidator.ts

@@ -0,0 +1,348 @@
+// ============================================================================
+// ModelValidator - Validates model availability and provider configuration
+// ============================================================================
+
+import fetch from 'node-fetch';
+import { AuthManager } from '../auth/AuthManager.js';
+
+export interface ProviderValidationResult {
+  isConfigured: boolean;
+  isAccessible: boolean;
+  error?: string;
+  models: string[];
+}
+
+export interface ModelValidationResult {
+  provider: string;
+  modelId: string;
+  isValid: boolean;
+  error?: string;
+  displayName?: string;
+}
+
+export class ModelValidator {
+  private authManager: any;
+
+  /**
+   * Validate if a provider is properly configured and accessible
+   */
+  async validateProvider(providerName: string): Promise<ProviderValidationResult> {
+    // Check if provider is configured
+    const isConfigured = this.authManager.hasCredentials(providerName);
+    if (!isConfigured) {
+      return {
+        isConfigured: false,
+        isAccessible: false,
+        error: `Provider "${providerName}" not configured`,
+        models: []
+      };
+    }
+
+    try {
+      switch (providerName.toLowerCase()) {
+        case 'ollama':
+          return await this.validateOllama();
+        case 'ollama-cloud':
+          return await this.validateOllamaCloud();
+        default:
+          return await this.validateApiProvider(providerName);
+      }
+    } catch (error) {
+      return {
+        isConfigured: true,
+        isAccessible: false,
+        error: `Failed to connect to ${providerName}: ${(error as Error).message}`,
+        models: []
+      };
+    }
+  }
+
+  /**
+   * Validate a specific model for a provider
+   */
+  async validateModel(providerName: string, modelId: string): Promise<ModelValidationResult> {
+    try {
+      const providerResult = await this.validateProvider(providerName);
+
+      if (!providerResult.isAccessible) {
+        return {
+          provider: providerName,
+          modelId,
+          isValid: false,
+          error: providerResult.error
+        };
+      }
+
+      // For API providers, basic validation is enough
+      if (this.isApiProvider(providerName)) {
+        return {
+          provider: providerName,
+          modelId,
+          isValid: true,
+          displayName: modelId
+        };
+      }
+
+      // For Ollama, check if model exists locally
+      if (providerName === 'ollama') {
+        return await this.validateOllamaModel(modelId);
+      }
+
+      return {
+        provider: providerName,
+        modelId,
+        isValid: true,
+        displayName: modelId
+      };
+
+    } catch (error) {
+      return {
+        provider: providerName,
+        modelId,
+        isValid: false,
+        error: `Validation failed: ${(error as Error).message}`
+      };
+    }
+  }
+
+  /**
+   * Get all available and validated models for all configured providers
+   */
+  async getValidatedModels(): Promise<Map<string, ModelValidationResult[]>> {
+    const result = new Map<string, ModelValidationResult[]>();
+
+    try {
+      // Get all providers from config
+      const { ConfigManager } = await import('../../../core/src/config/ConfigManager.js');
+      const config = ConfigManager.getInstance ? ConfigManager.getInstance() : new ConfigManager();
+      const providers = Object.keys(config.getConfig().models.providers);
+    } catch (error) {
+      console.warn(`⚠️  Could not load config: ${(error as Error).message}`);
+      return result; // Return empty map on error
+    }
+
+    for (const providerName of providers) {
+      const providerResult = await this.validateProvider(providerName);
+
+      if (providerResult.isAccessible && providerResult.models.length > 0) {
+        const models: ModelValidationResult[] = [];
+
+        // Validate each model in the provider
+        for (const modelId of providerResult.models) {
+          const modelResult = await this.validateModel(providerName, modelId);
+          if (modelResult.isValid) {
+            models.push(modelResult);
+          }
+        }
+
+        if (models.length > 0) {
+          result.set(providerName, models);
+        }
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Quick check if a provider is ready for use
+   */
+  isProviderReady(providerName: string): boolean {
+    if (!this.authManager.hasCredentials(providerName)) {
+      return false;
+    }
+
+    // Basic checks for common providers
+    switch (providerName.toLowerCase()) {
+      case 'ollama':
+        const ollamaCreds = this.authManager.getCredentials('ollama');
+        return !!ollamaCreds?.baseUrl || process.env.OLLAMA_HOST !== undefined;
+      case 'custom':
+        const customCreds = this.authManager.getCredentials('custom');
+        return !!(customCreds?.apiKey && customCreds?.baseUrl);
+      default:
+        // API providers just need an API key
+        return true;
+    }
+  }
+
+  private async validateOllama(): Promise<ProviderValidationResult> {
+    const baseUrl = this.authManager.getCredentials('ollama')?.baseUrl ||
+                   process.env.OLLAMA_HOST ||
+                   'http://localhost:11434';
+
+    try {
+      const response = await fetch(`${baseUrl}/api/tags`, {
+        method: 'GET',
+        timeout: 3000
+      });
+
+      if (!response.ok) {
+        return {
+          isConfigured: true,
+          isAccessible: false,
+          error: `Ollama server returned ${response.status}: ${response.statusText}`,
+          models: []
+        };
+      }
+
+      const data = await response.json() as { models: Array<{ name: string }> };
+      const modelNames = data.models.map(m => m.name);
+
+      return {
+        isConfigured: true,
+        isAccessible: true,
+        models: modelNames
+      };
+
+    } catch (error) {
+      return {
+        isConfigured: true,
+        isAccessible: false,
+        error: `Cannot connect to Ollama at ${baseUrl}: ${(error as Error).message}`,
+        models: []
+      };
+    }
+  }
+
+  private async validateOllamaCloud(): Promise<ProviderValidationResult> {
+    const apiKey = this.authManager.getCredentials('ollama-cloud')?.apiKey ||
+                  process.env.OLLAMA_API_KEY;
+
+    if (!apiKey) {
+      return {
+        isConfigured: false,
+        isAccessible: false,
+        error: 'Ollama Cloud API key not found',
+        models: []
+      };
+    }
+
+    try {
+      const baseUrl = this.authManager.getCredentials('ollama-cloud')?.baseUrl ||
+                     'https://ollama.com';
+
+      const response = await fetch(`${baseUrl}/api/tags`, {
+        headers: { 'Authorization': `Bearer ${apiKey}` },
+        timeout: 5000
+      });
+
+      if (!response.ok) {
+        return {
+          isConfigured: true,
+          isAccessible: false,
+          error: `Ollama Cloud returned ${response.status}: ${response.statusText}`,
+          models: []
+        };
+      }
+
+      const data = await response.json() as { models: Array<{ name: string }> };
+      const modelNames = data.models.map(m => m.name);
+
+      return {
+        isConfigured: true,
+        isAccessible: true,
+        models: modelNames
+      };
+
+    } catch (error) {
+      return {
+        isConfigured: true,
+        isAccessible: false,
+        error: `Cannot connect to Ollama Cloud: ${(error as Error).message}`,
+        models: []
+      };
+    }
+  }
+
+  private async validateApiProvider(providerName: string): Promise<ProviderValidationResult> {
+    // For API providers, we can't list models without making expensive calls
+    // So we return basic info and let the user try to use it
+    const creds = this.authManager.getCredentials(providerName);
+
+    if (!creds?.apiKey) {
+      return {
+        isConfigured: false,
+        isAccessible: false,
+        error: `API key not found for ${providerName}`,
+        models: []
+      };
+    }
+
+    // For now, return empty models array - actual model validation happens on use
+    return {
+      isConfigured: true,
+      isAccessible: true,
+      models: [] // Will be populated when actually used
+    };
+  }
+
+  private async validateOllamaModel(modelId: string): Promise<ModelValidationResult> {
+    try {
+      const validator = new ModelValidator();
+      const ollamaResult = await validator.validateOllama();
+
+      if (!ollamaResult.isAccessible) {
+        return {
+          provider: 'ollama',
+          modelId,
+          isValid: false,
+          error: ollamaResult.error
+        };
+      }
+
+      const modelExists = ollamaResult.models.includes(modelId);
+
+      return {
+        provider: 'ollama',
+        modelId,
+        isValid: modelExists,
+        displayName: modelExists ? modelId : undefined,
+        error: modelExists ? undefined : `Model "${modelId}" not found locally`
+      };
+
+    } catch (error) {
+      return {
+        provider: 'ollama',
+        modelId,
+        isValid: false,
+        error: `Failed to validate Ollama model: ${(error as Error).message}`
+      };
+    }
+  }
+
+  private isApiProvider(providerName: string): boolean {
+    const apiProviders = new Set([
+      'anthropic', 'openai', 'azure', 'google', 'deepseek',
+      'qwen', 'glm', 'moonshot', 'baichuan', 'minimax',
+      'yi', 'groq', 'mistral', 'together', 'perplexity',
+      'coding-plan-alibaba', 'coding-plan-tencent',
+      'coding-plan-volcengine', 'coding-plan-baidu',
+      'coding-plan-kimi', 'coding-plan-zhipu', 'coding-plan-minimax'
+    ]);
+
+    return apiProviders.has(providerName.toLowerCase());
+  }
+
+  private getEnvKeyName(provider: string): string {
+    const envMap: Record<string, string> = {
+      anthropic: 'ANTHROPIC_API_KEY',
+      openai: 'OPENAI_API_KEY',
+      google: 'GOOGLE_API_KEY',
+      deepseek: 'DEEPSEEK_API_KEY',
+      qwen: 'QWEN_API_KEY',
+      glm: 'GLM_API_KEY',
+      moonshot: 'MOONSHOT_API_KEY',
+      baichuan: 'BAICHUAN_API_KEY',
+      minimax: 'MINIMAX_API_KEY',
+      yi: 'YI_API_KEY',
+      groq: 'GROQ_API_KEY',
+      mistral: 'MISTRAL_API_KEY',
+      together: 'TOGETHER_API_KEY',
+      perplexity: 'PERPLEXITY_API_KEY',
+      'ollama-cloud': 'OLLAMA_API_KEY'
+    };
+
+    return envMap[provider] || `${provider.toUpperCase()}_API_KEY`;
+  }
+}

package/src/core/model/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,YAAY,EAAE,wBAAwB,EAAE,MAAM,kBAAkB,CAAC;AACjE,cAAc,YAAY,CAAC;AAC3B,cAAc,sBAAsB,CAAC"}

package/src/core/model/index.ts

@@ -0,0 +1,6 @@
+export { ModelClient } from './ModelClient.js';
+export type { CreateModelClientOptions } from './ModelClient.js';
+export { ModelConnectionTester } from './ModelConnectionTester.js';
+export type { ModelConnectionStatus, ProviderConnectionStatus } from './ModelConnectionTester.js';
+export * from './types.js';
+export * from './providers/index.js';

package/src/core/model/providers/AnthropicProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AnthropicProvider.d.ts","sourceRoot":"","sources":["AnthropicProvider.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,OAAO,EAA8D,MAAM,wBAAwB,CAAC;AAElH,OAAO,KAAK,EAAE,aAAa,EAAE,mBAAmB,EAAE,aAAa,EAAc,WAAW,EAAE,MAAM,aAAa,CAAC;AAK9G,MAAM,WAAW,uBAAuB;IACtC,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,qBAAa,iBAAkB,YAAW,aAAa;IACrD,QAAQ,CAAC,IAAI,eAAe;IAC5B,OAAO,CAAC,MAAM,CAAY;gBAEd,MAAM,EAAE,uBAAuB;IAQrC,QAAQ,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,aAAa,CAAC;IAsClF,MAAM,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,OAAO,EAAE,mBAAmB,GAAG,cAAc,CAAC,WAAW,CAAC;IAoEvF,WAAW,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC;IAWvD,OAAO,CAAC,eAAe;IAsCvB,OAAO,CAAC,YAAY;IAQpB,OAAO,CAAC,sBAAsB;IAa9B,OAAO,CAAC,YAAY;IAUpB,OAAO,CAAC,iBAAiB;CAS1B"}

package/src/core/model/providers/AnthropicProvider.ts

@@ -0,0 +1,279 @@
+// ============================================================================
+// Anthropic Provider - Claude API integration
+// ============================================================================
+
+import Anthropic from '@anthropic-ai/sdk';
+import type { Message, ContentBlock, ToolUseContent, ToolResultContent, SessionId } from '../../types/session.js';
+import type { ToolDefinition } from '../../types/tools.js';
+import type { ModelProvider, ModelRequestOptions, ModelResponse, TokenUsage, StreamEvent } from '../types.js';
+import { ModelError, RateLimitError } from '../../types/errors.js';
+import { createToolCallId, createMessageId } from '../../types/session.js';
+import { tokenCounter } from '../../utils/TokenCounter.js';
+
+export interface AnthropicProviderConfig {
+  apiKey: string;
+  baseUrl?: string;
+  model: string;
+  apiVersion?: string;
+}
+
+export class AnthropicProvider implements ModelProvider {
+  readonly name = 'Anthropic';
+  private client: Anthropic;
+  private enableCache: boolean;
+
+  constructor(config: AnthropicProviderConfig & { enableCache?: boolean }) {
+    this.client = new Anthropic({
+      apiKey: config.apiKey,
+      baseURL: config.baseUrl,
+      ...(config.apiVersion && { defaultHeaders: { 'anthropic-version': config.apiVersion } }),
+    });
+    this.enableCache = config.enableCache !== false; // Default to true
+  }
+
+  async complete(messages: Message[], options: ModelRequestOptions): Promise<ModelResponse> {
+    try {
+      const anthropicMessages = this.convertMessages(messages);
+      
+      // Convert tools with cache control if caching is enabled
+      const anthropicTools = this.convertTools(options.tools);
+      
+      // Prepare params
+      const params: any = {
+        model: options.model,
+        max_tokens: options.maxTokens,
+        messages: anthropicMessages,
+        ...(anthropicTools.length > 0 && { tools: anthropicTools }),
+        ...(options.stopSequences && options.stopSequences.length > 0 && { stop_sequences: options.stopSequences }),
+      };
+      
+      // Add system prompt with cache control if enabled
+      if (options.systemPrompt) {
+        if (this.enableCache && options.thinking !== 'disabled') {
+          params.system = [
+            {
+              type: 'text',
+              text: options.systemPrompt,
+              cache_control: { type: 'ephemeral' }
+            }
+          ];
+        } else {
+          params.system = options.systemPrompt;
+        }
+      }
+      
+      // Add beta header for caching
+      const requestOptions: any = {};
+      if (this.enableCache && options.thinking !== 'disabled') {
+        requestOptions.headers = {
+          'anthropic-beta': 'prompt-caching-2024-07-31'
+        };
+      }
+
+      const response = await this.client.messages.create(params, requestOptions);
+
+      const content = this.convertResponseContent(response.content);
+      const usage = this.convertUsage(response.usage);
+
+      return {
+        content,
+        model: response.model,
+        stopReason: this.convertStopReason(response.stop_reason),
+        usage,
+        sessionId: options.sessionId,
+      };
+    } catch (err) {
+      if (err instanceof Anthropic.APIError) {
+        if (err.status === 429) {
+          const retryAfter = parseInt(err.headers?.['retry-after'] || '60', 10) * 1000;
+          throw new RateLimitError(err.message, retryAfter, 'anthropic');
+        }
+        throw new ModelError(err.message, err.status, 'anthropic', err);
+      }
+      throw err;
+    }
+  }
+
+  async *stream(messages: Message[], options: ModelRequestOptions): AsyncGenerator<StreamEvent> {
+    try {
+      const anthropicMessages = this.convertMessages(messages);
+      
+      // Convert tools with cache control if caching is enabled
+      const anthropicTools = this.convertTools(options.tools);
+      
+      // Prepare params
+      const params: any = {
+        model: options.model,
+        max_tokens: options.maxTokens,
+        messages: anthropicMessages,
+        ...(anthropicTools.length > 0 && { tools: anthropicTools }),
+        stream: true,
+      };
+      
+      // Add system prompt with cache control if enabled
+      if (options.systemPrompt) {
+        if (this.enableCache && options.thinking !== 'disabled') {
+          params.system = [
+            {
+              type: 'text',
+              text: options.systemPrompt,
+              cache_control: { type: 'ephemeral' }
+            }
+          ];
+        } else {
+          params.system = options.systemPrompt;
+        }
+      }
+      
+      // Add beta header for caching
+      const requestOptions: any = {};
+      if (this.enableCache && options.thinking !== 'disabled') {
+        requestOptions.headers = {
+          'anthropic-beta': 'prompt-caching-2024-07-31'
+        };
+      }
+
+      const stream = await this.client.messages.create(params, requestOptions) as unknown as AsyncIterable<Anthropic.Messages.MessageStreamEvent>;
+
+      for await (const event of stream) {
+        if (event.type === 'message_start') {
+          yield { type: 'message_start', model: event.message.model };
+        } else if (event.type === 'content_block_start') {
+          if (event.content_block.type === 'text') {
+            // noop, deltas follow
+          } else if (event.content_block.type === 'tool_use') {
+            yield {
+              type: 'tool_call_start',
+              toolCallId: event.content_block.id,
+              toolName: event.content_block.name,
+            };
+          }
+        } else if (event.type === 'content_block_delta') {
+          if (event.delta.type === 'text_delta') {
+            yield { type: 'text_delta', delta: event.delta.text };
+          } else if ((event.delta as any).type === 'thinking_delta') {
+            yield { type: 'thinking_delta', delta: (event.delta as any).thinking };
+          } else if (event.delta.type === 'input_json_delta') {
+            yield {
+              type: 'tool_call_delta',
+              toolCallId: (event as Anthropic.ContentBlockDeltaEvent).index?.toString() || '',
+              delta: event.delta.partial_json,
+            };
+          }
+        } else if (event.type === 'content_block_stop') {
+          // noop
+        } else if (event.type === 'message_delta') {
+          if (event.delta.stop_reason) {
+            const usage: TokenUsage = {
+              inputTokens: (event.usage as any)?.input_tokens ?? 0,
+              outputTokens: (event.usage as any)?.output_tokens ?? 0,
+            };
+            yield {
+              type: 'message_complete',
+              stopReason: this.convertStopReason(event.delta.stop_reason),
+              usage,
+            };
+          }
+        } else if (event.type === 'message_stop') {
+          // Stream complete
+        }
+      }
+    } catch (err) {
+      if (err instanceof Anthropic.APIError) {
+        yield { type: 'error', error: new ModelError(err.message, err.status, 'anthropic', err) };
+      } else {
+        yield { type: 'error', error: err };
+      }
+    }
+  }
+
+  async countTokens(messages: Message[]): Promise<number> {
+    // Approximate: ~4 chars per token
+    const text = messages.map(m => {
+      if (typeof m.content === 'string') return m.content;
+      return m.content.map(c => c.type === 'text' ? (c as any).text || '' : '').join('');
+    }).join('');
+    return Math.ceil(text.length / 4);
+  }
+
+  // --- Conversion helpers ---
+
+  private convertMessages(messages: Message[]): Anthropic.MessageParam[] {
+    const result: Anthropic.MessageParam[] = [];
+
+    for (const msg of messages) {
+      if (msg.role === 'system') continue; // System messages handled separately
+
+      if (msg.role === 'tool') {
+        const toolResults = msg.content
+          .filter((c): c is ToolResultContent => c.type === 'tool_result')
+          .map((c): Anthropic.ToolResultBlockParam => ({
+            type: 'tool_result',
+            tool_use_id: c.tool_use_id,
+            content: typeof c.content === 'string' ? c.content : c.content.map((cc) => 'text' in cc ? (cc as any).text || '' : '').join(''),
+            is_error: c.is_error,
+          }));
+
+        result.push({ role: 'user', content: toolResults });
+        continue;
+      }
+
+      const content = msg.content
+        .map((c) => {
+          if (c.type === 'text') return { type: 'text' as const, text: c.text };
+          if (c.type === 'tool_use') return { type: 'tool_use' as const, id: c.id, name: c.name, input: c.input };
+          if (c.type === 'image') return {
+            type: 'image' as const,
+            source: { type: c.source.type === 'url' ? 'url' : 'base64', media_type: c.source.media_type, data: c.source.data || c.source.url || '' },
+          };
+          return null;
+        })
+        .filter((c): c is NonNullable<typeof c> => c !== null) as Anthropic.ContentBlock[];
+
+      result.push({ role: msg.role as 'user' | 'assistant', content });
+    }
+
+    return result;
+  }
+
+  private convertTools(tools: ToolDefinition[]): Anthropic.Tool[] {
+    return tools.map((t) => ({
+      name: t.name,
+      description: t.description,
+      input_schema: t.inputSchema as Anthropic.Tool.InputSchema,
+    }));
+  }
+
+  private convertResponseContent(content: Anthropic.Message['content']): ContentBlock[] {
+    return content.map((block) => {
+      if (block.type === 'text') return { type: 'text' as const, text: block.text };
+      if (block.type === 'tool_use') return {
+        type: 'tool_use' as const,
+        id: createToolCallId(block.id),
+        name: block.name,
+        input: block.input as Record<string, unknown>,
+      };
+      return { type: 'text', text: JSON.stringify(block) };
+    });
+  }
+
+  private convertUsage(usage: Anthropic.Usage): TokenUsage {
+    const usageAny = usage as any;
+    return {
+      inputTokens: usage.input_tokens,
+      outputTokens: usage.output_tokens,
+      cacheReadTokens: usageAny.cache_read_input_tokens as number | undefined,
+      cacheWriteTokens: usageAny.cache_creation_input_tokens as number | undefined,
+    };
+  }
+
+  private convertStopReason(reason: string | null): ModelResponse['stopReason'] {
+    switch (reason) {
+      case 'end_turn': return 'end_turn';
+      case 'tool_use': return 'tool_use';
+      case 'max_tokens': return 'max_tokens';
+      case 'stop_sequence': return 'stop_sequence';
+      default: return 'end_turn';
+    }
+  }
+}

package/src/core/model/providers/CodingPlanProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CodingPlanProvider.d.ts","sourceRoot":"","sources":["CodingPlanProvider.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,wBAAwB,EAAE,KAAK,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AAEtG,uCAAuC;AACvC,MAAM,MAAM,kBAAkB,GAC1B,SAAS,GACT,SAAS,GACT,YAAY,GACZ,OAAO,GACP,MAAM,GACN,OAAO,GACP,SAAS,GACT,QAAQ,CAAC;AAEb,gCAAgC;AAChC,MAAM,WAAW,gBAAiB,SAAQ,IAAI,CAAC,sBAAsB,EAAE,SAAS,CAAC;IAC/E,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,yDAAyD;IACzD,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAoDD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,kBAAmB,SAAQ,wBAAwB;IAC9D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,kBAAkB,CAAC;IACtC,QAAQ,CAAC,eAAe,EAAE,MAAM,EAAE,CAAC;gBAEvB,MAAM,EAAE,gBAAgB;IAmCpC;;OAEG;IACH,kBAAkB,IAAI,MAAM,EAAE;IAI9B;;OAEG;IACH,eAAe,IAAI;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,kBAAkB,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE;IASlF;;OAEG;IACH,mBAAmB,IAAI,MAAM,GAAG,IAAI;CAIrC;AAED;;GAEG;AACH,wBAAgB,+BAA+B,IAAI,KAAK,CAAC;IACvD,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC,CASD;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,kBAAkB,EAC5B,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,aAAa,CAAC,EAAE,MAAM,GACrB,kBAAkB,CAOpB"}