@takeshape/schema 12.1.1 → 12.1.5

package/dist/migration/to/v3.22.0.js

@@ -0,0 +1,25 @@
+import mapValues from 'lodash/mapValues.js';
+import omit from 'lodash/omit.js';
+const migrate = async (_, projectSchema) => {
+    const { indexedShapes, ...rest } = projectSchema;
+    const migrated = {
+        ...rest,
+        schemaVersion: '3.22.0'
+    };
+    if (indexedShapes) {
+        migrated.indexedShapes = mapValues(indexedShapes, (indexedShape) => {
+            // objectDepthLimit SHOULD be the same, so prefer list query which is more likely to be used
+            const { ignoreFields, objectDepthLimit } = indexedShape.queries.list ?? indexedShape.queries.get ?? {};
+            return {
+                ...indexedShape,
+                query: {
+                    ignoreFields,
+                    maxDepth: objectDepthLimit
+                },
+                queries: mapValues(indexedShape.queries, (config) => config && omit(config, ['ignoreFields', 'objectDepthLimit']))
+            };
+        });
+    }
+    return migrated;
+};
+export default migrate;

package/dist/migration/to/v3.24.0.d.ts

@@ -0,0 +1,4 @@
+import type { ProjectSchemaJSONV3_23_0, ProjectSchemaJSONV3_24_0 } from '../../project-schema/index.ts';
+import type { MigrateFunction } from '../types.ts';
+declare const migrate: MigrateFunction<ProjectSchemaJSONV3_23_0, ProjectSchemaJSONV3_24_0>;
+export default migrate;

package/dist/migration/to/v3.24.0.js

@@ -0,0 +1,11 @@
+const migrate = async (_, projectSchema) => {
+    /**
+     * This version removes some envelope properties.
+     */
+    const { updated, created, version, ...migrated } = projectSchema;
+    return {
+        ...migrated,
+        schemaVersion: '3.24.0'
+    };
+};
+export default migrate;

package/dist/migration/to/v3.25.0.d.ts

@@ -0,0 +1,4 @@
+import type { ProjectSchemaJSONV3_24_0, ProjectSchemaJSONV3_25_0 } from '../../project-schema/index.ts';
+import type { MigrateFunction } from '../types.ts';
+declare const migrate: MigrateFunction<ProjectSchemaJSONV3_24_0, ProjectSchemaJSONV3_25_0>;
+export default migrate;

package/dist/migration/to/v3.25.0.js

@@ -0,0 +1,11 @@
+const migrate = async (_, projectSchema) => {
+    /**
+     * This version relocates the dataKey in the project table.
+     */
+    const { dataKey, ...migrated } = projectSchema;
+    return {
+        ...migrated,
+        schemaVersion: '3.25.0'
+    };
+};
+export default migrate;

package/dist/migration/to/v3.3.0.d.ts

@@ -0,0 +1,4 @@
+import type { ProjectSchemaJSONV3_2_0, ProjectSchemaJSONV3_3_0 } from '../../project-schema/index.ts';
+import type { MigrateFunction } from '../types.ts';
+declare const migrate: MigrateFunction<ProjectSchemaJSONV3_2_0, ProjectSchemaJSONV3_3_0>;
+export default migrate;

package/dist/migration/to/v3.3.0.js

@@ -0,0 +1,13 @@
+const migrate = async (context, projectSchema) => {
+    const { generateDataKeyFn } = context;
+    const dataKey = projectSchema.dataKey ? projectSchema.dataKey : await generateDataKeyFn();
+    /**
+     * Generate a dataKey if none is present.
+     */
+    return {
+        ...projectSchema,
+        schemaVersion: '3.3.0',
+        dataKey
+    };
+};
+export default migrate;

package/dist/migration/to/v3.31.0.d.ts

@@ -0,0 +1,4 @@
+import type { ProjectSchemaJSONV3_30_0, ProjectSchemaJSONV3_31_0 } from '../../project-schema/index.ts';
+import type { MigrateFunction } from '../types.ts';
+declare const migrate: MigrateFunction<ProjectSchemaJSONV3_30_0, ProjectSchemaJSONV3_31_0>;
+export default migrate;

package/dist/migration/to/v3.31.0.js

@@ -0,0 +1,38 @@
+import { visit } from '@takeshape/util';
+import isString from 'lodash/isString.js';
+import last from 'lodash/last.js';
+import set from 'lodash/set.js';
+import unset from 'lodash/unset.js';
+const TAKESHAPE_RESOLVERS = ['takeshape:getUser', 'takeshape:search', 'takeshape:queryApiIndex', 'util:wrap'];
+function getServicePath(path) {
+    const servicePath = [...path];
+    servicePath.splice(-1, 1, 'service');
+    return servicePath;
+}
+const migrate = async (_, projectSchema) => {
+    visit(projectSchema, ['@ref', '@mapping', 'name'], (value, path) => {
+        if (isString(value)) {
+            const name = last(path);
+            if (name === 'name' && value === 'debug:noop') {
+                set(projectSchema, path, 'util:noop');
+                unset(projectSchema, getServicePath(path));
+            }
+            else if (name === 'name' && value === 'util:wrap') {
+                unset(projectSchema, getServicePath(path));
+            }
+            else if (name === 'name' && value.startsWith('takeshape:')) {
+                const serviceName = TAKESHAPE_RESOLVERS.includes(value) ? 'takeshape' : 'shapedb';
+                set(projectSchema, getServicePath(path), serviceName);
+                set(projectSchema, path, value.replace('takeshape:', `${serviceName}:`));
+            }
+            else {
+                set(projectSchema, path, value.replace('takeshape:local', 'shapedb'));
+            }
+        }
+    });
+    return {
+        ...projectSchema,
+        schemaVersion: '3.31.0'
+    };
+};
+export default migrate;

package/dist/migration/to/v3.32.0.d.ts

@@ -0,0 +1,4 @@
+import type { ProjectSchemaJSONV3_31_0, ProjectSchemaJSONV3_32_0 } from '../../project-schema/index.ts';
+import type { MigrateFunction } from '../types.ts';
+declare const migrate: MigrateFunction<ProjectSchemaJSONV3_31_0, ProjectSchemaJSONV3_32_0>;
+export default migrate;

package/dist/migration/to/v3.32.0.js

@@ -0,0 +1,59 @@
+import { normalizeRefExpression } from "../../refs.js";
+function migrateListQuery(listConfig) {
+    const { pagination, name, ...restConfig } = listConfig;
+    const result = { ...restConfig, query: name };
+    if (pagination) {
+        const { itemsToIndexPath, ...restPagination } = pagination;
+        result.pagination = { ...restPagination, itemsPath: itemsToIndexPath };
+    }
+    return result;
+}
+function queriesToLoaders(queries) {
+    if (queries.list) {
+        const loaders = {
+            list: Array.isArray(queries.list) ? queries.list.map(migrateListQuery) : migrateListQuery(queries.list)
+        };
+        if (queries.get) {
+            const { name, ...restGet } = queries.get;
+            loaders.get = { ...restGet, query: name };
+        }
+        return loaders;
+    }
+}
+function migrateTrigger(trigger) {
+    const { query, ...rest } = trigger;
+    return { ...rest, loader: query };
+}
+const migrate = async (_, projectSchema) => {
+    const updatedShapes = { ...projectSchema.shapes };
+    const { indexedShapes, ...rest } = projectSchema;
+    if (indexedShapes) {
+        for (const [name, config] of Object.entries(indexedShapes)) {
+            let shape = updatedShapes[name];
+            shape ||= {
+                name,
+                id: name,
+                title: name,
+                schema: {
+                    extends: [{ '@ref': normalizeRefExpression(projectSchema, name) }]
+                }
+            };
+            const loaders = queriesToLoaders(config.queries);
+            if (loaders) {
+                shape.loaders = loaders;
+            }
+            shape.cache = {
+                enabled: true,
+                fragment: config.query,
+                triggers: config.triggers.map(migrateTrigger)
+            };
+            updatedShapes[name] = shape;
+        }
+    }
+    return {
+        ...rest,
+        shapes: updatedShapes,
+        schemaVersion: '3.32.0'
+    };
+};
+export default migrate;

package/dist/migration/to/v3.34.0.d.ts

@@ -0,0 +1,6 @@
+import type { FormMapV3_33_0, ProjectSchemaJSONV3_33_0, ProjectSchemaJSONV3_34_0 } from '../../project-schema/index.ts';
+import type { MigrateFunction } from '../types.ts';
+export declare function normalizeForms(projectSchema: ProjectSchemaJSONV3_33_0): FormMapV3_33_0;
+export declare function migrateInterfaceShapes(projectSchema: ProjectSchemaJSONV3_33_0): ProjectSchemaJSONV3_33_0;
+declare const migrate: MigrateFunction<ProjectSchemaJSONV3_33_0, ProjectSchemaJSONV3_34_0>;
+export default migrate;

package/dist/migration/to/v3.34.0.js

@@ -0,0 +1,111 @@
+import { deepClone } from '@takeshape/util';
+import set from 'lodash/fp/set.js';
+import unset from 'lodash/fp/unset.js';
+import upperFirst from 'lodash/upperFirst.js';
+import { SERVICE_OBJECT_PATTERN_NAME } from "../../constants.js";
+import { getRefOrItemsRef, refItemToNamespacedShapeName } from "../../refs.js";
+import { createSchemaPropertyAccessor } from "../../schema-util.js";
+import { CURRENT_SCHEMA_VERSION } from "../../schemas/index.js";
+import { getServiceObjectFields } from "../../services/services.js";
+// Map of form studio widgets and their replacements in the shape editor
+const widgetMigrations = {
+    object: 'shapeObject',
+    repeater: 'shapeArray'
+};
+export function normalizeForms(projectSchema) {
+    const normalizedForms = {};
+    const { forms = {} } = projectSchema;
+    const storeSourceForm = (shapeName, formConfig, propName) => {
+        normalizedForms[shapeName] ||= { default: deepClone(formConfig) };
+        const propConfig = normalizedForms[shapeName].default.properties[propName];
+        propConfig.properties = undefined;
+        propConfig.order = undefined;
+        propConfig.widget = widgetMigrations[propConfig.widget] ?? propConfig.widget;
+    };
+    const normalizeNested = (shapeName, formConfig) => {
+        const shape = projectSchema.shapes[shapeName];
+        if (!shape || !formConfig.properties) {
+            return;
+        }
+        const propertyAccessor = createSchemaPropertyAccessor(projectSchema, shape);
+        for (const propName of Object.keys(formConfig.properties)) {
+            const propConfig = formConfig.properties[propName];
+            const propSchema = propertyAccessor.getValue(propName);
+            if (propSchema) {
+                const ref = getRefOrItemsRef(projectSchema, propSchema);
+                if (ref && propConfig.properties && propConfig.widget !== 'shopify') {
+                    const nestedShapeName = refItemToNamespacedShapeName(projectSchema, ref);
+                    normalizedForms[nestedShapeName] = { default: deepClone(propConfig) };
+                    storeSourceForm(shapeName, formConfig, propName);
+                    normalizeNested(nestedShapeName, propConfig);
+                }
+            }
+        }
+    };
+    if (forms) {
+        for (const shapeName of Object.keys(forms)) {
+            normalizeNested(shapeName, forms[shapeName].default);
+            // copy forms with no changes
+            normalizedForms[shapeName] ||= forms[shapeName];
+        }
+    }
+    return normalizedForms;
+}
+export function migrateInterfaceShapes(projectSchema) {
+    let updatedProjectSchema = projectSchema;
+    for (const shape of Object.values(projectSchema.shapes)) {
+        if (!shape.model) {
+            continue;
+        }
+        // Set the schema version to the current to appease type check this line will eventually break as the schema diverges
+        const serviceObjectFields = getServiceObjectFields({ ...projectSchema, schemaVersion: CURRENT_SCHEMA_VERSION }, shape, 'shopify');
+        for (const field of serviceObjectFields) {
+            const { fieldName, service } = field;
+            const { serviceObjectType } = field.generators[SERVICE_OBJECT_PATTERN_NAME];
+            const serviceShapeName = upperFirst(serviceObjectType);
+            const interfaceShapeName = `${serviceShapeName}Interface`;
+            updatedProjectSchema = unset(['shapes', interfaceShapeName], updatedProjectSchema);
+            if ('type' in shape.schema && shape.schema.type === 'object') {
+                const prop = shape.schema.properties[fieldName];
+                if (prop) {
+                    updatedProjectSchema = set(['shapes', shape.name, 'schema', 'properties', fieldName, '@input'], { '@ref': `${service}:${serviceShapeName}Input` }, updatedProjectSchema);
+                }
+            }
+            for (const [mutationName, mutation] of Object.entries(projectSchema.mutations)) {
+                if (!mutation || typeof mutation.args !== 'string') {
+                    continue;
+                }
+                for (const template of ['CreateArgs', 'UpdateArgs']) {
+                    if (mutation.args === `${template}<${interfaceShapeName}>`) {
+                        updatedProjectSchema = set(['mutations', mutationName], { ...mutation, args: `${template}<${serviceShapeName}>` }, updatedProjectSchema);
+                    }
+                }
+            }
+        }
+    }
+    return updatedProjectSchema;
+}
+const migrate = async (_, projectSchema) => {
+    let normalized = projectSchema;
+    try {
+        normalized = {
+            ...projectSchema,
+            forms: normalizeForms(projectSchema)
+        };
+    }
+    catch (e) {
+        // TODO remove console.log when a formal warning mechanism is added https://app.shortcut.com/takeshape/story/11533/return-warnings-from-schema-migration
+        console.info('v3.34.0 migration warning: Failed to normalize forms', e.message);
+    }
+    try {
+        normalized = migrateInterfaceShapes(normalized);
+    }
+    catch (e) {
+        console.info('v3.34.0 migration warning: Failed to migrate interface shapes', e.message);
+    }
+    return {
+        ...normalized,
+        schemaVersion: '3.34.0'
+    };
+};
+export default migrate;

package/dist/migration/to/v3.36.0.d.ts

@@ -0,0 +1,4 @@
+import type { ProjectSchemaJSONV3_35_0, ProjectSchemaJSONV3_36_0 } from '../../project-schema/index.ts';
+import type { MigrateFunction } from '../types.ts';
+declare const migrate: MigrateFunction<ProjectSchemaJSONV3_35_0, ProjectSchemaJSONV3_36_0>;
+export default migrate;

package/dist/migration/to/v3.36.0.js

@@ -0,0 +1,22 @@
+import mapValues from 'lodash/mapValues.js';
+const migrate = async (_, projectSchema) => {
+    const result = {
+        ...projectSchema,
+        schemaVersion: '3.36.0'
+    };
+    result.services &&= mapValues(result.services, (config) => {
+        // Add transformVersion to OpenAPI services so we can preserve the legacy behavior
+        if (config.serviceType === 'openapi') {
+            return {
+                ...config,
+                options: {
+                    ...config.options,
+                    transformVersion: '1.0.0'
+                }
+            };
+        }
+        return config;
+    });
+    return result;
+};
+export default migrate;

package/dist/migration/to/v3.39.0.d.ts

@@ -0,0 +1,4 @@
+import type { ProjectSchemaJSONV3_38_0, ProjectSchemaJSONV3_39_0 } from '../../project-schema/index.ts';
+import type { MigrateFunction } from '../types.ts';
+declare const migrate: MigrateFunction<ProjectSchemaJSONV3_38_0, ProjectSchemaJSONV3_39_0>;
+export default migrate;

package/dist/migration/to/v3.39.0.js

@@ -0,0 +1,45 @@
+import { isSearchParamsAuthentication, isServiceAuthentication } from "../../types/index.js";
+const migrate = async ({ decryptFn, encryptFn }, projectSchema) => {
+    /**
+     * Move unencrypted searchParams out of the authentication object.
+     */
+    for (const serviceConfig of Object.values(projectSchema.services ?? {})) {
+        if (serviceConfig.authentication) {
+            const authentication = decryptFn(serviceConfig.authentication);
+            if (isServiceAuthentication(authentication) && isSearchParamsAuthentication(authentication)) {
+                if (serviceConfig.provider === 'judgeMe') {
+                    const shopDomain = authentication.params.find((param) => param.name === 'shop_domain');
+                    if (shopDomain) {
+                        serviceConfig.options = {
+                            ...serviceConfig.options,
+                            searchParams: {
+                                shop_domain: shopDomain.value
+                            }
+                        };
+                        serviceConfig.options.shopDomain = undefined;
+                    }
+                    authentication.params = authentication.params.filter((param) => param.name !== 'shop_domain');
+                }
+                if (serviceConfig.provider === 'reviewsIo') {
+                    const storeId = authentication.params.find((param) => param.name === 'store');
+                    if (storeId) {
+                        serviceConfig.options = {
+                            ...serviceConfig.options,
+                            searchParams: {
+                                store: storeId.value
+                            }
+                        };
+                        serviceConfig.options.storeId = undefined;
+                    }
+                    authentication.params = authentication.params.filter((param) => param.name !== 'store');
+                }
+                serviceConfig.authentication = encryptFn(authentication);
+            }
+        }
+    }
+    return {
+        ...projectSchema,
+        schemaVersion: '3.39.0'
+    };
+};
+export default migrate;

package/dist/migration/to/v3.40.0.d.ts

@@ -0,0 +1,4 @@
+import type { ProjectSchemaJSONV3_39_0, ProjectSchemaJSONV3_40_0 } from '../../project-schema/index.ts';
+import type { MigrateFunction } from '../types.ts';
+declare const migrate: MigrateFunction<ProjectSchemaJSONV3_39_0, ProjectSchemaJSONV3_40_0>;
+export default migrate;

package/dist/migration/to/v3.40.0.js

@@ -0,0 +1,26 @@
+import mapValues from 'lodash/mapValues.js';
+const migrate = async (_, projectSchema) => {
+    const newShapes = mapValues(projectSchema.shapes, (shape) => {
+        // Set includeDeprecated to true for shapes to preserve behavior when indexing shapes by maxDepth
+        if (shape.cache?.fragment?.maxDepth !== undefined) {
+            const newShape = {
+                ...shape,
+                cache: {
+                    ...shape.cache,
+                    fragment: {
+                        ...shape.cache.fragment,
+                        includeDeprecated: true
+                    }
+                }
+            };
+            return newShape;
+        }
+        return shape;
+    });
+    return {
+        ...projectSchema,
+        shapes: newShapes,
+        schemaVersion: '3.40.0'
+    };
+};
+export default migrate;

package/dist/migration/to/v3.46.0.d.ts

@@ -0,0 +1,4 @@
+import type { ProjectSchemaJSONV3_45_0, ProjectSchemaJSONV3_46_0 } from '../../project-schema/index.ts';
+import type { MigrateFunction } from '../types.ts';
+declare const migrate: MigrateFunction<ProjectSchemaJSONV3_45_0, ProjectSchemaJSONV3_46_0>;
+export default migrate;

package/dist/migration/to/v3.46.0.js

@@ -0,0 +1,35 @@
+import { isRecord, visit } from '@takeshape/util';
+// copied in case we update these in the latest version
+function isBasicResolver(resolver) {
+    return isRecord(resolver) && typeof resolver.name === 'string';
+}
+function isComposeResolver(resolver) {
+    return Boolean(isRecord(resolver) &&
+        Array.isArray(resolver.compose) &&
+        resolver.compose.length &&
+        resolver.compose.every(isBasicResolver));
+}
+function renameResolver(resolver) {
+    // Replace ai:generateText with ai:chat unless history was disabled
+    if (resolver.name === 'ai:generateText' && (resolver.options?.history ?? true)) {
+        resolver.name = 'ai:chat';
+    }
+}
+const migrate = async (_, projectSchema) => {
+    /**
+     * Function will visit each resolver in the schema and mutate them.
+     */
+    visit(projectSchema, ['resolver', '@resolver'], (maybeResolver) => {
+        if (isComposeResolver(maybeResolver)) {
+            maybeResolver.compose.forEach(renameResolver);
+        }
+        else if (isBasicResolver(maybeResolver)) {
+            renameResolver(maybeResolver);
+        }
+    });
+    return {
+        ...projectSchema,
+        schemaVersion: '3.46.0'
+    };
+};
+export default migrate;

package/dist/migration/to/v3.57.0.d.ts

@@ -0,0 +1,4 @@
+import type { ProjectSchemaJSONV3_56_0, ProjectSchemaJSONV3_57_0 } from '../../project-schema/index.ts';
+import type { MigrateFunction } from '../types.ts';
+declare const migrate: MigrateFunction<ProjectSchemaJSONV3_56_0, ProjectSchemaJSONV3_57_0>;
+export default migrate;

package/dist/migration/to/v3.57.0.js

@@ -0,0 +1,18 @@
+import { validateSchema } from '../../validate/validate.js';
+const migrate = async (context, projectSchema) => {
+    const { ['ai-experimental']: ai, ...rest } = projectSchema;
+    const migrated = {
+        ...rest,
+        schemaVersion: '3.57.0'
+    };
+    if (ai) {
+        const migratedWithAi = Object.assign({ ...migrated }, ai);
+        const { valid } = await validateSchema({ ignoreEntitlements: true, structureOnly: true }, migratedWithAi);
+        if (valid) {
+            return migratedWithAi;
+        }
+        context.logger.warn(`Dropping "ai-experimental" properties schema for project "${projectSchema.projectId}".`);
+    }
+    return migrated;
+};
+export default migrate;

package/dist/migration/to/v3.60.0.d.ts

@@ -0,0 +1,4 @@
+import type { ProjectSchemaJSONV3_59_0, ProjectSchemaJSONV3_60_0 } from '../../project-schema/index.ts';
+import type { MigrateFunction } from '../types.ts';
+declare const migrate: MigrateFunction<ProjectSchemaJSONV3_59_0, ProjectSchemaJSONV3_60_0>;
+export default migrate;

package/dist/migration/to/v3.60.0.js

@@ -0,0 +1,129 @@
+import { deepCloneWith, isIterableObject } from '@takeshape/util';
+import isEmpty from 'lodash/isEmpty.js';
+import mapValues from 'lodash/mapValues.js';
+import { parsePropertyRef } from "../../refs.js";
+function migrateTool(tool, makePublic = false) {
+    if (typeof tool === 'string') {
+        return {
+            name: parsePropertyRef(tool)?.propertyName ?? tool,
+            execution: {
+                type: 'graphql',
+                query: {
+                    ref: tool
+                }
+            }
+        };
+    }
+    const name = 'name' in tool ? tool.name : (parsePropertyRef(tool.ref)?.propertyName ?? tool.ref);
+    const description = 'description' in tool ? tool.description : undefined;
+    const { ref, selectionSet } = tool;
+    let args;
+    if ('args' in tool) {
+        args = tool.args?.map((arg) => arg.argName);
+    }
+    const toolJson = {
+        name,
+        description,
+        execution: {
+            type: 'graphql',
+            query: {
+                ref,
+                selectionSet,
+                args
+            }
+        }
+    };
+    if (makePublic) {
+        toolJson.visibility = 'public';
+    }
+    return toolJson;
+}
+function migrateArgBindings(tool) {
+    if (typeof tool === 'object' && 'args' in tool) {
+        return tool.args?.filter((arg) => arg.type === 'variable');
+    }
+}
+function makePublic(tool) {
+    return { ...tool, visibility: 'public' };
+}
+function migrateAgent(migrateToolConfig, agent) {
+    return {
+        ...agent,
+        historyStrategies: mapValues(agent.historyStrategies, (strat) => {
+            if (strat.transform.type !== 'generate' || !strat.transform.tools?.length) {
+                return strat;
+            }
+            return {
+                ...strat,
+                transform: {
+                    ...strat.transform,
+                    tools: strat.transform.tools.map((tool) => migrateToolConfig(tool))
+                }
+            };
+        }),
+        states: mapValues(agent.states, (state) => {
+            if (state.execution.type === 'graphql' || !state.execution.tools?.length) {
+                return state;
+            }
+            return {
+                ...state,
+                execution: {
+                    ...state.execution,
+                    tools: state.execution.tools.map((tool) => migrateToolConfig(tool))
+                }
+            };
+        })
+    };
+}
+const migrate = async (context, projectSchema) => {
+    const { mcp, agents, shapes, queries, mutations, ...rest } = projectSchema;
+    const migratedTools = {};
+    const duplicateTools = new Set();
+    const migrateToolConfig = (legacyTool) => {
+        const { name, ...tool } = migrateTool(legacyTool);
+        if (migratedTools[name]) {
+            duplicateTools.add(name);
+        }
+        migratedTools[name] = tool;
+        return {
+            tool: `Tool.${name}`,
+            argBindings: migrateArgBindings(legacyTool)
+        };
+    };
+    const shapesQueriesMutations = deepCloneWith({ shapes, queries, mutations }, (value, key, parent) => {
+        // migrate ai resolver tools
+        if (key === 'tools' &&
+            Array.isArray(value) &&
+            isIterableObject(parent) &&
+            (parent.name === 'ai:generateText' || parent.name === 'ai:chat')) {
+            const tools = value;
+            return tools.map((tool) => migrateToolConfig(tool));
+        }
+    });
+    const migrated = {
+        ...rest,
+        ...shapesQueriesMutations,
+        schemaVersion: '3.60.0'
+    };
+    if (mcp?.tools) {
+        for (const tool of Object.values(mcp.tools)) {
+            migrateTool(tool, true);
+        }
+    }
+    if (agents) {
+        migrated.agents = mapValues(agents, (agent) => migrateAgent(migrateToolConfig, agent));
+    }
+    // Only re-order the schema if we migrated tools
+    if (!isEmpty(migratedTools)) {
+        if (duplicateTools.size > 0) {
+            context.logger.warn(`Duplicate tools ${[...duplicateTools].map((name) => `"${name}"`).join(', ')} found in project "${projectSchema.projectId}"`);
+        }
+        migrated.tools = migratedTools;
+        return migrated;
+    }
+    return {
+        ...projectSchema,
+        schemaVersion: '3.60.0'
+    };
+};
+export default migrate;

package/dist/migration/to/v3.9.0.d.ts

@@ -0,0 +1,4 @@
+import type { ProjectSchemaJSONV3_8_0, ProjectSchemaJSONV3_9_0 } from '../../project-schema/index.ts';
+import type { MigrateFunction } from '../types.ts';
+declare const migrate: MigrateFunction<ProjectSchemaJSONV3_8_0, ProjectSchemaJSONV3_9_0>;
+export default migrate;