@ank1015/providers 0.0.1 → 0.0.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Mario Zechner
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -2,7 +2,7 @@
 
 A provider abstraction layer for building agentic systems with multiple LLM providers. Built with a philosophy that **harnesses should be model-specific** while maintaining the ability to test and compose different models together.
 
-This documentation is written by claude. Most of the coding patterns are taken and inspired from [PI-mono](https://github.com/badlogic/pi-mono/tree/main)
+Most of the coding patterns are taken and inspired from [PI-mono](https://github.com/badlogic/pi-mono/tree/main)
 
 ## Philosophy
 
@@ -23,16 +23,7 @@ We achieve this by:
 
 - **🎯 Provider-Specific Implementations**: Each provider follows its own best practices
 - **🔄 Unified Streaming API**: Standardized event stream across all providers
-- **🤖 Agent Loop**: Multi-turn conversations with automatic tool execution
-- **🛠️ Type-Safe Tools**: TypeBox-powered JSON Schema validation
-- **💰 Cost Tracking**: Automatic token usage and cost calculation
-- **⚡ Real-Time Streaming**: 21 granular event types for UI updates
-- **🎨 Extended Thinking**: Support for reasoning/thinking modes
-
-## Supported Providers
-
-- **OpenAI**: GPT-5 series (Codex, Mini, Pro) with prompt caching and reasoning
-- **Google**: Gemini 2.5 Flash, Gemini 3 Pro with extended thinking
+- **💾 State Management**: Robust `Conversation` class to manage chat history, message queuing, and state persistence.
 
 ## Installation
 
@@ -40,414 +31,133 @@ We achieve this by:
 npm install @ank1015/providers
 ```
 
-Set up your API keys:
-```bash
-export OPENAI_API_KEY="your-key"
-export GEMINI_API_KEY="your-key"
-```
-
 ## Quick Start
 
-### Basic Streaming
+Here's how to create a simple agent that can perform calculations.
 
 ```typescript
-import { stream, MODELS } from "@ank1015/providers";
-
-const context = {
-  systemPrompt: "You are a helpful assistant.",
-  messages: [
-    {
-      role: "user",
-      content: [{ type: "text", content: "Hello!" }],
-      timestamp: Date.now(),
-    },
-  ],
-};
-
-const response = stream(MODELS.OPENAI_GPT5_MINI, context);
-
-for await (const event of response) {
-  if (event.type === "text_delta") {
-    process.stdout.write(event.delta);
+import { Conversation, calculateTool } from "@ank1015/providers";
+
+async function main() {
+  // 1. Initialize Conversation
+  // By default uses Gemini Flash, but you can configure any model
+  const conversation = new Conversation();
+  
+  // 2. Add Tools
+  // The SDK includes sample tools like 'calculate' for testing
+  conversation.setTools([calculateTool]);
+
+  // 3. Prompt the Agent
+  console.log("User: What is (123 * 45) + 9?");
+  const messages = await conversation.prompt("What is (123 * 45) + 9?");
+
+  // 4. Get the result
+  const lastMessage = messages[messages.length - 1];
+  
+  // content is an array of typed blocks (text, image, toolUse, etc.)
+  const responseContent = lastMessage.content.find(c => c.type === 'response');
+  
+  if (responseContent?.content[0].type === 'text') {
+    console.log("Agent:", responseContent.content[0].content);
   }
 }
-
-// Get the final native message (preserves provider-specific state)
-const nativeMessage = await response.result();
 ```
 
-### Agent Loop with Tools
-
-```typescript
-import { agentLoop, defineTool, MODELS } from "@ank1015/providers";
-import { Type } from "@sinclair/typebox";
-
-// Define tools with type-safe schemas
-const tools = [
-  defineTool({
-    name: "calculator",
-    description: "Perform mathematical calculations",
-    parameters: Type.Object({
-      expression: Type.String({ description: "Math expression to evaluate" }),
-    }),
-  }),
-] as const;
-
-// Create agent tools with execution logic
-const agentTools = tools.map((tool) => ({
-  ...tool,
-  label: "Calculator",
-  async execute(toolCallId, params, signal) {
-    const result = eval(params.expression); // Use a safe eval in production!
-    return {
-      content: [{ type: "text", content: `Result: ${result}` }],
-      details: { result },
-    };
-  },
-}));
-
-const context = {
-  systemPrompt: "You are a helpful assistant with access to a calculator.",
-  messages: [],
-  tools: agentTools,
-};
+## Usage
 
-const prompt = {
-  role: "user" as const,
-  content: [{ type: "text" as const, content: "What is 156 * 234?" }],
-  timestamp: Date.now(),
-};
+### 1. Configuration & Providers
 
-const config = {
-  model: MODELS.OPENAI_GPT5_MINI,
-  providerOptions: {},
-};
-
-const eventStream = agentLoop(prompt, context, config);
-
-for await (const event of eventStream) {
-  switch (event.type) {
-    case "message_update":
-      // Handle streaming assistant message
-      console.log("Assistant:", event.message);
-      break;
-    case "tool_execution_start":
-      console.log(`Executing tool: ${event.toolName}`);
-      break;
-    case "tool_execution_end":
-      console.log(`Result:`, event.result);
-      break;
-    case "agent_end":
-      console.log("Agent completed with status:", event.status);
-      break;
-  }
-}
-
-// Get all messages for conversation history
-const allMessages = await eventStream.result();
-```
-
-### Working with Different Providers
+You can switch providers easily by setting the provider configuration.
 
 ```typescript
-import { stream, MODELS } from "@ank1015/providers";
-
-// OpenAI with reasoning
-const openaiResponse = stream(MODELS.OPENAI_GPT5_MINI, context, {
-  reasoning: {
-    effort: "medium",
-    summaryStyle: "concise",
-  }
-});
-
-// Google with thinking
-const googleResponse = stream(MODELS.GOOGLE_GEMINI_2_5_FLASH, context, {
-  thinkingConfig: { extendedThinking: { level: "EXTENDED_THINKING_THINK_MODE" } },
-  temperature: 0.7,
-});
+import { Conversation } from "@ank1015/providers";
+import { getModel } from "@ank1015/providers/models";
 
-// Both return the same standardized stream format
-for await (const event of openaiResponse) {
-  // Handle events the same way regardless of provider
-}
-```
+const conversation = new Conversation();
 
-### Cost Tracking
+// Switch to OpenAI GPT-5.2 (Example Model ID from registry)
+const openAIModel = getModel('openai', 'gpt-5.2'); 
 
-```typescript
-for await (const event of response) {
-  if (event.type === "done") {
-    const { usage } = event.message;
-    console.log(`Tokens: ${usage.totalTokens}`);
-    console.log(`Cost: $${usage.cost.total.toFixed(4)}`);
-    console.log(`Input: ${usage.input} ($${usage.cost.input.toFixed(4)})`);
-    console.log(`Output: ${usage.output} ($${usage.cost.output.toFixed(4)})`);
-    if (usage.cacheRead > 0) {
-      console.log(`Cache Read: ${usage.cacheRead} ($${usage.cost.cacheRead.toFixed(4)})`);
-    }
-  }
+if (openAIModel) {
+    conversation.setProvider({
+        model: openAIModel,
+        providerOptions: {
+            apiKey: process.env.OPENAI_API_KEY
+        }
+    });
 }
 ```
 
-## Architecture
-
-### Message Storage Strategy
-
-```
-User Message ────────> Assistant Message ────────> Tool Result
-Standardized            Native Provider            Standardized
-✓ Can rebuild           ✗ Store as-is              ✓ Can rebuild
-```
-
-- **User Messages** & **Tool Results**: Stored in standardized format, can be converted to any provider
-- **Assistant Messages**: Stored in native provider format to preserve:
-  - Prompt caching state
-  - Thinking traces
-  - Internal provider state
-  - Response metadata
-
-### Streaming Events
+### 2. Defining Custom Tools
 
-The library provides 21 event types for granular control:
+Tools are defined using `TypeBox` for schema validation. This ensures the LLM generates arguments that match your code's expectations.
 
 ```typescript
-type AssistantMessageEvent =
-  | { type: "start"; partial: AssistantMessage }
-  | { type: "text_start"; contentIndex: number; partial: AssistantMessage }
-  | { type: "text_delta"; contentIndex: number; delta: string; partial: AssistantMessage }
-  | { type: "text_end"; contentIndex: number; content: string; partial: AssistantMessage }
-  | { type: "thinking_start"; contentIndex: number; partial: AssistantMessage }
-  | { type: "thinking_delta"; contentIndex: number; delta: string; partial: AssistantMessage }
-  | { type: "thinking_end"; contentIndex: number; content: string; partial: AssistantMessage }
-  | { type: "toolcall_start"; contentIndex: number; partial: AssistantMessage }
-  | { type: "toolcall_delta"; contentIndex: number; delta: string; partial: AssistantMessage }
-  | { type: "toolcall_end"; contentIndex: number; toolCall: AssistantToolCall; partial: AssistantMessage }
-  | { type: "done"; reason: StopReason; message: AssistantMessage }
-  | { type: "error"; reason: StopReason; error: AssistantMessage };
-```
-
-### Agent Loop Flow
-
-```
-Initial Prompt
-    ↓
-┌─────────────────────────┐
-│  While tool calls exist:│
-│  1. Stream response     │
-│  2. Execute tools       │
-│  3. Inject results      │
-│  4. Repeat              │
-└─────────────────────────┘
-    ↓
-Return all messages
-```
-
-The agent loop automatically handles multi-turn conversations with tool execution, preserving full conversation state.
-
-## API Reference
-
-### Core Functions
-
-#### `stream(model, context, options)`
-
-Stream an LLM response with standardized events.
-
-- **model**: Model object from `MODELS` registry
-- **context**: Conversation context with messages, system prompt, and tools
-- **options**: Provider-specific options (apiKey, temperature, reasoning, etc.)
-- **returns**: `AssistantMessageEventStream` (async iterable)
-
-#### `agentLoop(prompt, context, config, signal)`
-
-Run a multi-turn agent loop with automatic tool execution.
-
-- **prompt**: Initial user message
-- **context**: Agent context with messages, system prompt, and agent tools
-- **config**: Configuration with model, provider options, and optional preprocessor
-- **signal**: Optional AbortSignal for cancellation
-- **returns**: `EventStream<AgentEvent>` (async iterable)
-
-### Types
-
-#### `Message`
-
-Union type for all message types:
-```typescript
-type Message = UserMessage | NativeAssistantMessage | ToolResultMessage
-```
-
-#### `Tool`
-
-Type-safe tool definition:
-```typescript
-interface Tool<TParameters extends TSchema = TSchema> {
-  name: string;
-  description: string;
-  parameters: TParameters; // TypeBox JSON Schema
-}
-```
-
-#### `AgentTool`
-
-Extended tool with execution logic:
-```typescript
-interface AgentTool extends Tool {
-  label: string;
-  execute(
-    toolCallId: string,
-    params: Static<TParameters>,
-    signal?: AbortSignal
-  ): Promise<AgentToolResult>;
-}
-```
-
-### Utilities
-
-#### `defineTool(tool)`
+import { Type } from "@sinclair/typebox";
+import type { AgentTool } from "@ank1015/providers/agent/types";
 
-Helper for creating tools with better type inference:
-```typescript
-const tool = defineTool({
-  name: "search",
-  description: "Search the web",
-  parameters: Type.Object({
-    query: Type.String(),
-  }),
+// 1. Define the Schema
+const getWeatherSchema = Type.Object({
+    location: Type.String({ description: "The city and state, e.g. San Francisco, CA" }),
+    unit: Type.Optional(Type.Union([Type.Literal("celsius"), Type.Literal("fahrenheit")]))
 });
-```
-
-#### `calculateCost(model, usage)`
 
-Calculate costs based on token usage:
-```typescript
-import { calculateCost, MODELS } from "@ank1015/providers";
-
-const usage = {
-  input: 1000,
-  output: 500,
-  cacheRead: 200,
-  cacheWrite: 0,
-  totalTokens: 1700,
-  cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+// 2. Create the Tool Definition
+export const getWeatherTool: AgentTool<typeof getWeatherSchema> = {
+    name: "get_weather",
+    label: "Get Weather",
+    description: "Get the current weather for a location",
+    parameters: getWeatherSchema,
+    // 3. Implement Execution Logic
+    execute: async (toolCallId, args) => {
+        // args is fully typed here!
+        const { location, unit } = args;
+        
+        // Mock API call
+        return {
+            content: [{ type: "text", content: `Sunny, 25°C in ${location}` }],
+            details: { temp: 25, condition: "Sunny" }
+        };
+    }
 };
 
-calculateCost(MODELS.OPENAI_GPT5_MINI, usage);
-console.log(usage.cost.total); // Calculated cost in USD
+// 4. Register with Conversation
+conversation.setTools([getWeatherTool]);
 ```
 
-## Provider-Specific Features
+### 3. Streaming Events
 
-### OpenAI
+Subscribe to the conversation to receive real-time updates. This is crucial for building responsive UIs that show "thinking" states or streaming text.
 
 ```typescript
-stream(MODELS.OPENAI_GPT5_MINI, context, {
-  reasoning: {
-    effort: "low" | "medium" | "high",
-    summaryStyle: "concise" | "detailed",
-  },
-  parallelToolCalls: true,
-  prompt_cache_key: "unique-cache-key",
-  promptCacheRetention: "in-memory" | "24h",
-  maxOutputTokens: 4096,
-  temperature: 0.7,
-});
-```
-
-### Google
-
-```typescript
-stream(MODELS.GOOGLE_GEMINI_2_5_FLASH, context, {
-  thinkingConfig: {
-    extendedThinking: {
-      level: "EXTENDED_THINKING_THINK_MODE",
-    },
-  },
-  responseMimeType: "application/json",
-  imageConfig: {
-    aspectRatio: "ASPECT_RATIO_16_9",
-    size: "LARGE",
-  },
-  maxOutputTokens: 8192,
-  temperature: 0.7,
+conversation.subscribe((event) => {
+    switch (event.type) {
+        case "message_update":
+             // Can handle 'thinking_delta', 'text_delta', etc. inside the event.message
+            const msg = event.message;
+            if (msg.type === 'text_delta') {
+                process.stdout.write(msg.delta);
+            }
+            break;
+            
+        case "tool_execution_start":
+            console.log(`\nTool ${event.toolName} started...`);
+            break;
+            
+        case "tool_execution_end":
+            console.log(`Tool ${event.toolName} finished.`);
+            break;
+    }
 });
 ```
 
-## Design Principles
-
-1. **Model-Specific Best Practices**: Each provider implementation follows the provider's recommended patterns
-2. **State Preservation**: Native assistant messages preserve all provider-specific state
-3. **Type Safety**: TypeBox schemas provide compile-time and runtime validation
-4. **Stream-First**: All operations are async and support real-time updates
-5. **Cost Transparency**: Every response includes detailed token usage and costs
-6. **Graceful Degradation**: Validation falls back gracefully in restricted environments
-7. **Developer Experience**: Rich type inference and autocomplete support
-
-## Development
-
-```bash
-# Install dependencies
-npm install
-
-# Build
-npm run build
-
-# Watch mode
-npm run dev
-
-# Run tests
-npm run test
-
-# Lint and type check
-npm run check
-```
-
-## Project Structure
-
-```
-src/
-├── index.ts                 # Main exports
-├── types.ts                 # Core type definitions
-├── stream.ts                # Provider routing
-├── models.ts                # Cost calculation
-├── models.generated.ts      # Model registry
-├── agent/
-│   ├── agent-loop.ts       # Multi-turn agent orchestration
-│   └── types.ts            # Agent-specific types
-├── providers/
-│   ├── openai.ts           # OpenAI implementation
-│   ├── google.ts           # Google implementation
-│   └── convert.ts          # Message format conversion
-└── utils/
-    ├── event-stream.ts     # Async event streaming
-    ├── validation.ts       # Tool argument validation
-    ├── json-parse.ts       # Streaming JSON parser
-    └── sanitize-unicode.ts # Unicode sanitization
-```
-
-## Why This Architecture?
-
-Traditional LLM abstraction layers try to make all models interchangeable, leading to:
-- Lost provider-specific features (caching, thinking traces)
-- Lowest-common-denominator APIs
-- Poor utilization of each model's strengths
-
-Our approach:
-- ✅ Build provider-specific implementations following best practices
-- ✅ Preserve native state for optimal performance
-- ✅ Provide standardized interfaces for development flexibility
-- ✅ Enable model composition without forcing model switching
-- ✅ Support forking/conversion when truly needed
-
-The result: **You get the best of both worlds** - full provider capabilities without vendor lock-in.
-
-## Contributing
+## Architecture
 
-Contributions are welcome! Please feel free to submit issues or pull requests.
+- **`Conversation`**: The high-level state manager. It tracks the message history (`Memory`), handles message queuing (for handling rapid user inputs), and manages the `AgentRunner`.
+- **`AgentRunner`**: A stateless engine that executes the "Agent Protocol". It sends messages to the LLM, parses tool calls from the response, executes the tools, and feeds the results back to the LLM until a final response is reached or the loop terminates.
+- **`LLMClient`**: The low-level abstraction that standardizes API calls to OpenAI, Google, etc.
+- **`Utils`**: Includes powerful helpers like `parseStreamingJson` (for real-time tool visualization) and `isContextOverflow` (for handling token limits).
 
 ## License
 
 MIT
-
----
-
-**Built for developers who want to harness the full power of frontier models without sacrificing flexibility.**

package/dist/agent/conversation.d.ts

@@ -0,0 +1,97 @@
+import { Api, Message } from "../types.js";
+import { AgentEvent, AgentState, Attachment, Provider } from "./types.js";
+import { LLMClient } from "../llm.js";
+import { AgentRunner } from "./runner.js";
+export interface AgentOptions {
+    initialState?: Partial<AgentState>;
+    messageTransformer?: (messages: Message[]) => Message[] | Promise<Message[]>;
+    queueMode?: "all" | "one-at-a-time";
+    client?: LLMClient;
+    runner?: AgentRunner;
+}
+export declare class Conversation {
+    private client;
+    private runner;
+    private _state;
+    private listeners;
+    private abortController?;
+    private messageTransformer;
+    private messageQueue;
+    private queueMode;
+    private runningPrompt?;
+    private resolveRunningPrompt?;
+    private streamAssistantMessage;
+    constructor(opts?: AgentOptions);
+    get state(): AgentState;
+    subscribe(fn: (e: AgentEvent) => void): () => void;
+    private emit;
+    setStreamAssistantMessage(stream: boolean): void;
+    setSystemPrompt(v: string): void;
+    setProvider<TApi extends Api>(provider: Provider<TApi>): void;
+    setQueueMode(mode: "all" | "one-at-a-time"): void;
+    getQueueMode(): "all" | "one-at-a-time";
+    setTools(t: typeof this._state.tools): void;
+    replaceMessages(ms: Message[]): void;
+    appendMessage(m: Message): void;
+    appendMessages(ms: Message[]): void;
+    queueMessage(m: Message): Promise<void>;
+    clearMessageQueue(): void;
+    clearMessages(): void;
+    /**
+     * Remove all event listeners.
+     */
+    clearListeners(): void;
+    /**
+     * Remove a message by its ID.
+     * @returns true if the message was found and removed, false otherwise.
+     */
+    removeMessage(messageId: string): boolean;
+    /**
+     * Update a message by its ID using an updater function.
+     * @param messageId The ID of the message to update.
+     * @param updater A function that receives the current message and returns the updated message.
+     * @returns true if the message was found and updated, false otherwise.
+     */
+    updateMessage(messageId: string, updater: (message: Message) => Message): boolean;
+    abort(): void;
+    /**
+     * Returns a promise that resolves when the current prompt completes.
+     * Returns immediately resolved promise if no prompt is running.
+     */
+    waitForIdle(): Promise<void>;
+    /**
+     * Clear all messages and state. Aborts any running prompt.
+     */
+    reset(): void;
+    /**
+     * Internal cleanup after agent loop completes (success, error, or abort).
+     * Always called in finally block to ensure consistent state.
+     */
+    private _cleanup;
+    /**
+     * Append custom message to messages.
+     * Custom messages are inserted after running prompt resolves
+     */
+    addCustomMessage(message: Record<string, any>): Promise<void>;
+    prompt(input: string, attachments?: Attachment[]): Promise<Message[]>;
+    /**
+     * Continue from the current context without adding a new user message.
+     * Used for retry after overflow recovery when context already has user message or tool results.
+     */
+    continue(): Promise<Message[]>;
+    /**
+     * Prepare for running the agent loop.
+     * Returns the config, transformed messages, and abort signal.
+     */
+    private _prepareRun;
+    /**
+     * Internal: Run the agent loop with a new user message.
+     */
+    private _runAgentLoop;
+    private _runAgentLoopContinue;
+    /**
+     * Create callbacks for AgentRunner to interact with Conversation state.
+     */
+    private _createRunnerCallbacks;
+}
+//# sourceMappingURL=conversation.d.ts.map

package/dist/agent/conversation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversation.d.ts","sourceRoot":"","sources":["../../src/agent/conversation.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,GAAG,EAAiB,OAAO,EAAqB,MAAM,aAAa,CAAC;AAC7E,OAAO,EAAE,UAAU,EAAmB,UAAU,EAAa,UAAU,EAAE,QAAQ,EAAiB,MAAM,YAAY,CAAC;AAErH,OAAO,EAAE,SAAS,EAAoB,MAAM,WAAW,CAAC;AAExD,OAAO,EAAE,WAAW,EAA4C,MAAM,aAAa,CAAC;AAEpF,MAAM,WAAW,YAAY;IAC5B,YAAY,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC;IAEnC,kBAAkB,CAAC,EAAE,CAAC,QAAQ,EAAE,OAAO,EAAE,KAAK,OAAO,EAAE,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;IAE7E,SAAS,CAAC,EAAE,KAAK,GAAG,eAAe,CAAC;IAEpC,MAAM,CAAC,EAAE,SAAS,CAAC;IAEnB,MAAM,CAAC,EAAE,WAAW,CAAC;CACrB;AAyBD,qBAAa,YAAY;IACxB,OAAO,CAAC,MAAM,CAAY;IAC1B,OAAO,CAAC,MAAM,CAAc;IAC5B,OAAO,CAAC,MAAM,CAAwC;IACtD,OAAO,CAAC,SAAS,CAAsC;IACvD,OAAO,CAAC,eAAe,CAAC,CAAkB;IAC1C,OAAO,CAAC,kBAAkB,CAA0D;IACpF,OAAO,CAAC,YAAY,CAAqC;IACzD,OAAO,CAAC,SAAS,CAA0B;IAC3C,OAAO,CAAC,aAAa,CAAC,CAAgB;IACtC,OAAO,CAAC,oBAAoB,CAAC,CAAa;IAC1C,OAAO,CAAC,sBAAsB,CAAiB;gBAEnC,IAAI,GAAE,YAAiB;IAiBnC,IAAI,KAAK,IAAI,UAAU,CAEtB;IAED,SAAS,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,IAAI,GAAG,MAAM,IAAI;IAKlD,OAAO,CAAC,IAAI;IAMZ,yBAAyB,CAAC,MAAM,EAAE,OAAO;IAOzC,eAAe,CAAC,CAAC,EAAE,MAAM;IAIzB,WAAW,CAAC,IAAI,SAAS,GAAG,EAAE,QAAQ,EAAE,QAAQ,CAAC,IAAI,CAAC;IAItD,YAAY,CAAC,IAAI,EAAE,KAAK,GAAG,eAAe;IAI1C,YAAY,IAAI,KAAK,GAAG,eAAe;IAIvC,QAAQ,CAAC,CAAC,EAAE,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK;IAIpC,eAAe,CAAC,EAAE,EAAE,OAAO,EAAE;IAI7B,aAAa,CAAC,CAAC,EAAE,OAAO;IAIxB,cAAc,CAAC,EAAE,EAAE,OAAO,EAAE;IAItB,YAAY,CAAC,CAAC,EAAE,OAAO;IAS7B,iBAAiB;IAIjB,aAAa;IAIb;;OAEG;IACH,cAAc;IAId;;;OAGG;IACH,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;IAUzC;;;;;OAKG;IACH,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,GAAG,OAAO;IAYjF,KAAK;IAIL;;;OAGG;IACH,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;IAI5B;;OAEG;IACH,KAAK;IAkBL;;;OAGG;IACH,OAAO,CAAC,QAAQ;IAShB;;;OAGG;IACG,gBAAgB,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAgB7C,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC;IAgB3E;;;OAGG;IACG,QAAQ,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;IAepC;;;OAGG;YACW,WAAW;IAuCzB;;OAEG;YACW,aAAa;YAqBb,qBAAqB;IA2BnC;;OAEG;IACH,OAAO,CAAC,sBAAsB;CAQ9B"}