@takeshape/schema 11.98.5 → 11.99.0

package/dist/validate/validate.js

@@ -16,25 +16,27 @@ import coerce from 'semver/functions/coerce.js';
 import gte from 'semver/functions/gte.js';
 import lt from 'semver/functions/lt.js';
 import neq from 'semver/functions/neq.js';
-import { isGuardEnabled } from "../agents.js";
+import { GUARDS_SCHEMA_PATH, getGuards, isGuardEnabled } from "../agents.js";
 import { builtInShapes } from "../builtin-schema.js";
 import { isEnumLikeSchema } from "../enum.js";
 import { isLatestProjectSchemaJSON } from "../project-schema/index.js";
 import { createGetNamespace, getRefShapeName, getToolRef, isValidServiceId, parsePropertyRef, parseRef, propertyRefItemToPath, propertyRefItemToResolverPath, refItemToNamespacedShapeName, refItemToShape, serializeRef } from "../refs.js";
 import { getRelationship } from "../relationships.js";
 import { scalars } from "../scalars.js";
-import { getAllRefs, isBuiltinMutation, isBuiltinQuery } from "../schema-util.js";
+import { getAllRefs } 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";
 import { legacyProjectSchemaImportOptionalProps, projectSchemaImportOptionalProps } from "../types/types.js";
 import { isAIResolver, isBasicResolver, isComposeResolver, isExtendsSchema, isObjectSchema } from "../types/utils.js";
 import { isUnionSchema } from "../unions.js";
-import { validateExpression } from "../util/expressions.js";
+import { getMcpToolMap, TOOL_SCHEMA_PATH } from '../util/mcp.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";
+import { validateAgents, validateAIToolConfig } from "./ai.js";
 import { formatError } from "./errors.js";
+import { pushErrors } from './util.js';
 export const builtInShapeNames = new Set([...Object.keys(builtInShapes), ...scalars, 'object']);
 function findDuplicates(items) {
     const seen = {};
@@ -78,7 +80,7 @@ function checkToolNames(tools) {
     return Object.entries(tools)
         .filter(([name, tool]) => name !== tool.name)
         .map(([name, tool]) => ({
-        path: ['ai-experimental', 'mcp', 'tools', name, 'name'],
+        path: [...TOOL_SCHEMA_PATH, name, 'name'],
         type: 'conflict',
         message: `Tool.name "${tool.name}" must match key "${name}".`
     }));
@@ -135,11 +137,6 @@ function validateWorkflows(projectSchema) {
 function getSemver(schemaVersion) {
     return coerce(schemaVersion) ?? LEGACY_SCHEMA_VERSION;
 }
-function pushErrors(errors, error) {
-    if (error) {
-        errors.push(error);
-    }
-}
 function enumerateBasicResolvers(resolver, path) {
     const results = [];
     const visit = (resolver, path) => {
@@ -155,47 +152,6 @@ function enumerateBasicResolvers(resolver, path) {
     visit(resolver, path);
     return results;
 }
-const isValidAgentMutation = (projectSchema, mutationName) => {
-    return Boolean(projectSchema['ai-experimental']?.agents?.[mutationName]);
-};
-const validateAIToolConfig = (projectSchema, getNamespace, tool, basePath) => {
-    const toolRef = getToolRef(tool);
-    const path = typeof tool === 'string' ? basePath : basePath.concat('ref');
-    const parsed = parsePropertyRef(toolRef);
-    if (!parsed) {
-        return {
-            type: 'conflict',
-            path,
-            message: `Unable to parse property ref "${toolRef}"`
-        };
-    }
-    if (parsed.layerId !== '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 {
-            type: 'conflict',
-            path,
-            message: 'Tools must be a query or mutation'
-        };
-    }
-    const property = get(projectSchema, propertyPath);
-    if (propertyPath[0] === 'mutations' && isValidAgentMutation(projectSchema, propertyPath[1])) {
-        return;
-    }
-    if (!property) {
-        return {
-            type: 'notFound',
-            path,
-            message: `Missing tool ${propertyPath[0] === 'queries' ? 'query' : 'mutation'} "${toolRef}"`
-        };
-    }
-};
 function validateResolver(projectSchema, basePath, baseResolver) {
     const errors = [];
     const isValidShapeName = (shapeName) => {
@@ -359,7 +315,7 @@ function isValidShapeReference(context, layerState, shapeName) {
     }
     return Boolean(layerState.schema.shapes[shapeName]);
 }
-async function validateResolverReferences(context, projectSchema, basePath, baseResolver) {
+async function validateResolverReferences(context, basePath, baseResolver) {
     const errors = [];
     const isInvalidPropertyRef = async (refStr) => {
         const ref = parsePropertyRef(refStr);
@@ -415,9 +371,9 @@ async function validateResolverReferences(context, projectSchema, basePath, base
     });
     return errors;
 }
-async function validateQueryConfig(context, projectSchema, { query, name, operation }) {
+async function validateQueryConfig(context, { query, name, operation }) {
     const location = operation === 'query' ? 'queries' : 'mutations';
-    return validateResolverReferences(context, projectSchema, [location, name, 'resolver'], query.resolver);
+    return validateResolverReferences(context, [location, name, 'resolver'], query.resolver);
 }
 async function validateQueryConfigs(context, projectSchema) {
     const isLessThanV3_9_0 = lt(getSemver(projectSchema.schemaVersion), '3.9.0');
@@ -427,7 +383,7 @@ async function validateQueryConfigs(context, projectSchema) {
     const promises = [];
     for (const [operation, prop] of operationProps) {
         for (const name of Object.keys(projectSchema[prop])) {
-            promises.push(validateQueryConfig(context, projectSchema, {
+            promises.push(validateQueryConfig(context, {
                 query: projectSchema[prop][name],
                 operation,
                 name
@@ -492,7 +448,7 @@ async function validateShapeJoinRef(context, projectSchema, item) {
 async function validateShapeJoins(context, projectSchema) {
     const promises = [];
     for (const item of listShapeJoins(projectSchema)) {
-        promises.push(validateShapeJoinRef(context, projectSchema, item), validateResolverReferences(context, projectSchema, item.path, item.join.resolver));
+        promises.push(validateShapeJoinRef(context, projectSchema, item), validateResolverReferences(context, item.path, item.join.resolver));
     }
     return flatten(await Promise.all(promises));
 }
@@ -829,112 +785,6 @@ function validateInterfaceImplementations(projectSchema) {
     }
     return errors;
 }
-function validateAgents(projectSchema) {
-    const getNamespace = createGetNamespace(projectSchema);
-    const errors = [];
-    const guards = projectSchema['ai-experimental']?.guards;
-    const agents = projectSchema['ai-experimental']?.agents;
-    if (!agents) {
-        return errors;
-    }
-    for (const [agentName, agent] of Object.entries(agents)) {
-        const stateNames = new Set();
-        const agentPath = ['ai-experimental', 'agents', agentName];
-        for (const [stateId, state] of Object.entries(agent.states)) {
-            const statePath = [...agentPath, 'states', stateId];
-            if (stateNames.has(state.name)) {
-                errors.push({
-                    path: [...statePath, 'name'],
-                    type: 'conflict',
-                    message: `Duplicate state name "${state.name}"`
-                });
-            }
-            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;
-                }
-                state.execution.tools.forEach((tool, toolIndex) => {
-                    pushErrors(errors, validateAIToolConfig(projectSchema, getNamespace, tool, [
-                        ...statePath,
-                        'execution',
-                        'tools',
-                        toolIndex,
-                        'ref'
-                    ]));
-                });
-            }
-        }
-        if (agent.guards) {
-            const invalidGuards = agent.guards.filter(({ guardId }) => !guards?.[guardId]);
-            if (invalidGuards.length) {
-                const guardPath = [...agentPath, 'guards'];
-                errors.push(...invalidGuards.map(({ guardId }, index) => ({
-                    path: [...guardPath, index, 'guardId'],
-                    type: 'notFound',
-                    message: `Invalid guardId "${guardId}"`
-                })));
-            }
-        }
-        if (agent.historyStrategies) {
-            const seenStrategyNames = new Set();
-            for (const [historyStrategyId, historyStrategy] of Object.entries(agent.historyStrategies)) {
-                if (seenStrategyNames.has(historyStrategy.name)) {
-                    errors.push({
-                        path: [...agentPath, 'historyStrategies', historyStrategyId, 'name'],
-                        type: 'conflict',
-                        message: `Duplicate history strategy name "${historyStrategy.name}"`
-                    });
-                }
-                else {
-                    seenStrategyNames.add(historyStrategy.name);
-                }
-            }
-        }
-    }
-    return errors;
-}
 function validateInterfaces(projectSchema) {
     const errors = [];
     // Validate interface shapes must be an object schema with at least one property
@@ -1007,13 +857,13 @@ function validateGuards(context, schema) {
     if (context.ignoreEntitlements) {
         return errors;
     }
-    const numGuards = Object.values(schema['ai-experimental']?.guards ?? {}).filter((guard) => isGuardEnabled(guard)).length;
+    const numGuards = getGuards(schema).filter(isGuardEnabled).length;
     const entitledGuards = context.entitlements.guards ?? 0;
     if (numGuards > entitledGuards) {
         errors.push({
             type: 'entitlement',
             message: `Number of enabled guards exceeds your entitled limit of ${entitledGuards}`,
-            path: ['ai-experimental', 'guards']
+            path: [...GUARDS_SCHEMA_PATH]
         });
     }
     return errors;
@@ -1046,7 +896,7 @@ function validateSyntax(context, schema) {
         .concat(validateInterfaceImplementations(schema))
         .concat(validateAgents(schema))
         .concat(validateGuards(context, schema));
-    const mcpTools = schema['ai-experimental']?.mcp?.tools;
+    const mcpTools = getMcpToolMap(schema);
     if (mcpTools) {
         errors = errors.concat(checkToolNames(mcpTools ?? {}));
     }

package/examples/latest/agent-schema.json

@@ -187,18 +187,19 @@
       "findDogColor": {
         "description": "AI Agent finds a dog's color based on its name",
         "api": {
-          "type": "generate",
-          "arguments": [
+          "inputs": [
             {
-              "argName": "input",
-              "argType": "string",
-              "required": true
+              "name": "findDogColor",
+              "type": "mutation",
+              "args": "TSGenerateArgs"
             }
           ]
         },
         "start": {
           "transition": [
             {
+              "type": "suspend",
+              "input": "findDogColor",
               "destination": "bbb"
             }
           ]
@@ -229,6 +230,7 @@
             },
             "transition": [
               {
+                "type": "immediate",
                 "destination": "ccc"
               }
             ]
@@ -265,14 +267,17 @@
             },
             "transition": [
               {
+                "type": "immediate",
                 "condition": "stateOutputs['ccc'].answered",
                 "destination": "ddd"
               },
               {
+                "type": "immediate",
                 "limit": 3,
                 "destination": "bbb"
               },
               {
+                "type": "immediate",
                 "destination": "eee"
               }
             ]
@@ -328,12 +333,19 @@
       },
       "chat": {
         "api": {
-          "type": "chat",
-          "arguments": []
+          "inputs": [
+            {
+              "name": "chat",
+              "type": "mutation",
+              "args": "TSChatArgs"
+            }
+          ]
         },
         "start": {
           "transition": [
             {
+              "type": "suspend",
+              "input": "chat",
               "destination": "3pjuyB47X"
             }
           ]
@@ -352,12 +364,14 @@
             },
             "transition": [
               {
+                "type": "immediate",
                 "condition": "contains(currentStateOutput.content, 'ALL_DONE')",
-                "destination": "endAgentExecution"
+                "destination": "END"
               },
               {
+                "type": "suspend",
                 "destination": "3pjuyB47X",
-                "suspend": true
+                "input": "chat"
               }
             ]
           }
@@ -366,4 +380,4 @@
       }
     }
   }
-}
+}

package/examples/source/agent-schema.json

@@ -169,18 +169,19 @@
       "findDogColor": {
         "description": "AI Agent finds a dog's color based on its name",
         "api": {
-          "type": "generate",
-          "arguments": [
+          "inputs": [
             {
-              "argName": "input",
-              "argType": "string",
-              "required": true
+              "name": "findDogColor",
+              "type": "mutation",
+              "args": "TSGenerateArgs"
             }
           ]
         },
         "start": {
           "transition": [
             {
+              "type": "suspend",
+              "input": "findDogColor",
               "destination": "bbb"
             }
           ]
@@ -211,6 +212,7 @@
             },
             "transition": [
               {
+                "type": "immediate",
                 "destination": "ccc"
               }
             ]
@@ -247,14 +249,17 @@
             },
             "transition": [
               {
+                "type": "immediate",
                 "condition": "stateOutputs['ccc'].answered",
                 "destination": "ddd"
               },
               {
+                "type": "immediate",
                 "limit": 3,
                 "destination": "bbb"
               },
               {
+                "type": "immediate",
                 "destination": "eee"
               }
             ]
@@ -310,12 +315,19 @@
       },
       "chat": {
         "api": {
-          "type": "chat",
-          "arguments": []
+          "inputs": [
+            {
+              "name": "chat",
+              "type": "mutation",
+              "args": "TSChatArgs"
+            }
+          ]
         },
         "start": {
           "transition": [
             {
+              "type": "suspend",
+              "input": "chat",
               "destination": "3pjuyB47X"
             }
           ]
@@ -334,12 +346,14 @@
             },
             "transition": [
               {
+                "type": "immediate",
                 "condition": "contains(currentStateOutput.content, 'ALL_DONE')",
-                "destination": "endAgentExecution"
+                "destination": "END"
               },
               {
+                "type": "suspend",
                 "destination": "3pjuyB47X",
-                "suspend": true
+                "input": "chat"
               }
             ]
           }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@takeshape/schema",
-  "version": "11.98.5",
+  "version": "11.99.0",
   "description": "TakeShape Schema",
   "homepage": "https://www.takeshape.io",
   "repository": {
@@ -58,9 +58,9 @@
     "p-reduce": "^2.1.0",
     "semver": "^7.3.2",
     "tiny-invariant": "^1.2.0",
-    "@takeshape/errors": "11.98.5",
-    "@takeshape/util": "11.98.5",
-    "@takeshape/json-schema": "11.98.5"
+    "@takeshape/errors": "11.99.0",
+    "@takeshape/json-schema": "11.99.0",
+    "@takeshape/util": "11.99.0"
   },
   "devDependencies": {
     "@takeshape/json-schema-to-typescript": "^11.0.0",
@@ -76,7 +76,7 @@
     "glob": "^7.1.6",
     "json-schema-to-ts": "^3.1.1",
     "shortid": "^2.2.15",
-    "@takeshape/infra": "11.98.5"
+    "@takeshape/infra": "11.99.0"
   },
   "engines": {
     "node": ">=20"