@ai-setting/roy-agent-cli 1.3.15 → 1.3.16

package/dist/core/src/env/llm/invoke.js

@@ -0,0 +1,755 @@
+/**
+ * @fileoverview LLM invocation with AI SDK integration.
+ *
+ * This module provides LLM invocation using AI SDK for better provider support.
+ * Stream events are published via Environment.pushEnvEvent().
+ */
+import { randomUUID } from "crypto";
+import { streamText, jsonSchema } from "ai";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createGoogleGenerativeAI } from "@ai-sdk/google";
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import { zodToJsonSchema } from "zod-to-json-schema";
+import { createLogger } from "../log-trace/logger.js";
+// 创建 llm:invoke 模块日志器
+const logger = createLogger("llm:invoke");
+/**
+ * AI SDK 最大重试次数
+ * AI SDK 内部使用指数退避策略（默认 2s → 4s → 8s）
+ */
+const MAX_RETRIES = 3;
+/**
+ * LLM 默认超时时间（毫秒）
+ */
+const DEFAULT_TIMEOUT = 60000;
+/**
+ * 超时错误
+ */
+export class TimeoutError extends Error {
+    timeout;
+    constructor(message, timeout) {
+        super(message);
+        this.timeout = timeout;
+        this.name = "TimeoutError";
+    }
+}
+/**
+ * 带超时的 Promise 包装器
+ *
+ * @param promise 要执行的 Promise
+ * @param timeoutMs 超时时间（毫秒）
+ * @param message 自定义错误消息
+ * @returns Promise 结果
+ * @throws TimeoutError 当超时时
+ */
+export async function withTimeout(promise, timeoutMs = DEFAULT_TIMEOUT, message) {
+    const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => {
+            reject(new TimeoutError(message || `LLM invocation timeout after ${timeoutMs}ms`, timeoutMs));
+        }, timeoutMs);
+    });
+    return Promise.race([promise, timeoutPromise]);
+}
+/**
+ * 解析模型字符串
+ * 格式: "providerId/modelId"
+ */
+export function parseModelString(model) {
+    if (!model) {
+        return { providerId: "openai", modelId: "gpt-4o" };
+    }
+    const parts = model.split("/");
+    if (parts.length >= 2) {
+        return { providerId: parts[0], modelId: parts.slice(1).join("/") };
+    }
+    return { providerId: "openai", modelId: model };
+}
+/**
+ * 从 Usage 信息提取标准格式
+ */
+function extractUsageInfo(usage) {
+    if (!usage)
+        return undefined;
+    // 标准格式: inputTokens/outputTokens 是对象，包含 total 属性（AI SDK LanguageModelV3Usage）
+    if (usage.inputTokens && typeof usage.inputTokens === "object") {
+        return {
+            promptTokens: usage.inputTokens.total ?? 0,
+            completionTokens: usage.outputTokens?.total ?? 0,
+            totalTokens: usage.totalTokens ?? 0,
+        };
+    }
+    // 旧格式: 直接 number 属性
+    if (typeof usage.promptTokens === "number") {
+        return {
+            promptTokens: usage.promptTokens,
+            completionTokens: usage.completionTokens ?? 0,
+            totalTokens: usage.totalTokens ?? 0,
+        };
+    }
+    // MiniMax 格式: 使用 tokenDetails
+    if (usage.inputTokenDetails || usage.outputTokenDetails) {
+        return {
+            promptTokens: usage.inputTokenDetails?.tokens ?? 0,
+            completionTokens: usage.outputTokenDetails?.tokens ?? 0,
+            totalTokens: usage.totalTokens ?? 0,
+        };
+    }
+    // MiniMax 流式格式: 只有 total_tokens
+    if (usage.raw && typeof usage.raw.total_tokens === "number") {
+        return {
+            promptTokens: 0,
+            completionTokens: 0,
+            totalTokens: usage.raw.total_tokens,
+        };
+    }
+    return undefined;
+}
+/**
+ * 将 LLMMessage 转换为 AI SDK 格式
+ */
+function convertToSDKMessages(messages) {
+    return messages.map((msg) => {
+        // 处理 assistant 消息中的 toolCalls
+        if (msg.role === "assistant" && msg.toolCalls && msg.toolCalls.length > 0) {
+            // AI SDK v6 期望 toolCalls 在 content 数组中作为 tool-call part
+            // 注意：使用 input: unknown 而不是 arguments: string
+            const toolCallParts = msg.toolCalls.map((tc) => {
+                // 解析 arguments 为对象
+                let input = {};
+                if (tc.function?.arguments) {
+                    if (typeof tc.function.arguments === "string") {
+                        try {
+                            input = JSON.parse(tc.function.arguments);
+                        }
+                        catch {
+                            input = tc.function.arguments;
+                        }
+                    }
+                    else {
+                        input = tc.function.arguments;
+                    }
+                }
+                else if (tc.arguments) {
+                    if (typeof tc.arguments === "string") {
+                        try {
+                            input = JSON.parse(tc.arguments);
+                        }
+                        catch {
+                            input = tc.arguments;
+                        }
+                    }
+                    else {
+                        input = tc.arguments;
+                    }
+                }
+                return {
+                    type: "tool-call",
+                    toolCallId: tc.id,
+                    toolName: tc.function?.name || tc.name || "unknown",
+                    input,
+                };
+            });
+            return {
+                role: "assistant",
+                content: toolCallParts,
+            };
+        }
+        // 验证 tool 消息格式
+        if (msg.role === "tool") {
+            if (!msg.toolCallId) {
+                logger.warn("Tool message missing toolCallId", { msg });
+            }
+            // AI SDK v6 要求 tool 消息的 output 格式为 { type: 'text', value: string }
+            // 处理 content 可能是数组的情况（AI SDK v6 格式）
+            let outputValue = "";
+            const content = msg.content;
+            if (typeof content === "string") {
+                outputValue = content;
+            }
+            else if (Array.isArray(content)) {
+                // 如果是数组，可能是 [{ type: 'tool-result', output: '...' }]
+                const toolResultPart = content.find((p) => p?.type === "tool-result");
+                if (toolResultPart) {
+                    outputValue = typeof toolResultPart.output === "string"
+                        ? toolResultPart.output
+                        : JSON.stringify(toolResultPart.output);
+                }
+                else {
+                    // 尝试提取任何文本内容
+                    outputValue = JSON.stringify(content);
+                }
+            }
+            else {
+                outputValue = JSON.stringify(content);
+            }
+            const converted = {
+                role: "tool",
+                content: [{
+                        type: "tool-result",
+                        toolCallId: msg.toolCallId || "unknown",
+                        toolName: msg.name || "unknown",
+                        output: {
+                            type: "text",
+                            value: outputValue,
+                        },
+                    }],
+            };
+            return converted;
+        }
+        return msg;
+    });
+}
+/**
+ * 将 ToolInfo 转换为 AI SDK ToolSet 格式
+ */
+function convertToolsToSDK(tools) {
+    const result = {};
+    for (const tool of tools) {
+        const jsonSchemaObj = extractToolSchema(tool.parameters);
+        result[tool.name] = {
+            description: tool.description || "",
+            inputSchema: jsonSchema(jsonSchemaObj),
+        };
+    }
+    return result;
+}
+/**
+ * 从 Zod 类型提取 JSON Schema
+ */
+function extractToolSchema(parameters) {
+    // 如果是 Zod 类型
+    if (parameters && typeof parameters === "object" && "_def" in parameters) {
+        const zodSchema = parameters;
+        const schema = zodToJsonSchema(zodSchema, "zod");
+        if ("$ref" in schema && schema.definitions) {
+            const def = schema.definitions.zod;
+            if (def && def.type === "object" && def.properties) {
+                return {
+                    type: "object",
+                    properties: def.properties,
+                    required: def.required,
+                    additionalProperties: true,
+                };
+            }
+        }
+        return schema;
+    }
+    // 如果已经是 JSON Schema 格式
+    return parameters;
+}
+/**
+ * 生成 Provider 选项
+ */
+function generateProviderOptions(providerType, options) {
+    const result = {
+        providerOptions: {},
+    };
+    if (options.temperature !== undefined) {
+        result.temperature = options.temperature;
+    }
+    if (options.maxTokens !== undefined) {
+        result.maxTokens = options.maxTokens;
+    }
+    // Provider 特定配置
+    switch (providerType) {
+        case "anthropic":
+            // Anthropic 不支持 temperature，使用 top_p
+            break;
+        case "openai-compatible":
+            // OpenAI 兼容格式支持 includeUsage
+            result.providerOptions.includeUsage = true;
+            break;
+    }
+    return result;
+}
+/**
+ * 创建 Env 事件发布函数
+ * @param env Environment 实例
+ * @param context 上下文信息
+ * @returns 发布函数
+ */
+function createEnvEventEmitter(env, context) {
+    if (!env) {
+        return null;
+    }
+    return (event) => {
+        try {
+            env.pushEnvEvent({
+                id: randomUUID(),
+                type: `llm.${event.type}`,
+                timestamp: Date.now(),
+                metadata: {
+                    source: "llm.invoke",
+                    sessionId: context?.sessionId,
+                    messageId: context?.messageId,
+                },
+                payload: event,
+            });
+        }
+        catch (err) {
+            logger.warn("Failed to push env event", { error: String(err), eventType: event.type });
+        }
+    };
+}
+/**
+ * 处理文本中的 thinking 标签
+ */
+function processThinkingFromText(textDelta, config) {
+    if (!config.enabled || !textDelta) {
+        return { cleanedText: textDelta };
+    }
+    const tags = config.tags || ["thinking", "think"];
+    let remainingText = textDelta;
+    let extractedThinking = "";
+    for (const tag of tags) {
+        let openTag;
+        let closeTag;
+        // 特殊处理 "think" -> 映射到标准的 <think>/</think>
+        if (tag === "think") {
+            openTag = "<think>";
+            closeTag = "</think>";
+        }
+        else {
+            openTag = `<${tag}>`;
+            closeTag = `</${tag}>`;
+        }
+        // 匹配所有 thinking 标签
+        const regex = new RegExp(`${openTag}([\\s\\S]*?)${closeTag}`, "gi");
+        let match;
+        while ((match = regex.exec(remainingText)) !== null) {
+            const content = match[1];
+            extractedThinking += content;
+            // 从输出中移除 thinking 标签
+            if (config.removeFromOutput !== false) {
+                remainingText = remainingText.replaceAll(match[0], "");
+            }
+        }
+    }
+    return {
+        cleanedText: remainingText,
+        thinkingContent: extractedThinking || undefined,
+    };
+}
+/**
+ * 处理流式 thinking 标签
+ * 在检测到 opening/closing 标签时立即触发推理事件
+ */
+function processThinkingStream(textDelta, config, state) {
+    if (!config.enabled || !textDelta) {
+        return {
+            cleanedText: textDelta,
+            isThinkingTagOpen: state.isOpen,
+            currentThinkingContent: state.content,
+            reasoningEvents: [],
+        };
+    }
+    const tags = config.tags || ["thinking"];
+    let remainingText = textDelta;
+    const reasoningEvents = [];
+    let isOpen = state.isOpen;
+    let currentContent = state.content;
+    for (const tag of tags) {
+        const openTag = `<${tag}>`;
+        const closeTag = `</${tag}>`;
+        let text = remainingText;
+        let result = "";
+        const openIndex = text.toLowerCase().indexOf(openTag.toLowerCase());
+        const closeIndex = text.toLowerCase().indexOf(closeTag.toLowerCase());
+        if (openIndex !== -1 && (closeIndex === -1 || openIndex < closeIndex)) {
+            // 先找到 opening 标签
+            const beforeOpen = text.substring(0, openIndex);
+            const afterOpen = text.substring(openIndex + openTag.length);
+            if (!isOpen) {
+                isOpen = true;
+                currentContent = "";
+                reasoningEvents.push("");
+            }
+            result += beforeOpen;
+            const innerCloseIndex = afterOpen.toLowerCase().indexOf(closeTag.toLowerCase());
+            if (innerCloseIndex !== -1) {
+                // 同一 delta 中有 opening 和 closing
+                const thinkingContent = afterOpen.substring(0, innerCloseIndex);
+                const afterClose = afterOpen.substring(innerCloseIndex + closeTag.length);
+                currentContent += thinkingContent;
+                reasoningEvents.push(currentContent);
+                isOpen = false;
+                currentContent = "";
+                result += afterClose;
+            }
+            else {
+                // 只有 opening 标签
+                currentContent += afterOpen;
+                reasoningEvents.push(currentContent);
+                result += "";
+            }
+            remainingText = result;
+        }
+        else if (closeIndex !== -1) {
+            // 先找到 closing 标签
+            const beforeClose = text.substring(0, closeIndex);
+            const afterClose = text.substring(closeIndex + closeTag.length);
+            if (isOpen) {
+                currentContent += beforeClose;
+                reasoningEvents.push(currentContent);
+                isOpen = false;
+                currentContent = "";
+                result = afterClose;
+            }
+            else {
+                result = text;
+            }
+            remainingText = result;
+        }
+    }
+    return {
+        cleanedText: remainingText,
+        isThinkingTagOpen: isOpen,
+        currentThinkingContent: currentContent,
+        reasoningEvents,
+    };
+}
+/**
+ * 核心 LLM 调用函数
+ * 使用 AI SDK 的 streamText
+ *
+ * 流式事件通过 env.pushEnvEvent() 发布
+ *
+ * @param config - Invoke 配置
+ * @param options - LLM 选项
+ * @param ctx - Tool Context
+ * @returns ToolResult
+ */
+export async function invoke(config, options, ctx) {
+    try {
+        // 0. 创建 Env 事件发布器
+        const emitToEnv = createEnvEventEmitter(options.env, options.context);
+        // 1. 解析模型字符串
+        const { providerId, modelId } = parseModelString(options.model || config.model);
+        // 2. 获取 Provider 实例
+        // 注意：实际使用需要 ProviderManager 已初始化
+        // 这里简化处理，直接创建 SDK Provider
+        const provider = createProviderInstance(providerId, config.apiKey, config.baseURL);
+        if (!provider) {
+            throw new Error(`Failed to create provider for ${providerId}`);
+        }
+        // 3. 转换消息为 AI SDK 格式
+        const messages = convertToSDKMessages(options.messages);
+        // DEBUG: 记录转换后消息中的 toolCallId 匹配情况
+        const toolCallIds = new Set();
+        const assistantToolCalls = [];
+        const toolResultIds = [];
+        for (const msg of messages) {
+            if (msg.role === "assistant") {
+                // 检查 assistant 消息中的 toolCalls
+                const assistantContent = Array.isArray(msg.content) ? msg.content : [];
+                for (const part of assistantContent) {
+                    if (part && typeof part === "object" && part.type === "tool-call") {
+                        const tc = part.toolCall || part;
+                        assistantToolCalls.push({ id: tc.id, name: tc.name || (tc.function && tc.function.name) });
+                        toolCallIds.add(tc.id);
+                    }
+                }
+            }
+            if (msg.role === "tool") {
+                const toolContent = Array.isArray(msg.content) ? msg.content : [];
+                for (const part of toolContent) {
+                    if (part && typeof part === "object" && part.type === "tool-result") {
+                        toolResultIds.push(part.toolCallId);
+                    }
+                }
+            }
+        }
+        // 检查 toolCallId 匹配
+        const missingToolResults = assistantToolCalls.filter(tc => !toolResultIds.includes(tc.id));
+        const orphanedToolResults = toolResultIds.filter(id => !toolCallIds.has(id));
+        if (assistantToolCalls.length > 0 || toolResultIds.length > 0) {
+            logger.debug("[invoke] ToolCallId matching analysis:", {
+                assistantToolCalls,
+                toolResultIds,
+                missingToolResults: missingToolResults.length > 0 ? missingToolResults : "none",
+                orphanedToolResults: orphanedToolResults.length > 0 ? orphanedToolResults : "none",
+            });
+        }
+        // 4. 转换工具
+        const tools = options.tools && options.tools.length > 0 ? convertToolsToSDK(options.tools) : undefined;
+        // 5. 生成 Provider 选项
+        const providerOptions = generateProviderOptions(providerId, {
+            temperature: options.temperature,
+            maxTokens: options.maxTokens,
+        });
+        // 6. 发布开始事件
+        const model = `${providerId}/${modelId}`;
+        if (emitToEnv) {
+            emitToEnv({ type: "start", metadata: { model } });
+        }
+        // 7. 调用 AI SDK streamText
+        const streamTextOptions = {
+            model: provider.languageModel(modelId),
+            messages,
+            tools,
+            temperature: providerOptions.temperature,
+            maxTokens: providerOptions.maxTokens,
+            abortSignal: ctx.abort,
+            maxRetries: MAX_RETRIES,
+            streamOptions: {
+                includeUsage: true,
+            },
+        };
+        const result = await streamText(streamTextOptions);
+        // 8. 处理流
+        let fullContent = "";
+        let reasoningContent = "";
+        const toolCalls = [];
+        let usageInfo;
+        // 流式推理状态
+        let isThinkingTagOpen = false;
+        let currentThinkingContent = "";
+        for await (const part of result.fullStream) {
+            const streamPart = part;
+            switch (streamPart.type) {
+                case "text-delta":
+                    const textDelta = streamPart.text;
+                    // 检查是否有 thinkingInText 配置（从 config.options 中获取）
+                    const thinkingConfig = config.options?.thinkingInText;
+                    if (thinkingConfig?.enabled) {
+                        const thinkingResult = processThinkingStream(textDelta, thinkingConfig, {
+                            isOpen: isThinkingTagOpen,
+                            content: currentThinkingContent,
+                        });
+                        isThinkingTagOpen = thinkingResult.isThinkingTagOpen;
+                        currentThinkingContent = thinkingResult.currentThinkingContent;
+                        fullContent += thinkingResult.cleanedText;
+                        for (const reasoningDelta of thinkingResult.reasoningEvents) {
+                            reasoningContent = reasoningDelta;
+                            if (emitToEnv) {
+                                emitToEnv({ type: "reasoning", content: reasoningContent });
+                            }
+                        }
+                        if (emitToEnv) {
+                            emitToEnv({ type: "text", content: fullContent, delta: thinkingResult.cleanedText });
+                        }
+                    }
+                    else {
+                        fullContent += textDelta;
+                        if (emitToEnv) {
+                            emitToEnv({ type: "text", content: fullContent, delta: textDelta });
+                        }
+                    }
+                    break;
+                case "reasoning-delta":
+                    const reasoningDelta = streamPart.text;
+                    reasoningContent += reasoningDelta;
+                    if (emitToEnv) {
+                        emitToEnv({ type: "reasoning", content: reasoningContent });
+                    }
+                    break;
+                case "tool-call":
+                    const toolInput = streamPart.input;
+                    const toolCallId = streamPart.toolCallId;
+                    const toolName = streamPart.toolName;
+                    toolCalls.push({
+                        id: toolCallId,
+                        name: toolName,
+                        args: toolInput,
+                    });
+                    if (emitToEnv) {
+                        emitToEnv({
+                            type: "tool_call",
+                            toolCall: {
+                                id: toolCallId,
+                                name: toolName,
+                                arguments: JSON.stringify(toolInput),
+                            },
+                        });
+                    }
+                    break;
+                case "finish-step":
+                    const stepUsage = extractUsageInfo(streamPart.usage);
+                    if (stepUsage) {
+                        usageInfo = stepUsage;
+                    }
+                    break;
+                case "error":
+                    throw streamPart.error;
+                case "finish":
+                    usageInfo = extractUsageInfo(streamPart.totalUsage);
+                    if (!usageInfo && streamPart.usage) {
+                        usageInfo = extractUsageInfo(streamPart.usage);
+                    }
+                    break;
+            }
+        }
+        // 9. 发布完成事件
+        if (emitToEnv) {
+            emitToEnv({
+                type: "completed",
+                content: fullContent,
+                metadata: {
+                    model,
+                    usage: usageInfo,
+                },
+            });
+        }
+        // 10. 返回结果
+        if (toolCalls.length > 0) {
+            // 有工具调用时，返回第一个工具调用的结果
+            const firstToolCall = toolCalls[0];
+            return {
+                toolCallId: firstToolCall.id,
+                result: JSON.stringify({
+                    content: fullContent,
+                    reasoning: reasoningContent || undefined,
+                    tool_calls: toolCalls.map((tc) => ({
+                        id: tc.id,
+                        function: {
+                            name: tc.name,
+                            arguments: JSON.stringify(tc.args),
+                        },
+                    })),
+                }),
+            };
+        }
+        // 无工具调用时，返回内容
+        return {
+            toolCallId: "invoke-" + Date.now(),
+            result: JSON.stringify({
+                content: fullContent,
+                reasoning: reasoningContent || undefined,
+                usage: usageInfo,
+                model,
+            }),
+        };
+    }
+    catch (error) {
+        logger.error("Error during invocation", {
+            error: error instanceof Error ? error.message : String(error),
+            stack: error instanceof Error ? error.stack : undefined,
+        });
+        return {
+            toolCallId: "error-" + Date.now(),
+            result: error instanceof Error ? error.message : String(error),
+            isError: true,
+        };
+    }
+}
+/**
+ * 创建 Provider 实例
+ * 根据 providerId 创建对应的 AI SDK Provider
+ */
+function createProviderInstance(providerId, apiKey, baseURL) {
+    try {
+        // OpenAI
+        if (providerId === "openai") {
+            const openai = createOpenAI({
+                apiKey,
+                baseURL,
+            });
+            return openai;
+        }
+        // Anthropic
+        if (providerId === "anthropic") {
+            const anthropic = createAnthropic({
+                apiKey,
+            });
+            return anthropic;
+        }
+        // Google
+        if (providerId === "google") {
+            const google = createGoogleGenerativeAI({
+                apiKey,
+            });
+            return google;
+        }
+        // 默认: 使用 OpenAI 兼容格式（支持 minimax、deepseek 等）
+        const defaultProvider = createOpenAICompatible({
+            name: providerId,
+            apiKey,
+            baseURL: baseURL || "",
+            includeUsage: true, // Enable usage in stream responses for MiniMax etc.
+        });
+        return defaultProvider;
+    }
+    catch (error) {
+        logger.error(`Failed to create provider ${providerId}`, { error: String(error) });
+        return null;
+    }
+}
+/**
+ * 非流式 LLM 调用
+ *
+ * 使用 AI SDK 的 generateText API，返回完整响应
+ */
+export async function invokeNonStream(config, options, ctx) {
+    // 解析模型字符串
+    const { providerId, modelId } = parseModelString(options.model || config.model);
+    // 获取 Provider 实例
+    const provider = createProviderInstance(providerId, config.apiKey, config.baseURL);
+    if (!provider) {
+        throw new Error(`Failed to create provider for ${providerId}`);
+    }
+    // 转换消息和工具
+    const messages = convertToSDKMessages(options.messages);
+    const tools = options.tools && options.tools.length > 0 ? convertToolsToSDK(options.tools) : undefined;
+    // 生成 Provider 选项
+    const providerOptions = generateProviderOptions(providerId, {
+        temperature: options.temperature,
+        maxTokens: options.maxTokens,
+    });
+    // 使用 generateText API（非流式）
+    const { generateText } = await import("ai");
+    const genTextFn = generateText;
+    const result = await genTextFn({
+        model: provider.languageModel(modelId),
+        messages,
+        tools,
+        temperature: providerOptions.temperature,
+        maxTokens: providerOptions.maxTokens,
+        abortSignal: ctx.abort,
+    });
+    // 计算 usage
+    const usage = result.usage;
+    const usageInfo = usage ? {
+        promptTokens: usage.promptTokens ?? 0,
+        completionTokens: usage.completionTokens ?? 0,
+        totalTokens: usage.totalTokens ?? 0,
+    } : undefined;
+    // 发布完成事件（如果有 env）
+    if (options.env) {
+        options.env.pushEnvEvent({
+            id: randomUUID(),
+            type: "llm.completed",
+            timestamp: Date.now(),
+            metadata: {
+                source: "llm.invokeNonStream",
+                sessionId: options.context?.sessionId,
+                messageId: options.context?.messageId,
+            },
+            payload: {
+                type: "completed",
+                content: result.text,
+                metadata: {
+                    model: `${providerId}/${modelId}`,
+                    usage: usageInfo,
+                },
+            },
+        });
+    }
+    return {
+        content: result.text,
+        finishReason: result.finishReason === "stop" ? "stop" : "tool-calls",
+        model: `${providerId}/${modelId}`,
+        usage: usageInfo,
+    };
+}
+/**
+ * 创建 LLM 配置
+ */
+export function createInvokeConfig(model, apiKey, baseURL) {
+    return {
+        model,
+        apiKey,
+        baseURL,
+    };
+}
+//# sourceMappingURL=invoke.js.map