@aigne/core 0.0.1

package/lib/cjs/executor/index.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuntimeExecutor = void 0;
+const aid_1 = require("../common/aid");
+const logger_1 = __importDefault(require("../logger"));
+const agent_1 = require("./agent");
+const aigc_1 = require("./aigc");
+const api_1 = require("./api");
+const base_1 = require("./base");
+const blocklet_1 = require("./blocklet");
+const call_agent_1 = require("./call-agent");
+const decision_1 = require("./decision");
+const image_blender_1 = require("./image-blender");
+const llm_1 = require("./llm");
+const logic_1 = require("./logic");
+class RuntimeExecutor extends base_1.AgentExecutorBase {
+    parentAgent;
+    constructor(context, agent, options, parentAgent) {
+        super(new base_1.ExecutorContext({
+            ...context,
+            executor(agent, options) {
+                return new RuntimeExecutor(this, agent, options, agent);
+            },
+        }), agent, options);
+        this.parentAgent = parentAgent;
+    }
+    async process() {
+        // ignore
+    }
+    async execute() {
+        const { agent, options } = this;
+        if (this.parentAgent?.identity && agent.identity) {
+            const parent = (0, aid_1.parseIdentity)(this.parentAgent.identity.aid, { rejectWhenError: true });
+            const identity = (0, aid_1.parseIdentity)(agent.identity.aid, { rejectWhenError: true });
+            agent.identity.aid = (0, aid_1.stringifyIdentity)({
+                ...identity,
+                blockletDid: identity.blockletDid || parent.blockletDid,
+                projectId: identity.projectId || parent.projectId,
+                projectRef: identity.projectRef || parent.projectRef,
+            });
+            agent.identity.working ||= this.parentAgent.identity.working;
+        }
+        switch (agent.type) {
+            case 'agent': {
+                return new agent_1.AgentExecutor(this.context, agent, options).execute();
+            }
+            case 'prompt': {
+                return new llm_1.LLMAgentExecutor(this.context, agent, options).execute();
+            }
+            case 'image': {
+                return new aigc_1.AIGCAgentExecutor(this.context, agent, options).execute();
+            }
+            case 'api': {
+                return new api_1.APIAgentExecutor(this.context, agent, options).execute();
+            }
+            case 'function': {
+                return new logic_1.LogicAgentExecutor(this.context, agent, options).execute();
+            }
+            case 'router': {
+                return new decision_1.DecisionAgentExecutor(this.context, agent, options).execute();
+            }
+            case 'callAgent': {
+                return new call_agent_1.CallAgentExecutor(this.context, agent, options).execute();
+            }
+            case 'blocklet': {
+                return new blocklet_1.BlockletAgentExecutor(this.context, agent, options).execute();
+            }
+            case 'imageBlender': {
+                return new image_blender_1.ImageBlenderAgentExecutor(this.context, agent, options).execute();
+            }
+            default: {
+                logger_1.default.error('Unsupported agent type', { agent });
+                throw new Error(`Unsupported agent type: ${agent?.type}`);
+            }
+        }
+    }
+}
+exports.RuntimeExecutor = RuntimeExecutor;

package/lib/cjs/executor/llm.js

@@ -0,0 +1,379 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LLMAgentExecutor = void 0;
+const web_1 = require("stream/web");
+const index_1 = require("@blocklet/ai-kit/api/types/index");
+const config_1 = require("@blocklet/sdk/lib/config");
+const generate_output_1 = require("../assistant/generate-output");
+const common_1 = require("../common");
+const aid_1 = require("../common/aid");
+const types_1 = require("../types");
+const directive_1 = require("../types/assistant/mustache/directive");
+const retry_1 = __importDefault(require("../utils/retry"));
+const task_id_1 = require("../utils/task-id");
+const base_1 = require("./base");
+class LLMAgentExecutor extends base_1.AgentExecutorBase {
+    retryTimes = 0;
+    get modelInfo() {
+        const { agent } = this;
+        const model = agent.model || agent.project.model || common_1.defaultTextModel;
+        const defaultModelInfo = model === agent.project.model ? agent.project : undefined;
+        return {
+            model,
+            temperature: agent.temperature ?? defaultModelInfo?.temperature,
+            topP: agent.topP ?? defaultModelInfo?.topP,
+            presencePenalty: agent.presencePenalty ?? defaultModelInfo?.presencePenalty,
+            frequencyPenalty: agent.frequencyPenalty ?? defaultModelInfo?.frequencyPenalty,
+        };
+    }
+    _executor;
+    get executor() {
+        this._executor ??= (async () => {
+            const { agent } = this;
+            const identity = (0, aid_1.parseIdentity)(agent.identity.aid, { rejectWhenError: true });
+            return agent.executor?.agent?.id
+                ? {
+                    executor: await this.context.getAgent({
+                        aid: (0, aid_1.stringifyIdentity)({
+                            blockletDid: agent.executor.agent.blockletDid || identity.blockletDid,
+                            projectId: agent.executor.agent.projectId || identity.projectId,
+                            projectRef: identity.projectRef,
+                            agentId: agent.executor.agent.id,
+                        }),
+                        working: agent.identity.working,
+                        rejectOnEmpty: true,
+                    }),
+                    inputValues: agent.executor.inputValues,
+                }
+                : agent.project.executor?.agent?.id
+                    ? {
+                        executor: await this.context.getAgent({
+                            aid: (0, aid_1.stringifyIdentity)({
+                                blockletDid: agent.project.executor.agent.blockletDid || identity.blockletDid,
+                                projectId: agent.project.executor.agent.projectId || identity.projectId,
+                                projectRef: identity.projectRef,
+                                agentId: agent.project.executor.agent.id,
+                            }),
+                            working: agent.identity.working,
+                            rejectOnEmpty: true,
+                        }),
+                        inputValues: agent.project.executor.inputValues,
+                    }
+                    : undefined;
+        })();
+        return this._executor;
+    }
+    _outputsInfo;
+    get outputsInfo() {
+        this._outputsInfo ??= (async () => {
+            const { agent } = this;
+            const outputVariables = (agent.outputVariables ?? []).filter((i) => !!i.name && !i.hidden && i.from?.type !== 'callAgent') ?? [];
+            const schema = (0, types_1.outputVariablesToJsonSchema)(agent, {
+                variables: await this.context.getMemoryVariables({
+                    ...(0, aid_1.parseIdentity)(agent.identity.aid, { rejectWhenError: true }),
+                    working: agent.identity.working,
+                }),
+            });
+            const hasStreamingTextOutput = outputVariables.some((i) => i.name === types_1.RuntimeOutputVariable.text);
+            const hasJsonOutputs = !!schema && Object.values(schema.properties).length > 0;
+            return { outputs: outputVariables, schema, hasStreamingTextOutput, hasJsonOutputs };
+        })();
+        return this._outputsInfo;
+    }
+    getMessages({ inputs }) {
+        const { agent } = this;
+        const createContentStructure = async (content, variables, agent, prompt) => {
+            const parameters = agent.parameters ?? [];
+            // 没有特殊变量
+            if (!variables.length) {
+                const renderedContent = await this.renderMessage(content, { ...inputs, ...this.globalContext });
+                return renderedContent;
+            }
+            // 没有图片变量
+            const haveImageParameter = parameters.filter((i) => i.type === 'image').some((i) => variables.includes(i.key));
+            if (!haveImageParameter) {
+                const renderedContent = await this.renderMessage(content, { ...inputs, ...this.globalContext });
+                return renderedContent;
+            }
+            // 创建图片变量标记
+            const createImageMarker = (variable) => `__IMAGE_${variable}__`;
+            const imageVariablesMap = {};
+            const imageVariables = [];
+            // 当前参数有图片变量
+            parameters
+                .filter((i) => i.type === 'image' && i.key && variables.includes(i.key))
+                .forEach((param) => {
+                if (param.type === 'image' && param.key && inputs[param.key]) {
+                    const marker = createImageMarker(param.key);
+                    imageVariablesMap[param.key] = marker;
+                    imageVariables.push({ marker, value: inputs[param.key] });
+                }
+            });
+            const renderedContent = await this.renderMessage(content, {
+                ...inputs,
+                ...this.globalContext,
+                ...imageVariablesMap,
+            });
+            const contentParts = [];
+            if (imageVariables.length === 0) {
+                return renderedContent;
+            }
+            let remainingContent = renderedContent;
+            for (const { marker, value } of imageVariables) {
+                const parts = remainingContent.split(marker);
+                if (parts[0]) {
+                    contentParts.push({ type: 'text', text: parts[0] });
+                }
+                // 只有是 user 时，才处理
+                if (prompt.data.role === 'user') {
+                    const list = Array.isArray(value) ? value : [value];
+                    list.forEach((item) => contentParts.push({ type: 'image_url', imageUrl: { url: item } }));
+                }
+                remainingContent = parts[1] || '';
+            }
+            if (remainingContent) {
+                contentParts.push({ type: 'text', text: remainingContent });
+            }
+            config_1.logger.info('have image messages', contentParts);
+            return contentParts;
+        };
+        return (async () => (await Promise.all((agent.prompts ?? [])
+            .filter((i) => i.visibility !== 'hidden')
+            .map(async (prompt) => {
+            if (prompt.type === 'message') {
+                const content = prompt.data.content
+                    ?.split('\n')
+                    .filter((i) => !i.startsWith('//'))
+                    .join('\n') || '';
+                const variables = (0, directive_1.parseDirectives)(content)
+                    .filter((i) => i.type === 'variable')
+                    .map((i) => i.name);
+                const contentStructure = await createContentStructure(content, variables, agent, prompt);
+                return {
+                    role: prompt.data.role,
+                    content: contentStructure,
+                };
+            }
+            console.warn('Unsupported prompt type', prompt);
+            return undefined;
+        })))
+            .flat()
+            .filter((i) => !!i?.content))();
+    }
+    async process({ inputs }) {
+        const { hasJsonOutputs } = await this.outputsInfo;
+        const messages = await this.getMessages({ inputs });
+        const { modelInfo } = this;
+        const e = await this.executor;
+        // NOTE: use json_schema output for models that support it
+        if (common_1.supportJsonSchemaModels.includes(modelInfo.model) &&
+            hasJsonOutputs &&
+            // check the llm executor is support json schema output
+            (!e || e.executor.parameters?.some((i) => i.type === 'llmInputResponseFormat'))) {
+            return this.processWithJsonSchemaFormat({ messages, inputs });
+        }
+        return this.processWithOutJsonSchemaFormatSupport({ inputs, messages });
+    }
+    async processWithOutJsonSchemaFormatSupport({ inputs, messages, }) {
+        const { agent, options: { taskId, parentTaskId }, } = this;
+        const { hasStreamingTextOutput, hasJsonOutputs, schema } = await this.outputsInfo;
+        const outputSchema = JSON.stringify(schema);
+        const messagesWithSystemPrompt = [...messages];
+        const lastSystemIndex = messagesWithSystemPrompt.findLastIndex((i) => i.role === 'system');
+        if (hasJsonOutputs) {
+            if (hasStreamingTextOutput) {
+                messagesWithSystemPrompt.splice(lastSystemIndex + 1, 0, {
+                    role: 'system',
+                    content: (0, generate_output_1.metadataStreamOutputFormatPrompt)(outputSchema),
+                });
+            }
+            else {
+                messagesWithSystemPrompt.splice(lastSystemIndex + 1, 0, {
+                    role: 'system',
+                    content: (0, generate_output_1.metadataOutputFormatPrompt)(outputSchema),
+                });
+            }
+        }
+        if (!messagesWithSystemPrompt.length)
+            return undefined;
+        this.context.callback?.({
+            type: types_1.AssistantResponseType.INPUT,
+            assistantId: agent.id,
+            parentTaskId,
+            taskId,
+            assistantName: agent.name,
+            inputParameters: this.hideSecretInputs(inputs, agent),
+            promptMessages: messagesWithSystemPrompt,
+        });
+        const run = async () => {
+            this.retryTimes += 1;
+            let result = '';
+            const metadataStrings = [];
+            const chatCompletionChunk = await this.callAIOrExecutor({ messages: messagesWithSystemPrompt, inputs });
+            const stream = (0, generate_output_1.extractMetadataFromStream)(chatCompletionChunk.pipeThrough(new web_1.TransformStream({
+                transform: (chunk, controller) => {
+                    if ((0, index_1.isChatCompletionUsage)(chunk)) {
+                        this.context.callback?.({
+                            type: types_1.AssistantResponseType.USAGE,
+                            taskId,
+                            assistantId: agent.id,
+                            usage: chunk.usage,
+                        });
+                    }
+                    controller.enqueue(chunk);
+                },
+            })), hasJsonOutputs);
+            for await (const chunk of stream) {
+                if (chunk.type === 'text') {
+                    const { text } = chunk;
+                    result += text;
+                    if (hasStreamingTextOutput && this.retryTimes === 1) {
+                        this.context.callback?.({
+                            type: types_1.AssistantResponseType.CHUNK,
+                            taskId,
+                            assistantId: agent.id,
+                            delta: { content: text },
+                        });
+                    }
+                }
+                else if (chunk.type === 'match') {
+                    metadataStrings.push(chunk.text);
+                }
+            }
+            const json = {};
+            for (const i of metadataStrings) {
+                try {
+                    const obj = JSON.parse(i);
+                    Object.assign(json, obj);
+                }
+                catch {
+                    // ignore
+                }
+            }
+            // try to parse all text content as a json
+            try {
+                Object.assign(json, JSON.parse(result));
+            }
+            catch {
+                // ignore
+            }
+            try {
+                return await super.validateOutputs({
+                    inputs,
+                    outputs: { ...json, $text: result },
+                });
+            }
+            catch (error) {
+                config_1.logger.error('validate LLM outputs error', error);
+                throw new Error('Unexpected response format from AI');
+            }
+        };
+        return await (0, retry_1.default)(run, this.context.maxRetries);
+    }
+    async processWithJsonSchemaFormat({ messages, inputs, }) {
+        const { agent, options: { parentTaskId, taskId }, } = this;
+        this.context.callback?.({
+            type: types_1.AssistantResponseType.INPUT,
+            assistantId: agent.id,
+            parentTaskId,
+            taskId,
+            assistantName: agent.name,
+            inputParameters: this.hideSecretInputs(inputs, agent),
+            promptMessages: messages,
+        });
+        const { hasStreamingTextOutput, schema } = await this.outputsInfo;
+        const [json, { text }] = await Promise.all([
+            this.callAIGetJsonOutput({ messages, schema }),
+            hasStreamingTextOutput ? this.callAIGetTextStreamOutput({ messages, inputs }) : { text: undefined },
+        ]);
+        try {
+            return await super.validateOutputs({
+                inputs,
+                outputs: { ...json, $text: text },
+            });
+        }
+        catch (error) {
+            config_1.logger.error('validate LLM outputs error', error);
+            throw new Error('Unexpected response format from AI');
+        }
+    }
+    async callAIGetJsonOutput({ messages, schema }) {
+        const { modelInfo } = this;
+        const result = await this.context.callAI({
+            assistant: this.agent,
+            input: {
+                messages,
+                ...modelInfo,
+                responseFormat: {
+                    type: 'json_schema',
+                    jsonSchema: {
+                        name: 'output',
+                        schema: (0, types_1.jsonSchemaToOpenAIJsonSchema)(schema),
+                        strict: true,
+                    },
+                },
+            },
+        });
+        let json = '';
+        for await (const i of result) {
+            if ((0, index_1.isChatCompletionChunk)(i)) {
+                json += i.delta.content || '';
+            }
+        }
+        try {
+            return JSON.parse(json);
+        }
+        catch (error) {
+            config_1.logger.error(json, error);
+            throw new Error('parse ai json schema output error');
+        }
+    }
+    async callAIGetTextStreamOutput({ messages, inputs, }) {
+        const { agent, options: { taskId }, } = this;
+        const stream = await this.callAIOrExecutor({
+            messages,
+            inputs,
+        });
+        let text = '';
+        for await (const chunk of stream) {
+            if ((0, index_1.isChatCompletionChunk)(chunk)) {
+                text += chunk.delta.content || '';
+                this.context.callback?.({
+                    type: types_1.AssistantResponseType.CHUNK,
+                    taskId,
+                    assistantId: agent.id,
+                    delta: { content: chunk.delta.content },
+                });
+            }
+        }
+        return { text };
+    }
+    async callAIOrExecutor({ messages, inputs, }) {
+        const { agent, modelInfo, options: { taskId }, } = this;
+        const e = await this.executor;
+        return e
+            ? (await this.context
+                .executor(e.executor, {
+                inputs: {
+                    ...inputs,
+                    ...e.inputValues,
+                    [e.executor.parameters?.find((i) => i.type === 'llmInputMessages' && !i.hidden)?.key]: messages,
+                },
+                taskId: (0, task_id_1.nextId)(),
+                parentTaskId: taskId,
+            })
+                .execute())[types_1.RuntimeOutputVariable.llmResponseStream]
+            : await this.context.callAI({
+                assistant: agent,
+                input: {
+                    stream: true,
+                    messages,
+                    ...modelInfo,
+                },
+            });
+    }
+}
+exports.LLMAgentExecutor = LLMAgentExecutor;

package/lib/cjs/executor/logic.js

@@ -0,0 +1,167 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogicAgentExecutor = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const quickjs_1 = require("@blocklet/quickjs");
+const component_1 = require("@blocklet/sdk/lib/component");
+const config_1 = __importDefault(require("@blocklet/sdk/lib/config"));
+const fast_deep_equal_1 = __importDefault(require("fast-deep-equal"));
+const joi_1 = __importDefault(require("joi"));
+const pick_1 = __importDefault(require("lodash/pick"));
+const aid_1 = require("../common/aid");
+const logger_1 = __importDefault(require("../logger"));
+const types_1 = require("../types");
+const ReadableMustache_1 = require("../types/assistant/mustache/ReadableMustache");
+const geti_1 = require("../utils/geti");
+const task_id_1 = require("../utils/task-id");
+const base_1 = require("./base");
+async function parseJSONInVM(str) {
+    return quickjs_1.Sandbox.callFunction({
+        code: `\
+function parse(json) {
+  return eval(\`const j = \${json}; j\`)
+}
+`,
+        filename: 'parserJSONInVm.js',
+        functionName: 'parse',
+        args: [str.trim()],
+    });
+}
+class LogicAgentExecutor extends base_1.AgentExecutorBase {
+    async process({ inputs }) {
+        const { agent, options: { taskId }, } = this;
+        if (!agent.code)
+            throw new Error(`Assistant ${agent.id}'s code is empty`);
+        const args = Object.fromEntries(await Promise.all((agent.parameters ?? [])
+            .filter((i) => !!i.key && !i.hidden)
+            .map(async (i) => [i.key, inputs?.[i.key] ?? i.defaultValue])));
+        const $json = (variables, ...rest) => {
+            const taggedFn = async (t, ...rest) => {
+                const template = t.map((s, i) => `${s}${i === t.length - 1 ? '' : rest[i]}`).join('');
+                const renderCtx = {
+                    ...args,
+                    ...variables,
+                    ...this.globalContext,
+                    get: () => async (template, render) => {
+                        const s = await render(template);
+                        return (0, geti_1.geti)(renderCtx, s);
+                    },
+                    runAgent: () => async (template, render) => {
+                        const t = (await parseJSONInVM(template))?.template;
+                        const s = await render(template);
+                        const j = await parseJSONInVM(s);
+                        const { agentId, inputs } = await joi_1.default.object({
+                            agentId: joi_1.default.string().required(),
+                            inputs: joi_1.default.object().pattern(joi_1.default.string(), joi_1.default.any()).required(),
+                        }).validateAsync(j, { stripUnknown: true });
+                        const a = await this.context.getAgent({
+                            aid: (0, aid_1.stringifyIdentity)({ ...(0, aid_1.parseIdentity)(agent.identity.aid, { rejectWhenError: true }), agentId }),
+                            working: agent.identity.working,
+                            rejectOnEmpty: true,
+                        });
+                        const result = await this.context.execute(a, { taskId: (0, task_id_1.nextId)(), parentTaskId: taskId, inputs });
+                        return this.renderMessage(t, { ...renderCtx, $result: result }, { escapeJsonSymbols: true });
+                    },
+                };
+                const result = (0, ReadableMustache_1.renderMustacheStream)(template, (enqueue) => ({
+                    ...renderCtx,
+                    runAgent: () => enqueue(renderCtx.runAgent()),
+                }));
+                let object;
+                for await (const chunk of result) {
+                    const newObj = await parseJSONInVM(chunk);
+                    // skip if the object is equal
+                    // TODO: throttle the output
+                    if ((0, fast_deep_equal_1.default)(object, newObj)) {
+                        continue;
+                    }
+                    object = newObj;
+                    try {
+                        const obj = await this.validateOutputs({ outputs: object, partial: true });
+                        this.context.callback?.({
+                            type: types_1.AssistantResponseType.CHUNK,
+                            taskId,
+                            assistantId: agent.id,
+                            delta: { object: obj },
+                        });
+                    }
+                    catch (error) {
+                        logger_1.default.error('validate LLM outputs error', error, object);
+                    }
+                }
+                return object;
+            };
+            // 支持 $json({foo:"xxx"})`` 和 $json`` 两种调用方式
+            if (Array.isArray(variables)) {
+                return taggedFn(variables, ...rest);
+            }
+            return taggedFn;
+        };
+        const log = (...args) => this.context.callback({
+            type: types_1.AssistantResponseType.LOG,
+            log: JSON.stringify(args),
+            timestamp: Date.now(),
+            taskId,
+            assistantId: agent.id,
+        });
+        const global = {
+            console: {
+                // NOTE: do not return logger.xxx result, it will cause memory leak
+                log: (...args) => log(...args),
+                info: (...args) => log(...args),
+                debug: (...args) => log(...args),
+                warn: (...args) => log(...args),
+                error: (...args) => log(...args),
+            },
+            getComponentMountPoint: component_1.getComponentMountPoint,
+            call: (...args) => (0, component_1.call)(...args).then((res) => ({ data: res.data })),
+            crypto: { randomInt: crypto_1.default.randomInt },
+            config: { env: (0, pick_1.default)(config_1.default.env, 'appId', 'appName', 'appDescription', 'appUrl') },
+        };
+        const allArgs = {
+            $json,
+            runAgent: async ({ agentId, inputs, streaming, }) => {
+                const a = await this.context.getAgent({
+                    aid: (0, aid_1.stringifyIdentity)({ ...(0, aid_1.parseIdentity)(agent.identity.aid, { rejectWhenError: true }), agentId }),
+                    working: agent.identity.working,
+                    rejectOnEmpty: true,
+                });
+                const { callback } = this.context;
+                const currentTaskId = (0, task_id_1.nextId)();
+                return this.context
+                    .copy(streaming
+                    ? {
+                        callback: function hello(args) {
+                            callback(args);
+                            if (args.type === types_1.AssistantResponseType.CHUNK &&
+                                args.delta.content &&
+                                args.taskId === currentTaskId) {
+                                callback({ ...args, taskId });
+                            }
+                        },
+                    }
+                    : {})
+                    .execute(a, { taskId: currentTaskId, parentTaskId: taskId, inputs });
+            },
+            ...this.globalContext,
+            ...args,
+        };
+        const argKeys = Object.keys(allArgs);
+        const resultPromise = await quickjs_1.Sandbox.callFunction({
+            code: `\
+async function main({${argKeys.join(', ')}) {
+  ${agent.code}
+}
+`,
+            filename: `${agent.name || agent.id}.js`,
+            global,
+            functionName: 'main',
+            args: [allArgs],
+        });
+        return resultPromise;
+    }
+}
+exports.LogicAgentExecutor = LogicAgentExecutor;

package/lib/cjs/index.js

@@ -0,0 +1,17 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./runtime/runtime"), exports);