@takeshape/schema 11.98.6 → 11.99.0

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

@@ -193,58 +193,16 @@
     },
     "agentApi": {
       "title": "Agent API",
-      "discriminator": {
-        "propertyName": "type"
-      },
-      "oneOf": [
-        {
-          "$ref": "#/definitions/agentApiChat"
-        },
-        {
-          "$ref": "#/definitions/agentApiGenerate"
-        }
-      ]
-    },
-    "agentApiChat": {
-      "title": "Agent API Chat",
       "type": "object",
       "properties": {
-        "type": {
-          "enum": ["chat"]
-        },
-        "interactionTimeout": {
-          "title": "Interaction Timeout (milliseconds)",
-          "type": "integer"
-        },
-        "arguments": {
+        "inputs": {
           "type": "array",
           "items": {
-            "$ref": "#/definitions/agentApiArgument"
+            "$ref": "#/definitions/agentApiInput"
           }
         }
       },
-      "required": ["type"],
-      "additionalProperties": false
-    },
-    "agentApiGenerate": {
-      "title": "Agent API Generate",
-      "type": "object",
-      "properties": {
-        "type": {
-          "enum": ["generate"]
-        },
-        "interactionTimeout": {
-          "title": "Interaction Timeout (milliseconds)",
-          "type": "integer"
-        },
-        "arguments": {
-          "type": "array",
-          "items": {
-            "$ref": "#/definitions/agentApiArgument"
-          }
-        }
-      },
-      "required": ["type"],
+      "required": ["inputs"],
       "additionalProperties": false
     },
     "agentMemory": {
@@ -309,7 +267,7 @@
         "transition": {
           "type": "array",
           "items": {
-            "$ref": "#/definitions/agentTransitionStep"
+            "$ref": "#/definitions/agentTransitionSuspend"
           }
         }
       },
@@ -346,22 +304,10 @@
         "execution": {
           "$ref": "#/definitions/agentExecution"
         },
-        "sessionMemory": {
-          "title": "Agent State Session Memory",
-          "type": "array",
-          "items": {
-            "default": {
-              "condition": {
-                "type": "none"
-              }
-            },
-            "$ref": "#/definitions/agentStateSessionMemoryLocation"
-          }
-        },
         "transition": {
           "type": "array",
           "items": {
-            "$ref": "#/definitions/agentTransitionStep"
+            "$ref": "#/definitions/agentTransition"
           }
         }
       },
@@ -385,110 +331,68 @@
         }
       ]
     },
-    "agentApiArgument": {
-      "title": "Agent API Argument",
-      "type": "object",
-      "properties": {
-        "argName": {
-          "type": "string",
-          "pattern": "^[0-9A-Za-z_]+$"
-        },
-        "argDescription": {
-          "type": "string"
-        },
-        "argType": {
-          "enum": ["boolean", "integer", "number", "string", "sessionId"]
-        },
-        "required": {
-          "type": "boolean"
-        }
-      },
-      "required": ["argName", "argType"],
-      "additionalProperties": false
-    },
-    "agentExecutionGraphql": {
-      "title": "Agent Execution GraphQL",
-      "type": "object",
-      "properties": {
-        "type": {
-          "enum": ["graphql"]
-        },
-        "query": {
-          "type": "string"
-        },
-        "path": {
-          "type": "string"
-        }
-      },
-      "required": ["type", "query"],
-      "additionalProperties": false
-    },
-    "agentStateSessionMemoryLocation": {
-      "title": "Agent State Session Memory Location",
+    "agentApiInput": {
+      "title": "Agent API Input",
       "discriminator": {
         "propertyName": "type"
       },
       "oneOf": [
         {
-          "$ref": "#/definitions/agentStateSessionMemoryLocationContent"
-        },
-        {
-          "$ref": "#/definitions/agentStateSessionMemoryLocationArtifact"
-        },
-        {
-          "$ref": "#/definitions/agentStateSessionMemoryLocationStaticValue"
+          "$ref": "#/definitions/agentApiMutationInput"
         }
       ]
     },
-    "agentStateSessionMemoryLocationStaticValue": {
-      "title": "Agent State Session Memory Location Static Value",
+    "agentApiMutationInput": {
+      "title": "Agent API Mutation Input",
       "type": "object",
       "properties": {
         "type": {
-          "enum": ["staticValue"]
+          "enum": ["mutation"]
         },
-        "memoryPath": {
-          "type": "string"
+        "name": {
+          "type": "string",
+          "pattern": "^[0-9A-Za-z_]+$"
         },
-        "value": {
+        "args": {
           "type": "string"
+        },
+        "interactionTimeout": {
+          "title": "Interaction Timeout (milliseconds)",
+          "type": "integer"
         }
       },
-      "required": ["type"],
+      "required": ["type", "name", "args"],
       "additionalProperties": false
     },
-    "agentStateSessionMemoryLocationArtifact": {
-      "title": "Agent State Session Memory Location Artifact",
+    "agentExecutionGraphql": {
+      "title": "Agent Execution GraphQL",
       "type": "object",
       "properties": {
         "type": {
-          "enum": ["artifactValue"]
+          "enum": ["graphql"]
         },
-        "memoryPath": {
+        "query": {
           "type": "string"
         },
-        "artifactPath": {
+        "path": {
           "type": "string"
         }
       },
-      "required": ["type"],
+      "required": ["type", "query"],
       "additionalProperties": false
     },
-    "agentStateSessionMemoryLocationContent": {
-      "title": "Agent State Session Memory Location Content",
+    "agentStateSessionMemoryAssignment": {
+      "title": "Agent State Session Memory Assignment",
       "type": "object",
       "properties": {
-        "type": {
-          "enum": ["content"]
-        },
         "memoryPath": {
           "type": "string"
         },
-        "path": {
+        "expression": {
           "type": "string"
         }
       },
-      "required": ["type"],
+      "required": ["expression"],
       "additionalProperties": false
     },
     "agentAiStateInputArg": {
@@ -792,17 +696,35 @@
       "required": ["type", "service", "model", "input"],
       "additionalProperties": false
     },
-    "agentTransitionStep": {
-      "title": "Agent Transition Step",
+
+    "agentTransition": {
+      "title": "Agent Transition",
       "description": "These steps are evaluated in order until a destination is found.",
+      "discriminator": {
+        "propertyName": "type"
+      },
+      "oneOf": [
+        {
+          "$ref": "#/definitions/agentTransitionImmediate"
+        },
+        {
+          "$ref": "#/definitions/agentTransitionSuspend"
+        }
+      ]
+    },
+    "agentTransitionSuspend": {
+      "title": "Agent Transition Suspend",
       "type": "object",
       "properties": {
+        "type": {
+          "enum": ["suspend"]
+        },
         "destination": {
           "type": "string",
           "pattern": "^[0-9A-Za-z_]+$"
         },
-        "suspend": {
-          "type": "boolean"
+        "input": {
+          "type": "string"
         },
         "condition": {
           "type": "string"
@@ -810,12 +732,60 @@
         "limit": {
           "type": "integer"
         },
+        "sessionMemory": {
+          "title": "Agent State Session Memory",
+          "type": "array",
+          "items": {
+            "default": {
+              "condition": {
+                "type": "none"
+              }
+            },
+            "$ref": "#/definitions/agentStateSessionMemoryAssignment"
+          }
+        },
+        "historyStrategy": {
+          "type": "string"
+        }
+      },
+      "additionalProperties": false,
+      "required": ["type", "destination", "input"]
+    },
+    "agentTransitionImmediate": {
+      "title": "Agent Transition Immediate",
+      "type": "object",
+      "properties": {
+        "type": {
+          "enum": ["immediate"]
+        },
+        "destination": {
+          "type": "string",
+          "pattern": "^[0-9A-Za-z_]+$"
+        },
+        "condition": {
+          "type": "string"
+        },
+        "limit": {
+          "type": "integer"
+        },
+        "sessionMemory": {
+          "title": "Agent State Session Memory",
+          "type": "array",
+          "items": {
+            "default": {
+              "condition": {
+                "type": "none"
+              }
+            },
+            "$ref": "#/definitions/agentStateSessionMemoryAssignment"
+          }
+        },
         "historyStrategy": {
           "type": "string"
         }
       },
       "additionalProperties": false,
-      "required": ["destination"]
+      "required": ["type", "destination"]
     },
     "agentMap": {
       "title": "Agent Map",

package/dist/util/mcp.d.ts

@@ -1,4 +1,5 @@
 import type { ProjectSchemaJSON, ToolJSON, ToolMap } from '../project-schema/latest.ts';
+export declare const TOOL_SCHEMA_PATH: readonly ["ai-experimental", "mcp", "tools"];
 export declare function getMcpToolMap(projectSchema: ProjectSchemaJSON): ToolMap | undefined;
 export declare function getMcpTools(projectSchema: ProjectSchemaJSON): ToolJSON[] | undefined;
 export declare function getMcpToolNames(projectSchema: ProjectSchemaJSON): string[];

package/dist/util/mcp.js

@@ -1,5 +1,5 @@
 import set from 'lodash/fp/set.js';
-const TOOL_SCHEMA_PATH = ['ai-experimental', 'mcp', 'tools'];
+export const TOOL_SCHEMA_PATH = ['ai-experimental', 'mcp', 'tools'];
 export function getMcpToolMap(projectSchema) {
     return projectSchema['ai-experimental']?.mcp?.tools;
 }

package/dist/validate/ai.d.ts

@@ -0,0 +1,6 @@
+import type { SchemaValidationErrorItem } from '@takeshape/errors';
+import type { AIToolConfig, ProjectSchemaJSON } from '../project-schema/latest.ts';
+import { type GetNamespace } from '../refs.ts';
+import type { Path } from './types.ts';
+export declare function validateAIToolConfig(projectSchema: ProjectSchemaJSON, getNamespace: GetNamespace, tool: AIToolConfig | string, basePath: Path): SchemaValidationErrorItem | undefined;
+export declare function validateAgents(projectSchema: ProjectSchemaJSON): SchemaValidationErrorItem[];

package/dist/validate/ai.js

@@ -0,0 +1,183 @@
+import get from 'lodash/get.js';
+import { AGENTS_SCHEMA_PATH, getAgentMap, getGuardConfig, isValidAgentMutation } from '../agents.js';
+import { createGetNamespace, getToolRef, parsePropertyRef, propertyRefItemToPath } from "../refs.js";
+import { isBuiltinMutation, isBuiltinQuery } from "../schema-util.js";
+import { validateExpression } from "../util/expressions.js";
+import { findDuplicateIndices, pushErrors } from "./util.js";
+export function 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 validateAgentTransitions(parentPath, inputNames, transitions) {
+    const errors = [];
+    transitions.forEach((transition, transitionIndex) => {
+        if (transition.type === 'suspend') {
+            if (!inputNames.has(transition.input)) {
+                errors.push({
+                    path: [...parentPath, transitionIndex, 'input'],
+                    type: 'notFound',
+                    message: `Invalid input "${transition.input}"`
+                });
+            }
+        }
+        if (transition.condition) {
+            const conditionValidation = validateExpression(transition.condition);
+            if (!conditionValidation.valid) {
+                const common = {
+                    path: [...parentPath, transitionIndex, 'expression'],
+                    type: 'conflict'
+                };
+                errors.push(...conditionValidation.errors.map((message) => ({ ...common, message })));
+            }
+        }
+    });
+    return errors;
+}
+export function validateAgents(projectSchema) {
+    const getNamespace = createGetNamespace(projectSchema);
+    const errors = [];
+    const agents = getAgentMap(projectSchema);
+    if (!agents) {
+        return errors;
+    }
+    for (const [agentName, agent] of Object.entries(agents)) {
+        const stateNames = new Set();
+        const agentPath = [...AGENTS_SCHEMA_PATH, agentName];
+        const inputNames = new Set(agent.api.inputs.map((input) => input.name));
+        for (const [name, indices] of findDuplicateIndices(agent.api.inputs, 'name')) {
+            for (const index of indices) {
+                errors.push({
+                    path: [...agentPath, 'api', 'inputs', index, 'name'],
+                    type: 'conflict',
+                    message: `Duplicate input name "${name}"`
+                });
+            }
+        }
+        pushErrors(errors, validateAgentTransitions([...agentPath, 'start', 'transition'], inputNames, agent.start.transition));
+        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) {
+                errors.push(...validateAgentTransitions([...statePath, 'transition'], inputNames, state.transition));
+            }
+            if (state.execution.type === 'generate' || state.execution.type === 'chat') {
+                if (!state.execution.tools) {
+                    continue;
+                }
+                for (const [name, indices] of findDuplicateIndices(state.execution.tools, 'name')) {
+                    for (const index of indices) {
+                        errors.push({
+                            path: [...statePath, 'execution', 'tools', index, 'name'],
+                            type: 'conflict',
+                            message: `Duplicate tool name "${name}"`
+                        });
+                    }
+                }
+                state.execution.tools.forEach((tool, toolIndex) => {
+                    pushErrors(errors, validateAIToolConfig(projectSchema, getNamespace, tool, [
+                        ...statePath,
+                        'execution',
+                        'tools',
+                        toolIndex,
+                        'ref'
+                    ]));
+                });
+            }
+        }
+        if (agent.guards) {
+            agent.guards.forEach(({ guardId }, index) => {
+                if (!getGuardConfig(projectSchema, guardId)) {
+                    errors.push({
+                        path: [...agentPath, 'guards', 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;
+}

package/dist/validate/types.d.ts

@@ -0,0 +1 @@
+export type Path = Array<string | number>;

package/dist/validate/types.js

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

package/dist/validate/util.d.ts

@@ -0,0 +1,3 @@
+import type { SchemaValidationErrorItem } from '@takeshape/errors';
+export declare function findDuplicateIndices<Obj extends object, Key extends keyof Obj>(array: Obj[], key: Key): [Obj[Key], number[]][];
+export declare function pushErrors(errors: SchemaValidationErrorItem[], error: SchemaValidationErrorItem | SchemaValidationErrorItem[] | undefined): void;

package/dist/validate/util.js

@@ -0,0 +1,28 @@
+export function findDuplicateIndices(array, key) {
+    const indicesByValue = new Map();
+    for (let i = 0; i < array.length; i++) {
+        const value = array[i][key];
+        const indices = indicesByValue.get(value) ?? [];
+        indices.push(i);
+        indicesByValue.set(value, indices);
+    }
+    const result = [];
+    for (const [value, indices] of indicesByValue) {
+        if (indices.length > 1) {
+            result.push([value, indices]);
+        }
+    }
+    return result;
+}
+export function pushErrors(errors, error) {
+    if (error) {
+        if (Array.isArray(error)) {
+            if (error.length) {
+                errors.push(...error);
+            }
+        }
+        else {
+            errors.push(error);
+        }
+    }
+}

package/dist/validate/validate.d.ts

@@ -34,6 +34,7 @@ export type EntitlementsOptions = {
 };
 export type ValidateContext = {
     allowDisconnectedLayers?: boolean;
+    generatedApi?: Pick<ProjectSchemaJSON, 'queries' | 'mutations'>;
 } & EntitlementsOptions & ValidateSyntaxOptions;
 export type ValidateReferencesContext = SetRequired<ValidateContext, 'resolveLayer'>;
 export declare function validateSchemaSyntax(obj: unknown, options?: ValidateSyntaxOptions): SchemaValidationResult;