@data-club/ai-hub-server 0.0.9 → 0.0.10

package/dist/letta/client.d.ts

@@ -1,47 +1,40 @@
 /**
- * Hybrid Letta access layer.
+ * Letta access layer — server-less local backend.
  *
- * **Two SDKs, two roles:**
+ * AI Hub drives **Letta Code's local backend** through
+ * `@data-club/letta-runtime`: agent/conversation state lives on the local
+ * filesystem (`AI_HUB_LETTA_STORE_DIR`), chat turns run in an SDK-spawned
+ * Letta Code CLI subprocess, and inference is client-side (Letta Code's Pi
+ * provider layer calling Anthropic / AWS Bedrock directly). There is no
+ * Letta server and no `@letta-ai/letta-client` anywhere in this path — the
+ * server-backed implementation was removed in the local-backend migration
+ * (see docs/investigations/2026-07-01-letta-code-local-backend-migration.md).
  *
- * - **`@letta-ai/letta-client`** owns *direct REST operations* —
- *   `retrieveAgent`, `createConversation`, `listMessages`. These are
- *   stable agent / conversation / message CRUD against the Letta
- *   server's REST surface; they don't involve model routing or
- *   provider shape.
- * - **`@letta-ai/letta-code-sdk`** owns the *chat-streaming path* —
- *   `streamUserMessage`. Spawns a Letta Code CLI subprocess per turn;
- *   the CLI's internal Pi (Provider Interface) + bundled `models.json`
- *   handle model selection, reasoning-tier presets, and provider
- *   fallback routing (e.g. Anthropic → Bedrock Opus 4.7). This is what
- *   keeps ai-hub current with model releases without code changes.
+ * **MCP tools.** Letta Code is not an MCP client; with no Letta server, AI
+ * Hub is the MCP host. On the first chat turn this module connects to the
+ * servers configured in `AI_HUB_MCP_SERVERS` (`name=url,name2=url2`,
+ * Streamable HTTP) and injects their tools into every session via the
+ * runtime's `tools` option; tool executions round-trip through the SDK's
+ * `execute_external_tool` control channel in this process.
  *
- * **The hard rule from §6.4 is preserved** — every Letta interaction
- * goes through one of these two SDKs; no raw HTTP, no parallel fetch.
+ * **Tool suppression.** Letta Code's bundled tools are hidden from the
+ * model via `disallowedTools` (the headless-mode equivalent of the TUI's
+ * `/toolset none`). The old `--tools ""` CLI shim is gone — emptying the
+ * CLI's tool registry also strips SDK-injected MCP tools (verified
+ * empirically), so the disallow list is the only suppression mechanism.
  *
- * Configuration source: `admin_setting.letta_base_url` +
- * `admin_setting.letta_api_key_encrypted` (decrypted with
- * `AI_HUB_ENCRYPTION_KEY`). The Letta-Client wrapper memoizes one SDK
- * instance per `(apiKey, baseURL)` pair so super-admin connection
- * edits propagate without restart. The Letta-Code subprocess inherits
- * `process.env` (which must carry `LETTA_BASE_URL` + `LETTA_API_KEY` —
- * the boot script sets these from the same decrypted DB row).
- *
- * @see SPECIFICATIONS.md §6.4 — Letta integration
- * @see SPECIFICATIONS.md §6.4.1 — first-class SDK surfaces
+ * This module composes AI-Hub policy (subprocess throttle, tool
+ * disallow-lists, sandbox cwd) around the runtime; everything Letta-shaped
+ * lives in `@data-club/letta-runtime`.
  */
-import LettaSdkDefault from "@letta-ai/letta-client";
-import { resumeSession, type SDKMessage } from "@letta-ai/letta-code-sdk";
-import type { DrizzleDB } from "../db/connection.js";
+import { type LettaMessageRecord, type LettaRuntime, type SDKMessage } from "@data-club/letta-runtime";
 import { type SubprocessThrottle } from "./subprocessThrottle.js";
-import type { LettaMessage } from "./types.js";
 export { ServerOverloadedError, SubprocessThrottle } from "./subprocessThrottle.js";
 /**
- * Thrown when `forkConversation(sourceId)` or `retrieveConversation(id)`
- * resolves to "no such conversation" (Letta 404). The admin agents
- * validator catches this and returns `400 fork_source_not_found` inline
- * on the field; the chat route surfaces it as a 500 (admin-side
- * validation should have caught it before any user-facing session
- * create reached the fork path).
+ * Thrown when `forkConversation(sourceId)` resolves to "no such
+ * conversation". The admin agents validator catches this and returns
+ * `400 fork_source_not_found` inline on the field; the chat route surfaces
+ * it as a 500 (admin-side validation should have caught it earlier).
  *
  * @see docs/server/session-sandboxes.md
  */
@@ -49,307 +42,137 @@ export declare class ForkSourceNotFoundError extends Error {
     readonly conversationId: string;
     constructor(conversationId: string);
 }
-/**
- * Provider-reported token usage for a single Letta run + the run's
- * last assistant-message id (so callers can stamp the badge on the
- * visible bubble). All token fields are nullable because the
- * producing provider may not report every dimension — Anthropic
- * reports `cache_write_tokens`, others don't; reasoning tokens come
- * back only when the model produced any; etc.
- *
- * Sourced via a single `GET /v1/runs/{run_id}/messages` call.
- */
-export interface RunUsageStats {
-    /**
-     * Id of the LAST `assistant_message`-typed entry in the run. `null`
-     * when the run had no assistant messages (rare — error-only runs).
-     * Callers stamp `message_usage` against this id.
-     */
-    lastAssistantMessageId: string | null;
-    promptTokens: number | null;
-    completionTokens: number | null;
-    totalTokens: number | null;
-    cachedInputTokens: number | null;
-    cacheWriteTokens: number | null;
-    reasoningTokens: number | null;
-    contextTokens: number | null;
-}
 /** Parameters for `streamUserMessage`. */
 export interface StreamUserMessageOpts {
     /** The Letta conversation id (`session.letta_conversation_id`). */
     conversationId: string;
     /**
-     * The Letta agent id the session is against. Required so we can
-     * re-seed `~/.letta/settings.json` on every spawn — concurrent CLI
-     * subprocesses race on writes and can wipe the entry, so the
-     * agent-registration-time seed isn't reliable on its own. The
-     * seed-on-spawn call below is idempotent (no-op when the entry
-     * is already present with the same value).
+     * The Letta agent id the session is against. Not needed to spawn a turn
+     * on the local backend (the conversation record carries its agent), but
+     * kept on the opts shape for logging and interface stability.
      */
     lettaAgentId: string;
     /**
-     * Plain-text user message body. Sent verbatim to Letta. The admin's
-     * system prompt is delivered through Letta's normal channel (the
-     * agent's persisted `system` field), so we don't re-inject it here.
+     * Plain-text user message body. Sent verbatim. The admin's system prompt
+     * is delivered through the agent record's persisted `system` field.
      */
     userMessage: string;
     /**
      * Step-12.5 — optional working directory for the spawned Letta Code
-     * subprocess. When set, threaded into the SDK's `resumeSession({ cwd })`
-     * option (maps to the CLI's `--cwd` flag). Used to confine the agent's
-     * filesystem-tool access to a per-session sandbox folder; when
-     * provided, the spawn ALSO drops the `FILESYSTEM_TOOLS` group from
-     * the `disallowedTools` list so the agent can actually read / write
-     * inside that folder.
-     *
-     * When `undefined`, no `cwd` is passed (the CLI inherits the
-     * ai-hub-server process's working directory, as it always has) AND
-     * the filesystem tools remain disallowed — today's stateless agent
-     * shape.
+     * subprocess (per-session sandbox folder). When set, the filesystem
+     * tools are re-enabled so the agent can use the seeded files; when
+     * `undefined`, they stay disallowed.
      *
      * @see docs/server/session-sandboxes.md
      */
     cwd?: string;
 }
 /**
- * Handle returned by `streamUserMessage`. Wraps the Letta Code SDK
- * `Session` + the subprocess-throttle lease so the caller owns one
- * resource bundle to drain, cancel, and clean up.
- *
- * Lifecycle expectations:
+ * Handle returned by `streamUserMessage`. Wraps the runtime's turn handle +
+ * the subprocess-throttle lease so the caller owns one resource bundle to
+ * drain, cancel, and clean up.
  *
- * 1. Caller iterates `events` to consume `SDKMessage`s in real time.
- * 2. At any point, calling `abort()` sends an `interrupt` control to
- *    the spawned CLI. Behavior depends on what the CLI is doing —
- *    during model generation interrupts work cleanly; during a
- *    long-running tool call the interrupt is currently queued (see
- *    migration plan §7 open question 5).
- * 3. Caller MUST call `close()` in a `finally` regardless of how the
- *    iteration ended (done, cancelled, error). `close()` terminates
- *    the CLI subprocess + releases the throttle lease. Idempotent.
+ * Lifecycle: iterate `events`; `abort()` to interrupt; ALWAYS `close()` in
+ * a `finally` (terminates the CLI subprocess + releases the throttle lease;
+ * idempotent).
  */
 export interface ChatTurnHandle {
     /** Async iterable of Letta Code SDK messages — caller drains this. */
     events: AsyncIterable<SDKMessage>;
-    /**
-     * Sends an `interrupt` control to the spawned CLI. Best-effort; if
-     * the CLI is mid-tool the interrupt may be queued. The caller still
-     * needs to call `close()` to release subprocess + lease.
-     */
+    /** Sends an `interrupt` control to the spawned CLI. Best-effort. */
     abort(): Promise<void>;
-    /**
-     * Tears down the Letta Code subprocess + releases the throttle slot.
-     * Idempotent — safe to call twice. Caller MUST invoke this in a
-     * `finally`. Sync because the SDK's `session.close()` is sync.
-     */
+    /** Tears down the subprocess + releases the throttle slot. Idempotent. */
     close(): void;
 }
 /**
- * Project-shaped Letta client. The handlers depend on this interface,
- * not on the underlying SDKs, so tests can plug a mock implementation
- * in via `getLettaClient` on the server context.
- *
- * @see SPECIFICATIONS.md §6.4
+ * Project-shaped Letta client. The handlers depend on this interface, not
+ * on the underlying runtime, so tests can plug a mock implementation in via
+ * `getLettaClient` on the server context.
  */
 export interface LettaClient {
     /**
-     * Retrieves a Letta agent by id (via `@letta-ai/letta-client`).
-     * Returns `null` (not throws) on miss so the agent-validation flow
-     * on `POST/PATCH /admin/agents` can return a 400
-     * `letta_agent_not_found` without try/catch noise. Any non-404 SDK
-     * error rethrows — the admin handler returns 500.
-     *
-     * @param lettaAgentId - candidate Letta-side agent id.
-     * @returns the agent state or `null` if not found.
+     * Retrieves a Letta agent by id from the local store. Returns `null`
+     * (not throws) on miss so the agent-validation flow on
+     * `POST/PATCH /admin/agents` can return a 400 `letta_agent_not_found`
+     * without try/catch noise.
      */
     retrieveAgent(lettaAgentId: string): Promise<{
         id: string;
         name: string;
-        /** Provider-prefixed model handle (e.g. `"anthropic/claude-opus-4-7"`). */
+        /** Provider-prefixed model handle (e.g. `"bedrock/eu.anthropic.claude-opus-4-6-v1"`). */
         model: string;
     } | null>;
-    /**
-     * Creates a fresh conversation against the given Letta agent (via
-     * `@letta-ai/letta-client`). Returns the conversation id we store
-     * on the new session row.
-     *
-     * @param lettaAgentId - the Letta-side agent id.
-     * @returns the new conversation's id.
-     */
+    /** Creates a fresh conversation against the given agent. */
     createConversation(lettaAgentId: string): Promise<{
         id: string;
     }>;
     /**
-     * Step-12.5 — retrieves a Letta conversation by id (via
-     * `client.conversations.retrieve`). Used by the admin agents
-     * validator to verify `fork_source_conversation_id` resolves to a
-     * real conversation AND that its `agent_id` matches the agent's
-     * `letta_agent_id` (Letta's fork API requires same-agent forking).
-     *
-     * Returns `null` on Letta 404 so the handler can surface
-     * `400 fork_source_not_found` without try/catch noise; non-404
-     * SDK errors propagate.
-     *
-     * @param conversationId - the candidate Letta conversation id.
-     * @returns `{ id, agentId }` or `null` if not found.
+     * Retrieves a conversation by id (admin fork-source validation). Returns
+     * `null` on miss.
      */
     retrieveConversation(conversationId: string): Promise<{
         id: string;
         agentId: string;
     } | null>;
     /**
-     * Step-12.5 — forks an existing Letta conversation into a new
-     * conversation belonging to the same agent (via
-     * `client.conversations.fork`). The new conversation shares the
-     * source's in-context messages and gets a freshly compiled system
-     * message reflecting the agent's current memory-block values.
+     * Clones an existing conversation (transcript included) into a new one
+     * on the same agent. Powers session creation from a rotating message's
+     * prepared conversation.
      *
-     * Used by `POST /sessions` when the parent agent's
-     * `fork_source_conversation_id` is set. The admin endpoint validates
-     * source existence + agent match at write time, so this call is
-     * expected to succeed in the happy path; a 404 here is treated as
-     * "operator deleted the source conversation between admin-validate
-     * and user-session-create" and surfaced as `ForkSourceNotFoundError`.
-     *
-     * @param sourceConversationId - the Letta conversation id to fork.
-     * @returns the new conversation's `{ id, agentId }`.
-     * @throws ForkSourceNotFoundError on Letta 404.
+     * @throws ForkSourceNotFoundError when the source no longer exists.
      */
     forkConversation(sourceConversationId: string): Promise<{
         id: string;
         agentId: string;
     }>;
-    /**
-     * Lists every message in a conversation, oldest first (via
-     * `@letta-ai/letta-client`). Used for `GET /sessions/{id}/messages`
-     * history rendering.
-     *
-     * @param conversationId - the Letta conversation id.
-     * @returns the (oldest-first) array of messages.
-     */
+    /** Lists every message in a conversation, oldest first. */
     listMessages(conversationId: string): Promise<ReadonlyArray<LettaMessage>>;
     /**
-     * Deletes a single message from an agent's history by id.
-     *
-     * The typed SDK only exposes `create` / `list` on conversation messages,
-     * so this reaches the Letta server's `DELETE /v1/agents/{agent_id}/messages/{message_id}`
-     * endpoint via the SDK's raw HTTP escape hatch (`sdk.delete(...)`) — the
-     * same pattern `getRunUsageStats` uses for `sdk.get(...)`. A 404 is treated
-     * as "already gone" and swallowed; other errors propagate.
-     *
-     * Used by the rotation runner to remove the prompt's `user_message` so a
-     * rotating starting message's prepared conversation opens with the agent's
-     * reply.
-     *
-     * @param lettaAgentId - the agent the message belongs to.
-     * @param messageId - the message id (from `listMessages`).
+     * NO-OP on the local backend. Message deletion was a Letta-server REST
+     * capability; per the migration decision, rotating messages now keep
+     * their initial prompt message instead of deleting it. The method stays
+     * on the interface so the rotation runner's flow is unchanged.
      */
     deleteMessage(lettaAgentId: string, messageId: string): Promise<void>;
     /**
-     * Deletes an entire Letta conversation (via `client.conversations.delete`).
-     * Best-effort cleanup of a rotating message's previous prepared
-     * conversation after a successful rotation produces a fresh one — a 404 is
-     * swallowed; other errors propagate to the caller (which logs + continues).
-     *
-     * @param conversationId - the Letta conversation id to delete.
+     * NO-OP on the local backend. Old prepared conversations are left in the
+     * local store (orphans are harmless files); a cleanup pass can come later.
      */
     deleteConversation(conversationId: string): Promise<void>;
     /**
-     * Fetches provider-reported token usage for a Letta run, including
-     * prompt-cache hit / write counts. The SDK's `session.stream()`
-     * drops `usage_statistics` messages, so we re-fetch via REST after
-     * the turn lands; the runner uses this to stamp a usage badge on
-     * the last assistant message.
+     * Spawns a Letta Code CLI subprocess and streams a chat turn.
      *
-     * Returns `null` when:
-     *   - the run id is unknown to Letta (404),
-     *   - the run hasn't emitted a usage_statistics message yet,
-     *   - the network call fails (best-effort — the badge is a nicety,
-     *     not load-bearing).
-     *
-     * @param runId - Letta run id captured from `SDKAssistantMessage.runId`.
-     */
-    getRunUsageStats(runId: string): Promise<RunUsageStats | null>;
-    /**
-     * Spawns a Letta Code CLI subprocess and streams a chat turn against
-     * the given conversation. Returns a `ChatTurnHandle` the caller
-     * drains + cancels + closes.
-     *
-     * Pre-flight checks (in order, all may throw):
-     * 1. **Subprocess throttle.** `SubprocessThrottle.acquire()` runs
-     *    first — throws `ServerOverloadedError` if RAM is under the
-     *    threshold or the hard-cap is reached. The chat route catches
-     *    this and returns HTTP 503 `server_overloaded`.
-     * 2. **Session initialization.** `session.initialize()` may throw if
-     *    the CLI subprocess fails to spawn or can't reach Letta. The
-     *    lease is released before the throw so the throttle counter
-     *    doesn't leak.
-     *
-     * The Letta Code session is configured for the ai-hub use case:
-     * - `permissionMode: "bypassPermissions"` — no interactive approvals
-     *   (we don't expose them to end-users in v1).
-     * - `skillSources: []` — no auto-loaded skills (challenge 2 in the
-     *   migration brief).
-     * - `systemInfoReminder: false` — no first-turn environment dump.
-     * - `memfsStartup: "skip"` — no git-backed memory filesystem.
-     * - `disallowedTools: ["AskUserQuestion", "EnterPlanMode",
-     *   "ExitPlanMode"]` — tools that require runtime user input.
-     *
-     * Toolset suppression is handled out-of-band by the
-     * `seedAgentToolsetNone` upsert into `~/.letta/settings.json` at
-     * agent-registration time.
-     *
-     * @param opts - see `StreamUserMessageOpts`.
-     * @returns a `ChatTurnHandle` the caller drains and closes.
-     * @throws `ServerOverloadedError` when the throttle rejects.
+     * Pre-flight (in order, both may throw):
+     * 1. `SubprocessThrottle.acquire()` — `ServerOverloadedError` → HTTP 503.
+     * 2. MCP bridge connect (first turn only, cached after) — a configured
+     *    MCP server that can't be reached fails the turn rather than
+     *    presenting a differently-capable agent.
      */
     streamUserMessage(opts: StreamUserMessageOpts): Promise<ChatTurnHandle>;
 }
+/** One Letta-format message as consumed by history renderers. */
+export type LettaMessage = LettaMessageRecord;
 /** Dependency bundle for `createDefaultLettaClient`. */
 export interface CreateLettaClientDeps {
-    /** Drizzle handle. */
-    db: DrizzleDB;
-    /** Parsed encryption key for decrypting the Letta API key at rest. */
-    encryptionKey: Buffer;
     /** Subprocess-spawn throttle (shared across the server instance). */
     subprocessThrottle: SubprocessThrottle;
     /**
-     * Env source — used as the fallback when the DB column is empty or
-     * whitespace. Production passes `process.env`; tests pass a synthesized
-     * record so the env precedence behaviour is exercisable without
-     * touching the real environment. Re-read on every `getSdk()` call so a
-     * server restart with a different `.env` reflects immediately.
+     * Env source. Reads:
+     * - `AI_HUB_LETTA_STORE_DIR` — local-backend store (default
+     *   `~/.letta/lc-local-backend`; on deployments point this at the
+     *   persistent encrypted volume, shared with operator SSH sessions).
+     * - `AI_HUB_LETTA_CLI_PATH` — Letta Code CLI entry override (default:
+     *   the installed `@data-club/letta-code` package).
+     * - `AI_HUB_MCP_SERVERS` — MCP servers to host (`name=url,...`); empty
+     *   or unset → no MCP tools.
      */
     envSource?: Record<string, string | undefined>;
-    /**
-     * Override the Letta Client SDK constructor — only used by tests.
-     * Production passes the SDK's `Letta` class (or omits to use the
-     * default).
-     */
-    sdkConstructor?: typeof LettaSdkDefault;
-    /**
-     * Override `resumeSession` from `@letta-ai/letta-code-sdk` — only
-     * used by tests, which inject a fake session factory.
-     */
-    resumeSessionFn?: typeof resumeSession;
+    /** Override the runtime — only used by tests. */
+    runtime?: LettaRuntime;
 }
 /**
- * Constructs the default `LettaClient` implementation.
- *
- * Reads `admin_setting.letta_base_url` + `letta_api_key_encrypted` on
- * each Letta-Client call (no in-flight polling — fresh-on-demand) and
- * memoizes the underlying SDK instance against `(apiKey, baseURL)` so
- * super-admin connection-settings edits propagate without restart.
- *
- * Throws on the first Letta-Client call if `admin_setting` has no
- * `letta_base_url` or no decryptable API key.
- *
- * @param deps - see `CreateLettaClientDeps`.
- * @returns the project-shaped Letta client.
- *
- * @see SPECIFICATIONS.md §6.4
- * @see SPECIFICATIONS.md §11 — `admin_setting` schema
+ * Constructs the default `LettaClient` implementation over the local
+ * backend. See the module doc for the architecture.
  */
 export declare function createDefaultLettaClient(deps: CreateLettaClientDeps): LettaClient;
-export type { LettaMessage, LettaSdk } from "./types.js";
 //# sourceMappingURL=client.d.ts.map

package/dist/letta/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/letta/client.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/letta/client.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAMH,OAAO,EAML,KAAK,kBAAkB,EACvB,KAAK,YAAY,EACjB,KAAK,UAAU,EAEhB,MAAM,0BAA0B,CAAC;AAElC,OAAO,EACL,KAAK,kBAAkB,EAExB,MAAM,yBAAyB,CAAC;AAGjC,OAAO,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAEpF;;;;;;;GAOG;AACH,qBAAa,uBAAwB,SAAQ,KAAK;aACpB,cAAc,EAAE,MAAM;gBAAtB,cAAc,EAAE,MAAM;CAInD;AAsED,0CAA0C;AAC1C,MAAM,WAAW,qBAAqB;IACpC,mEAAmE;IACnE,cAAc,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,YAAY,EAAE,MAAM,CAAC;IACrB;;;OAGG;IACH,WAAW,EAAE,MAAM,CAAC;IACpB;;;;;;;OAOG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,cAAc;IAC7B,sEAAsE;IACtE,MAAM,EAAE,aAAa,CAAC,UAAU,CAAC,CAAC;IAClC,oEAAoE;IACpE,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,0EAA0E;IAC1E,KAAK,IAAI,IAAI,CAAC;CACf;AAED;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC1B;;;;;OAKG;IACH,aAAa,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC;QAC3C,EAAE,EAAE,MAAM,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;QACb,yFAAyF;QACzF,KAAK,EAAE,MAAM,CAAC;KACf,GAAG,IAAI,CAAC,CAAC;IACV,4DAA4D;IAC5D,kBAAkB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAClE;;;OAGG;IACH,oBAAoB,CAClB,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC,CAAC;IACnD;;;;;;OAMG;IACH,gBAAgB,CACd,oBAAoB,EAAE,MAAM,GAC3B,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC5C,2DAA2D;IAC3D,YAAY,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,YAAY,CAAC,CAAC,CAAC;IAC3E;;;;;OAKG;IACH,aAAa,CAAC,YAAY,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACtE;;;OAGG;IACH,kBAAkB,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1D;;;;;;;;OAQG;IACH,iBAAiB,CAAC,IAAI,EAAE,qBAAqB,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;CACzE;AAED,iEAAiE;AACjE,MAAM,MAAM,YAAY,GAAG,kBAAkB,CAAC;AAM9C,wDAAwD;AACxD,MAAM,WAAW,qBAAqB;IACpC,qEAAqE;IACrE,kBAAkB,EAAE,kBAAkB,CAAC;IACvC;;;;;;;;;OASG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;IAC/C,iDAAiD;IACjD,OAAO,CAAC,EAAE,YAAY,CAAC;CACxB;AAQD;;;GAGG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,qBAAqB,GAC1B,WAAW,CAiHb"}