@imenam/unified-llm-client 1.2.0

package/dist/adapters/gemini/GeminiPromptAdapter.js

@@ -0,0 +1,334 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeminiPromptAdapter = void 0;
+const genai_1 = require("@google/genai");
+const mime = __importStar(require("mime-types"));
+class GeminiPromptAdapter {
+    constructor(opts) {
+        this.opts = opts;
+        if (!opts.apiKey) {
+            throw new Error("Google API key is missing in options. Please provide it via opts.apiKey.");
+        }
+        this.genAI = new genai_1.GoogleGenAI({ apiKey: opts.apiKey });
+    }
+    formatMessage(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            if (message.role === "function" || message.parts) {
+                return message;
+            }
+            // Assistant message with tool calls — inject dummy thought_signature on the first
+            // functionCall part to satisfy Gemini 3 validation when history is rebuilt manually.
+            // Ref: https://ai.google.dev/gemini-api/docs/thought-signatures (FAQ section)
+            if (message.role === "assistant" && message.tool_calls && message.tool_calls.length > 0) {
+                return {
+                    role: "model",
+                    parts: message.tool_calls.map((tc, index) => (Object.assign(Object.assign({}, (index === 0 ? { thoughtSignature: "skip_thought_signature_validator" } : {})), { functionCall: {
+                            name: tc.name,
+                            args: tc.arguments,
+                        } }))),
+                };
+            }
+            // Tool result message → function turn with functionResponse parts
+            // For Gemini, tool_call_id must contain the function name
+            if (message.role === "tool") {
+                return {
+                    role: "function",
+                    parts: [{
+                            functionResponse: {
+                                name: (_a = message.tool_call_id) !== null && _a !== void 0 ? _a : "",
+                                response: { result: (_b = message.content) !== null && _b !== void 0 ? _b : "" },
+                            },
+                        }],
+                };
+            }
+            const parts = [];
+            if (message.content) {
+                parts.push({ text: message.content || "" });
+            }
+            if (message.attachedFile) {
+                const files = Array.isArray(message.attachedFile) ? message.attachedFile : [message.attachedFile];
+                for (const file of files) {
+                    if (typeof file === 'string') {
+                        const determinedMimeType = mime.lookup(file) || 'application/octet-stream';
+                        const uploadedFile = yield this.genAI.files.upload({
+                            file: file,
+                            config: { mimeType: determinedMimeType },
+                        });
+                        if (typeof uploadedFile.uri === 'string') {
+                            parts.push((0, genai_1.createPartFromUri)(uploadedFile.uri, (_c = uploadedFile.mimeType) !== null && _c !== void 0 ? _c : determinedMimeType));
+                        }
+                        else {
+                            console.warn("Uploaded file URI is not a string, skipping file part:", uploadedFile);
+                        }
+                    }
+                }
+            }
+            return {
+                role: message.role === "assistant" ? "model" : message.role,
+                parts: parts,
+            };
+        });
+    }
+    sendToProvider(messages_1) {
+        return __awaiter(this, arguments, void 0, function* (messages, tools = [], toolChoice = "auto", attachedFile, model, config) {
+            var _a, _b, _c;
+            const contents = messages.filter((m) => m !== undefined);
+            let sdkTools = undefined;
+            if ((tools === null || tools === void 0 ? void 0 : tools.length) > 0) {
+                sdkTools = [{
+                        functionDeclarations: tools === null || tools === void 0 ? void 0 : tools.map(t => ({
+                            name: t.name,
+                            description: t.description,
+                            parameters: t.parameters,
+                        })),
+                    }];
+            }
+            let toolConfig = undefined;
+            if (sdkTools && sdkTools.length > 0) {
+                if (toolChoice === "none") {
+                    toolConfig = { functionCallingConfig: { mode: genai_1.FunctionCallingConfigMode.NONE } };
+                }
+                else if (toolChoice === "any") {
+                    toolConfig = { functionCallingConfig: { mode: genai_1.FunctionCallingConfigMode.ANY } };
+                }
+                else if (toolChoice !== "auto" && typeof toolChoice === 'string') {
+                    toolConfig = {
+                        functionCallingConfig: {
+                            mode: genai_1.FunctionCallingConfigMode.ANY,
+                            allowedFunctionNames: [toolChoice],
+                        },
+                    };
+                }
+                else if (toolChoice === "auto") {
+                    toolConfig = { functionCallingConfig: { mode: genai_1.FunctionCallingConfigMode.AUTO } };
+                }
+            }
+            const result = yield this.genAI.models.generateContent({
+                model: model || this.opts.model,
+                contents,
+                config: {
+                    thinkingConfig: {
+                        thinkingBudget: (_a = config === null || config === void 0 ? void 0 : config.thinkingBudget) !== null && _a !== void 0 ? _a : 128,
+                    },
+                    maxOutputTokens: 65535,
+                    tools: sdkTools,
+                    toolConfig,
+                },
+            });
+            const sdkResponse = result;
+            const responseCandidate = (_b = sdkResponse.candidates) === null || _b === void 0 ? void 0 : _b[0];
+            let responseText = null;
+            if ((_c = responseCandidate === null || responseCandidate === void 0 ? void 0 : responseCandidate.content) === null || _c === void 0 ? void 0 : _c.parts) {
+                for (const part of responseCandidate.content.parts) {
+                    if (part.text) {
+                        responseText = (responseText !== null && responseText !== void 0 ? responseText : "") + part.text;
+                    }
+                }
+            }
+            return {
+                content: responseText,
+                raw: sdkResponse,
+            };
+        });
+    }
+    /**
+     * Initiates a streaming chat session with the Gemini model.
+     *
+     * This method sends the conversation history and any specified tools to the Gemini API
+     * and returns an asynchronous iterable that yields chunks of the response as they become available.
+     * It also provides a way to retrieve the final aggregated response metadata once the stream completes.
+     *
+     * @param messages An array of `ChatMessage` objects representing the conversation history.
+     * @param tools Optional. An array of `ToolDefinition` objects that the LLM can use.
+     * @param toolChoice Optional. Controls how the LLM uses tools: "auto", "none", or a specific tool name.
+     * @returns A `StreamingChatResult` object containing the stream of `StreamedChatChunk` and a function `getFinalResponse`
+     *          to retrieve the final response metadata (excluding content, which is streamed).
+     * @throws Error if the Gemini API key is not configured or if the underlying SDK call fails.
+     */
+    streamFromProvider(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ messages, tools, toolChoice, model, onChunk, onFinalResponse, config, }) {
+            var _b, e_1, _c, _d;
+            var _e, _f, _g, _h, _j, _k;
+            if (!this.genAI) {
+                throw new Error("Gemini API not configured");
+            }
+            const contents = messages.filter((m) => m !== undefined);
+            let sdkTools = undefined;
+            if (tools && tools.length > 0) {
+                sdkTools = [{
+                        functionDeclarations: tools === null || tools === void 0 ? void 0 : tools.map(t => ({
+                            name: t.name,
+                            description: t.description,
+                            parameters: t.parameters,
+                        })),
+                    }];
+            }
+            let toolConfigValue = undefined;
+            if (sdkTools && sdkTools.length > 0) {
+                if (toolChoice === "none") {
+                    toolConfigValue = { functionCallingConfig: { mode: genai_1.FunctionCallingConfigMode.NONE } };
+                }
+                else if (toolChoice === "any") {
+                    toolConfigValue = { functionCallingConfig: { mode: genai_1.FunctionCallingConfigMode.ANY } };
+                }
+                else if (toolChoice !== "auto" && typeof toolChoice === 'string') {
+                    toolConfigValue = {
+                        functionCallingConfig: {
+                            mode: genai_1.FunctionCallingConfigMode.ANY,
+                            allowedFunctionNames: [toolChoice],
+                        },
+                    };
+                }
+                else if (toolChoice === "auto") {
+                    toolConfigValue = { functionCallingConfig: { mode: genai_1.FunctionCallingConfigMode.AUTO } };
+                }
+            }
+            const finalResponseData = {
+                content: "",
+                raw: null,
+                toolCalls: [],
+                usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0, promptTokensDetails: [], thoughtsToken: 0 },
+                finishReason: undefined
+            };
+            const formattedContents = contents;
+            const streamResult = yield this.genAI.models.generateContentStream({
+                model: model || this.opts.model,
+                contents: formattedContents,
+                config: {
+                    tools: sdkTools,
+                    toolConfig: toolConfigValue,
+                    thinkingConfig: {
+                        thinkingBudget: (config === null || config === void 0 ? void 0 : config.thinkingBudget) || 0,
+                    }
+                },
+            });
+            let aggregatedContent = "";
+            const aggregatedToolCalls = [];
+            let lastChunk = null;
+            try {
+                for (var _l = true, streamResult_1 = __asyncValues(streamResult), streamResult_1_1; streamResult_1_1 = yield streamResult_1.next(), _b = streamResult_1_1.done, !_b; _l = true) {
+                    _d = streamResult_1_1.value;
+                    _l = false;
+                    const chunk = _d;
+                    lastChunk = chunk; // Keep track of the last chunk
+                    const candidate = (_e = chunk.candidates) === null || _e === void 0 ? void 0 : _e[0];
+                    if (!candidate)
+                        continue;
+                    let contentChunkText = "";
+                    if ((_f = candidate.content) === null || _f === void 0 ? void 0 : _f.parts) {
+                        for (const part of candidate.content.parts) {
+                            if (part.text) {
+                                contentChunkText += part.text;
+                            }
+                            if (part.functionCall) {
+                                const fc = part.functionCall;
+                                const toolCall = {
+                                    id: fc.name || "",
+                                    name: fc.name || "",
+                                    arguments: fc.args || {},
+                                };
+                                aggregatedToolCalls.push(toolCall);
+                            }
+                        }
+                    }
+                    if (contentChunkText) {
+                        aggregatedContent += contentChunkText;
+                        onChunk === null || onChunk === void 0 ? void 0 : onChunk({ contentChunk: contentChunkText, rawChunk: chunk });
+                    }
+                    if (((_h = (_g = candidate.content) === null || _g === void 0 ? void 0 : _g.parts) === null || _h === void 0 ? void 0 : _h.some((p) => p.functionCall)) && aggregatedToolCalls.length > 0) {
+                    }
+                    if (chunk.usageMetadata) {
+                        finalResponseData.usage = {
+                            promptTokens: chunk.usageMetadata.promptTokenCount || 0,
+                            completionTokens: chunk.usageMetadata.candidatesTokenCount || 0,
+                            totalTokens: chunk.usageMetadata.totalTokenCount || 0,
+                            promptTokensDetails: chunk.usageMetadata.promptTokensDetails || [],
+                            thoughtsToken: chunk.usageMetadata.thoughtsTokenCount || 0,
+                        };
+                    }
+                    if (candidate.finishReason) {
+                        finalResponseData.finishReason = candidate.finishReason;
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_l && !_b && (_c = streamResult_1.return)) yield _c.call(streamResult_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            // If streamResult is the generator, there's no separate .response object.
+            // We derive final data from the stream's completion and the last chunk seen.
+            finalResponseData.raw = lastChunk; // The last chunk might contain some aggregated data or be the closest to a "final response"
+            if ((_k = (_j = lastChunk === null || lastChunk === void 0 ? void 0 : lastChunk.candidates) === null || _j === void 0 ? void 0 : _j[0]) === null || _k === void 0 ? void 0 : _k.finishReason) {
+                finalResponseData.finishReason = lastChunk.candidates[0].finishReason;
+            }
+            if (lastChunk === null || lastChunk === void 0 ? void 0 : lastChunk.usageMetadata) {
+                finalResponseData.usage = {
+                    promptTokens: lastChunk.usageMetadata.promptTokenCount || 0,
+                    completionTokens: lastChunk.usageMetadata.candidatesTokenCount || 0,
+                    totalTokens: lastChunk.usageMetadata.totalTokenCount || 0,
+                    promptTokensDetails: lastChunk.usageMetadata.promptTokensDetails || [],
+                    thoughtsToken: lastChunk.usageMetadata.thoughtsTokenCount || 0,
+                };
+            }
+            // Tool calls are aggregated during the stream. Ensure they are set.
+            finalResponseData.toolCalls = aggregatedToolCalls.length > 0 ? aggregatedToolCalls : undefined;
+            onChunk === null || onChunk === void 0 ? void 0 : onChunk({ isFinal: true, contentChunk: "" });
+            onFinalResponse === null || onFinalResponse === void 0 ? void 0 : onFinalResponse(finalResponseData);
+            return finalResponseData;
+        });
+    }
+}
+exports.GeminiPromptAdapter = GeminiPromptAdapter;

package/dist/adapters/gemini/GeminiToolAdapter.d.ts

@@ -0,0 +1,8 @@
+import { ToolCall } from "../../common/types";
+import { ToolAdapter } from "../../core/LLMAdapter";
+import { ToolDefinition } from "../../common/types";
+export declare class GeminiToolAdapter implements ToolAdapter {
+    formatToolCallResult(toolCall: ToolCall): any;
+    formatTool(tool: ToolDefinition): any;
+}
+//# sourceMappingURL=GeminiToolAdapter.d.ts.map

package/dist/adapters/gemini/GeminiToolAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GeminiToolAdapter.d.ts","sourceRoot":"","sources":["../../../src/adapters/gemini/GeminiToolAdapter.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAC9C,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEpD,qBAAa,iBAAkB,YAAW,WAAW;IACnD,oBAAoB,CAAC,QAAQ,EAAE,QAAQ,GAAG,GAAG;IA6B7C,UAAU,CAAC,IAAI,EAAE,cAAc,GAAG,GAAG;CAOtC"}

package/dist/adapters/gemini/GeminiToolAdapter.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeminiToolAdapter = void 0;
+class GeminiToolAdapter {
+    formatToolCallResult(toolCall) {
+        let result_content;
+        if (typeof toolCall.result === 'string') {
+            // Si le résultat est une simple chaîne, on essaie de la parser comme JSON
+            // au cas où ce serait une chaîne JSON. Sinon, on l'utilise telle quelle.
+            try {
+                result_content = JSON.parse(toolCall.result);
+            }
+            catch (e) {
+                result_content = toolCall.result;
+            }
+        }
+        else {
+            result_content = toolCall.result;
+        }
+        return {
+            role: "function",
+            parts: [
+                {
+                    functionResponse: {
+                        name: toolCall.name,
+                        response: {
+                            output: result_content,
+                        },
+                    }
+                },
+            ],
+        };
+    }
+    formatTool(tool) {
+        return {
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.parameters,
+        };
+    }
+}
+exports.GeminiToolAdapter = GeminiToolAdapter;

package/dist/adapters/gemini/types.d.ts

@@ -0,0 +1,14 @@
+export interface GeminiModalityTokenCount {
+    modality: 'TEXT' | 'IMAGE' | 'AUDIO' | 'VIDEO';
+    tokenCount: number;
+}
+export interface GeminiUsageMetadata {
+    promptTokenCount: number;
+    candidatesTokenCount: number;
+    totalTokenCount: number;
+    promptTokensDetails?: GeminiModalityTokenCount[];
+    candidatesTokensDetails?: GeminiModalityTokenCount[];
+    cachedContentTokenCount?: number;
+    thoughtsTokenCount?: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/adapters/gemini/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/adapters/gemini/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,wBAAwB;IACvC,QAAQ,EAAE,MAAM,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,CAAC;IAC/C,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,mBAAmB;IAClC,gBAAgB,EAAE,MAAM,CAAC;IACzB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,eAAe,EAAE,MAAM,CAAC;IACxB,mBAAmB,CAAC,EAAE,wBAAwB,EAAE,CAAC;IACjD,uBAAuB,CAAC,EAAE,wBAAwB,EAAE,CAAC;IACrD,uBAAuB,CAAC,EAAE,MAAM,CAAC;IACjC,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B"}

package/dist/adapters/gemini/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/adapters/openai/OpenAIOutputAdapter.d.ts

@@ -0,0 +1,6 @@
+import { ChatResponse } from "../../common/types";
+import { OutputAdapter } from "../../core/LLMAdapter";
+export declare class OpenAIOutputAdapter implements OutputAdapter {
+    parse(providerResponse: any): ChatResponse;
+}
+//# sourceMappingURL=OpenAIOutputAdapter.d.ts.map

package/dist/adapters/openai/OpenAIOutputAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OpenAIOutputAdapter.d.ts","sourceRoot":"","sources":["../../../src/adapters/openai/OpenAIOutputAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAEtD,qBAAa,mBAAoB,YAAW,aAAa;IAChD,KAAK,CAAC,gBAAgB,EAAE,GAAG,GAAG,YAAY;CAclD"}

package/dist/adapters/openai/OpenAIOutputAdapter.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIOutputAdapter = void 0;
+class OpenAIOutputAdapter {
+    parse(providerResponse) {
+        var _a, _b, _c, _d, _e;
+        const usage = providerResponse.raw.usage;
+        let output = Object.assign(Object.assign({}, providerResponse), { usage: {
+                promptTokens: (_a = usage.promptTokens) !== null && _a !== void 0 ? _a : usage.prompt_tokens,
+                completionTokens: (_b = usage.completionTokens) !== null && _b !== void 0 ? _b : usage.completion_tokens,
+                totalTokens: (_c = usage.totalTokens) !== null && _c !== void 0 ? _c : usage.total_tokens,
+                promptTokensDetails: (_d = usage.promptTokensDetails) !== null && _d !== void 0 ? _d : usage.prompt_tokens_details,
+                completionTokensDetails: (_e = usage.completionTokensDetails) !== null && _e !== void 0 ? _e : usage.completion_tokens_details,
+            } });
+        return output;
+    }
+}
+exports.OpenAIOutputAdapter = OpenAIOutputAdapter;

package/dist/adapters/openai/OpenAIPromptAdapter.d.ts

@@ -0,0 +1,13 @@
+import { PromptAdapterOptions, PromptAdapter } from "../../core/LLMAdapter";
+import { ChatMessage, ToolDefinition, ChatResponse } from "../../common/types";
+export declare class OpenAIPromptAdapter implements PromptAdapter {
+    private readonly opts;
+    private readonly endpoint;
+    private messages;
+    constructor(opts: PromptAdapterOptions);
+    formatMessage(message: ChatMessage): any;
+    sendToProvider(messages: any, tools?: ToolDefinition[], toolChoice?: "auto" | "none" | string, attachedFile?: string | string[], model?: string): Promise<ChatResponse>;
+    private processFiles;
+    private request;
+}
+//# sourceMappingURL=OpenAIPromptAdapter.d.ts.map

package/dist/adapters/openai/OpenAIPromptAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OpenAIPromptAdapter.d.ts","sourceRoot":"","sources":["../../../src/adapters/openai/OpenAIPromptAdapter.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC5E,OAAO,EAAE,WAAW,EAAY,cAAc,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAKzF,qBAAa,mBAAoB,YAAW,aAAa;IAI3C,OAAO,CAAC,QAAQ,CAAC,IAAI;IAHjC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAa;gBAEA,IAAI,EAAE,oBAAoB;IAMhD,aAAa,CAAC,OAAO,EAAE,WAAW,GAAG,GAAG;IA4CzC,cAAc,CAClB,QAAQ,EAAE,GAAG,EACb,KAAK,GAAE,cAAc,EAAO,EAC5B,UAAU,GAAE,MAAM,GAAG,MAAM,GAAG,MAAe,EAC7C,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,EAChC,KAAK,CAAC,EAAE,MAAM,GACb,OAAO,CAAC,YAAY,CAAC;IAmDxB,OAAO,CAAC,YAAY;YAmCN,OAAO;CAetB"}