@takeshape/schema 11.63.7 → 11.64.0

package/dist/project-schema/v3.53.0.d.ts

@@ -285,8 +285,6 @@ export type CacheTriggerConfigV3_53_0 = CacheScheduleTriggerConfigV3_53_0 | Cach
 export type ShapeSchemaV3_53_0 = ShapeSchemaAllOfV3_53_0 | ShapeSchemaExtendsV3_53_0 | ShapeSchemaOneOfV3_53_0 | ShapeSchemaEnumV3_53_0 | ObjectSchemaV3_53_0 | ShapeSchemaAnyV3_53_0;
 export type AgentAPIV3_53_0 = AgentAPIChatV3_53_0 | AgentAPIGenerateV3_53_0;
 export type MemoryLocationsV3_53_0 = AgentSessionMemoryLocationV3_53_0[];
-export type AgentVariableStepV3_53_0 = AgentVariableStepSessionMemoryV3_53_0 | AgentVariableStepGraphQLArgV3_53_0 | AgentVariableStepStateOutputV3_53_0 | AgentVariableStepPreviousStateOutputV3_53_0 | AgentVariableStepStaticValueV3_53_0;
-export type AgentVariableStepConditionV3_53_0 = AgentVariableStepConditionNoneV3_53_0 | AgentVariableStepConditionSourceStateV3_53_0;
 export type VariablesV3_53_0 = AgentVariableV3_53_0[];
 export type AgentExecutionV3_53_0 = AgentExecutionGraphQLV3_53_0 | AgentExecutionGenerateV3_53_0 | AgentExecutionChatV3_53_0;
 export type AgentAIStateInputV3_53_0 = AgentAIStateInputArgumentV3_53_0 | AgentAIStateInputTemplateV3_53_0;
@@ -1762,34 +1760,9 @@ export interface AgentStartV3_53_0 {
 export interface AgentTransitionStepV3_53_0 {
     destination: string;
     suspend?: boolean;
-    condition: AgentTransitionStepConditionNoneV3_53_0 | AgentTransitionStepConditionArtifactV3_53_0 | AgentTransitionStepConditionStateOutputV3_53_0 | AgentTransitionStepConditionStringContainsV3_53_0 | AgentTransitionStepConditionArgumentV3_53_0;
+    condition?: string;
     limit?: number;
 }
-export interface AgentTransitionStepConditionNoneV3_53_0 {
-    type: 'none';
-}
-export interface AgentTransitionStepConditionArtifactV3_53_0 {
-    type: 'artifact';
-    path?: string;
-    negated?: boolean;
-}
-export interface AgentTransitionStepConditionStateOutputV3_53_0 {
-    type: 'stateOutput';
-    stateId: string;
-    path?: string;
-    negated?: boolean;
-}
-export interface AgentTransitionStepConditionStringContainsV3_53_0 {
-    type: 'stringContains';
-    path?: string;
-    string: string;
-    negated?: boolean;
-}
-export interface AgentTransitionStepConditionArgumentV3_53_0 {
-    type: 'argument';
-    argument: string;
-    negated?: boolean;
-}
 /**
  * States that are traversed during the execution of an agent.
  */
@@ -1816,39 +1789,9 @@ export interface AgentVariableV3_53_0 {
      */
     steps: AgentVariableStepV3_53_0[];
 }
-export interface AgentVariableStepSessionMemoryV3_53_0 {
-    type: 'sessionMemory';
-    memoryKey: string;
-    path?: string;
-}
-export interface AgentVariableStepGraphQLArgV3_53_0 {
-    type: 'graphqlArg';
-    argName: string;
-}
-export interface AgentVariableStepStateOutputV3_53_0 {
-    type: 'stateOutput';
-    stateId: string;
-    path?: string;
-}
-export interface AgentVariableStepPreviousStateOutputV3_53_0 {
-    type: 'previousStateOutput';
-    path?: string;
-}
-/**
- * An Agent Variable that has a static value.
- */
-export interface AgentVariableStepStaticValueV3_53_0 {
-    type: 'staticValue';
-    condition?: AgentVariableStepConditionV3_53_0;
-    value: string;
-}
-export interface AgentVariableStepConditionNoneV3_53_0 {
-    type: 'none';
-}
-export interface AgentVariableStepConditionSourceStateV3_53_0 {
-    type: 'sourceState';
-    stateId: string;
-    negated?: boolean;
+export interface AgentVariableStepV3_53_0 {
+    condition?: string;
+    expression: string;
 }
 export interface AgentExecutionGraphQLV3_53_0 {
     type: 'graphql';

package/dist/schemas/project-schema/experimental.json

@@ -143,148 +143,16 @@
     },
     "agentVariableStep": {
       "title": "Agent Variable Step",
-      "discriminator": {
-        "propertyName": "type"
-      },
-      "oneOf": [
-        {
-          "$ref": "#/definitions/agentVariableStepSessionMemory"
-        },
-        {
-          "$ref": "#/definitions/agentVariableStepGraphqlArg"
-        },
-        {
-          "$ref": "#/definitions/agentVariableStepStateOutput"
-        },
-        {
-          "$ref": "#/definitions/agentVariableStepPreviousStateOutput"
-        },
-        {
-          "$ref": "#/definitions/agentVariableStepStaticValue"
-        }
-      ]
-    },
-    "agentVariableStepSessionMemory": {
-      "title": "Agent Variable Step Session Memory",
-      "type": "object",
-      "properties": {
-        "type": {
-          "enum": ["sessionMemory"]
-        },
-        "memoryKey": {
-          "type": "string"
-        },
-        "path": {
-          "type": "string"
-        }
-      },
-      "required": ["type", "memoryKey"],
-      "additionalProperties": false
-    },
-    "agentVariableStepGraphqlArg": {
-      "title": "Agent Variable Step GraphQL Arg",
-      "type": "object",
-      "properties": {
-        "type": {
-          "enum": ["graphqlArg"]
-        },
-        "argName": {
-          "type": "string"
-        }
-      },
-      "required": ["type", "argName"],
-      "additionalProperties": false
-    },
-    "agentVariableStepPreviousStateOutput": {
-      "title": "Agent Variable Step Previous State Output",
-      "type": "object",
-      "properties": {
-        "type": {
-          "enum": ["previousStateOutput"]
-        },
-        "path": {
-          "type": "string"
-        }
-      },
-      "required": ["type"],
-      "additionalProperties": false
-    },
-    "agentVariableStepStateOutput": {
-      "title": "Agent Variable Step State Output",
       "type": "object",
       "properties": {
-        "type": {
-          "enum": ["stateOutput"]
-        },
-        "stateId": {
-          "type": "string",
-          "pattern": "^[0-9A-Za-z_]+$"
-        },
-        "path": {
-          "type": "string"
-        }
-      },
-      "required": ["type", "stateId"],
-      "additionalProperties": false
-    },
-    "agentVariableStepCondition": {
-      "title": "Agent Variable Step Condition",
-      "discriminator": {
-        "propertyName": "type"
-      },
-      "oneOf": [
-        {
-          "$ref": "#/definitions/agentVariableStepConditionNone"
-        },
-        {
-          "$ref": "#/definitions/agentVariableStepConditionSourceState"
-        }
-      ]
-    },
-    "agentVariableStepStaticValue": {
-      "title": "Agent Variable Step Static Value",
-      "description": "An Agent Variable that has a static value.",
-      "type": "object",
-      "properties": {
-        "type": {
-          "enum": ["staticValue"]
-        },
         "condition": {
-          "$ref": "#/definitions/agentVariableStepCondition"
-        },
-        "value": {
           "type": "string"
-        }
-      },
-      "required": ["type", "value"],
-      "additionalProperties": false
-    },
-    "agentVariableStepConditionNone": {
-      "title": "Agent Variable Step Condition None",
-      "type": "object",
-      "properties": {
-        "type": {
-          "enum": ["none"]
-        }
-      },
-      "required": ["type"],
-      "additionalProperties": false
-    },
-    "agentVariableStepConditionSourceState": {
-      "title": "Agent Variable Step Condition Source State",
-      "type": "object",
-      "properties": {
-        "type": {
-          "enum": ["sourceState"]
         },
-        "stateId": {
+        "expression": {
           "type": "string"
-        },
-        "negated": {
-          "type": "boolean"
         }
       },
-      "required": ["type", "stateId"],
+      "required": ["expression"],
       "additionalProperties": false
     },
     "agentStart": {
@@ -695,91 +563,6 @@
       "required": ["type", "service", "model", "input"],
       "additionalProperties": false
     },
-    "agentTransitionStepConditionNone": {
-      "title": "Agent Transition Step Condition None",
-      "type": "object",
-      "properties": {
-        "type": {
-          "enum": ["none"]
-        }
-      },
-      "required": ["type"],
-      "additionalProperties": false
-    },
-    "agentTransitionStepConditionStateOutput": {
-      "title": "Agent Transition Step Condition State Output",
-      "type": "object",
-      "properties": {
-        "type": {
-          "enum": ["stateOutput"]
-        },
-        "stateId": {
-          "type": "string"
-        },
-        "path": {
-          "type": "string"
-        },
-        "negated": {
-          "type": "boolean"
-        }
-      },
-      "required": ["type", "stateId"],
-      "additionalProperties": false
-    },
-    "agentTransitionStepConditionArtifact": {
-      "title": "Agent Transition Step Condition Artifact",
-      "type": "object",
-      "properties": {
-        "type": {
-          "enum": ["artifact"]
-        },
-        "path": {
-          "type": "string"
-        },
-        "negated": {
-          "type": "boolean"
-        }
-      },
-      "required": ["type"],
-      "additionalProperties": false
-    },
-    "agentTransitionStepConditionStringContains": {
-      "title": "Agent Transition Step Condition String Contains",
-      "type": "object",
-      "properties": {
-        "type": {
-          "enum": ["stringContains"]
-        },
-        "path": {
-          "type": "string"
-        },
-        "string": {
-          "type": "string"
-        },
-        "negated": {
-          "type": "boolean"
-        }
-      },
-      "required": ["type", "string"],
-      "additionalProperties": false
-    },
-    "agentTransitionStepConditionArgument": {
-      "title": "Agent Transition Step Condition Argument",
-      "type": "object",
-      "properties": {
-        "type": {
-          "enum": ["argument"]
-        },
-        "argument": {
-          "type": "string"
-        },
-        "negated": {
-          "type": "boolean"
-        }
-      },
-      "required": ["type", "argument"],
-      "additionalProperties": false
-    },
     "agentTransitionStep": {
       "title": "Agent Transition Step",
       "description": "These steps are evaluated in order until a destination is found.",
@@ -793,38 +576,14 @@
           "type": "boolean"
         },
         "condition": {
-          "discriminator": {
-            "propertyName": "type"
-          },
-          "oneOf": [
-            {
-              "$ref": "#/definitions/agentTransitionStepConditionNone"
-            },
-            {
-              "$ref": "#/definitions/agentTransitionStepConditionArtifact"
-            },
-            {
-              "$ref": "#/definitions/agentTransitionStepConditionStateOutput"
-            },
-            {
-              "$ref": "#/definitions/agentTransitionStepConditionStringContains"
-            },
-            {
-              "$ref": "#/definitions/agentTransitionStepConditionArgument"
-            }
-          ]
+          "type": "string"
         },
         "limit": {
           "type": "integer"
         }
       },
       "additionalProperties": false,
-      "required": ["destination", "condition"],
-      "default": {
-        "condition": {
-          "type": "none"
-        }
-      }
+      "required": ["destination"]
     },
     "agentMap": {
       "title": "Agent Map",

package/dist/util/__tests__/expressions.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/util/__tests__/expressions.test.js

@@ -0,0 +1,172 @@
+import jsep from 'jsep';
+import { describe, expect, test } from 'vitest';
+import { compileExpression, expressionToString, METHODS_NOT_SUPPORTED, THIS_NOT_SUPPORTED, validateExpression } from '../expressions.js';
+const disallowedMemberError = /Access to member "\w+" disallowed/;
+const fixtures = [
+    // array expression
+    { expr: '([1,2,3])[0]', expected: 1, normalized: '[1,2,3][0]' },
+    { expr: '(["one","two","three"])[1]', expected: 'two', normalized: '["one","two","three"][1]' },
+    { expr: '([true,false,true])[1]', expected: false, normalized: '[true,false,true][1]' },
+    { expr: '([true,false,true])[2]', expected: true, normalized: '[true,false,true][2]' },
+    { expr: '([1,2,3]).length', expected: 3, normalized: '[1,2,3].length' },
+    { expr: '([1,true,"three"]).length', expected: 3, normalized: '[1,true,"three"].length' },
+    { expr: 'isArray([1,2,3])', expected: true },
+    { expr: 'list[3]', expected: 4 },
+    { expr: '(1 + 5) * 10', expected: 60 },
+    { expr: '1 + 5 * 10', expected: 51 },
+    { expr: 'numMap[1 + two]', expected: 'three' },
+    // binary expression
+    { expr: '1+2', expected: 3, normalized: '1 + 2' },
+    { expr: '2-1', expected: 1, normalized: '2 - 1' },
+    { expr: '2*2', expected: 4, normalized: '2 * 2' },
+    { expr: '6/3', expected: 2, normalized: '6 / 3' },
+    { expr: '(1 + 2) + (3 + 5)', expected: 11, normalized: '1 + 2 + 3 + 5' },
+    // {expr: '5|3', expected: 7},
+    // {expr: '5&3', expected: 1},
+    // {expr: '5^3', expected: 6},
+    // {expr: '4<<2', expected: 16},
+    // {expr: '256>>4', expected: 16},
+    // {expr: '-14>>>2', expected: 1073741820},
+    { expr: '10%6', expected: 4, normalized: '10 % 6' },
+    { expr: '"a"+"b"', expected: 'ab', normalized: '"a" + "b"' },
+    { expr: 'one + three', expected: 4 },
+    // call expression
+    { expr: 'func(5)', expected: 6 },
+    { expr: 'func(1+2)', expected: 4, normalized: 'func(1 + 2)' },
+    // conditional expression
+    { expr: '(true ? "true" : "false")', expected: 'true', normalized: 'true ? "true" : "false"' },
+    { expr: '( ( bool || false ) ? "true" : "false")', expected: 'true', normalized: 'bool || false ? "true" : "false"' },
+    { expr: 'bool || false ? "true" : "false"', expected: 'true' },
+    { expr: '( true ? ( 123*456 ) : "false")', expected: 123 * 456, normalized: 'true ? 123 * 456 : "false"' },
+    { expr: '( false ? "true" : one + two )', expected: 3, normalized: 'false ? "true" : one + two' },
+    // identifier
+    { expr: 'string', expected: 'string' },
+    { expr: 'number', expected: 123 },
+    { expr: 'bool', expected: true },
+    // literal
+    { expr: '"foo"', expected: 'foo' }, // string literal
+    { expr: "'foo'", expected: 'foo' }, // string literal
+    { expr: '123', expected: 123 }, // numeric literal
+    { expr: 'true', expected: true }, // boolean literal
+    // logical expression
+    { expr: 'true || false', expected: true },
+    { expr: 'true && false', expected: false },
+    { expr: '1 == "1"', expected: true },
+    { expr: '2 != "2"', expected: false },
+    { expr: '1.234 === 1.234', expected: true },
+    { expr: '123 !== "123"', expected: true },
+    { expr: '1 < 2', expected: true },
+    { expr: '1 > 2', expected: false },
+    { expr: '2 <= 2', expected: true },
+    { expr: '1 >= 2', expected: false },
+    // logical expression lazy evaluation
+    { expr: 'true || throw()', expected: true },
+    { expr: 'false || true', expected: true },
+    { expr: 'false && throw()', expected: false },
+    { expr: 'true && false', expected: false },
+    // member expression
+    { expr: 'foo.bar', expected: 'baz' },
+    { expr: 'foo["bar"]', expected: 'baz' },
+    { expr: 'foo[foo.bar]', expected: 'wow' },
+    // call expression with member
+    { expr: 'foo.func("bar")', throws: METHODS_NOT_SUPPORTED },
+    // unary expression
+    { expr: '-one', expected: -1 },
+    { expr: '+two', expected: 2 },
+    { expr: '!false', expected: true },
+    { expr: '!!true', expected: true },
+    // {expr: '~15', expected: -16},
+    { expr: '+[]', expected: 0 },
+    // 'this' context
+    { expr: 'this.three', expected: 3 },
+    // custom operators
+    // {expr: '@2', expected: 'two'},
+    // {expr: '3#4', expected: 3.4},
+    // {expr: '(1 # 2 # 3)', expected: 1.5}, // Fails with undefined precedence, see issue #45
+    // {expr: '1 + 2 ~ 3', expected: 9} // ~ is * but with low precedence
+    // Disallowed members
+    { expr: 'o.__proto__', throws: disallowedMemberError },
+    { expr: 'o.prototype', throws: disallowedMemberError },
+    { expr: 'o.constructor', throws: disallowedMemberError },
+    { expr: 'o["__proto__"]', throws: disallowedMemberError },
+    { expr: 'o["prototype"]', throws: disallowedMemberError },
+    { expr: 'o["constructor"]', throws: disallowedMemberError },
+    { expr: 'o[p1]', throws: disallowedMemberError },
+    { expr: 'o[p2]', throws: disallowedMemberError },
+    { expr: 'o[c]', throws: disallowedMemberError }
+];
+const context = {
+    string: 'string',
+    number: 123,
+    bool: true,
+    one: 1,
+    two: 2,
+    three: 3,
+    foo: {
+        bar: 'baz',
+        baz: 'wow',
+        func() {
+            throw new Error('Should not be called.');
+        }
+    },
+    numMap: { 10: 'ten', 3: 'three' },
+    list: [1, 2, 3, 4, 5],
+    func(x) {
+        return x + 1;
+    },
+    isArray: Array.isArray,
+    throw() {
+        throw new Error('Should not be called.');
+    },
+    o: {},
+    p1: '__proto__',
+    p2: 'prototype',
+    c: 'constructor'
+};
+test.each(fixtures)('eval $expr', ({ expr, expected, throws }) => {
+    const compiled = compileExpression(expr);
+    if (throws) {
+        expect(() => compiled(context)).toThrow(throws);
+    }
+    else {
+        expect(compiled(context)).toEqual(expected);
+    }
+});
+test.each(fixtures)('astToString $expr', ({ expr, normalized }) => {
+    const ast = jsep(expr);
+    expect(expressionToString(ast)).toEqual(normalized ?? expr);
+});
+describe('validateExpression', () => {
+    test('valid', () => {
+        expect(validateExpression('1 + 2')).toEqual({ valid: true });
+    });
+    test('invalid variable', () => {
+        expect(validateExpression('bogus[currentStateOutput].value')).toEqual({
+            errors: ['Unknown variable "bogus"'],
+            valid: false
+        });
+    });
+    test('invalid variable in member expression', () => {
+        expect(validateExpression('currentStateOutput[bogus].value')).toEqual({
+            errors: ['Unknown variable "bogus"'],
+            valid: false
+        });
+    });
+    test('valid member expression', () => {
+        expect(validateExpression('currentStateOutput.bogus.value')).toEqual({
+            valid: true
+        });
+    });
+    test('invalid function', () => {
+        expect(validateExpression('foo(currentStateOutput)')).toEqual({ errors: ['Unknown function "foo"'], valid: false });
+    });
+    test('invalid this', () => {
+        expect(validateExpression('this')).toEqual({ errors: [THIS_NOT_SUPPORTED], valid: false });
+    });
+    test('invalid member expression', () => {
+        expect(validateExpression('currentStateOutput.foo()')).toEqual({
+            valid: false,
+            errors: [METHODS_NOT_SUPPORTED]
+        });
+    });
+});

package/dist/util/expressions.d.ts

@@ -0,0 +1,25 @@
+import jsep from 'jsep';
+type AnyExpression = jsep.ArrayExpression | jsep.BinaryExpression | jsep.MemberExpression | jsep.CallExpression | jsep.ConditionalExpression | jsep.Identifier | jsep.Literal | jsep.ThisExpression | jsep.UnaryExpression;
+export declare const METHODS_NOT_SUPPORTED = "Methods are not supported in expressions";
+export declare const THIS_NOT_SUPPORTED = "This is not supported in expressions";
+export declare function parseExpression(expression: string): AnyExpression;
+export type ExpressionContext = {
+    previousStateOutput?: unknown;
+    currentStateId: string;
+    previousStateId?: string;
+    stateOutputs: Record<string, unknown>;
+    currentStateOutput?: unknown;
+    sessionMemory: Record<string, unknown>;
+    claims: Record<string, unknown>;
+    args: Record<string, unknown>;
+    vars: Record<string, unknown>;
+};
+export declare function validateExpression(expression: string): {
+    valid: true;
+} | {
+    valid: false;
+    errors: string[];
+};
+export declare function compileExpression(expression: string): (context: Record<string, unknown>) => unknown;
+export declare function expressionToString(_node: jsep.Expression | null, parent?: AnyExpression): string;
+export {};