@letta-ai/letta-code-sdk 0.0.3 → 0.0.5

package/README.md

@@ -2,16 +2,19 @@
 
 [![npm](https://img.shields.io/npm/v/@letta-ai/letta-code-sdk.svg?style=flat-square)](https://www.npmjs.com/package/@letta-ai/letta-code-sdk) [![Discord](https://img.shields.io/badge/discord-join-blue?style=flat-square&logo=discord)](https://discord.gg/letta)
 
-The SDK interface to [Letta Code](https://github.com/letta-ai/letta-code). Build agents with persistent memory that learn over time.
+> [!TIP]
+> Check out [**LettaBot**](https://github.com/letta-ai/lettabot) and [**Letta Cowork**](https://github.com/letta-ai/letta-cowork), two open-source apps built on the **Letta Code SDK**.
+
+The SDK interface to [**Letta Code**](https://github.com/letta-ai/letta-code). Build agents with persistent memory that learn over time.
 
 ```typescript
-import { prompt } from '@letta-ai/letta-code-sdk';
+import { createSession } from '@letta-ai/letta-code-sdk';
 
-const result = await prompt('Find and fix the bug in auth.py', {
-  allowedTools: ['Read', 'Edit', 'Bash'],
-  permissionMode: 'bypassPermissions'
-});
-console.log(result.result);
+const session = createSession();
+await session.send('Find and fix the bug in auth.py');
+for await (const msg of session.stream()) {
+  if (msg.type === 'assistant') console.log(msg.content);
+}
 ```
 
 ## Installation
@@ -27,19 +30,27 @@ npm install @letta-ai/letta-code-sdk
 ```typescript
 import { prompt } from '@letta-ai/letta-code-sdk';
 
-const result = await prompt('Run: echo hello', {
-  allowedTools: ['Bash'],
-  permissionMode: 'bypassPermissions'
-});
-console.log(result.result); // "hello"
+// One-shot (uses default agent - like `letta -p`)
+const result = await prompt('What is 2 + 2?');
+console.log(result.result);
+
+// One-shot with specific agent
+const result2 = await prompt('Run: echo hello', agentId);
 ```
 
 ### Multi-turn session
 
 ```typescript
-import { createSession } from '@letta-ai/letta-code-sdk';
+import { createAgent, resumeSession } from '@letta-ai/letta-code-sdk';
+
+// Create an agent with custom memory (has default conversation)
+const agentId = await createAgent({
+  memory: ['persona'],
+  persona: 'You are a helpful coding assistant for TypeScript projects'
+});
 
-await using session = createSession();
+// Resume the default conversation
+await using session = resumeSession(agentId);
 
 await session.send('What is 5 + 3?');
 for await (const msg of session.stream()) {
@@ -57,16 +68,16 @@ for await (const msg of session.stream()) {
 Agents persist across sessions and remember context:
 
 ```typescript
-import { createSession, resumeSession } from '@letta-ai/letta-code-sdk';
+import { createAgent, resumeSession } from '@letta-ai/letta-code-sdk';
 
-// First session
-const session1 = createSession();
+// Create agent and teach it something
+const agentId = await createAgent();
+const session1 = resumeSession(agentId);
 await session1.send('Remember: the secret word is "banana"');
 for await (const msg of session1.stream()) { /* ... */ }
-const agentId = session1.agentId;
 session1.close();
 
-// Later...
+// Later... resume the default conversation
 await using session2 = resumeSession(agentId);
 await session2.send('What is the secret word?');
 for await (const msg of session2.stream()) {
@@ -74,49 +85,46 @@ for await (const msg of session2.stream()) {
 }
 ```
 
-### Multi-threaded Conversations
+## Multi-threaded Conversations
 
 Run multiple concurrent conversations with the same agent. Each conversation has its own message history while sharing the agent's persistent memory.
 
 ```typescript
-import { createSession, resumeSession, resumeConversation } from '@letta-ai/letta-code-sdk';
+import { createAgent, createSession, resumeSession } from '@letta-ai/letta-code-sdk';
 
-// Create an agent
-const session = createSession();
-await session.send('Hello!');
-for await (const msg of session.stream()) { /* ... */ }
-const agentId = session.agentId;
-const conversationId = session.conversationId; // Save this!
-session.close();
-
-// Resume a specific conversation
-await using session2 = resumeConversation(conversationId);
+// Create an agent (has default conversation)
+const agentId = await createAgent();
+
+// Resume the default conversation
+const session1 = resumeSession(agentId);
+await session1.send('Hello!');
+for await (const msg of session1.stream()) { /* ... */ }
+const conversationId = session1.conversationId; // Save this!
+session1.close();
+
+// Resume a specific conversation by ID
+await using session2 = resumeSession(conversationId);  // auto-detects conv-xxx
 await session2.send('Continue our discussion...');
 for await (const msg of session2.stream()) { /* ... */ }
 
 // Create a NEW conversation on the same agent
-await using session3 = resumeSession(agentId, { newConversation: true });
+await using session3 = createSession(agentId);
 await session3.send('Start a fresh thread...');
 // session3.conversationId is different from conversationId
 
-// Resume with agent's default conversation
-await using session4 = resumeSession(agentId, { defaultConversation: true });
-
-// Resume last used session (agent + conversation)
-await using session5 = createSession({ continue: true });
-
-// Create new agent with a new (non-default) conversation
-await using session6 = createSession({ newConversation: true });
+// Start fresh conversation with default agent
+await using session4 = createSession();
 ```
 
 **Key concepts:**
 - **Agent** (`agentId`): Persistent entity with memory that survives across sessions
 - **Conversation** (`conversationId`): A message thread within an agent
-- **Session** (`sessionId`): A single execution/connection
+- **Session**: A single execution/connection
+- **Default conversation**: Always exists after `createAgent()` - use `resumeSession(agentId)` to access it
 
 Agents remember across conversations (via memory blocks), but each conversation has its own message history.
 
-## Agent Configuration
+## Session Configuration
 
 ### System Prompt
 
@@ -124,12 +132,12 @@ Choose from built-in presets or provide a custom prompt:
 
 ```typescript
 // Use a preset
-createSession({
+createSession(agentId, {
   systemPrompt: { type: 'preset', preset: 'letta-claude' }
 });
 
 // Use a preset with additional instructions
-createSession({
+createSession(agentId, {
   systemPrompt: { 
     type: 'preset', 
     preset: 'letta-claude',
@@ -138,7 +146,7 @@ createSession({
 });
 
 // Use a completely custom prompt
-createSession({
+createSession(agentId, {
   systemPrompt: 'You are a helpful Python expert.'
 });
 ```
@@ -151,80 +159,7 @@ createSession({
 - `codex` - Basic Codex
 - `gemini` - Basic Gemini
 
-### Memory Blocks
-
-Configure which memory blocks the agent uses:
-
-```typescript
-// Use default blocks (persona, human, project)
-createSession({});
-
-// Use specific preset blocks
-createSession({
-  memory: ['project', 'persona']  // Only these blocks
-});
-
-// Use custom blocks
-createSession({
-  memory: [
-    { label: 'context', value: 'API documentation for Acme Corp...' },
-    { label: 'rules', value: 'Always use TypeScript. Prefer functional patterns.' }
-  ]
-});
-
-// Mix presets and custom blocks
-createSession({
-  memory: [
-    'project',  // Use default project block
-    { label: 'custom', value: 'Additional context...' }
-  ]
-});
-
-// No optional blocks (only core skills blocks)
-createSession({
-  memory: []
-});
-```
-
-### Convenience Props
 
-Quickly customize common memory blocks:
-
-```typescript
-createSession({
-  persona: 'You are a senior Python developer who writes clean, tested code.',
-  human: 'Name: Alice. Prefers concise responses.',
-  project: 'FastAPI backend for a todo app using PostgreSQL.'
-});
-
-// Combine with memory config
-createSession({
-  memory: ['persona', 'project'],  // Only include these blocks
-  persona: 'You are a Go expert.',
-  project: 'CLI tool for managing Docker containers.'
-});
-```
-
-### Tool Execution
-
-Execute tools with automatic permission handling:
-
-```typescript
-import { prompt } from '@letta-ai/letta-code-sdk';
-
-// Run shell commands
-const result = await prompt('List all TypeScript files', {
-  allowedTools: ['Glob', 'Bash'],
-  permissionMode: 'bypassPermissions',
-  cwd: '/path/to/project'
-});
-
-// Read and analyze code
-const analysis = await prompt('Explain what auth.ts does', {
-  allowedTools: ['Read', 'Grep'],
-  permissionMode: 'bypassPermissions'
-});
-```
 
 ## API Reference
 
@@ -232,10 +167,10 @@ const analysis = await prompt('Explain what auth.ts does', {
 
 | Function | Description |
 |----------|-------------|
-| `prompt(message, options?)` | One-shot query, returns result directly |
-| `createSession(options?)` | Create new agent session |
-| `resumeSession(agentId, options?)` | Resume existing agent by ID |
-| `resumeConversation(conversationId, options?)` | Resume specific conversation (derives agent automatically) |
+| `createAgent(options?)` | Create new agent with custom memory/prompt. No options = blank agent with default memory blocks. Returns `agentId` |
+| `createSession(agentId?, options?)` | New conversation on specified agent. No agentId = uses LRU agent (or creates "Memo" if none exists) |
+| `resumeSession(id, options?)` | Resume session - pass `agent-xxx` for default conv, `conv-xxx` for specific conv |
+| `prompt(message, agentId?)` | One-shot query with default/specified agent (like `letta -p`) |
 
 ### Session
 
@@ -250,41 +185,38 @@ const analysis = await prompt('Explain what auth.ts does', {
 
 ### Options
 
+**CreateAgentOptions** (for `createAgent()` - full control):
+
 ```typescript
-interface SessionOptions {
-  // Model selection
-  model?: string;
-
-  // Conversation options
-  conversationId?: string;      // Resume specific conversation
-  newConversation?: boolean;    // Create new conversation on agent
-  continue?: boolean;           // Resume last session (agent + conversation)
-  defaultConversation?: boolean; // Use agent's default conversation
-
-  // System prompt: string or preset config
-  systemPrompt?: string | {
-    type: 'preset';
-    preset: 'default' | 'letta-claude' | 'letta-codex' | 'letta-gemini' | 'claude' | 'codex' | 'gemini';
-    append?: string;
-  };
-
-  // Memory blocks: preset names, custom blocks, or mixed
-  memory?: Array<string | CreateBlock | { blockId: string }>;
-
-  // Convenience: set block values directly
-  persona?: string;
-  human?: string;
-  project?: string;
-
-  // Tool configuration
-  allowedTools?: string[];
-  permissionMode?: 'default' | 'acceptEdits' | 'bypassPermissions';
-
-  // Working directory
-  cwd?: string;
-}
+// Create blank agent
+await createAgent();
+
+// Create agent with custom memory and system prompt
+await createAgent({
+  model: 'claude-sonnet-4',
+  systemPrompt: 'You are a helpful Python expert.',
+  memory: [
+    { label: 'persona', value: 'You are a senior Python developer' },
+    { label: 'project', value: 'FastAPI backend for a todo app' }
+  ]
+});
 ```
 
+**CreateSessionOptions** (for `createSession()` / `resumeSession()` - runtime options):
+
+```typescript
+// Start session with permissions
+createSession(agentId, {
+  permissionMode: 'bypassPermissions',
+  allowedTools: ['Bash', 'Glob'],
+  cwd: '/path/to/project'
+});
+```
+
+**Available system prompt presets:**
+- `default` / `letta-claude`, `letta-codex`, `letta-gemini` - Full Letta Code prompts
+- `claude`, `codex`, `gemini` - Basic (no skills/memory instructions)
+
 ### Message Types
 
 ```typescript
@@ -313,7 +245,7 @@ See [`examples/`](./examples/) for comprehensive examples including:
 - Basic session usage
 - Multi-turn conversations
 - Session resume with persistent memory
-- **Multi-threaded conversations** (resumeConversation, newConversation)
+- **Multi-threaded conversations** (createSession, resumeSession)
 - System prompt configuration
 - Memory block customization
 - Tool execution (Bash, Glob, Read, etc.)
@@ -326,6 +258,27 @@ bun examples/v2-examples.ts all
 bun examples/v2-examples.ts conversations
 ```
 
+## Internals
+
+### CLI Mapping
+
+The SDK spawns the Letta Code CLI as a subprocess. Here's how API calls map to CLI flags:
+
+| Function | CLI Flags | Behavior |
+|----------|-----------|----------|
+| `createSession()` | `--new` | LRU agent + new conversation |
+| `createSession(agentId)` | `--agent X --new` | Specified agent + new conversation |
+| `createAgent()` | `--new-agent` | New agent + default conversation |
+| `resumeSession(agentId)` | `--agent X --default` | Specified agent + default conversation |
+| `resumeSession(convId)` | `--conversation X` | Derived agent + specified conversation |
+| `prompt(msg)` | *(none)* | LRU agent + default conversation |
+| `prompt(msg, agentId)` | `--agent X --new` | Specified agent + new conversation |
+
+**Key concepts:**
+- **LRU agent**: Most recently used agent from `.letta/settings.local.json`, or creates "Memo" if none exists
+- **Default conversation**: The agent's primary message history (always exists)
+- **New conversation**: Fresh message thread, isolated from other conversations
+
 ## License
 
 Apache-2.0

package/dist/index.d.ts

@@ -5,92 +5,139 @@
  *
  * @example
  * ```typescript
- * import { createSession, prompt } from '@letta-ai/letta-code-sdk';
+ * import { createAgent, createSession, resumeSession, prompt } from '@letta-ai/letta-code-sdk';
  *
- * // One-shot
- * const result = await prompt('What is 2+2?', { model: 'claude-sonnet-4-20250514' });
+ * // Start session with default agent + new conversation (like `letta`)
+ * const session = createSession();
  *
- * // Multi-turn session
- * await using session = createSession({ model: 'claude-sonnet-4-20250514' });
- * await session.send('Hello!');
- * for await (const msg of session.stream()) {
- *   if (msg.type === 'assistant') console.log(msg.content);
- * }
+ * // Create a new agent explicitly
+ * const agentId = await createAgent();
  *
- * // Resume with persistent memory
- * await using resumed = resumeSession(agentId, { model: 'claude-sonnet-4-20250514' });
+ * // Resume default conversation on an agent
+ * const session = resumeSession(agentId);
+ *
+ * // Resume specific conversation
+ * const session = resumeSession('conv-xxx');
+ *
+ * // Create new conversation on specific agent
+ * const session = createSession(agentId);
+ *
+ * // One-shot prompt (uses default agent)
+ * const result = await prompt('Hello');
+ * const result = await prompt('Hello', agentId);  // specific agent
  * ```
  */
 import { Session } from "./session.js";
-import type { SessionOptions, SDKResultMessage } from "./types.js";
-export type { SessionOptions, SDKMessage, SDKInitMessage, SDKAssistantMessage, SDKToolCallMessage, SDKToolResultMessage, SDKReasoningMessage, SDKResultMessage, SDKStreamEventMessage, PermissionMode, PermissionResult, CanUseToolCallback, } from "./types.js";
+import type { CreateSessionOptions, CreateAgentOptions, SDKResultMessage } from "./types.js";
+export type { CreateSessionOptions, CreateAgentOptions, SDKMessage, SDKInitMessage, SDKAssistantMessage, SDKToolCallMessage, SDKToolResultMessage, SDKReasoningMessage, SDKResultMessage, SDKStreamEventMessage, PermissionMode, CanUseToolCallback, CanUseToolResponse, CanUseToolResponseAllow, CanUseToolResponseDeny, TextContent, ImageContent, MessageContentItem, SendMessage, } from "./types.js";
 export { Session } from "./session.js";
 /**
- * Create a new session with a fresh Letta agent.
- *
- * The agent will have persistent memory that survives across sessions.
- * Use `resumeSession` to continue a conversation with an existing agent.
+ * Create a new agent with a default conversation.
+ * Returns the agentId which can be used with resumeSession or createSession.
  *
  * @example
  * ```typescript
- * await using session = createSession({ model: 'claude-sonnet-4-20250514' });
- * await session.send('My name is Alice');
- * for await (const msg of session.stream()) {
- *   console.log(msg);
- * }
- * console.log(`Agent ID: ${session.agentId}`); // Save this to resume later
+ * // Create agent with default settings
+ * const agentId = await createAgent();
+ *
+ * // Create agent with custom memory
+ * const agentId = await createAgent({
+ *   memory: ['persona', 'project'],
+ *   persona: 'You are a helpful coding assistant',
+ *   model: 'claude-sonnet-4'
+ * });
+ *
+ * // Then resume the default conversation:
+ * const session = resumeSession(agentId);
  * ```
  */
-export declare function createSession(options?: SessionOptions): Session;
+export declare function createAgent(options?: CreateAgentOptions): Promise<string>;
 /**
- * Resume an existing session with a Letta agent.
+ * Create a new conversation (session).
  *
- * Unlike Claude Agent SDK (ephemeral sessions), Letta agents have persistent
- * memory. You can resume a conversation days later and the agent will remember.
+ * - Without agentId: uses default/LRU agent with new conversation (like `letta`)
+ * - With agentId: creates new conversation on specified agent
  *
  * @example
  * ```typescript
- * // Days later...
- * await using session = resumeSession(agentId, { model: 'claude-sonnet-4-20250514' });
- * await session.send('What is my name?');
- * for await (const msg of session.stream()) {
- *   // Agent remembers: "Your name is Alice"
- * }
+ * // New conversation on default agent (like `letta`)
+ * await using session = createSession();
+ *
+ * // New conversation on specific agent
+ * await using session = createSession(agentId);
  * ```
  */
-export declare function resumeSession(agentId: string, options?: SessionOptions): Session;
+export declare function createSession(agentId?: string, options?: CreateSessionOptions): Session;
 /**
- * Resume an existing conversation.
+ * Resume an existing session.
  *
- * Conversations are threads within an agent. The agent is derived automatically
- * from the conversation ID. Use this to continue a specific conversation thread.
+ * - Pass an agent ID (agent-xxx) to resume the default conversation
+ * - Pass a conversation ID (conv-xxx) to resume a specific conversation
+ *
+ * The default conversation always exists after createAgent, so you can:
+ * `createAgent()` → `resumeSession(agentId)` without needing createSession first.
  *
  * @example
  * ```typescript
- * // Resume a specific conversation
- * await using session = resumeConversation(conversationId);
- * await session.send('Continue our discussion...');
- * for await (const msg of session.stream()) {
- *   console.log(msg);
- * }
+ * // Resume default conversation
+ * await using session = resumeSession(agentId);
+ *
+ * // Resume specific conversation
+ * await using session = resumeSession('conv-xxx');
  * ```
  */
-export declare function resumeConversation(conversationId: string, options?: SessionOptions): Session;
+export declare function resumeSession(id: string, options?: CreateSessionOptions): Session;
 /**
  * One-shot prompt convenience function.
  *
- * Creates a session, sends the prompt, collects the response, and closes.
- * Returns the final result message.
+ * - Without agentId: uses default agent (like `letta -p`), new conversation
+ * - With agentId: uses specific agent, new conversation
  *
  * @example
  * ```typescript
- * const result = await prompt('What is the capital of France?', {
- *   model: 'claude-sonnet-4-20250514'
- * });
- * if (result.success) {
- *   console.log(result.result);
- * }
+ * const result = await prompt('What is 2+2?');  // default agent
+ * const result = await prompt('What is the capital of France?', agentId);  // specific agent
+ * ```
+ */
+export declare function prompt(message: string, agentId?: string): Promise<SDKResultMessage>;
+import type { ImageContent } from "./types.js";
+/**
+ * Create image content from a file path.
+ *
+ * @example
+ * ```typescript
+ * await session.send([
+ *   { type: "text", text: "What's in this image?" },
+ *   imageFromFile("./screenshot.png")
+ * ]);
+ * ```
+ */
+export declare function imageFromFile(filePath: string): ImageContent;
+/**
+ * Create image content from base64 data.
+ *
+ * @example
+ * ```typescript
+ * const base64 = fs.readFileSync("image.png").toString("base64");
+ * await session.send([
+ *   { type: "text", text: "Describe this" },
+ *   imageFromBase64(base64, "image/png")
+ * ]);
+ * ```
+ */
+export declare function imageFromBase64(data: string, media_type?: ImageContent["source"]["media_type"]): ImageContent;
+/**
+ * Create image content from a URL.
+ * Fetches the image and converts to base64.
+ *
+ * @example
+ * ```typescript
+ * const img = await imageFromURL("https://example.com/image.png");
+ * await session.send([
+ *   { type: "text", text: "What's this?" },
+ *   img
+ * ]);
  * ```
  */
-export declare function prompt(message: string, options?: SessionOptions): Promise<SDKResultMessage>;
+export declare function imageFromURL(url: string): Promise<ImageContent>;
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,KAAK,EAAE,cAAc,EAAc,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAG/E,YAAY,EACV,cAAc,EACd,UAAU,EACV,cAAc,EACd,mBAAmB,EACnB,kBAAkB,EAClB,oBAAoB,EACpB,mBAAmB,EACnB,gBAAgB,EAChB,qBAAqB,EACrB,cAAc,EACd,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAEvC;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,aAAa,CAAC,OAAO,GAAE,cAAmB,GAAG,OAAO,CAEnE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAET;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAChC,cAAc,EAAE,MAAM,EACtB,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAET;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,MAAM,CAC1B,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,gBAAgB,CAAC,CA4B3B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,KAAK,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAI7F,YAAY,EACV,oBAAoB,EACpB,kBAAkB,EAClB,UAAU,EACV,cAAc,EACd,mBAAmB,EACnB,kBAAkB,EAClB,oBAAoB,EACpB,mBAAmB,EACnB,gBAAgB,EAChB,qBAAqB,EACrB,cAAc,EACd,kBAAkB,EAClB,kBAAkB,EAClB,uBAAuB,EACvB,sBAAsB,EAEtB,WAAW,EACX,YAAY,EACZ,kBAAkB,EAClB,WAAW,GACZ,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAEvC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,WAAW,CAAC,OAAO,GAAE,kBAAuB,GAAG,OAAO,CAAC,MAAM,CAAC,CAMnF;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,OAAO,GAAE,oBAAyB,GAAG,OAAO,CAO3F;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,aAAa,CAC3B,EAAE,EAAE,MAAM,EACV,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAOT;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,MAAM,CAC1B,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,gBAAgB,CAAC,CA+B3B;AAOD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/C;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,YAAY,CAa5D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,EACZ,UAAU,GAAE,YAAY,CAAC,QAAQ,CAAC,CAAC,YAAY,CAAe,GAC7D,YAAY,CAKd;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CAqBrE"}