@takeshape/schema 11.63.7 → 11.66.0

package/dist/util/expressions.js

@@ -0,0 +1,323 @@
+import jsep from 'jsep';
+// Default operator precedence from https://github.com/EricSmekens/jsep/blob/master/src/jsep.js#L55
+const DEFAULT_PRECEDENCE = {
+    '||': 1,
+    '&&': 2,
+    '|': 3,
+    '^': 4,
+    '&': 5,
+    '==': 6,
+    '!=': 6,
+    '===': 6,
+    '!==': 6,
+    '<': 7,
+    '>': 7,
+    '<=': 7,
+    '>=': 7,
+    '<<': 8,
+    '>>': 8,
+    '>>>': 8,
+    '+': 9,
+    '-': 9,
+    '*': 10,
+    '/': 10,
+    '%': 10
+};
+/**
+ * Evaluation code from JSEP project, under MIT License.
+ * Copyright (c) 2013 Stephen Oney, http://jsep.from.so/
+ */
+const binops = {
+    // '|'(a, b) {
+    //   return a | b;
+    // },
+    // '^'(a, b) {
+    //   return a ^ b;
+    // },
+    // '&'(a, b) {
+    //   return a & b;
+    // },
+    '=='(a, b) {
+        // biome-ignore lint/suspicious/noDoubleEquals: <explanation>
+        return a == b;
+    },
+    '!='(a, b) {
+        // biome-ignore lint/suspicious/noDoubleEquals: <explanation>
+        return a != b;
+    },
+    '==='(a, b) {
+        return a === b;
+    },
+    '!=='(a, b) {
+        return a !== b;
+    },
+    '<'(a, b) {
+        return a < b;
+    },
+    '>'(a, b) {
+        return a > b;
+    },
+    '<='(a, b) {
+        return a <= b;
+    },
+    '>='(a, b) {
+        return a >= b;
+    },
+    // '<<'(a, b) {
+    //   return a << b;
+    // },
+    // '>>'(a, b) {
+    //   return a >> b;
+    // },
+    // '>>>'(a, b) {
+    //   return a >>> b;
+    // },
+    '+'(a, b) {
+        // eslint-disable-next-line @typescript-eslint/restrict-plus-operands
+        return a + b;
+    },
+    '-'(a, b) {
+        return a - b;
+    },
+    '*'(a, b) {
+        return a * b;
+    },
+    '/'(a, b) {
+        return a / b;
+    },
+    '%'(a, b) {
+        return a % b;
+    }
+};
+const unops = {
+    '-'(a) {
+        return -a;
+    },
+    '+'(a) {
+        return Number(a);
+    },
+    // '~'(a) {
+    //   return ~a;
+    // },
+    '!'(a) {
+        return !a;
+    }
+};
+function evaluateArray(list, context) {
+    return list.map((v) => (v ? evaluate(v, context) : undefined));
+}
+function isObject(x) {
+    return Boolean(x) && typeof x === 'object';
+}
+export const METHODS_NOT_SUPPORTED = 'Methods are not supported in expressions';
+export const THIS_NOT_SUPPORTED = 'This is not supported in expressions';
+function evaluateMember(node, context) {
+    const object = evaluate(node.object, context);
+    let key;
+    if (node.computed) {
+        key = evaluate(node.property, context);
+    }
+    else {
+        key = node.property.name;
+    }
+    if (typeof key === 'string' && /^__proto__|prototype|constructor$/.test(key)) {
+        throw Error(`Access to member "${key}" disallowed.`);
+    }
+    if (isObject(object) && Object.hasOwn(object, key)) {
+        return [object, object[key]];
+    }
+}
+function evaluate(_node, context) {
+    const node = _node;
+    switch (node.type) {
+        case 'ArrayExpression':
+            return evaluateArray(node.elements, context);
+        case 'CallExpression': {
+            if (node.callee.type === 'MemberExpression') {
+                throw Error(METHODS_NOT_SUPPORTED);
+            }
+            const fn = evaluate(node.callee, context);
+            if (typeof fn !== 'function') {
+                return undefined;
+            }
+            return fn.apply(null, evaluateArray(node.arguments, context));
+        }
+        case 'ConditionalExpression':
+            return evaluate(node.test, context) ? evaluate(node.consequent, context) : evaluate(node.alternate, context);
+        case 'Identifier':
+            return context[node.name];
+        case 'Literal':
+            return node.value;
+        case 'BinaryExpression': {
+            if (node.operator === '||') {
+                return evaluate(node.left, context) || evaluate(node.right, context);
+            }
+            if (node.operator === '&&') {
+                return evaluate(node.left, context) && evaluate(node.right, context);
+            }
+            const op = binops[node.operator];
+            if (!op) {
+                throw new Error(`Unsupported operator ${node.operator}`);
+            }
+            return op(evaluate(node.left, context), evaluate(node.right, context));
+        }
+        case 'UnaryExpression': {
+            const op = unops[node.operator];
+            if (!op) {
+                throw new Error(`Unsupported operator ${node.operator}`);
+            }
+            return op(evaluate(node.argument, context));
+        }
+        case 'MemberExpression':
+            return evaluateMember(node, context)?.[1];
+        case 'ThisExpression':
+            return context;
+        // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
+        default:
+            return undefined;
+    }
+}
+export function parseExpression(expression) {
+    return jsep(expression);
+}
+function validateAST(options, rootNode) {
+    const validate = (_node, parent, parentKey) => {
+        const node = _node;
+        // eslint-disable-next-line default-case
+        switch (node.type) {
+            case 'ArrayExpression':
+                return node.elements.flatMap((v) => (v ? validate(v, node, 'elements') : []));
+            case 'CallExpression': {
+                if (node.callee.type === 'MemberExpression') {
+                    return [{ message: METHODS_NOT_SUPPORTED }];
+                }
+                return [
+                    ...validate(node.callee, node, 'callee'),
+                    ...node.arguments.flatMap((v) => (v ? validate(v, node, 'arguments') : []))
+                ];
+            }
+            case 'ConditionalExpression':
+                return [
+                    ...validate(node.test, node, 'test'),
+                    ...validate(node.consequent, node, 'consequent'),
+                    ...validate(node.alternate, node, 'alternate')
+                ];
+            case 'Identifier': {
+                const errors = [];
+                if (parent?.type === 'CallExpression' && parentKey === 'callee' && options.allowedFunctions) {
+                    if (!options.allowedFunctions.includes(node.name)) {
+                        errors.push({ message: `Unknown function "${node.name}"` });
+                    }
+                }
+                else {
+                    if (parent?.type === 'MemberExpression' && !parent.computed && parentKey === 'property') {
+                        return errors;
+                    }
+                    if (options.allowedVars && !options.allowedVars.includes(node.name)) {
+                        errors.push({ message: `Unknown variable "${node.name}"` });
+                    }
+                }
+                return errors;
+            }
+            case 'Literal':
+                return [];
+            case 'BinaryExpression': {
+                const op = binops[node.operator];
+                if (!op) {
+                    throw new Error(`Unsupported operator ${node.operator}`);
+                }
+                return [...validate(node.left, node, 'left'), ...validate(node.right, node, 'right')];
+            }
+            case 'UnaryExpression': {
+                const op = unops[node.operator];
+                if (!op) {
+                    return [{ message: `Unsupported operator ${node.operator}` }];
+                }
+                return validate(node.argument, node, 'argument');
+            }
+            case 'MemberExpression':
+                return [
+                    ...validate(node.object, node, 'object'),
+                    ...(node.computed ? validate(node.property, node, 'property') : [])
+                ];
+            case 'ThisExpression':
+                return [{ message: THIS_NOT_SUPPORTED }];
+        }
+    };
+    return validate(rootNode, undefined, undefined);
+}
+const contextKeys = [
+    'previousStateOutput',
+    'currentStateId',
+    'previousStateId',
+    'stateOutputs',
+    'currentStateOutput',
+    'sessionMemory',
+    'claims',
+    'args',
+    'vars'
+];
+export function validateExpression(expression) {
+    try {
+        const ast = parseExpression(expression);
+        const errors = validateAST({
+            allowedVars: contextKeys,
+            allowedFunctions: ['contains']
+        }, ast);
+        if (errors.length) {
+            return {
+                valid: false,
+                errors: errors.map((e) => e.message)
+            };
+        }
+        return { valid: true };
+    }
+    catch (e) {
+        return { valid: false, errors: [e.message] };
+    }
+}
+export function compileExpression(expression) {
+    const ast = parseExpression(expression);
+    return (context) => evaluate(ast, context);
+}
+export function expressionToString(_node, parent) {
+    if (!_node) {
+        return '';
+    }
+    const node = _node;
+    if (node.type === 'BinaryExpression') {
+        const wrap = parent?.type === 'BinaryExpression' && DEFAULT_PRECEDENCE[parent.operator] > DEFAULT_PRECEDENCE[node.operator];
+        const str = `${expressionToString(node.left, node)} ${node.operator} ${expressionToString(node.right, node)}`;
+        return wrap ? `(${str})` : str;
+    }
+    if (node.type === 'CallExpression') {
+        const args = node.arguments.map((arg) => expressionToString(arg, node));
+        return `${expressionToString(node.callee, node)}(${args.join(', ')})`;
+    }
+    if (node.type === 'UnaryExpression') {
+        return node.operator + expressionToString(node.argument, node);
+    }
+    if (node.type === 'MemberExpression') {
+        if (node.computed) {
+            return `${expressionToString(node.object, node)}[${expressionToString(node.property, node)}]`;
+        }
+        return `${expressionToString(node.object, node)}.${expressionToString(node.property, node)}`;
+    }
+    if (node.type === 'ArrayExpression') {
+        const arr = node.elements.map((element) => expressionToString(element, node)).join(',');
+        return `[${arr}]`;
+    }
+    if (node.type === 'Literal') {
+        return node.raw;
+    }
+    if (node.type === 'Identifier') {
+        return node.name;
+    }
+    if (node.type === 'ConditionalExpression') {
+        return `${expressionToString(node.test, node)} ? ${expressionToString(node.consequent, node)} : ${expressionToString(node.alternate, node)}`;
+    }
+    if (node.type === 'ThisExpression') {
+        return 'this';
+    }
+    return '';
+}

package/dist/validate/validate.js

@@ -22,7 +22,7 @@ import { isLatestProjectSchemaJSON } from "../project-schema/index.js";
 import { atRefToRefItem, createGetNamespace, getRefShapeName, parsePropertyRef, propertyRefItemToPath, propertyRefItemToResolverPath, refItemToAtRef, refItemToNamespacedShapeName, refItemToShape } from "../refs.js";
 import { getRelationship } from "../relationships.js";
 import { scalars } from "../scalars.js";
-import { getAllRefs } from "../schema-util.js";
+import { getAllRefs, isBuiltinMutation, isBuiltinQuery } from "../schema-util.js";
 import authSchemas from '../schemas/auth-schemas.json' with { type: 'json' };
 import { allProjectSchemas } from "../schemas/index.js";
 import { isValidTemplate } from "../template-shapes/index.js";
@@ -30,6 +30,7 @@ import { legacyProjectSchemaImportOptionalProps, projectSchemaImportOptionalProp
 import { isAIResolver, isBasicResolver, isComposeResolver, isExtendsSchema, isObjectSchema } from "../types/utils.js";
 import { isUnionSchema } from "../unions.js";
 import { getToolRef } from "../util/ai-tools.js";
+import { validateExpression } from "../util/expressions.js";
 import { getShape } from "../util/shapes.js";
 import { CURRENT_SCHEMA_VERSION, LEGACY_API_VERSION, LEGACY_SCHEMA_VERSION } from "../versions.js";
 import { defaultWorkflow } from "../workflows.js";
@@ -162,6 +163,10 @@ const validateAIToolConfig = (projectSchema, getNamespace, tool, basePath) => {
     if (parsed.serviceId !== 'local') {
         return;
     }
+    if ((parsed.shapeName === 'Query' && isBuiltinQuery(parsed.propertyName)) ||
+        (parsed.shapeName === 'Mutation' && isBuiltinMutation(parsed.propertyName))) {
+        return;
+    }
     const propertyPath = propertyRefItemToPath(getNamespace, parsed);
     if (propertyPath[0] !== 'queries' && propertyPath[0] !== 'mutations') {
         return {
@@ -834,6 +839,45 @@ function validateAgents(projectSchema) {
             else {
                 stateNames.add(state.name);
             }
+            if (state.variables) {
+                state.variables.forEach((variable, variableIndex) => {
+                    variable.steps.forEach((step, stepIndex) => {
+                        const stepPath = [...statePath, 'variables', variableIndex, 'steps', stepIndex];
+                        if (step.condition) {
+                            const conditionValidation = validateExpression(step.condition);
+                            if (!conditionValidation.valid) {
+                                const common = {
+                                    path: [...stepPath, 'condition'],
+                                    type: 'conflict'
+                                };
+                                errors.push(...conditionValidation.errors.map((message) => ({ ...common, message })));
+                            }
+                        }
+                        const exprValidation = validateExpression(step.expression);
+                        if (!exprValidation.valid) {
+                            const common = {
+                                path: [...stepPath, 'expression'],
+                                type: 'conflict'
+                            };
+                            errors.push(...exprValidation.errors.map((message) => ({ ...common, message })));
+                        }
+                    });
+                });
+            }
+            if (state.transition) {
+                state.transition.forEach((transition, transitionIndex) => {
+                    if (transition.condition) {
+                        const conditionValidation = validateExpression(transition.condition);
+                        if (!conditionValidation.valid) {
+                            const common = {
+                                path: [...statePath, 'transition', transitionIndex, 'expression'],
+                                type: 'conflict'
+                            };
+                            errors.push(...conditionValidation.errors.map((message) => ({ ...common, message })));
+                        }
+                    }
+                });
+            }
             if (state.execution.type === 'generate' || state.execution.type === 'chat') {
                 if (!state.execution.tools) {
                     continue;

package/examples/latest/agent-schema.json

@@ -199,9 +199,6 @@
         "start": {
           "transition": [
             {
-              "condition": {
-                "type": "none"
-              },
               "destination": "bbb"
             }
           ]
@@ -219,13 +216,10 @@
                 "name": "input",
                 "steps": [
                   {
-                    "type": "stateOutput",
-                    "stateId": "ccc",
-                    "path": "dogName"
+                    "expression": "stateOutputs['ccc'].dogName"
                   },
                   {
-                    "type": "graphqlArg",
-                    "argName": "input"
+                    "expression": "args.input"
                   }
                 ]
               }
@@ -233,13 +227,10 @@
             "execution": {
               "type": "graphql",
               "query": "query ($input: String!) {\n  getDogList(terms: $input) {\n    items {\n      name\n      color\n    }\n  }\n}\n",
-              "path": "getDogList.items"
+              "path": "getDogList.items[0]"
             },
             "transition": [
               {
-                "condition": {
-                  "type": "none"
-                },
                 "destination": "ccc"
               }
             ]
@@ -247,11 +238,19 @@
           "ccc": {
             "name": "answer",
             "variables": [
+              {
+                "name": "input",
+                "steps": [
+                  {
+                    "expression": "args.input"
+                  }
+                ]
+              },
               {
                 "name": "results",
                 "steps": [
                   {
-                    "type": "previousStateOutput"
+                    "expression": "previousStateOutput"
                   }
                 ]
               }
@@ -268,24 +267,14 @@
             },
             "transition": [
               {
-                "condition": {
-                  "type": "stateOutput",
-                  "stateId": "ccc",
-                  "path": "answered"
-                },
+                "condition": "stateOutputs['ccc'].answered",
                 "destination": "ddd"
               },
               {
-                "condition": {
-                  "type": "none"
-                },
                 "limit": 3,
                 "destination": "bbb"
               },
               {
-                "condition": {
-                  "type": "none"
-                },
                 "destination": "eee"
               }
             ]
@@ -297,8 +286,7 @@
                 "name": "results",
                 "steps": [
                   {
-                    "type": "previousStateOutput",
-                    "path": "message"
+                    "expression": "previousStateOutput.message"
                   }
                 ]
               }
@@ -321,8 +309,7 @@
                 "name": "results",
                 "steps": [
                   {
-                    "type": "previousStateOutput",
-                    "path": "message"
+                    "expression": "previousStateOutput.message"
                   }
                 ]
               }
@@ -348,9 +335,6 @@
         "start": {
           "transition": [
             {
-              "condition": {
-                "type": "none"
-              },
               "destination": "3pjuyB47X"
             }
           ]
@@ -369,17 +353,10 @@
             },
             "transition": [
               {
-                "condition": {
-                  "type": "stringContains",
-                  "string": "ALL_DONE",
-                  "path": "content"
-                },
+                "condition": "contains(currentStateOutput.content, 'ALL_DONE')",
                 "destination": "endAgentExecution"
               },
               {
-                "condition": {
-                  "type": "none"
-                },
                 "destination": "3pjuyB47X",
                 "suspend": true
               }

package/examples/source/agent-schema.json

@@ -181,9 +181,6 @@
         "start": {
           "transition": [
             {
-              "condition": {
-                "type": "none"
-              },
               "destination": "bbb"
             }
           ]
@@ -201,13 +198,10 @@
                 "name": "input",
                 "steps": [
                   {
-                    "type": "stateOutput",
-                    "stateId": "ccc",
-                    "path": "dogName"
+                    "expression": "stateOutputs['ccc'].dogName"
                   },
                   {
-                    "type": "graphqlArg",
-                    "argName": "input"
+                    "expression": "args.input"
                   }
                 ]
               }
@@ -215,16 +209,32 @@
             "execution": {
               "type": "graphql",
               "query": "query ($input: String!) {\n  getDogList(terms: $input) {\n    items {\n      name\n      color\n    }\n  }\n}\n",
-              "path": "getDogList.items"
+              "path": "getDogList.items[0]"
             },
-            "transition": [{ "condition": { "type": "none" }, "destination": "ccc" }]
+            "transition": [
+              {
+                "destination": "ccc"
+              }
+            ]
           },
           "ccc": {
             "name": "answer",
             "variables": [
+              {
+                "name": "input",
+                "steps": [
+                  {
+                    "expression": "args.input"
+                  }
+                ]
+              },
               {
                 "name": "results",
-                "steps": [{ "type": "previousStateOutput" }]
+                "steps": [
+                  {
+                    "expression": "previousStateOutput"
+                  }
+                ]
               }
             ],
             "execution": {
@@ -239,19 +249,16 @@
             },
             "transition": [
               {
-                "condition": {
-                  "type": "stateOutput",
-                  "stateId": "ccc",
-                  "path": "answered"
-                },
+                "condition": "stateOutputs['ccc'].answered",
                 "destination": "ddd"
               },
               {
-                "condition": { "type": "none" },
                 "limit": 3,
                 "destination": "bbb"
               },
-              { "condition": { "type": "none" }, "destination": "eee" }
+              {
+                "destination": "eee"
+              }
             ]
           },
           "ddd": {
@@ -259,7 +266,11 @@
             "variables": [
               {
                 "name": "results",
-                "steps": [{ "type": "previousStateOutput", "path": "message" }]
+                "steps": [
+                  {
+                    "expression": "previousStateOutput.message"
+                  }
+                ]
               }
             ],
             "execution": {
@@ -278,7 +289,11 @@
             "variables": [
               {
                 "name": "results",
-                "steps": [{ "type": "previousStateOutput", "path": "message" }]
+                "steps": [
+                  {
+                    "expression": "previousStateOutput.message"
+                  }
+                ]
               }
             ],
             "execution": {
@@ -302,9 +317,6 @@
         "start": {
           "transition": [
             {
-              "condition": {
-                "type": "none"
-              },
               "destination": "3pjuyB47X"
             }
           ]
@@ -323,17 +335,10 @@
             },
             "transition": [
               {
-                "condition": {
-                  "type": "stringContains",
-                  "string": "ALL_DONE",
-                  "path": "content"
-                },
+                "condition": "contains(currentStateOutput.content, 'ALL_DONE')",
                 "destination": "endAgentExecution"
               },
               {
-                "condition": {
-                  "type": "none"
-                },
                 "destination": "3pjuyB47X",
                 "suspend": true
               }