@aigne/core 0.0.1

package/lib/cjs/libs/blocklet/vc.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authService = void 0;
+exports.issueVC = issueVC;
+const auth_1 = __importDefault(require("@blocklet/sdk/lib/service/auth"));
+const constants_1 = require("../../constants");
+exports.authService = new auth_1.default();
+async function issueVC({ context: { entry }, userDid, name, title, description, reissue = false, displayUrl, notify = true, }) {
+    // NOTE: ensure name starts with AIGNE_ISSUE_VC_PREFIX to avoid conflict with internal passports such as admin/owner
+    if (!name.startsWith(constants_1.AIGNE_ISSUE_VC_PREFIX))
+        name = `${constants_1.AIGNE_ISSUE_VC_PREFIX}${name}`;
+    await createPassportIfNotExist({ name, title, description });
+    const userResult = await exports.authService.getUser(userDid, { includeTags: true });
+    if (!userResult.user)
+        throw new Error(`User not found ${userDid}`);
+    if (!reissue) {
+        const vc = userResult.user.passports.find((p) => p.role === name);
+        if (vc)
+            return { user: userResult.user, vc };
+    }
+    const issueResult = await exports.authService.issuePassportToUser({
+        userDid,
+        role: name,
+        display: displayUrl ? { type: 'url', content: displayUrl } : undefined,
+        notify,
+        notification: JSON.stringify({
+            title: `You just received a VC ${title}`,
+            body: description,
+            attachments: [
+                {
+                    type: 'image',
+                    data: {
+                        url: displayUrl,
+                        alt: title,
+                    },
+                },
+            ],
+            appInfo: {
+                title: entry.project.name,
+                // logo: getProjectIconUrl(entry.project.id, {
+                //   blockletDid: entry.blockletDid,
+                //   working: entry.working,
+                //   updatedAt: entry.project.updatedAt,
+                // }),
+                url: entry.appUrl,
+                description: entry.project.description,
+            },
+            poweredBy: {
+                name: 'AIGNE',
+                url: 'https://www.aigne.io',
+            },
+            severity: 'success',
+        }),
+    });
+    if (issueResult.code !== 'ok')
+        throw new Error(`Issue VC failed got ${issueResult.code}`);
+    const vc = issueResult.user.passports.findLast((p) => p.role === name);
+    if (!vc)
+        throw new Error('Issue VC got empty result');
+    return { user: issueResult.user, vc };
+}
+const CREATE_PASSPORT_TASKS = {};
+async function createPassportIfNotExist({ name, title, description, }) {
+    CREATE_PASSPORT_TASKS[name] ??= (async () => {
+        try {
+            let result = await exports.authService.getRole(name);
+            if (!result.role) {
+                // Create a role for custom display
+                result = await exports.authService.createRole({
+                    title,
+                    name,
+                    description,
+                    permissions: [],
+                    extra: JSON.stringify({
+                        display: 'custom',
+                        types: [name],
+                    }),
+                });
+            }
+            return result;
+        }
+        catch (error) {
+            // NOTE: reset task if failed
+            delete CREATE_PASSPORT_TASKS[name];
+            throw error;
+        }
+    })();
+    return CREATE_PASSPORT_TASKS[name];
+}

package/lib/cjs/libs/openapi/request/index.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callBlockletApi = void 0;
+const component_1 = require("@blocklet/sdk/lib/component");
+const util_1 = require("./util");
+const callBlockletApi = (pathItem, data, options) => {
+    const requestConfig = (0, util_1.getRequestConfig)(pathItem, data, {
+        params: options?.params || {},
+        data: options?.data || {},
+    });
+    const { headers, method, url, params, ...config } = requestConfig;
+    const did = options?.user?.did || '';
+    if (!pathItem.name)
+        throw new Error('Blocklet name is required to call blocklet api');
+    return (0, component_1.call)({
+        ...config,
+        method: method,
+        name: pathItem.name,
+        path: url,
+        headers,
+        params: { ...params, userId: did },
+    });
+};
+exports.callBlockletApi = callBlockletApi;

package/lib/cjs/libs/openapi/request/util.js

@@ -0,0 +1,146 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRequestConfig = void 0;
+exports.extractRequestBodyParameters = extractRequestBodyParameters;
+exports.getAllParameters = getAllParameters;
+exports.getRequiredFields = getRequiredFields;
+const convert_schema_1 = __importDefault(require("../util/convert-schema"));
+const getRequestConfig = (pathItem, requestData, options) => {
+    let url = pathItem.path || '';
+    const config = {
+        method: pathItem.method,
+        url,
+        headers: {},
+        params: options?.params || {},
+        data: options?.data || {},
+        cookies: {},
+        body: {},
+    };
+    const data = { ...requestData };
+    const requestBodyData = { ...data };
+    for (const parameter of pathItem.parameters || []) {
+        if (Object.prototype.hasOwnProperty.call(data, parameter.name)) {
+            const value = data[parameter.name];
+            switch (parameter.in) {
+                case 'path':
+                    url = url.replace(`{${parameter.name}}`, encodeURIComponent(value));
+                    break;
+                case 'query':
+                    config.params[parameter.name] = value;
+                    break;
+                case 'header':
+                    config.headers[parameter.name] = value;
+                    break;
+                case 'cookie':
+                    config.cookies[parameter.name] = value;
+                    break;
+                default:
+                    throw new Error('Unsupported parameter type');
+            }
+            delete requestBodyData[parameter.name];
+        }
+    }
+    if (['POST', 'PUT', 'PATCH'].includes(pathItem.method.toUpperCase()) && pathItem.requestBody) {
+        config.headers['Content-Type'] = getContentType(pathItem.requestBody);
+        config.data = getRequestBody(pathItem.requestBody, requestBodyData || {});
+    }
+    config.url = url;
+    config.body = requestBodyData;
+    return config;
+};
+exports.getRequestConfig = getRequestConfig;
+function getContentType(requestBody) {
+    if (requestBody && requestBody.content) {
+        const [firstMediaType] = Object.keys(requestBody.content);
+        return firstMediaType || 'application/json';
+    }
+    return 'application/json';
+}
+function getRequestBody(requestBody, requestBodyData) {
+    if (requestBody && requestBody.content) {
+        const contentType = getContentType(requestBody);
+        const mediaTypeObject = requestBody.content[contentType];
+        if (mediaTypeObject && mediaTypeObject.schema) {
+            switch (contentType) {
+                case 'application/json':
+                    return JSON.stringify(requestBodyData);
+                case 'application/x-www-form-urlencoded':
+                    return serializeFormEncoded(requestBodyData);
+                case 'multipart/form-data':
+                    // eslint-disable-next-line no-case-declarations
+                    const formData = new FormData();
+                    Object.keys(requestBodyData).forEach((key) => {
+                        const value = requestBodyData[key];
+                        if (Array.isArray(value)) {
+                            value.forEach((item, index) => formData.append(`${key}[${index}]`, item));
+                        }
+                        else if (typeof value === 'object' && value !== null) {
+                            Object.keys(value).forEach((subKey) => {
+                                formData.append(`${key}[${subKey}]`, value[subKey]);
+                            });
+                        }
+                        else {
+                            formData.append(key, value);
+                        }
+                    });
+                    return formData;
+                default:
+                    throw new Error(`Unsupported content type: ${contentType}`);
+            }
+        }
+    }
+    return requestBodyData;
+}
+function serializeFormEncoded(data) {
+    return Object.keys(data)
+        .map((key) => {
+        const value = data[key];
+        if (typeof value === 'object' && value !== null) {
+            return serializeNestedObject(key, value);
+        }
+        return `${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
+    })
+        .join('&');
+}
+function serializeNestedObject(parentKey, obj) {
+    return Object.keys(obj)
+        .map((key) => {
+        const value = obj[key];
+        const fullKey = `${parentKey}[${key}]`;
+        if (typeof value === 'object' && value !== null) {
+            return serializeNestedObject(fullKey, value);
+        }
+        return `${encodeURIComponent(fullKey)}=${encodeURIComponent(value)}`;
+    })
+        .join('&');
+}
+function extractRequestBodyParameters(requestBody) {
+    if (!requestBody || !requestBody.content) {
+        return [];
+    }
+    const contentType = getContentType(requestBody);
+    const mediaTypeObject = requestBody.content[contentType];
+    if (!mediaTypeObject || !mediaTypeObject.schema) {
+        console.warn(`No schema available for content type: ${contentType}`);
+        return [];
+    }
+    const { schema } = mediaTypeObject;
+    const schemaObject = (0, convert_schema_1.default)(schema);
+    return Object.entries(schemaObject).map(([key, value]) => ({ name: key, ...value })) || [];
+}
+function getAllParameters(dataset) {
+    const requestBody = extractRequestBodyParameters(dataset?.requestBody);
+    const datasetParameters = [
+        ...(dataset?.parameters ?? []).map((i) => ({ ...i, type: i.schema?.type })),
+        ...(requestBody ?? []),
+    ];
+    return datasetParameters;
+}
+function getRequiredFields(dataset) {
+    const parameterFields = dataset.parameters?.filter((param) => param.required).map((param) => param.name) || [];
+    const requestBodyFields = Object.values(dataset.requestBody?.content || {}).flatMap((mediaObject) => mediaObject.schema?.required || []);
+    return [...new Set([...parameterFields, ...requestBodyFields])];
+}

package/lib/cjs/libs/openapi/types/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("openapi3-ts/oas31"), exports);

package/lib/cjs/libs/openapi/util/call.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.call = void 0;
+const component_1 = require("@blocklet/sdk/lib/component");
+const isNil_1 = __importDefault(require("lodash/isNil"));
+const call = (options) => {
+    return (0, component_1.call)({
+        ...options,
+        params: Object.fromEntries(Object.entries(options.params ?? {}).map(([key, value]) => [key, (0, isNil_1.default)(value) ? '' : String(value)])),
+    });
+};
+exports.call = call;

package/lib/cjs/libs/openapi/util/check-schema.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const joi_1 = __importDefault(require("joi"));
+const CustomJoi = joi_1.default.extend((joi) => ({
+    type: 'string',
+    base: joi.string(),
+    messages: {
+        'string.customId': '{{#label}} does not match the expected format (type:path:method)',
+    },
+    rules: {
+        customId: {
+            validate(value, helpers) {
+                const [, path, method] = value.split(':');
+                const parts = helpers.state.ancestors[0];
+                if (!path || !method) {
+                    return helpers.error('string.customId');
+                }
+                if (path !== parts.path || (method || '').toLocaleLowerCase() !== (parts.method || '').toLocaleLowerCase()) {
+                    return helpers.error('string.customId');
+                }
+                return value;
+            },
+        },
+    },
+}));
+const BaseParameterObjectSchema = joi_1.default.object({
+    description: joi_1.default.string().optional(),
+    required: joi_1.default.boolean().optional(),
+    deprecated: joi_1.default.boolean().optional(),
+    allowEmptyValue: joi_1.default.boolean().optional(),
+    style: joi_1.default.string()
+        .valid('matrix', 'label', 'form', 'simple', 'spaceDelimited', 'pipeDelimited', 'deepObject')
+        .insensitive()
+        .optional(),
+    explode: joi_1.default.boolean().optional(),
+    allowReserved: joi_1.default.boolean().optional(),
+    schema: joi_1.default.any().optional(),
+    examples: joi_1.default.object().pattern(joi_1.default.string(), joi_1.default.any).optional(),
+    example: joi_1.default.any().optional(),
+    content: joi_1.default.any().optional(),
+}).optional();
+const ParameterObjectSchema = BaseParameterObjectSchema.keys({
+    name: joi_1.default.string().required(),
+    in: joi_1.default.string().valid('query', 'header', 'path', 'cookie').insensitive().required(),
+});
+const RequestBodyObjectSchema = joi_1.default.object({});
+const ResponsesObjectSchema = joi_1.default.object({});
+exports.default = joi_1.default.object({
+    id: CustomJoi.string().customId().required(),
+    name: joi_1.default.string().optional().allow('').empty([null, '']),
+    type: joi_1.default.string().optional().allow('').empty([null, '']),
+    url: joi_1.default.string()
+        .pattern(/^https?:\/\//)
+        .optional()
+        .allow('')
+        .empty([null, '']),
+    path: joi_1.default.string().required(),
+    method: joi_1.default.string().valid('GET', 'POST', 'PUT', 'DELETE', 'PATCH').insensitive().required(),
+    summary: joi_1.default.string().optional().allow('').empty([null, '']),
+    description: joi_1.default.string().optional().allow('').empty([null, '']),
+    parameters: joi_1.default.array().items(ParameterObjectSchema).optional().allow(null, '').empty([null, '']),
+    requestBody: RequestBodyObjectSchema.optional().allow('').empty([null, '']),
+    responses: ResponsesObjectSchema.optional().allow('').empty([null, '']),
+}).unknown(true);

package/lib/cjs/libs/openapi/util/convert-schema.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const convertSchemaToObject = (schema) => {
+    if (!schema || typeof schema !== 'object') {
+        throw new Error('Invalid schema: Schema must be an object');
+    }
+    switch (schema.type) {
+        case 'object':
+            return convertObjectSchema(schema);
+        case 'array':
+            return convertArraySchema(schema);
+        default:
+            return convertPrimitiveSchema(schema);
+    }
+};
+const convertObjectSchema = (schema) => {
+    const result = {};
+    if (schema.properties && typeof schema.properties === 'object') {
+        Object.keys(schema.properties).forEach((property) => {
+            result[property] = schema.properties[property];
+        });
+    }
+    return result;
+};
+const convertArraySchema = (schema) => {
+    if (!schema.items) {
+        return [];
+    }
+    return [convertSchemaToObject(schema.items)];
+};
+const convertPrimitiveSchema = (schema) => {
+    switch (schema.type) {
+        case 'string':
+            return { ...schema, value: schema.default ?? (schema.enum ? schema.enum[0] : '') };
+        case 'integer':
+        case 'number':
+            return { ...schema, value: schema.default ?? 0 };
+        case 'boolean':
+            return { ...schema, value: schema.default ?? false };
+        default:
+            return { ...schema, value: schema.default ?? null };
+    }
+};
+exports.default = convertSchemaToObject;

package/lib/cjs/libs/openapi/util/flatten-open-api.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function flattenApiStructure(apiStructure) {
+    const flattened = [];
+    const paths = apiStructure?.paths || {};
+    for (const path in paths) {
+        for (const method in paths[path]) {
+            const endpoint = paths[path]?.[method];
+            flattened.push({
+                id: endpoint['x-id'],
+                name: endpoint['x-did'],
+                path: endpoint['x-path'],
+                method: endpoint['x-method'],
+                did: endpoint['x-did'],
+                ...endpoint,
+            });
+        }
+    }
+    return flattened;
+}
+exports.default = flattenApiStructure;

package/lib/cjs/libs/openapi/util/get-open-api-i18n-text.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const getOpenApiTextFromI18n = (data, key, locale) => {
+    const i18nKey = `x-${key}-${locale}`;
+    return data[i18nKey] || data[key];
+};
+exports.default = getOpenApiTextFromI18n;

package/lib/cjs/logger.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger = console;
+exports.default = logger;

package/lib/cjs/runtime/resource-blocklet.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resourceManager = void 0;
+const resource_manager_1 = require("../common/resource-manager");
+exports.resourceManager = new resource_manager_1.ResourceManager();

package/lib/cjs/runtime/runtime.js

@@ -0,0 +1,143 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AIGNERuntime = void 0;
+const path_1 = require("path");
+const call_1 = require("@blocklet/ai-kit/api/call");
+const fs_extra_1 = require("fs-extra");
+const glob_1 = require("glob");
+const yaml_1 = require("yaml");
+const common_1 = require("../common");
+const aid_1 = require("../common/aid");
+const executor_1 = require("../executor");
+const logger_1 = __importDefault(require("../logger"));
+const task_id_1 = require("../utils/task-id");
+const resource_blocklet_1 = require("./resource-blocklet");
+class AIGNERuntime {
+    project;
+    static async load(options) {
+        const projectFilePath = (0, path_1.join)(options.path, 'project.yaml');
+        const project = (0, yaml_1.parse)((await (0, fs_extra_1.readFile)(projectFilePath)).toString());
+        // TODO: validate parsed project
+        const agentFilePaths = await (0, glob_1.glob)((0, path_1.join)(options.path, 'prompts', '**/*.yaml'));
+        const agents = await Promise.all(agentFilePaths.map(async (filename) => {
+            const agent = (0, yaml_1.parse)((await (0, fs_extra_1.readFile)(filename)).toString());
+            // TODO: validate parsed agent
+            return agent;
+        }));
+        const memoryFilePath = (0, path_1.join)(options.path, 'config/variable.yaml');
+        const memories = (0, yaml_1.parse)((await (0, fs_extra_1.readFile)(memoryFilePath)).toString())?.variables;
+        // TODO: validate parsed memories
+        const p = {
+            ...project,
+            agents,
+            memories,
+        };
+        return new AIGNERuntime(p);
+    }
+    constructor(project) {
+        this.project = project;
+    }
+    async runAgent(agentId, inputs) {
+        const agent = this.project.agents?.find((a) => a.id === agentId);
+        if (!agent)
+            throw new Error(`Agent ${agentId} not found`);
+        const taskId = (0, task_id_1.nextId)();
+        const messageId = (0, task_id_1.nextId)();
+        const callAI = async ({ input }) => {
+            return await (0, call_1.chatCompletions)({ ...input, model: input.model || common_1.defaultTextModel });
+        };
+        const callAIImage = async ({ assistant, input }) => {
+            const imageAssistant = assistant.type === 'image' ? assistant : undefined;
+            const supportImages = await (0, common_1.getSupportedImagesModels)();
+            const imageModel = supportImages.find((i) => i.model === (imageAssistant?.model || common_1.defaultImageModel));
+            const model = {
+                model: input.model || imageModel?.model,
+                n: input.n || imageModel?.nDefault,
+                quality: input.quality || imageModel?.qualityDefault,
+                style: input.style || imageModel?.styleDefault,
+                size: input.size || imageModel?.sizeDefault,
+            };
+            return (0, call_1.imageGenerations)({
+                ...input,
+                ...model,
+                responseFormat: 'url',
+            });
+        };
+        const executor = new executor_1.RuntimeExecutor({
+            entry: { project: this.project },
+            callback: () => { },
+            callAI,
+            callAIImage,
+            getMemoryVariables: async (options) => {
+                if (options.projectId === this.project.id)
+                    return this.project.memories ?? [];
+                logger_1.default.warn('Unsupported to get memory variables from other projects');
+                return [];
+            },
+            getAgent: async (options) => {
+                const identity = (0, aid_1.parseIdentity)(options.aid, { rejectWhenError: true });
+                let agent;
+                if (identity.blockletDid) {
+                    const { blockletDid, projectId, agentId } = identity;
+                    const res = await resource_blocklet_1.resourceManager.getAgent({ blockletDid, projectId, agentId });
+                    if (res) {
+                        agent = {
+                            ...res.agent,
+                            project: res.project,
+                            identity: {
+                                blockletDid,
+                                projectId,
+                                agentId,
+                                aid: (0, aid_1.stringifyIdentity)({ blockletDid, projectId, agentId }),
+                            },
+                        };
+                    }
+                }
+                else if (identity.projectId === this.project.id) {
+                    const a = this.project.agents?.find((a) => a.id === identity.agentId);
+                    if (a) {
+                        agent = {
+                            ...a,
+                            project: this.project,
+                            identity: {
+                                projectId: this.project.id,
+                                agentId: a.id,
+                                aid: (0, aid_1.stringifyIdentity)({ projectId: this.project.id, agentId: a.id }),
+                            },
+                        };
+                    }
+                }
+                if (options.rejectOnEmpty && !agent)
+                    throw new Error('No such agent');
+                return agent;
+            },
+            entryProjectId: this.project.id,
+            sessionId: this.project.id,
+            messageId,
+            clientTime: new Date().toISOString(),
+            queryCache: async ({ aid, cacheKey }) => {
+                // TODO: implement cache
+                return null;
+            },
+            setCache: async ({ aid, cacheKey, inputs, outputs }) => {
+                // TODO: implement cache
+            },
+        }, {
+            ...agent,
+            identity: {
+                projectId: this.project.id,
+                agentId: agent.id,
+                aid: (0, aid_1.stringifyIdentity)({ projectId: this.project.id, agentId: agent.id }),
+            },
+            project: this.project,
+        }, {
+            inputs,
+            taskId,
+        });
+        return executor.execute();
+    }
+}
+exports.AIGNERuntime = AIGNERuntime;

package/lib/cjs/types/assistant/index.js

@@ -0,0 +1,31 @@
+"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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnTaskCompletion = exports.Mustache = void 0;
+exports.isUserInputParameter = isUserInputParameter;
+var mustache_1 = require("./mustache/mustache");
+Object.defineProperty(exports, "Mustache", { enumerable: true, get: function () { return __importDefault(mustache_1).default; } });
+__exportStar(require("./mustache/directive"), exports);
+var OnTaskCompletion;
+(function (OnTaskCompletion) {
+    OnTaskCompletion["EXIT"] = "EXIT";
+})(OnTaskCompletion || (exports.OnTaskCompletion = OnTaskCompletion = {}));
+function isUserInputParameter(parameter) {
+    return parameter.type !== 'source';
+}