@revealui/ai 0.2.9 → 0.4.0

package/dist/tools/mcp-adapter.js

@@ -1,9 +1,418 @@
 /**
  * MCP Tool Adapter
  *
- * Bridges MCP (Model Context Protocol) servers to the tool system
+ * Bridges MCP (Model Context Protocol) servers to the tool system.
+ *
+ * Two paths:
+ *
+ *   1. **Standard MCP client** (Stage 5.1a, preferred) — consumers construct an
+ *      `McpClient` from `@revealui/mcp/client` against stdio or Streamable HTTP,
+ *      and pass it to `createToolsFromMcpClient()` (or to `AgentRuntime` via
+ *      `mcpClients`). This is the full-protocol path: future stages will extend
+ *      this to resources, prompts, sampling, elicitation, etc.
+ *
+ *   2. **Hypervisor** (legacy, pre-5.1a) — consumers pass an `MCPHypervisor` (or
+ *      any `MCPToolSource`) to `discoverMCPTools()`. Kept for backwards compat;
+ *      deprecated in favor of path (1). The hypervisor still owns server-side
+ *      subprocess + tenant-scoping concerns and isn't going away.
+ *
+ * Both paths are deliberately **structurally typed** — `@revealui/ai` has no
+ * runtime dependency on `@revealui/mcp`. Consumers satisfy the shapes
+ * `McpClientLike` / `MCPToolSource` with whichever client they construct.
  */
 import { z } from 'zod/v4';
+import { emitMcpEvent } from './mcp-events.js';
+/**
+ * Connect the agent's tool registry to a standard MCP client. Lists tools
+ * from the MCP server and returns agent-side `Tool` instances that dispatch
+ * calls back through the client. Safe to call multiple times per server —
+ * each invocation re-reads the current tool list.
+ *
+ * @example
+ * ```typescript
+ * import { McpClient } from '@revealui/mcp/client';
+ * import { createToolsFromMcpClient } from '@revealui/ai';
+ *
+ * const client = new McpClient({
+ *   clientInfo: { name: 'my-agent', version: '1.0.0' },
+ *   transport: { kind: 'streamable-http', url: 'https://example.com/mcp' },
+ * });
+ * await client.connect();
+ *
+ * const tools = await createToolsFromMcpClient(client, {
+ *   namespace: 'example-server',
+ * });
+ *
+ * agent.tools.push(...tools);
+ * ```
+ */
+export async function createToolsFromMcpClient(client, options) {
+    if (!(options.namespace && /^[a-zA-Z0-9_-]+$/.test(options.namespace))) {
+        throw new Error(`createToolsFromMcpClient: namespace must be a non-empty string of [a-zA-Z0-9_-], got ${JSON.stringify(options.namespace)}`);
+    }
+    const category = options.category ?? 'mcp';
+    const includeTools = options.include?.tools !== false;
+    const includeResources = options.include?.resources !== false;
+    const includePrompts = options.include?.prompts !== false;
+    const ctx = {
+        namespace: options.namespace,
+        category,
+        ...(options.onProgress !== undefined ? { onProgress: options.onProgress } : {}),
+        ...(options.signal !== undefined ? { signal: options.signal } : {}),
+        ...(options.onEvent !== undefined ? { onEvent: options.onEvent } : {}),
+    };
+    const tools = [];
+    // --- Server tools (Stage 5.1a) -----------------------------------------
+    if (includeTools) {
+        const descriptors = await client.listTools();
+        for (const descriptor of descriptors) {
+            tools.push(buildServerTool(client, descriptor, ctx));
+        }
+    }
+    // --- Resource meta-tools (Stage 5.1b) ----------------------------------
+    if (includeResources && client.listResources && client.readResource) {
+        tools.push(buildListResourcesTool(client, ctx));
+        tools.push(buildReadResourceTool(client, ctx));
+    }
+    // --- Prompt meta-tools (Stage 5.1b) ------------------------------------
+    if (includePrompts && client.listPrompts && client.getPrompt) {
+        tools.push(buildListPromptsTool(client, ctx));
+        tools.push(buildGetPromptTool(client, ctx));
+    }
+    return tools;
+}
+/**
+ * Build the request-options object passed to `client.callTool()` /
+ * `readResource()` / etc. Wraps the ctx's `onProgress` with the
+ * specific tool name + namespace so every emitted event is attributable.
+ */
+function buildRequestOptions(ctx, toolName) {
+    const opts = {};
+    if (ctx.onProgress) {
+        const emit = ctx.onProgress;
+        opts.onProgress = (progress) => emit({ namespace: ctx.namespace, toolName, progress });
+    }
+    if (ctx.signal)
+        opts.signal = ctx.signal;
+    return opts.onProgress || opts.signal ? opts : undefined;
+}
+function buildServerTool(client, descriptor, ctx) {
+    const zodSchema = jsonSchemaObjectToZod(descriptor.inputSchema);
+    const namespacedName = `mcp_${ctx.namespace}__${descriptor.name}`;
+    return {
+        name: namespacedName,
+        label: descriptor.name,
+        description: descriptor.description ?? `${ctx.namespace}: ${descriptor.name}`,
+        parameters: zodSchema,
+        async execute(params) {
+            const validated = zodSchema.parse(params);
+            const started = Date.now();
+            try {
+                const result = await client.callTool(descriptor.name, validated, buildRequestOptions(ctx, descriptor.name));
+                if (result.isError) {
+                    const errorText = extractErrorText(result);
+                    emitMcpEvent(ctx.onEvent, {
+                        kind: 'mcp.tool.call',
+                        namespace: ctx.namespace,
+                        toolName: descriptor.name,
+                        duration_ms: Date.now() - started,
+                        success: false,
+                        error: errorText,
+                    });
+                    return { success: false, error: errorText };
+                }
+                emitMcpEvent(ctx.onEvent, {
+                    kind: 'mcp.tool.call',
+                    namespace: ctx.namespace,
+                    toolName: descriptor.name,
+                    duration_ms: Date.now() - started,
+                    success: true,
+                });
+                const payload = result.structuredContent ?? result.content;
+                return { success: true, data: serializeMCPResult(payload) };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                emitMcpEvent(ctx.onEvent, {
+                    kind: 'mcp.tool.call',
+                    namespace: ctx.namespace,
+                    toolName: descriptor.name,
+                    duration_ms: Date.now() - started,
+                    success: false,
+                    error: message,
+                });
+                return { success: false, error: message };
+            }
+        },
+        getMetadata() {
+            return { category: ctx.category, version: '1.0.0', mcpNamespace: ctx.namespace };
+        },
+    };
+}
+function buildListResourcesTool(client, ctx) {
+    return {
+        name: `mcp_${ctx.namespace}__list_resources`,
+        label: 'list_resources',
+        description: `List resources exposed by the ${ctx.namespace} MCP server. Returns an array of { uri, name, description?, mimeType? }.`,
+        parameters: z.object({}),
+        async execute() {
+            const started = Date.now();
+            try {
+                const resources = (await client.listResources?.(buildRequestOptions(ctx, 'list_resources'))) ?? [];
+                emitMcpEvent(ctx.onEvent, {
+                    kind: 'mcp.resource.list',
+                    namespace: ctx.namespace,
+                    duration_ms: Date.now() - started,
+                    success: true,
+                    resourceCount: resources.length,
+                });
+                return { success: true, data: serializeMCPResult(resources) };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                emitMcpEvent(ctx.onEvent, {
+                    kind: 'mcp.resource.list',
+                    namespace: ctx.namespace,
+                    duration_ms: Date.now() - started,
+                    success: false,
+                    error: message,
+                });
+                return { success: false, error: message };
+            }
+        },
+        getMetadata() {
+            return {
+                category: ctx.category,
+                version: '1.0.0',
+                mcpNamespace: ctx.namespace,
+                kind: 'resources',
+            };
+        },
+    };
+}
+function buildReadResourceTool(client, ctx) {
+    const paramsSchema = z.object({
+        uri: z.string().min(1).describe('Resource URI to read (e.g. revealui-content://posts/abc)'),
+    });
+    return {
+        name: `mcp_${ctx.namespace}__read_resource`,
+        label: 'read_resource',
+        description: `Read a resource by URI from the ${ctx.namespace} MCP server. Returns the resource contents (text parts flattened to a joined string when possible).`,
+        parameters: paramsSchema,
+        async execute(params) {
+            const { uri } = paramsSchema.parse(params);
+            const started = Date.now();
+            try {
+                const contents = (await client.readResource?.(uri, buildRequestOptions(ctx, 'read_resource'))) ?? [];
+                emitMcpEvent(ctx.onEvent, {
+                    kind: 'mcp.resource.read',
+                    namespace: ctx.namespace,
+                    uri,
+                    duration_ms: Date.now() - started,
+                    success: true,
+                });
+                const joinedText = flattenResourceText(contents);
+                const base = {
+                    success: true,
+                    data: serializeMCPResult(contents),
+                };
+                return joinedText !== undefined ? { ...base, content: joinedText } : base;
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                emitMcpEvent(ctx.onEvent, {
+                    kind: 'mcp.resource.read',
+                    namespace: ctx.namespace,
+                    uri,
+                    duration_ms: Date.now() - started,
+                    success: false,
+                    error: message,
+                });
+                return { success: false, error: message };
+            }
+        },
+        getMetadata() {
+            return {
+                category: ctx.category,
+                version: '1.0.0',
+                mcpNamespace: ctx.namespace,
+                kind: 'resources',
+            };
+        },
+    };
+}
+function buildListPromptsTool(client, ctx) {
+    return {
+        name: `mcp_${ctx.namespace}__list_prompts`,
+        label: 'list_prompts',
+        description: `List prompts exposed by the ${ctx.namespace} MCP server. Returns an array of { name, description?, arguments? }.`,
+        parameters: z.object({}),
+        async execute() {
+            const started = Date.now();
+            try {
+                const prompts = (await client.listPrompts?.(buildRequestOptions(ctx, 'list_prompts'))) ?? [];
+                emitMcpEvent(ctx.onEvent, {
+                    kind: 'mcp.prompt.list',
+                    namespace: ctx.namespace,
+                    duration_ms: Date.now() - started,
+                    success: true,
+                    promptCount: prompts.length,
+                });
+                return { success: true, data: serializeMCPResult(prompts) };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                emitMcpEvent(ctx.onEvent, {
+                    kind: 'mcp.prompt.list',
+                    namespace: ctx.namespace,
+                    duration_ms: Date.now() - started,
+                    success: false,
+                    error: message,
+                });
+                return { success: false, error: message };
+            }
+        },
+        getMetadata() {
+            return {
+                category: ctx.category,
+                version: '1.0.0',
+                mcpNamespace: ctx.namespace,
+                kind: 'prompts',
+            };
+        },
+    };
+}
+function buildGetPromptTool(client, ctx) {
+    const paramsSchema = z.object({
+        name: z.string().min(1).describe('Prompt name to retrieve'),
+        args: z
+            .record(z.string(), z.string())
+            .optional()
+            .describe('Prompt arguments as a string-valued map (per MCP spec)'),
+    });
+    return {
+        name: `mcp_${ctx.namespace}__get_prompt`,
+        label: 'get_prompt',
+        description: `Get a resolved prompt from the ${ctx.namespace} MCP server. Returns { description?, messages } — messages is an array of { role, content }.`,
+        parameters: paramsSchema,
+        async execute(params) {
+            const { name, args } = paramsSchema.parse(params);
+            const started = Date.now();
+            try {
+                const result = await client.getPrompt?.(name, args, buildRequestOptions(ctx, 'get_prompt'));
+                if (!result) {
+                    const msg = 'client does not implement getPrompt';
+                    emitMcpEvent(ctx.onEvent, {
+                        kind: 'mcp.prompt.get',
+                        namespace: ctx.namespace,
+                        promptName: name,
+                        duration_ms: Date.now() - started,
+                        success: false,
+                        error: msg,
+                    });
+                    return { success: false, error: msg };
+                }
+                emitMcpEvent(ctx.onEvent, {
+                    kind: 'mcp.prompt.get',
+                    namespace: ctx.namespace,
+                    promptName: name,
+                    duration_ms: Date.now() - started,
+                    success: true,
+                });
+                const joinedText = flattenPromptMessages(result.messages);
+                const base = {
+                    success: true,
+                    data: serializeMCPResult(result),
+                };
+                return joinedText !== undefined ? { ...base, content: joinedText } : base;
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                emitMcpEvent(ctx.onEvent, {
+                    kind: 'mcp.prompt.get',
+                    namespace: ctx.namespace,
+                    promptName: name,
+                    duration_ms: Date.now() - started,
+                    success: false,
+                    error: message,
+                });
+                return { success: false, error: message };
+            }
+        },
+        getMetadata() {
+            return {
+                category: ctx.category,
+                version: '1.0.0',
+                mcpNamespace: ctx.namespace,
+                kind: 'prompts',
+            };
+        },
+    };
+}
+/**
+ * Collapse an array of resource contents to a single text string when every
+ * part carries text. Returns `undefined` if any part is binary (blob) or has
+ * no text, signaling the caller that a token-efficient summary isn't
+ * available — in which case the full `data` array still carries everything.
+ */
+function flattenResourceText(contents) {
+    if (contents.length === 0)
+        return undefined;
+    const parts = [];
+    for (const part of contents) {
+        if (typeof part.text === 'string') {
+            parts.push(part.text);
+        }
+        else {
+            return undefined;
+        }
+    }
+    return parts.join('\n\n');
+}
+/**
+ * Collapse a prompt's message array to a single text summary in
+ * `<role>: <text>` format. Returns `undefined` when any message has a
+ * non-text content shape (image, resource reference, …).
+ */
+function flattenPromptMessages(messages) {
+    if (messages.length === 0)
+        return undefined;
+    const lines = [];
+    for (const msg of messages) {
+        const text = extractMessageText(msg.content);
+        if (text === undefined)
+            return undefined;
+        lines.push(`${msg.role}: ${text}`);
+    }
+    return lines.join('\n\n');
+}
+function extractMessageText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (content && typeof content === 'object') {
+        const c = content;
+        if (c.type === 'text' && typeof c.text === 'string')
+            return c.text;
+    }
+    return undefined;
+}
+/**
+ * Extract a human-readable error string from an MCP `CallToolResult` that
+ * came back with `isError: true`. Servers put the error detail in `content`
+ * per spec; we concatenate any text parts.
+ */
+function extractErrorText(result) {
+    const texts = [];
+    for (const part of result.content) {
+        if (part && typeof part === 'object') {
+            const p = part;
+            if (p.type === 'text' && typeof p.text === 'string') {
+                texts.push(p.text);
+            }
+        }
+    }
+    return texts.length > 0 ? texts.join('\n') : 'Tool reported error (no detail)';
+}
 /**
  * Create a Tool from an MCP tool definition
  */
@@ -108,6 +517,30 @@ export function discoverMCPTools(source) {
         return agentTool;
     });
 }
+/**
+ * Narrow an untyped `inputSchema` from a spec `Tool` into the shape
+ * `jsonSchemaToZod` understands, then delegate. Falls back to a permissive
+ * `z.object({})` when the input is malformed so tool discovery never hard-fails
+ * on a misbehaving server.
+ */
+function jsonSchemaObjectToZod(raw) {
+    if (!(raw && typeof raw === 'object'))
+        return z.object({});
+    const s = raw;
+    if (s.type !== 'object')
+        return z.object({});
+    const properties = s.properties && typeof s.properties === 'object'
+        ? s.properties
+        : undefined;
+    const required = Array.isArray(s.required)
+        ? s.required.filter((r) => typeof r === 'string')
+        : undefined;
+    return jsonSchemaToZod({
+        type: 'object',
+        ...(properties !== undefined ? { properties } : {}),
+        ...(required !== undefined ? { required } : {}),
+    });
+}
 /**
  * Convert JSON Schema to Zod schema (simplified version)
  * For production, use a proper library like json-schema-to-zod

package/dist/tools/mcp-elicitation.d.ts

@@ -0,0 +1,128 @@
+/**
+ * MCP Elicitation — route server `elicitation/create` requests through
+ * a consumer-provided UI callback (Stage 5.3 of the MCP v1 plan).
+ *
+ * The MCP spec defines `elicitation/create` as a server-to-client
+ * request: a server asks the client to collect structured input from
+ * the user mid-flow (form inputs, confirmations, auth prompts). The
+ * agent runtime is NOT the right place to decide what UI to show —
+ * each consumer (admin inspector, agent execution panel, CLI tool,
+ * Slack bot, …) renders in its own idiom. This module exposes
+ * `createElicitationHandler({ onElicit })` — a thin factory that
+ * wraps the consumer's async UI callback into the structural handler
+ * shape that `McpClient` from `@revealui/mcp/client` expects.
+ *
+ * Safety defaults
+ * ---------------
+ * - Servers that request **URL mode** (out-of-band consent via a
+ *   separate browser tab) are auto-declined unless `allowUrlMode: true`
+ *   is passed. URL mode is a phishing vector when the user can't
+ *   easily verify what domain they're on — admin inspector (Stage 3.4)
+ *   takes the same posture; agent runtime matches for consistency.
+ * - Optional `timeoutMs` auto-declines after the deadline. Useful in
+ *   headless automation where no human is at the keyboard.
+ * - Thrown errors inside `onElicit` are converted to `{ action:
+ *   'cancel' }` rather than propagating — servers should see a clean
+ *   decline, not a protocol error the UI crashed on.
+ *
+ * As with the rest of the MCP-adapter surface, this module uses
+ * structural typing to stay decoupled from `@revealui/mcp` — the real
+ * `ElicitationHandler` from `@revealui/mcp/client` structurally
+ * satisfies the `McpElicitationHandler` shape exported here.
+ *
+ * @example
+ * ```typescript
+ * import { McpClient } from '@revealui/mcp/client';
+ * import { createElicitationHandler } from '@revealui/ai';
+ *
+ * const client = new McpClient({
+ *   clientInfo: { name: 'my-agent', version: '1.0.0' },
+ *   transport: { kind: 'streamable-http', url: '…' },
+ *   elicitationHandler: createElicitationHandler({
+ *     onElicit: async ({ message, requestedSchema }) => {
+ *       const form = await showFormDialog({ title: message, schema: requestedSchema });
+ *       if (!form) return { action: 'cancel' };
+ *       return { action: 'accept', content: form.values };
+ *     },
+ *     timeoutMs: 60_000,
+ *   }),
+ * });
+ * ```
+ */
+import { type McpEventSink } from './mcp-events.js';
+/** Parameters of an `elicitation/create` request (spec-shaped subset). */
+export interface McpElicitRequestParams {
+    /**
+     * Elicitation mode. Currently the spec defines `'form'` (inline form
+     * fields) as the only named value; future modes (e.g. `'url'` for
+     * out-of-band consent) may appear. Undefined = `'form'`.
+     */
+    mode?: string;
+    /** User-facing prompt message. */
+    message: string;
+    /** JSON Schema describing the fields to collect. */
+    requestedSchema: {
+        type: 'object';
+        properties: Record<string, unknown>;
+        required?: ReadonlyArray<string>;
+    };
+}
+/** Allowed values for `ElicitResult.content` per the MCP spec. */
+export type McpElicitContentValue = string | number | boolean | ReadonlyArray<string>;
+/** Result of an `elicitation/create` request (spec-shaped subset). */
+export interface McpElicitResult {
+    action: 'accept' | 'decline' | 'cancel';
+    content?: Record<string, McpElicitContentValue>;
+}
+/** Structural shape of the handler — matches `ElicitationHandler` from `@revealui/mcp/client`. */
+export type McpElicitationHandler = (params: McpElicitRequestParams) => Promise<McpElicitResult>;
+export interface CreateElicitationHandlerOptions {
+    /**
+     * Consumer-supplied async callback that renders UI and collects the
+     * response. Receives the spec-shaped request params; returns a
+     * spec-shaped result. The factory handles URL-mode auto-decline,
+     * timeouts, and error-to-cancel mapping around this callback.
+     */
+    onElicit: (params: McpElicitRequestParams) => Promise<McpElicitResult>;
+    /**
+     * Auto-decline deadline in milliseconds. When set and no response
+     * arrives within the window, the handler returns `{ action: 'cancel' }`
+     * (not `'decline'` — the timeout wasn't a user decision). Set to
+     * `undefined` / omit to wait indefinitely.
+     */
+    timeoutMs?: number;
+    /**
+     * Accept `mode: 'url'` elicitation requests (out-of-band consent via
+     * a separate browser tab). Default `false` — URL-mode requests are
+     * auto-declined for safety. Flip to `true` only if the consumer's
+     * UI renders a verifiable domain-check + explicit user approval.
+     */
+    allowUrlMode?: boolean;
+    /**
+     * Observability hook. Fires before `onElicit` is invoked with the
+     * message + field count. Useful for audit trails.
+     */
+    onElicitationRequest?: (info: {
+        message: string;
+        fieldCount: number;
+        mode?: string;
+    }) => void;
+    /**
+     * Protocol-level observability sink (Stage 6.1). Fires once per
+     * `elicitation/create` call (after the handler decides — whether
+     * the user accepted, declined, cancelled, url-mode auto-declined,
+     * or the timeout fired) with `{ kind: 'mcp.elicitation.create',
+     * action, fieldCount, mode?, duration_ms, success }`. URL-mode
+     * auto-decline + timeout-cancel both emit `success: true` — they
+     * are legitimate handler outcomes, not failures. Only thrown errors
+     * report `success: false`.
+     */
+    onEvent?: McpEventSink;
+    /**
+     * Optional server identifier included in emitted events. Leave unset
+     * when the handler is shared across multiple servers.
+     */
+    namespace?: string;
+}
+export declare function createElicitationHandler(options: CreateElicitationHandlerOptions): McpElicitationHandler;
+//# sourceMappingURL=mcp-elicitation.d.ts.map

package/dist/tools/mcp-elicitation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-elicitation.d.ts","sourceRoot":"","sources":["../../src/tools/mcp-elicitation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AAGH,OAAO,EAAgB,KAAK,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAMlE,0EAA0E;AAC1E,MAAM,WAAW,sBAAsB;IACrC;;;;OAIG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,kCAAkC;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,oDAAoD;IACpD,eAAe,EAAE;QACf,IAAI,EAAE,QAAQ,CAAC;QACf,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACpC,QAAQ,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;KAClC,CAAC;CACH;AAED,kEAAkE;AAClE,MAAM,MAAM,qBAAqB,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,aAAa,CAAC,MAAM,CAAC,CAAC;AAEtF,sEAAsE;AACtE,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,QAAQ,GAAG,SAAS,GAAG,QAAQ,CAAC;IACxC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,qBAAqB,CAAC,CAAC;CACjD;AAED,kGAAkG;AAClG,MAAM,MAAM,qBAAqB,GAAG,CAAC,MAAM,EAAE,sBAAsB,KAAK,OAAO,CAAC,eAAe,CAAC,CAAC;AAMjG,MAAM,WAAW,+BAA+B;IAC9C;;;;;OAKG;IACH,QAAQ,EAAE,CAAC,MAAM,EAAE,sBAAsB,KAAK,OAAO,CAAC,eAAe,CAAC,CAAC;IACvE;;;;;OAKG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;;OAKG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB;;;OAGG;IACH,oBAAoB,CAAC,EAAE,CAAC,IAAI,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAC;IAC9F;;;;;;;;;OASG;IACH,OAAO,CAAC,EAAE,YAAY,CAAC;IACvB;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,+BAA+B,GACvC,qBAAqB,CAiEvB"}