@takeshape/schema 11.143.2 → 11.154.1

package/dist/util/is-asset-property.js

@@ -1,11 +0,0 @@
-import { getRef, parseRef } from "../refs.js";
-export function isAssetProperty(prop) {
-    const ref = getRef({}, prop.oneOf?.[0] ?? prop);
-    return Boolean(ref && isAssetRefItem(ref));
-}
-export function isAssetRef(str) {
-    return isAssetRefItem(parseRef({}, str));
-}
-function isAssetRefItem(ref) {
-    return ref.layerId === 'local' && ref.shapeName === 'Asset';
-}

package/dist/util/mcp.d.ts

@@ -1,8 +0,0 @@
-import type { ProjectSchemaJSON, ToolJSON, ToolMap } from '../project-schema/latest.ts';
-export declare const TOOL_SCHEMA_PATH: readonly ["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[];
-export declare function getMcpTool(projectSchema: ProjectSchemaJSON, toolName: string): ToolJSON | undefined;
-export declare function setMcpToolMap<S extends Partial<ProjectSchemaJSON>>(projectSchema: S, tools: ToolMap): S;
-export declare function setMcpTool<S extends Partial<ProjectSchemaJSON>>(projectSchema: S, tool: ToolJSON): S;

package/dist/util/mcp.js

@@ -1,21 +0,0 @@
-import set from 'lodash/fp/set.js';
-export const TOOL_SCHEMA_PATH = ['mcp', 'tools'];
-export function getMcpToolMap(projectSchema) {
-    return projectSchema.mcp?.tools;
-}
-export function getMcpTools(projectSchema) {
-    const toolMap = getMcpToolMap(projectSchema);
-    return toolMap && Object.values(toolMap);
-}
-export function getMcpToolNames(projectSchema) {
-    return Object.keys(getMcpToolMap(projectSchema) ?? {});
-}
-export function getMcpTool(projectSchema, toolName) {
-    return getMcpToolMap(projectSchema)?.[toolName];
-}
-export function setMcpToolMap(projectSchema, tools) {
-    return set(TOOL_SCHEMA_PATH, tools, projectSchema);
-}
-export function setMcpTool(projectSchema, tool) {
-    return set([...TOOL_SCHEMA_PATH, tool.name], tool, projectSchema);
-}

package/dist/util/merge.d.ts

@@ -1,15 +0,0 @@
-import type { FormConfig, ObjectSchema, ProjectSchemaJSON } from '../project-schema/index.ts';
-export declare function mergeObjectSchemas(...args: Array<ObjectSchema | undefined>): ObjectSchema;
-export declare function mergeDeepObjectSchemas(...args: Array<ObjectSchema | undefined>): ObjectSchema;
-export declare function mergeSchemaProperties(parent: ObjectSchema, overrides: ObjectSchema, deep?: boolean): ObjectSchema;
-export declare function rebaseSchemaProperties(base: ObjectSchema, parent: ObjectSchema, head: ObjectSchema): ObjectSchema;
-export declare function mergeFormProperties(parent: FormConfig, overrides: FormConfig): FormConfig;
-export declare function rebaseFormProperties(base: FormConfig, parent: FormConfig, head: FormConfig): FormConfig;
-export declare function mergeFormConfigs(...configs: FormConfig[]): FormConfig;
-export declare function mergeProjectSchemas(base: ProjectSchemaJSON, parent: ProjectSchemaJSON, head: ProjectSchemaJSON): {
-    error: string;
-    mergedSchema: undefined;
-} | {
-    error: undefined;
-    mergedSchema: ProjectSchemaJSON;
-};

package/dist/util/merge.js

@@ -1,254 +0,0 @@
-import { assert, deepClone, isDefined, rebaseArray, rebaseObject } from '@takeshape/util';
-import assignWith from 'lodash/assignWith.js';
-import difference from 'lodash/difference.js';
-import isEqual from 'lodash/isEqual.js';
-import last from 'lodash/last.js';
-import omit from 'lodash/omit.js';
-import pickBy from 'lodash/pickBy.js';
-import set from 'lodash/set.js';
-import union from 'lodash/union.js';
-import unset from 'lodash/unset.js';
-import { isExtendsSchema, isObjectSchema, isRefSchema } from "../types/index.js";
-export function mergeObjectSchemas(...args) {
-    return args.filter(isDefined).reduce((parent, schemas) => mergeSchemaProperties(parent, schemas), {
-        type: 'object',
-        properties: {}
-    });
-}
-export function mergeDeepObjectSchemas(...args) {
-    return args.filter(isDefined).reduce((parent, schemas) => mergeSchemaProperties(parent, schemas, true), {
-        type: 'object',
-        properties: {}
-    });
-}
-export function mergeSchemaProperties(parent, overrides, deep = false) {
-    const result = {
-        ...parent,
-        properties: deep
-            ? assignWith({}, parent.properties, overrides.properties, (objValue, srcValue) => {
-                // merge objects if possible
-                if (objValue !== undefined && srcValue !== undefined) {
-                    // skip merging if they are equal this avoids allOf with duplicate refs
-                    if (isEqual(objValue, srcValue)) {
-                        return objValue;
-                    }
-                    if (isObjectSchema(objValue) && isObjectSchema(srcValue)) {
-                        return mergeObjectSchemas(objValue, srcValue);
-                    }
-                    if ((isObjectSchema(objValue) || isRefSchema(objValue)) &&
-                        (isObjectSchema(srcValue) || isRefSchema(srcValue))) {
-                        return { allOf: [objValue, srcValue] };
-                    }
-                }
-            })
-            : { ...parent.properties, ...overrides.properties }
-    };
-    const required = union(parent.required, overrides.required);
-    if (required.length) {
-        result.required = required;
-    }
-    return result;
-}
-export function rebaseSchemaProperties(base, parent, head) {
-    const { properties: toProperties, required: toRequired, ...toOther } = base;
-    const { properties: baseProperties, required: baseRequired, ...baseOther } = parent;
-    const { properties: fromProperties, required: fromRequired, ...fromOther } = head;
-    const newSchema = {
-        ...rebaseObject(toOther, baseOther, fromOther),
-        type: 'object',
-        properties: rebaseObject(toProperties, baseProperties, fromProperties)
-    };
-    const required = rebaseArray(toRequired ?? [], baseRequired ?? [], fromRequired ?? []);
-    if (required.length) {
-        newSchema.required = required;
-    }
-    return newSchema;
-}
-export function mergeFormProperties(parent, overrides) {
-    const result = {
-        ...parent,
-        properties: {
-            ...parent.properties,
-            ...overrides.properties
-        }
-    };
-    const order = union(parent.order, overrides.order);
-    if (order.length) {
-        result.order = order;
-    }
-    return result;
-}
-export function rebaseFormProperties(base, parent, head) {
-    const { properties: toProperties, order: toOrder, ...toOther } = base;
-    const { properties: baseProperties, order: baseOrder, ...baseOther } = parent;
-    const { properties: fromProperties, order: fromOrder, ...fromOther } = head;
-    const newForm = {
-        ...rebaseObject(toOther, baseOther, fromOther),
-        properties: rebaseObject(toProperties, baseProperties, fromProperties)
-    };
-    const order = rebaseArray(toOrder ?? [], baseOrder ?? [], fromOrder ?? []);
-    if (order.length) {
-        newForm.order = order;
-    }
-    return newForm;
-}
-export function mergeFormConfigs(...configs) {
-    return configs.reduce(mergeFormProperties, { properties: {}, order: [] });
-}
-const mergeableSections = ['shapes', 'mutations', 'queries', 'forms', 'services'];
-const isMergeableSection = (str) => {
-    return mergeableSections.includes(str);
-};
-const pickUnmergeable = (projectSchema) => {
-    return pickBy(projectSchema, (_value, key) => !isMergeableSection(key));
-};
-function compareSection(section, original, updated) {
-    const changes = [];
-    const originalKeys = Object.keys(original);
-    const updatedKeys = Object.keys(updated);
-    for (const removedKey of difference(originalKeys, updatedKeys)) {
-        changes.push({ path: [section, removedKey], section, op: 'remove' });
-    }
-    for (const [key, value] of Object.entries(updated)) {
-        if (!original[key]) {
-            changes.push({ path: [section, key], section, op: 'add', value });
-        }
-        else if (!isEqual(original[key], updated[key])) {
-            changes.push({ path: [section, key], section, op: 'update', value });
-        }
-    }
-    return changes;
-}
-function compareSections(parent, branch) {
-    return mergeableSections.flatMap((section) => (parent[section] ?? branch[section]) ? compareSection(section, parent[section] ?? {}, branch[section] ?? {}) : []);
-}
-function findChangedShape(schema, change) {
-    return schema.shapes[change.path[1]];
-}
-function getChangedShape(schema, change) {
-    const shape = findChangedShape(schema, change);
-    assert(shape, 'Expected shape not found');
-    return shape;
-}
-function rebaseShapeProperties(toShape, fromShape, baseShape) {
-    return baseShape
-        ? rebaseObject(omit(toShape, 'schema'), omit(baseShape, 'schema'), omit(fromShape, 'schema'))
-        : { ...toShape, ...fromShape };
-}
-function attemptToMerge(base, parent, head, change) {
-    const toShape = getChangedShape(base, change);
-    const fromShape = getChangedShape(head, change);
-    const toSchema = toShape.schema;
-    const fromSchema = fromShape.schema;
-    if (isEqual(toSchema, fromSchema)) {
-        const baseShape = findChangedShape(parent, change);
-        return {
-            ...rebaseShapeProperties(toShape, fromShape, baseShape),
-            schema: toSchema
-        };
-    }
-    if (isObjectSchema(toSchema) && isObjectSchema(fromSchema)) {
-        const baseShape = findChangedShape(parent, change);
-        const baseSchema = baseShape?.schema;
-        return {
-            ...rebaseShapeProperties(toShape, fromShape, baseShape),
-            schema: change.op === 'update' && baseSchema && isObjectSchema(baseSchema)
-                ? rebaseSchemaProperties(toSchema, baseSchema, fromSchema)
-                : mergeSchemaProperties(toSchema, fromSchema)
-        };
-    }
-    if (isExtendsSchema(toSchema) &&
-        isExtendsSchema(fromSchema) &&
-        toSchema.extends.length === fromSchema.extends.length) {
-        const fromExtends = fromSchema.extends;
-        const toObj = last(toSchema.extends);
-        const fromObj = last(fromSchema.extends);
-        if (toObj &&
-            isObjectSchema(toObj) &&
-            fromObj &&
-            isObjectSchema(fromObj) &&
-            toSchema.extends.slice(0, toSchema.extends.length - 1).every((item, i) => isEqual(item, fromExtends[i]))) {
-            let mergedObjSchema;
-            const baseShape = findChangedShape(parent, change);
-            const baseSchema = baseShape?.schema;
-            if (change.op === 'update' && baseSchema && isExtendsSchema(baseSchema)) {
-                const baseObj = last(baseSchema.extends);
-                if (baseObj && isObjectSchema(baseObj)) {
-                    mergedObjSchema = rebaseSchemaProperties(toObj, baseObj, fromObj);
-                }
-            }
-            mergedObjSchema ||= mergeSchemaProperties(toObj, fromObj);
-            return {
-                ...rebaseShapeProperties(toShape, fromShape, baseShape),
-                schema: {
-                    extends: [...toSchema.extends.slice(0, toSchema.extends.length - 1), mergedObjSchema]
-                }
-            };
-        }
-    }
-}
-function applyChange(base, parent, head, change) {
-    if (change.op === 'remove') {
-        unset(base, change.path);
-    }
-    else if (change.op === 'add') {
-        set(base, change.path, change.value);
-    }
-    else if (change.op === 'update') {
-        if (change.section === 'shapes') {
-            const mergedShape = attemptToMerge(base, parent, head, change);
-            if (mergedShape) {
-                set(base, change.path, mergedShape);
-                return;
-            }
-        }
-        else if (change.section === 'forms') {
-            const shapeName = change.path[1];
-            const toForm = base.forms?.[shapeName]?.default;
-            const fromForm = head.forms?.[shapeName]?.default;
-            if (toForm && fromForm) {
-                const baseForm = parent.forms?.[shapeName]?.default;
-                set(base, change.path, {
-                    default: baseForm ? rebaseFormProperties(toForm, baseForm, fromForm) : mergeFormConfigs(toForm, fromForm)
-                });
-                return;
-            }
-        }
-        set(base, change.path, change.value);
-    }
-}
-export function mergeProjectSchemas(base, parent, head) {
-    const changesTo = compareSections(parent, base);
-    const changesFrom = compareSections(parent, head);
-    const mergedSchema = deepClone(base);
-    for (let change of changesFrom) {
-        const potentialConflict = changesTo.find((changeTo) => isEqual(changeTo.path, change.path));
-        if (potentialConflict) {
-            if (potentialConflict.op === 'remove' && change.op !== 'remove') {
-                return {
-                    error: `Attempting to ${change.op} ${change.path.join('.')} which has already been removed`,
-                    mergedSchema: undefined
-                };
-            }
-            if ((potentialConflict.op === 'add' && change.op === 'add') ||
-                (potentialConflict.op === 'update' && change.op === 'update')) {
-                if (change.section === 'shapes') {
-                    const mergedValue = attemptToMerge(base, parent, head, change);
-                    if (!mergedValue) {
-                        return {
-                            error: `Unable to merge ${change.path.join('.')} schemas conflict`,
-                            mergedSchema: undefined
-                        };
-                    }
-                    change = { ...change, op: 'add', value: mergedValue };
-                }
-                else if (change.section === 'forms') {
-                    change = { ...change, op: 'update' };
-                }
-            }
-        }
-        applyChange(mergedSchema, parent, head, change);
-    }
-    Object.assign(mergedSchema, rebaseObject(pickUnmergeable(base), pickUnmergeable(parent), pickUnmergeable(head)));
-    return { error: undefined, mergedSchema };
-}

package/dist/util/patch-schema.d.ts

@@ -1,8 +0,0 @@
-import { type ProjectSchemaUpdate } from '../migration/types.ts';
-import type { ProjectSchemaJSON } from '../project-schema/index.ts';
-/**
- * Apply a schema update to a schema. This can operate on a schema with frozen properties,
- * such as one produced by immer. Resulting schema is not assumed to be valid and should
- * be validated if appropriate.
- */
-export declare function patchSchema<T extends ProjectSchemaJSON>(projectSchema: T, schemaUpdate: ProjectSchemaUpdate): T;

package/dist/util/patch-schema.js

@@ -1,51 +0,0 @@
-import set from 'lodash/fp/set.js';
-import get from 'lodash/get.js';
-import omit from 'lodash/omit.js';
-import unset from 'lodash/unset.js';
-import { AGENTS_UPDATE_KEY, GUARDS_UPDATE_KEY, MCP_TOOLS_UPDATE_KEY } from "../migration/types.js";
-/**
- * Array of lodash.get paths to keys that are merged when applying a schema update.
- */
-const schemaUpdateMergedKeys = [
-    'queries',
-    'mutations',
-    'shapes',
-    'workflows',
-    'forms',
-    'services',
-    AGENTS_UPDATE_KEY,
-    GUARDS_UPDATE_KEY,
-    MCP_TOOLS_UPDATE_KEY
-];
-function shallowMerge(original, update) {
-    const result = { ...original };
-    for (const [key, obj] of Object.entries(update)) {
-        // Null is a sentinel value to indicate delete
-        if (obj === null) {
-            unset(result, key);
-        }
-        else {
-            result[key] = obj;
-        }
-    }
-    return result;
-}
-/**
- * Apply a schema update to a schema. This can operate on a schema with frozen properties,
- * such as one produced by immer. Resulting schema is not assumed to be valid and should
- * be validated if appropriate.
- */
-export function patchSchema(projectSchema, schemaUpdate) {
-    // Patch old schema with update
-    let updatedSchema = {
-        ...projectSchema,
-        ...omit(schemaUpdate, schemaUpdateMergedKeys)
-    };
-    for (const key of schemaUpdateMergedKeys) {
-        const update = get(schemaUpdate, key);
-        if (update) {
-            updatedSchema = set(key, shallowMerge(get(projectSchema, key) ?? {}, update), updatedSchema);
-        }
-    }
-    return updatedSchema;
-}

package/dist/util/query-field-path.d.ts

@@ -1,9 +0,0 @@
-import type { ProjectSchemaJSON } from '../project-schema/index.ts';
-export declare function getQueryFieldPath(operation: 'query' | 'mutation', fieldName: string): ['queries' | 'mutations', ...string[]];
-/**
- * Get a query or property schema
- * @param schema
- * @param queryFieldPath
- * @returns
- */
-export declare function findSchemaAtQueryFieldPath(schema: Pick<ProjectSchemaJSON, 'queries' | 'mutations' | 'services' | 'shapes'>, queryFieldPath: ReturnType<typeof getQueryFieldPath>): import("../project-schema/latest.ts").PropertySchema | undefined;

package/dist/util/query-field-path.js

@@ -1,23 +0,0 @@
-import { findSchemaAtPath } from "./find-shape-at-path.js";
-import { getReturnShape } from "./get-return-shape.js";
-function parseFieldName(fieldName) {
-    return fieldName.split('.');
-}
-export function getQueryFieldPath(operation, fieldName) {
-    return [operation === 'query' ? 'queries' : 'mutations', ...parseFieldName(fieldName)];
-}
-/**
- * Get a query or property schema
- * @param schema
- * @param queryFieldPath
- * @returns
- */
-export function findSchemaAtQueryFieldPath(schema, queryFieldPath) {
-    const [operationName, queryName, ...fieldPath] = queryFieldPath;
-    const queryOrMutation = schema[operationName]?.[queryName];
-    if (!queryOrMutation) {
-        return undefined;
-    }
-    const shape = getReturnShape(schema, queryOrMutation);
-    return shape ? findSchemaAtPath(schema, shape.schema, fieldPath) : undefined;
-}

package/dist/util/shapes.d.ts

@@ -1,5 +0,0 @@
-import type { ProjectSchemaJSON, ShapeJSON } from '../project-schema/index.ts';
-export declare function getShapeById(projectSchema: Pick<ProjectSchemaJSON, 'shapes'>, shapeId: string): ShapeJSON | undefined;
-export declare function getShape(context: Pick<ProjectSchemaJSON, 'shapes'>, name: string): ShapeJSON | undefined;
-export declare function ensureShape(projectSchema: Pick<ProjectSchemaJSON, 'shapes'>, name: string): ShapeJSON;
-export declare function ensureShapeById(projectSchema: Pick<ProjectSchemaJSON, 'shapes'>, shapeId: string): ShapeJSON;

package/dist/util/shapes.js

@@ -1,22 +0,0 @@
-import { NotFoundError } from '@takeshape/errors';
-import find from 'lodash/find.js';
-export function getShapeById(projectSchema, shapeId) {
-    return find(projectSchema.shapes, (shape) => shape.id === shapeId);
-}
-export function getShape(context, name) {
-    return context.shapes[name];
-}
-export function ensureShape(projectSchema, name) {
-    const shape = getShape(projectSchema, name);
-    if (!shape) {
-        throw new NotFoundError(`Shape "${name}" Not found`);
-    }
-    return shape;
-}
-export function ensureShapeById(projectSchema, shapeId) {
-    const shape = getShapeById(projectSchema, shapeId);
-    if (!shape) {
-        throw new NotFoundError(`Shape with id "${shapeId}" Not found`);
-    }
-    return shape;
-}

package/dist/validate/ai.d.ts

@@ -1,6 +0,0 @@
-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

@@ -1,183 +0,0 @@
-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', 'transitions'], inputNames, agent.start.transitions));
-        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.transitions) {
-                errors.push(...validateAgentTransitions([...statePath, 'transitions'], inputNames, state.transitions));
-            }
-            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/errors.d.ts

@@ -1,3 +0,0 @@
-import type { SchemaValidationErrorItem } from '@takeshape/errors';
-import type { ErrorObject } from 'ajv';
-export declare function formatError(error: ErrorObject): SchemaValidationErrorItem;

package/dist/validate/errors.js

@@ -1,20 +0,0 @@
-export function formatError(error) {
-    let pathStr = error.instancePath;
-    let message = error.message ?? '';
-    if ('missingProperty' in error.params) {
-        pathStr = `${pathStr}.${error.params.missingProperty}`;
-    }
-    if ('additionalProperty' in error.params) {
-        pathStr = `${pathStr}.${error.params.additionalProperty}`;
-        message = `${message} "${error.params.additionalProperty}"`;
-    }
-    if ('allowedValues' in error.params) {
-        message = `${message} "${error.params.allowedValues.join('", "')}"`;
-    }
-    const path = pathStr === '' ? [] : pathStr.substr(1).split(/\.|\/|\['|']\./);
-    return {
-        type: 'json',
-        message,
-        path
-    };
-}

package/dist/validate/types.d.ts

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

package/dist/validate/types.js

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

package/dist/validate/util.d.ts

@@ -1,3 +0,0 @@
-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;