@olane/o-intelligence 0.7.59 → 0.7.61

package/dist/src/base-intelligence-router.tool.d.ts

@@ -0,0 +1,135 @@
+/**
+ * BaseIntelligenceRouter - Abstract base class for intelligence routing tools
+ *
+ * This base class extracts common patterns from intelligence routers:
+ * - Secure storage access (getSecureValue)
+ * - Provider selection logic (getModelProvider, getProviderApiKey)
+ * - Request routing (chooseIntelligence)
+ * - Configuration management (_tool_configure)
+ * - Prompt execution (_tool_prompt)
+ *
+ * Subclasses implement:
+ * - createChildTools(): Returns array of provider tools to register
+ *
+ * This allows o-braintrust to extend with Braintrust-instrumented children
+ * while reusing all routing, API key management, and configuration logic.
+ */
+import { oAddress } from '@olane/o-core';
+import { oLaneTool } from '@olane/o-lane';
+import { oNodeToolConfig } from '@olane/o-node';
+import { ToolResult } from '@olane/o-tool';
+import { LLMProviders } from './enums/llm-providers.enum.js';
+export interface BaseIntelligenceRouterConfig extends oNodeToolConfig {
+    description?: string;
+}
+export interface PromptRequest {
+    params: {
+        userMessage?: string;
+        prompt: string;
+        _isStreaming?: boolean;
+    };
+    stream?: any;
+}
+export interface ConfigureRequest {
+    params: {
+        modelProvider?: LLMProviders;
+        hostingProvider?: string;
+        accessToken?: string;
+        address?: string;
+    };
+}
+/**
+ * Abstract base router for intelligence tools
+ *
+ * Usage (subclass example):
+ * ```typescript
+ * export class IntelligenceTool extends BaseIntelligenceRouter {
+ *   constructor(config: oNodeToolConfig) {
+ *     super({
+ *       ...config,
+ *       address: new oAddress('o://intelligence'),
+ *       methods: INTELLIGENCE_PARAMS,
+ *       description: 'Intelligence router',
+ *     });
+ *   }
+ *
+ *   protected createChildTools(): oLaneTool[] {
+ *     return [
+ *       new AnthropicIntelligenceTool({ parent: this.address, leader: this.leader }),
+ *       new OpenAIIntelligenceTool({ parent: this.address, leader: this.leader }),
+ *       // ... other providers
+ *     ];
+ *   }
+ * }
+ * ```
+ */
+export declare abstract class BaseIntelligenceRouter extends oLaneTool {
+    protected roundRobinIndex: number;
+    constructor(config: BaseIntelligenceRouterConfig & {
+        address: oAddress;
+        methods: any;
+    });
+    /**
+     * Abstract method: Create child provider tools
+     * Subclasses implement to return appropriate provider tools
+     * (standard HTTP-based or Braintrust-instrumented)
+     */
+    protected abstract createChildTools(): oLaneTool[];
+    /**
+     * Get secure value from vault
+     * ✅ Shared secure storage access
+     */
+    getSecureValue(key: string): Promise<string | null>;
+    /**
+     * Get model provider preference
+     * ✅ Shared provider selection logic
+     *
+     * Priority:
+     * 1. Environment variable MODEL_PROVIDER_CHOICE
+     * 2. Secure storage preference
+     * 3. Ask user (if o://human available)
+     * 4. Default to anthropic
+     */
+    getModelProvider(): Promise<{
+        provider: LLMProviders;
+    }>;
+    /**
+     * Get provider API key
+     * ✅ Shared API key retrieval logic
+     *
+     * Priority:
+     * 1. Environment variable (ANTHROPIC_API_KEY, OPENAI_API_KEY, etc.)
+     * 2. Secure storage
+     * 3. Ask user (if o://human available)
+     */
+    getProviderApiKey(provider: LLMProviders): Promise<{
+        apiKey: string;
+    }>;
+    /**
+     * Choose intelligence provider and get configuration
+     * ✅ Shared routing logic
+     */
+    chooseIntelligence(request: PromptRequest): Promise<{
+        choice: oAddress;
+        apiKey: string;
+        options: any;
+    }>;
+    /**
+     * Configure intelligence preferences
+     * ✅ Shared configuration management
+     */
+    _tool_configure(request: ConfigureRequest): Promise<ToolResult>;
+    /**
+     * Main prompt method - routes to appropriate provider
+     * ✅ Shared routing and streaming logic
+     *
+     * We cannot wrap this tool use in a plan because it is a core dependency in all planning
+     */
+    _tool_prompt(request: PromptRequest): Promise<ToolResult>;
+    /**
+     * Initialize router and register child provider tools
+     * ✅ Calls abstract createChildTools() for subclass customization
+     */
+    initialize(): Promise<void>;
+}
+//# sourceMappingURL=base-intelligence-router.tool.d.ts.map

package/dist/src/base-intelligence-router.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-intelligence-router.tool.d.ts","sourceRoot":"","sources":["../../src/base-intelligence-router.tool.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,QAAQ,EAAwB,MAAM,eAAe,CAAC;AAC/D,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,OAAO,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAE7D,MAAM,WAAW,4BAA6B,SAAQ,eAAe;IACnE,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE;QACN,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,MAAM,EAAE,MAAM,CAAC;QACf,YAAY,CAAC,EAAE,OAAO,CAAC;KACxB,CAAC;IACF,MAAM,CAAC,EAAE,GAAG,CAAC;CACd;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE;QACN,aAAa,CAAC,EAAE,YAAY,CAAC;QAC7B,eAAe,CAAC,EAAE,MAAM,CAAC;QACzB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB,CAAC;CACH;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,8BAAsB,sBAAuB,SAAQ,SAAS;IAC5D,SAAS,CAAC,eAAe,SAAK;gBAElB,MAAM,EAAE,4BAA4B,GAAG;QAAE,OAAO,EAAE,QAAQ,CAAC;QAAC,OAAO,EAAE,GAAG,CAAA;KAAE;IAqBtF;;;;OAIG;IACH,SAAS,CAAC,QAAQ,CAAC,gBAAgB,IAAI,SAAS,EAAE;IAElD;;;OAGG;IACG,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAmBzD;;;;;;;;;OASG;IACG,gBAAgB,IAAI,OAAO,CAAC;QAAE,QAAQ,EAAE,YAAY,CAAA;KAAE,CAAC;IA+D7D;;;;;;;;OAQG;IACG,iBAAiB,CAAC,QAAQ,EAAE,YAAY,GAAG,OAAO,CAAC;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IA0E5E;;;OAGG;IACG,kBAAkB,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC;QACxD,MAAM,EAAE,QAAQ,CAAC;QACjB,MAAM,EAAE,MAAM,CAAC;QACf,OAAO,EAAE,GAAG,CAAC;KACd,CAAC;IAYF;;;OAGG;IACG,eAAe,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,UAAU,CAAC;IAkDrE;;;;;OAKG;IACG,YAAY,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,UAAU,CAAC;IA4C/D;;;OAGG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;CAYlC"}

package/dist/src/base-intelligence-router.tool.js

@@ -0,0 +1,338 @@
+/**
+ * BaseIntelligenceRouter - Abstract base class for intelligence routing tools
+ *
+ * This base class extracts common patterns from intelligence routers:
+ * - Secure storage access (getSecureValue)
+ * - Provider selection logic (getModelProvider, getProviderApiKey)
+ * - Request routing (chooseIntelligence)
+ * - Configuration management (_tool_configure)
+ * - Prompt execution (_tool_prompt)
+ *
+ * Subclasses implement:
+ * - createChildTools(): Returns array of provider tools to register
+ *
+ * This allows o-braintrust to extend with Braintrust-instrumented children
+ * while reusing all routing, API key management, and configuration logic.
+ */
+import { oAddress, oResponse, CoreUtils } from '@olane/o-core';
+import { oLaneTool } from '@olane/o-lane';
+import { IntelligenceStorageKeys } from './enums/intelligence-storage-keys.enum.js';
+import { LLMProviders } from './enums/llm-providers.enum.js';
+/**
+ * Abstract base router for intelligence tools
+ *
+ * Usage (subclass example):
+ * ```typescript
+ * export class IntelligenceTool extends BaseIntelligenceRouter {
+ *   constructor(config: oNodeToolConfig) {
+ *     super({
+ *       ...config,
+ *       address: new oAddress('o://intelligence'),
+ *       methods: INTELLIGENCE_PARAMS,
+ *       description: 'Intelligence router',
+ *     });
+ *   }
+ *
+ *   protected createChildTools(): oLaneTool[] {
+ *     return [
+ *       new AnthropicIntelligenceTool({ parent: this.address, leader: this.leader }),
+ *       new OpenAIIntelligenceTool({ parent: this.address, leader: this.leader }),
+ *       // ... other providers
+ *     ];
+ *   }
+ * }
+ * ```
+ */
+export class BaseIntelligenceRouter extends oLaneTool {
+    constructor(config) {
+        super({
+            ...config,
+            description: config.description ||
+                'Tool to help route LLM requests to the best intelligence tool',
+            dependencies: config.dependencies || [
+                {
+                    address: 'o://setup',
+                    parameters: [
+                        {
+                            name: 'intelligence',
+                            type: 'string',
+                            description: 'The intelligence tool to use',
+                        },
+                    ],
+                },
+            ],
+        });
+        this.roundRobinIndex = 0;
+    }
+    /**
+     * Get secure value from vault
+     * ✅ Shared secure storage access
+     */
+    async getSecureValue(key) {
+        try {
+            const response = await this.use(new oAddress('o://secure'), {
+                method: 'get',
+                params: {
+                    key: key,
+                },
+            });
+            const payload = response.result.data;
+            if (payload && payload.value) {
+                return payload.value;
+            }
+            return null;
+        }
+        catch (error) {
+            this.logger.error('Error getting secure value: ', error);
+            return null;
+        }
+    }
+    /**
+     * Get model provider preference
+     * ✅ Shared provider selection logic
+     *
+     * Priority:
+     * 1. Environment variable MODEL_PROVIDER_CHOICE
+     * 2. Secure storage preference
+     * 3. Ask user (if o://human available)
+     * 4. Default to anthropic
+     */
+    async getModelProvider() {
+        // Check ENV vars for override
+        if (process.env.MODEL_PROVIDER_CHOICE) {
+            if (Object.values(LLMProviders).includes(process.env.MODEL_PROVIDER_CHOICE)) {
+                return {
+                    provider: process.env.MODEL_PROVIDER_CHOICE,
+                };
+            }
+            throw new Error('Invalid model provider choice, please set the MODEL_PROVIDER_CHOICE environment variable to a valid model provider');
+        }
+        let model = LLMProviders.ANTHROPIC;
+        // Check secure storage for preference
+        const modelProviderStored = await this.getSecureValue(IntelligenceStorageKeys.MODEL_PROVIDER_PREFERENCE);
+        if (modelProviderStored) {
+            model = modelProviderStored;
+            return {
+                provider: model,
+            };
+        }
+        // No preference found, ask the human
+        this.logger.info('Asking human for model selection...');
+        try {
+            const modelResponse = await this.use(new oAddress('o://human'), {
+                method: 'question',
+                params: {
+                    question: 'Which AI model do you want to use? (anthropic, openai, ollama, perplexity, grok)',
+                },
+            });
+            // Process the human response
+            const { answer: modelHuman } = modelResponse.result.data;
+            model = modelHuman.toLowerCase();
+            await this.use(new oAddress('o://secure'), {
+                method: 'put',
+                params: {
+                    key: IntelligenceStorageKeys.MODEL_PROVIDER_PREFERENCE,
+                    value: model,
+                },
+            });
+        }
+        catch (error) {
+            this.logger.warn('Defaulting to anthropic');
+            model = LLMProviders.ANTHROPIC;
+        }
+        return {
+            provider: model,
+        };
+    }
+    /**
+     * Get provider API key
+     * ✅ Shared API key retrieval logic
+     *
+     * Priority:
+     * 1. Environment variable (ANTHROPIC_API_KEY, OPENAI_API_KEY, etc.)
+     * 2. Secure storage
+     * 3. Ask user (if o://human available)
+     */
+    async getProviderApiKey(provider) {
+        // Leverage the ENV vars first
+        const ENV_KEYS = [
+            {
+                key: process.env.ANTHROPIC_API_KEY,
+                address: 'o://anthropic',
+                name: 'anthropic',
+            },
+            {
+                key: process.env.OPENAI_API_KEY,
+                address: 'o://openai',
+                name: 'openai',
+            },
+            {
+                key: process.env.SONAR_API_KEY,
+                address: 'o://sonar',
+                name: 'sonar',
+            },
+            {
+                key: process.env.GEMINI_API_KEY,
+                address: 'o://gemini',
+                name: 'gemini',
+            },
+            {
+                key: process.env.GROK_API_KEY,
+                address: 'o://grok',
+                name: 'grok',
+            },
+        ];
+        const modelEnvConfig = ENV_KEYS.find((key) => key.name === provider);
+        if (modelEnvConfig && !!modelEnvConfig.key) {
+            return {
+                apiKey: modelEnvConfig.key,
+            };
+        }
+        let apiKey = '';
+        // Check secure storage 2nd
+        const apiKeyStored = await this.getSecureValue(`${provider}-${IntelligenceStorageKeys.API_KEY_SUFFIX}`);
+        if (apiKeyStored) {
+            return {
+                apiKey: apiKeyStored,
+            };
+        }
+        // No preference found, ask the human
+        this.logger.info('Asking human for API key...');
+        const keyResponse = await this.use(new oAddress('o://human'), {
+            method: 'question',
+            params: {
+                question: `What is the API key for the ${provider} model?`,
+            },
+        });
+        // Process the human response
+        const { answer: key } = keyResponse.result.data;
+        apiKey = key;
+        await this.use(new oAddress('o://secure'), {
+            method: 'put',
+            params: {
+                key: `${provider}-${IntelligenceStorageKeys.API_KEY_SUFFIX}`,
+                value: key,
+            },
+        });
+        return {
+            apiKey: apiKey,
+        };
+    }
+    /**
+     * Choose intelligence provider and get configuration
+     * ✅ Shared routing logic
+     */
+    async chooseIntelligence(request) {
+        // Check to see if provider key is in vault
+        const { provider } = await this.getModelProvider();
+        const { apiKey } = await this.getProviderApiKey(provider);
+        return {
+            choice: new oAddress(`o://${provider}`),
+            apiKey,
+            options: {},
+        };
+    }
+    /**
+     * Configure intelligence preferences
+     * ✅ Shared configuration management
+     */
+    async _tool_configure(request) {
+        const { modelProvider, hostingProvider, accessToken, address } = request.params;
+        if (hostingProvider) {
+            await this.use(new oAddress('o://secure'), {
+                method: 'put',
+                params: {
+                    key: `${IntelligenceStorageKeys.HOSTING_PROVIDER_PREFERENCE}`,
+                    value: hostingProvider,
+                },
+            });
+        }
+        if (accessToken) {
+            await this.use(new oAddress('o://secure'), {
+                method: 'put',
+                params: {
+                    key: `${IntelligenceStorageKeys.ACCESS_TOKEN}`,
+                    value: accessToken,
+                },
+            });
+        }
+        if (address) {
+            await this.use(new oAddress('o://secure'), {
+                method: 'put',
+                params: {
+                    key: `${IntelligenceStorageKeys.OLANE_ADDRESS}`,
+                    value: address,
+                },
+            });
+        }
+        if (modelProvider) {
+            await this.use(new oAddress('o://secure'), {
+                method: 'put',
+                params: {
+                    key: `${IntelligenceStorageKeys.MODEL_PROVIDER_PREFERENCE}`,
+                    value: modelProvider,
+                },
+            });
+        }
+        // ✅ Return raw data (not wrapped)
+        return {
+            success: true,
+        };
+    }
+    /**
+     * Main prompt method - routes to appropriate provider
+     * ✅ Shared routing and streaming logic
+     *
+     * We cannot wrap this tool use in a plan because it is a core dependency in all planning
+     */
+    async _tool_prompt(request) {
+        const { userMessage, prompt, _isStreaming = false } = request.params;
+        const stream = request.stream;
+        const intelligence = await this.chooseIntelligence(request);
+        const child = this.hierarchyManager.getChild(intelligence.choice);
+        const response = await this.useChild(child || intelligence.choice, {
+            method: 'completion',
+            params: {
+                _isStreaming: _isStreaming,
+                apiKey: intelligence.apiKey,
+                messages: !!userMessage
+                    ? [
+                        {
+                            role: 'assistant',
+                            content: prompt,
+                        },
+                        {
+                            role: 'user',
+                            content: userMessage,
+                        },
+                    ]
+                    : [
+                        {
+                            role: 'user',
+                            content: prompt,
+                        },
+                    ],
+            },
+        }, {
+            isStream: _isStreaming || false,
+            onChunk: async (chunk) => {
+                await CoreUtils.sendResponse(oResponse.fromJSON(chunk), stream);
+            },
+        });
+        return response.result.data;
+    }
+    /**
+     * Initialize router and register child provider tools
+     * ✅ Calls abstract createChildTools() for subclass customization
+     */
+    async initialize() {
+        await super.initialize();
+        const tools = this.createChildTools();
+        for (const tool of tools) {
+            tool.onInitFinished(() => {
+                this.addChildNode(tool);
+            });
+            await tool.start();
+        }
+    }
+}

package/dist/src/base-intelligence.tool.d.ts

@@ -0,0 +1,140 @@
+/**
+ * BaseIntelligenceTool - Abstract base class for LLM provider tools
+ *
+ * This base class extracts common patterns from all provider intelligence tools:
+ * - Validation (API keys, messages, prompts)
+ * - Error handling (throw errors, no error returns)
+ * - Streaming vs non-streaming patterns
+ * - Tool method templates (_tool_completion, _tool_generate, etc.)
+ *
+ * Provider-specific implementations extend this class and implement:
+ * - getApiKeyEnvVar(): Returns the environment variable name for the API key
+ * - callCompletion(params): Makes the actual API call for completion
+ * - streamCompletion(params): Handles streaming completion
+ * - callGenerate(params): Makes the actual API call for generation
+ * - streamGenerate(params): Handles streaming generation
+ *
+ * Subclasses can use either HTTP fetch() or official SDKs with Braintrust instrumentation.
+ */
+import { oLaneTool } from '@olane/o-lane';
+import { oNodeToolConfig, oStreamRequest } from '@olane/o-node';
+import { oAddress, oRequest } from '@olane/o-core';
+import { ToolResult } from '@olane/o-tool';
+export interface BaseIntelligenceConfig extends oNodeToolConfig {
+    apiKey?: string;
+    defaultModel?: string;
+}
+/**
+ * Abstract base class for intelligence provider tools
+ *
+ * Usage (subclass example):
+ * ```typescript
+ * export class AnthropicIntelligenceTool extends BaseIntelligenceTool {
+ *   constructor(config: oNodeToolConfig) {
+ *     super({
+ *       ...config,
+ *       address: new oAddress('o://anthropic'),
+ *       description: 'Anthropic LLM provider',
+ *       defaultModel: 'claude-sonnet-4-5-20250929',
+ *     });
+ *   }
+ *
+ *   protected getApiKeyEnvVar(): string {
+ *     return 'ANTHROPIC_API_KEY';
+ *   }
+ *
+ *   protected async callCompletion(params: any): Promise<ToolResult> {
+ *     // Anthropic-specific HTTP implementation or SDK call
+ *   }
+ *
+ *   protected async *streamCompletion(params: any): AsyncGenerator<ToolResult> {
+ *     // Anthropic-specific streaming implementation
+ *   }
+ * }
+ * ```
+ */
+export declare abstract class BaseIntelligenceTool extends oLaneTool {
+    protected defaultModel: string;
+    protected apiKey: string;
+    constructor(config: BaseIntelligenceConfig & {
+        address: oAddress;
+        description: string;
+        methods: any;
+    });
+    /**
+     * Abstract method: Get the environment variable name for the provider's API key
+     * Subclasses must implement this
+     */
+    protected abstract getApiKeyEnvVar(): string;
+    /**
+     * Abstract method: Call completion API (non-streaming)
+     * Subclasses implement with HTTP fetch() or SDK
+     *
+     * Must throw errors for validation failures
+     * Must return raw data (not wrapped in success object)
+     */
+    protected abstract callCompletion(params: any): Promise<ToolResult>;
+    /**
+     * Abstract method: Stream completion API
+     * Subclasses implement with HTTP fetch() or SDK streaming
+     *
+     * Must yield errors by throwing (generator will catch and wrap)
+     * Must yield raw data chunks
+     */
+    protected abstract streamCompletion(params: any): AsyncGenerator<ToolResult>;
+    /**
+     * Abstract method: Call generate API (non-streaming)
+     * Optional - some providers may not implement this
+     */
+    protected abstract callGenerate(params: any): Promise<ToolResult>;
+    /**
+     * Abstract method: Stream generate API
+     * Optional - some providers may not implement this
+     */
+    protected abstract streamGenerate(params: any): AsyncGenerator<ToolResult>;
+    /**
+     * Shared validation: API key
+     * ✅ Throws error for validation failure
+     */
+    protected validateApiKey(apiKey: string | undefined): void;
+    /**
+     * Shared validation: Messages array
+     * ✅ Throws error for validation failure
+     */
+    protected validateMessages(messages: any): void;
+    /**
+     * Shared validation: Prompt string
+     * ✅ Throws error for validation failure
+     */
+    protected validatePrompt(prompt: any): void;
+    /**
+     * Tool method: Chat completion
+     * ✅ Template method pattern - delegates to subclass
+     * ✅ Handles streaming vs non-streaming
+     * ✅ Throws errors (base class wraps them)
+     */
+    _tool_completion(request: oStreamRequest): Promise<ToolResult>;
+    /**
+     * Tool method: Text generation
+     * ✅ Template method pattern - delegates to subclass
+     * ✅ Handles streaming vs non-streaming
+     * ✅ Throws errors (base class wraps them)
+     */
+    _tool_generate(request: oStreamRequest): Promise<ToolResult>;
+    /**
+     * Tool method: List models
+     * Default implementation - subclasses can override
+     */
+    _tool_list_models(request: oRequest): Promise<ToolResult>;
+    /**
+     * Tool method: Get model info
+     * Default implementation - subclasses can override
+     */
+    _tool_model_info(request: oRequest): Promise<ToolResult>;
+    /**
+     * Tool method: Check API status
+     * Default implementation - subclasses can override
+     */
+    _tool_status(request: oRequest): Promise<ToolResult>;
+}
+//# sourceMappingURL=base-intelligence.tool.d.ts.map

package/dist/src/base-intelligence.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-intelligence.tool.d.ts","sourceRoot":"","sources":["../../src/base-intelligence.tool.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,EAAE,eAAe,EAAE,cAAc,EAAe,MAAM,eAAe,CAAC;AAC7E,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,MAAM,WAAW,sBAAuB,SAAQ,eAAe;IAC7D,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,8BAAsB,oBAAqB,SAAQ,SAAS;IAC1D,SAAS,CAAC,YAAY,EAAE,MAAM,CAAC;IAC/B,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC;gBAEb,MAAM,EAAE,sBAAsB,GAAG;QAAE,OAAO,EAAE,QAAQ,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,GAAG,CAAA;KAAE;IAUrG;;;OAGG;IACH,SAAS,CAAC,QAAQ,CAAC,eAAe,IAAI,MAAM;IAE5C;;;;;;OAMG;IACH,SAAS,CAAC,QAAQ,CAAC,cAAc,CAAC,MAAM,EAAE,GAAG,GAAG,OAAO,CAAC,UAAU,CAAC;IAEnE;;;;;;OAMG;IACH,SAAS,CAAC,QAAQ,CAAC,gBAAgB,CAAC,MAAM,EAAE,GAAG,GAAG,cAAc,CAAC,UAAU,CAAC;IAE5E;;;OAGG;IACH,SAAS,CAAC,QAAQ,CAAC,YAAY,CAAC,MAAM,EAAE,GAAG,GAAG,OAAO,CAAC,UAAU,CAAC;IAEjE;;;OAGG;IACH,SAAS,CAAC,QAAQ,CAAC,cAAc,CAAC,MAAM,EAAE,GAAG,GAAG,cAAc,CAAC,UAAU,CAAC;IAE1E;;;OAGG;IACH,SAAS,CAAC,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI;IAM1D;;;OAGG;IACH,SAAS,CAAC,gBAAgB,CAAC,QAAQ,EAAE,GAAG,GAAG,IAAI;IAS/C;;;OAGG;IACH,SAAS,CAAC,cAAc,CAAC,MAAM,EAAE,GAAG,GAAG,IAAI;IAS3C;;;;;OAKG;IACG,gBAAgB,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,UAAU,CAAC;IAiBpE;;;;;OAKG;IACG,cAAc,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,UAAU,CAAC;IAmBlE;;;OAGG;IACG,iBAAiB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IAI/D;;;OAGG;IACG,gBAAgB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IAI9D;;;OAGG;IACG,YAAY,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;CAG3D"}