@takeshape/cli 11.108.1 → 11.110.0

package/dist/index.js

@@ -206930,7 +206930,7 @@ var engines = {
 };
 var package_default = {
   name: "@takeshape/cli",
-  version: "11.108.1",
+  version: "11.110.0",
   description: "TakeShape CLI",
   homepage: "https://www.takeshape.io",
   repository: {
@@ -217545,7 +217545,7 @@ var schema6 = {
       required: ["name"]
     }
   },
-  required: ["messageId", "sessionId", "projectId", "runMode"],
+  required: ["messageId", "sessionId", "projectId", "runMode", "sentAt"],
   additionalProperties: false
 };
 var validate6 = createTypedValidator(schema6);
@@ -219695,10 +219695,10 @@ var import_isPlainObject2 = __toESM(require_isPlainObject(), 1);
 var import_isString3 = __toESM(require_isString(), 1);
 var import_isUndefined = __toESM(require_isUndefined(), 1);
 
-// ../schema/dist/schemas/project-schema/v3.57.0.json
-var v3_57_0_default = {
+// ../schema/dist/schemas/project-schema/v3.58.0.json
+var v3_58_0_default = {
   $schema: "http://json-schema.org/draft-07/schema#",
-  $id: "https://schema.takeshape.io/project-schema/v3.57.0#",
+  $id: "https://schema.takeshape.io/project-schema/v3.58.0#",
   title: "Project Schema JSON",
   definitions: {
     schemaArray: {
@@ -222274,6 +222274,11 @@ var v3_57_0_default = {
           description: "Number of seconds this Shape should be cached. Default 0.",
           type: "number",
           minimum: 0
+        },
+        staleWhileRevalidate: {
+          description: "Requests after maxAge will send a request to origin to revalidate while serving stale content for this duration in the meantime.",
+          type: "number",
+          minimum: 0
         }
       },
       additionalProperties: false,
@@ -224427,7 +224432,7 @@ var v3_57_0_default = {
     },
     schemaVersion: {
       type: "string",
-      enum: ["3.57.0"],
+      enum: ["3.58.0"],
       description: "The version of the schema format your project is using. We increase the version as we make breaking changes to the schema format."
     },
     projectId: {
@@ -385329,6 +385334,4823 @@ var v3_56_0_default = {
   ]
 };
 
+// ../schema/dist/schemas/project-schema/v3.57.0.json
+var v3_57_0_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "https://schema.takeshape.io/project-schema/v3.57.0#",
+  title: "Project Schema JSON",
+  definitions: {
+    schemaArray: {
+      title: "Schema Array",
+      type: "array",
+      minItems: 1,
+      items: {
+        $ref: "#/definitions/propertySchema"
+      }
+    },
+    nonNegativeInteger: {
+      title: "Non Negative Integer",
+      type: "integer",
+      minimum: 0
+    },
+    nonNegativeIntegerDefault0: {
+      title: "Non Negative Integer Default 0",
+      allOf: [
+        {
+          $ref: "#/definitions/nonNegativeInteger"
+        },
+        {
+          default: 0
+        }
+      ]
+    },
+    simpleTypes: {
+      title: "Simple Types",
+      enum: ["array", "boolean", "integer", "null", "number", "object", "string"]
+    },
+    stringArray: {
+      title: "String Array",
+      type: "array",
+      items: {
+        type: "string"
+      },
+      uniqueItems: true,
+      default: []
+    },
+    backreference: {
+      title: "Back Reference",
+      description: "A configuration object for a reverse reference in a relationship.",
+      type: "object",
+      properties: {
+        enabled: {
+          type: "boolean"
+        },
+        name: {
+          type: "string",
+          pattern: "^[_a-zA-Z][_a-zA-Z0-9]*$"
+        }
+      },
+      additionalProperties: false,
+      required: ["enabled"]
+    },
+    mappingString: {
+      title: "Mapping String",
+      type: "string",
+      pattern: "^[\\w-]+(?::[\\w-]+)+(?:\\.[\\w%-]+)+$"
+    },
+    fieldMapping: {
+      title: "Field Mapping",
+      oneOf: [
+        {
+          $ref: "#/definitions/mappingString"
+        },
+        {
+          type: "array",
+          items: {
+            $ref: "#/definitions/mappingString"
+          }
+        }
+      ]
+    },
+    refSchema: {
+      title: "Ref Schema",
+      type: "object",
+      properties: {
+        "@ref": {
+          $ref: "#/definitions/ref"
+        }
+      },
+      required: ["@ref"]
+    },
+    refSchemaLegacy: {
+      title: "Ref Schema Legacy",
+      type: "object",
+      properties: {
+        $ref: {
+          $ref: "#/definitions/ref"
+        }
+      },
+      required: ["$ref"]
+    },
+    shapeSchemaEnum: {
+      title: "Shape Schema Enum",
+      type: "object",
+      properties: {
+        enum: {
+          type: "array",
+          minItems: 1,
+          uniqueItems: true
+        }
+      },
+      additionalProperties: false,
+      required: ["enum"]
+    },
+    objectSchema: {
+      title: "Object Schema",
+      type: "object",
+      allOf: [
+        {
+          $ref: "#/definitions/propertySchema"
+        },
+        {
+          properties: {
+            type: {
+              type: "string",
+              const: "object"
+            },
+            properties: {
+              type: "object",
+              additionalProperties: {
+                $ref: "#/definitions/propertySchema"
+              }
+            }
+          },
+          required: ["type", "properties"]
+        }
+      ]
+    },
+    returnShapeArraySchema: {
+      title: "Return Shape Array Schema",
+      type: "object",
+      allOf: [
+        {
+          $ref: "#/definitions/propertySchema"
+        },
+        {
+          properties: {
+            type: {
+              type: "string",
+              const: "array"
+            },
+            items: {
+              oneOf: [
+                {
+                  $ref: "#/definitions/refSchema"
+                },
+                {
+                  type: "object",
+                  properties: {
+                    type: {
+                      enum: ["boolean", "integer", "number", "string", "object"]
+                    }
+                  },
+                  required: ["type"]
+                }
+              ]
+            }
+          },
+          required: ["type", "items"]
+        }
+      ]
+    },
+    objectOrRefArray: {
+      title: "ObjectOrRefArray",
+      type: "array",
+      items: {
+        oneOf: [
+          {
+            $ref: "#/definitions/refSchema"
+          },
+          {
+            $ref: "#/definitions/refSchemaLegacy"
+          },
+          {
+            $ref: "#/definitions/objectSchema"
+          }
+        ],
+        unevaluatedProperties: true
+      }
+    },
+    shapeSchemaAllOf: {
+      title: "Shape Schema All Of",
+      type: "object",
+      properties: {
+        allOf: {
+          $ref: "#/definitions/objectOrRefArray"
+        }
+      },
+      required: ["allOf"],
+      additionalProperties: false
+    },
+    allOfSchema: {
+      title: "AllOfSchema",
+      allOf: [
+        {
+          $ref: "#/definitions/propertySchema"
+        },
+        {
+          type: "object",
+          properties: {
+            allOf: {
+              $ref: "#/definitions/objectOrRefArray"
+            }
+          },
+          required: ["allOf"]
+        }
+      ]
+    },
+    shapeSchemaExtends: {
+      title: "ShapeSchemaExtends",
+      type: "object",
+      properties: {
+        extends: {
+          $ref: "#/definitions/objectOrRefArray"
+        }
+      },
+      required: ["extends"],
+      additionalProperties: false
+    },
+    extendsSchema: {
+      title: "ExtendsSchema",
+      allOf: [
+        {
+          $ref: "#/definitions/propertySchema"
+        },
+        {
+          type: "object",
+          properties: {
+            extends: {
+              $ref: "#/definitions/objectOrRefArray"
+            }
+          },
+          required: ["extends"]
+        }
+      ]
+    },
+    shapeSchemaOneOf: {
+      title: "Shape Schema One Of",
+      type: "object",
+      properties: {
+        oneOf: {
+          $ref: "#/definitions/objectOrRefArray"
+        }
+      },
+      required: ["oneOf"],
+      additionalProperties: false
+    },
+    oneOfSchema: {
+      title: "OneOfSchema",
+      allOf: [
+        {
+          $ref: "#/definitions/propertySchema"
+        },
+        {
+          type: "object",
+          properties: {
+            oneOf: {
+              $ref: "#/definitions/objectOrRefArray"
+            }
+          },
+          required: ["oneOf"],
+          additionalProperties: false
+        }
+      ]
+    },
+    shapeSchemaAny: {
+      type: "object",
+      title: "ShapeSchemaAny",
+      additionalProperties: false
+    },
+    shapeSchema: {
+      title: "Shape Schema",
+      type: "object",
+      oneOf: [
+        {
+          $ref: "#/definitions/shapeSchemaAllOf"
+        },
+        {
+          $ref: "#/definitions/shapeSchemaExtends"
+        },
+        {
+          $ref: "#/definitions/shapeSchemaOneOf"
+        },
+        {
+          $ref: "#/definitions/shapeSchemaEnum"
+        },
+        {
+          $ref: "#/definitions/objectSchema"
+        },
+        {
+          $ref: "#/definitions/shapeSchemaAny"
+        }
+      ]
+    },
+    queryMap: {
+      title: "Query Map",
+      type: "object",
+      patternProperties: {
+        "^[0-9A-Za-z_]+$": {
+          $ref: "#/definitions/query"
+        }
+      },
+      additionalProperties: false
+    },
+    args: {
+      title: "Args",
+      oneOf: [
+        {
+          type: "string"
+        },
+        {
+          $ref: "#/definitions/objectSchema"
+        },
+        {
+          $ref: "#/definitions/extendsSchema"
+        }
+      ]
+    },
+    returnShape: {
+      title: "Return Shape",
+      oneOf: [
+        {
+          type: "string"
+        },
+        {
+          $ref: "#/definitions/returnShapeArraySchema"
+        }
+      ]
+    },
+    directiveConfigItem: {
+      title: "Directive Config Item",
+      description: "A tuple with a string directive name, and options to pass to the directive",
+      type: "array",
+      items: [
+        {
+          title: "Directive Name",
+          type: "string"
+        },
+        {
+          title: "Directive Options",
+          type: "object",
+          propertyNames: {
+            pattern: "[0-9A-Za-z_-]+"
+          }
+        }
+      ]
+    },
+    parameterSerializeStyleOptions: {
+      title: "Parameter Serialize Style Options",
+      description: "All possible options for the more specific ParameterSerializeStyleOptions types.",
+      type: "object",
+      properties: {
+        style: {
+          type: "string",
+          enum: ["simple", "label", "matrix", "form", "spaceDelimited", "pipeDelimited", "deepObject", "none"]
+        },
+        explode: {
+          type: "boolean"
+        },
+        allowEmptyValue: {
+          type: "boolean"
+        },
+        allowReserved: {
+          description: "The allowReserved keyword specifies whether the reserved characters :/?#[]@!$&'()*+,;= in parameter values are allowed to be sent as they are.",
+          type: "boolean"
+        },
+        skipEncoding: {
+          type: "boolean"
+        }
+      },
+      required: ["style"],
+      additionalProperties: false
+    },
+    parameterSerializeStyleOptionsForPathParams: {
+      title: "Parameter Serialize Style Options For Path Params",
+      description: "Options to be passed to the serialization routine.",
+      type: "object",
+      properties: {
+        style: {
+          type: "string",
+          enum: ["simple", "label", "matrix", "none"]
+        },
+        explode: {
+          type: "boolean"
+        },
+        allowEmptyValue: {
+          type: "boolean"
+        },
+        allowReserved: {
+          description: "The allowReserved keyword specifies whether the reserved characters :/?#[]@!$&'()*+,;= in parameter values are allowed to be sent as they are.",
+          type: "boolean"
+        },
+        skipEncoding: {
+          type: "boolean"
+        }
+      },
+      required: ["style"],
+      additionalProperties: false
+    },
+    parameterSerializeStyleOptionsForSearchParams: {
+      title: "Parameter Serialize Style Options For Search Params",
+      description: "Options to be passed to the serialization routine.",
+      type: "object",
+      properties: {
+        style: {
+          type: "string",
+          enum: ["form", "spaceDelimited", "pipeDelimited", "deepObject", "none"]
+        },
+        explode: {
+          type: "boolean"
+        },
+        allowEmptyValue: {
+          type: "boolean"
+        },
+        allowReserved: {
+          description: "The allowReserved keyword specifies whether the reserved characters :/?#[]@!$&'()*+,;= in parameter values are allowed to be sent as they are.",
+          type: "boolean"
+        },
+        skipEncoding: {
+          type: "boolean"
+        }
+      },
+      required: ["style"],
+      additionalProperties: false
+    },
+    parameterSerializeStyleOptionsForHeaders: {
+      title: "Parameter Serialize Style Options For Headers",
+      description: "Options to be passed to the serialization routine.",
+      type: "object",
+      properties: {
+        style: {
+          type: "string",
+          enum: ["simple", "none"]
+        },
+        explode: {
+          type: "boolean"
+        }
+      },
+      required: ["style"],
+      additionalProperties: false
+    },
+    parameterSerializeContentOptions: {
+      title: "Parameter Serialize Content Options",
+      description: "Options to be passed to the serialization routine.",
+      type: "object",
+      properties: {
+        contentType: {
+          type: "string"
+        },
+        allowReserved: {
+          description: "The allowReserved keyword specifies whether the reserved characters :/?#[]@!$&'()*+,;= in parameter values are allowed to be sent as they are.",
+          type: "boolean"
+        },
+        skipEncoding: {
+          type: "boolean"
+        },
+        options: {
+          description: "Options to be passed directly to the content serializer library. Valid options depend upon your contentType.",
+          type: "object"
+        }
+      },
+      required: ["contentType"],
+      additionalProperties: false
+    },
+    parameterSerializeOptions: {
+      title: "Parameter Serialize Options",
+      description: "Options to be passed to the serialization routine.",
+      type: "object",
+      oneOf: [
+        {
+          $ref: "#/definitions/parameterSerializeStyleOptions"
+        },
+        {
+          $ref: "#/definitions/parameterSerializeContentOptions"
+        }
+      ]
+    },
+    parameterSerializeConfig: {
+      title: "Parameter Serialize Config",
+      description: "All possible options for the more specific ParameterSerializeConfig types.",
+      type: "object",
+      properties: {
+        content: {
+          $ref: "#/definitions/parameterSerializeContentOptions"
+        },
+        defaults: {
+          $ref: "#/definitions/parameterSerializeOptions"
+        },
+        paths: {
+          type: "object",
+          patternProperties: {
+            "^[^\\n\\r]*$": {
+              $ref: "#/definitions/parameterSerializeOptions"
+            }
+          }
+        }
+      },
+      additionalProperties: false
+    },
+    parameterSerializeConfigForBody: {
+      title: "Parameter Serialize Config For Body",
+      description: "Top-level paths to use serialization options for.",
+      type: "object",
+      properties: {
+        content: {
+          $ref: "#/definitions/parameterSerializeContentOptions"
+        }
+      },
+      additionalProperties: false
+    },
+    parameterSerializeConfigForPathParams: {
+      title: "Parameter Serialize Config For Path Params",
+      description: "Top-level paths to use path params serialization options for.",
+      type: "object",
+      properties: {
+        template: {
+          description: "For generating the path using tokens frpm the ParameterOps, e.g., '/products/{productId}'",
+          type: "string"
+        },
+        defaults: {
+          oneOf: [
+            {
+              $ref: "#/definitions/parameterSerializeStyleOptionsForPathParams"
+            },
+            {
+              $ref: "#/definitions/parameterSerializeContentOptions"
+            }
+          ]
+        },
+        paths: {
+          type: "object",
+          patternProperties: {
+            "^[^\\n\\r]*$": {
+              oneOf: [
+                {
+                  $ref: "#/definitions/parameterSerializeStyleOptionsForPathParams"
+                },
+                {
+                  $ref: "#/definitions/parameterSerializeContentOptions"
+                }
+              ]
+            }
+          }
+        }
+      },
+      required: ["template"],
+      additionalProperties: false
+    },
+    parameterSerializeConfigForSearchParams: {
+      title: "Parameter Serialize Config For Search Params",
+      description: "Top-level paths to use search params serialization options for.",
+      type: "object",
+      properties: {
+        defaults: {
+          oneOf: [
+            {
+              $ref: "#/definitions/parameterSerializeStyleOptionsForSearchParams"
+            },
+            {
+              $ref: "#/definitions/parameterSerializeContentOptions"
+            }
+          ]
+        },
+        paths: {
+          type: "object",
+          patternProperties: {
+            "^[^\\n\\r]*$": {
+              oneOf: [
+                {
+                  $ref: "#/definitions/parameterSerializeStyleOptionsForSearchParams"
+                },
+                {
+                  $ref: "#/definitions/parameterSerializeContentOptions"
+                }
+              ]
+            }
+          }
+        }
+      },
+      additionalProperties: false
+    },
+    parameterSerializeConfigForHeaders: {
+      title: "Parameter Serialize Config For Headers",
+      description: "Top-level paths to use headers serialization options for.",
+      type: "object",
+      properties: {
+        defaults: {
+          oneOf: [
+            {
+              $ref: "#/definitions/parameterSerializeStyleOptionsForHeaders"
+            },
+            {
+              $ref: "#/definitions/parameterSerializeContentOptions"
+            }
+          ]
+        },
+        paths: {
+          type: "object",
+          patternProperties: {
+            "^[^\\n\\r]*$": {
+              oneOf: [
+                {
+                  $ref: "#/definitions/parameterSerializeStyleOptionsForHeaders"
+                },
+                {
+                  $ref: "#/definitions/parameterSerializeContentOptions"
+                }
+              ]
+            }
+          }
+        }
+      },
+      additionalProperties: false
+    },
+    parameterOpNested: {
+      title: "Parameter Op Nested",
+      description: "An object describing an operation to generate a parameter, using a nested OpList.",
+      type: "object",
+      properties: {
+        path: {
+          description: "A path to the parameter for this operation.",
+          type: "string",
+          minLength: 1,
+          pattern: "^[^\\n\\r]*$"
+        },
+        op: {
+          description: "A mode for this parameter's operation.",
+          type: "string",
+          enum: ["set", "concat", "extend", "remove"]
+        },
+        ops: {
+          description: "A nested op list.",
+          $ref: "#/definitions/parameterOpList"
+        }
+      },
+      required: ["path", "ops"],
+      additionalProperties: false
+    },
+    parameterOpValue: {
+      title: "Parameter Op Value",
+      description: "An object describing an operation to generate a parameter using a value.",
+      type: "object",
+      properties: {
+        path: {
+          description: "A path to the parameter for this operation.",
+          type: "string",
+          minLength: 1,
+          pattern: "^[^\\n\\r]*$"
+        },
+        op: {
+          description: "A mode for this parameter's operation.",
+          type: "string",
+          enum: ["set", "concat", "extend", "remove"]
+        },
+        value: {
+          description: "A value to set directly at this path.",
+          type: ["number", "string", "boolean", "object", "array", "null"]
+        }
+      },
+      required: ["path", "value"],
+      additionalProperties: false
+    },
+    parameterOpMapping: {
+      title: "Parameter Op Mapping",
+      description: "An object describing an operation to generate a parameter using a mapping.",
+      type: "object",
+      properties: {
+        path: {
+          description: "A path to the parameter for this operation.",
+          type: "string",
+          minLength: 1,
+          pattern: "^[^\\n\\r]*$"
+        },
+        op: {
+          description: "A mode for this parameter's operation.",
+          type: "string",
+          enum: ["set", "concat", "extend", "remove"]
+        },
+        mapping: {
+          description: "Either a valid JSONPath or a directive pipeline to evaluate against the query context.",
+          oneOf: [
+            {
+              type: "string",
+              minLength: 1
+            },
+            {
+              $ref: "#/definitions/directiveConfig"
+            }
+          ]
+        }
+      },
+      required: ["path", "mapping"],
+      additionalProperties: false
+    },
+    parameterOpOp: {
+      title: "Parameter Op Op",
+      description: "An object describing an operation to generate a parameter using a mapping.",
+      type: "object",
+      properties: {
+        path: {
+          description: "A path to the parameter for this operation.",
+          type: "string",
+          minLength: 1,
+          pattern: "^[^\\n\\r]*$"
+        },
+        op: {
+          description: "A mode for this parameter's operation.",
+          type: "string",
+          enum: ["set", "concat", "extend", "remove"]
+        }
+      },
+      required: ["path", "op"],
+      additionalProperties: false
+    },
+    parameterOp: {
+      title: "Parameter Op",
+      description: "An object describing an operation to generate a parameter.",
+      oneOf: [
+        {
+          $ref: "#/definitions/parameterOpNested"
+        },
+        {
+          $ref: "#/definitions/parameterOpValue"
+        },
+        {
+          $ref: "#/definitions/parameterOpMapping"
+        },
+        {
+          $ref: "#/definitions/parameterOpOp"
+        }
+      ]
+    },
+    parameterOpList: {
+      title: "Parameter Op List",
+      type: "array",
+      items: {
+        $ref: "#/definitions/parameterOp"
+      },
+      minItems: 1
+    },
+    parameterConfig: {
+      title: "Parameter Config",
+      description: "All possible options for the more specific ParameterConfig types.",
+      type: "object",
+      properties: {
+        ops: {
+          $ref: "#/definitions/parameterOpList"
+        },
+        serialize: {
+          $ref: "#/definitions/parameterSerializeConfig"
+        }
+      },
+      required: ["ops"],
+      additionalProperties: false
+    },
+    parameterConfigForBody: {
+      title: "Parameter Config For Body",
+      type: "object",
+      properties: {
+        ops: {
+          $ref: "#/definitions/parameterOpList"
+        },
+        serialize: {
+          $ref: "#/definitions/parameterSerializeConfigForBody"
+        }
+      },
+      required: ["ops"],
+      additionalProperties: false
+    },
+    parameterConfigForPathParams: {
+      title: "Parameter Config For Path Params",
+      type: "object",
+      properties: {
+        ops: {
+          $ref: "#/definitions/parameterOpList"
+        },
+        serialize: {
+          $ref: "#/definitions/parameterSerializeConfigForPathParams"
+        }
+      },
+      required: ["ops", "serialize"],
+      additionalProperties: false
+    },
+    parameterConfigForAwsLambda: {
+      title: "ParameterConfigForAwsLambda",
+      type: "object",
+      properties: {
+        ops: {
+          $ref: "#/definitions/parameterOpList"
+        },
+        serialize: {
+          $ref: "#/definitions/parameterSerializeConfigForPathParams"
+        }
+      },
+      required: ["ops", "serialize"],
+      additionalProperties: false
+    },
+    parameterConfigForSearchParams: {
+      title: "Parameter Config For Search Params",
+      type: "object",
+      properties: {
+        ops: {
+          $ref: "#/definitions/parameterOpList"
+        },
+        serialize: {
+          $ref: "#/definitions/parameterSerializeConfigForSearchParams"
+        }
+      },
+      required: ["ops"],
+      additionalProperties: false
+    },
+    parameterConfigForHeaders: {
+      title: "Parameter Config For Headers",
+      type: "object",
+      properties: {
+        ops: {
+          $ref: "#/definitions/parameterOpList"
+        },
+        serialize: {
+          $ref: "#/definitions/parameterSerializeConfigForHeaders"
+        }
+      },
+      required: ["ops"],
+      additionalProperties: false
+    },
+    parameterConfigForJson: {
+      title: "Parameter Config For Json",
+      type: "object",
+      properties: {
+        ops: {
+          $ref: "#/definitions/parameterOpList"
+        }
+      },
+      required: ["ops"],
+      additionalProperties: false
+    },
+    directiveConfig: {
+      title: "Directive Config",
+      description: "An array of individual directive config items to process in order",
+      type: "array",
+      items: {
+        $ref: "#/definitions/directiveConfigItem"
+      },
+      minItems: 1
+    },
+    directiveMappingMap: {
+      title: "Directive Mapping Map",
+      description: "An map of object keys / key paths to directive configs",
+      type: "object",
+      patternProperties: {
+        "[0-9A-Za-z_-]+": {
+          $ref: "#/definitions/directiveConfig"
+        }
+      }
+    },
+    directiveMappingArrayItem: {
+      title: "Directive Mapping Array Item",
+      description: "A tuple with a string key and a directive config to evaluate",
+      type: "array",
+      items: [
+        {
+          type: "string"
+        },
+        {
+          $ref: "#/definitions/directiveConfig"
+        }
+      ]
+    },
+    directiveMappingArray: {
+      title: "Directive Mapping Array",
+      description: "An array of key / value or directive config tuples",
+      type: "array",
+      items: {
+        $ref: "#/definitions/directiveMappingArrayItem"
+      }
+    },
+    basicResolver: {
+      title: "BasicResolver",
+      description: "A single resolver, can be composed with the ComposeResolver.",
+      discriminator: {
+        propertyName: "name"
+      },
+      oneOf: [
+        {
+          $ref: "#/definitions/utilResolver"
+        },
+        {
+          $ref: "#/definitions/delegateResolver"
+        },
+        {
+          $ref: "#/definitions/takeshapeResolver"
+        },
+        {
+          $ref: "#/definitions/shapedbResolver"
+        },
+        {
+          $ref: "#/definitions/shapedbResolverShapeNameNotRequired"
+        },
+        {
+          $ref: "#/definitions/graphqlResolver"
+        },
+        {
+          $ref: "#/definitions/restResolver"
+        },
+        {
+          $ref: "#/definitions/awsLambdaResolver"
+        },
+        {
+          $ref: "#/definitions/salsifyResolver"
+        },
+        {
+          $ref: "#/definitions/syndigoResolver"
+        },
+        {
+          $ref: "#/definitions/functionResolver"
+        },
+        {
+          $ref: "#/definitions/aiGenerateTextResolver"
+        },
+        {
+          $ref: "#/definitions/aiGeneratePropertyResolver"
+        },
+        {
+          $ref: "#/definitions/aiEmbeddingResolver"
+        },
+        {
+          $ref: "#/definitions/aiEmbeddingSearchResolver"
+        },
+        {
+          $ref: "#/definitions/aiParseFileResolver"
+        },
+        {
+          $ref: "#/definitions/utilChunkResolver"
+        },
+        {
+          $ref: "#/definitions/aiRunAgentResolver"
+        },
+        {
+          $ref: "#/definitions/aiInspectAgentResolver"
+        },
+        {
+          $ref: "#/definitions/aiCreateAgentSessionResolver"
+        },
+        {
+          $ref: "#/definitions/aiGetAgentMessageResolver"
+        },
+        {
+          $ref: "#/definitions/aiAbortAgentMessageResolver"
+        },
+        {
+          $ref: "#/definitions/aiSendAgentFeedbackResolver"
+        }
+      ]
+    },
+    serviceResolver: {
+      title: "ServiceResolver",
+      description: "A resolver which references a specific service",
+      discriminator: {
+        propertyName: "name"
+      },
+      oneOf: [
+        {
+          $ref: "#/definitions/takeshapeResolver"
+        },
+        {
+          $ref: "#/definitions/shapedbResolverShapeNameNotRequired"
+        },
+        {
+          $ref: "#/definitions/shapedbResolver"
+        },
+        {
+          $ref: "#/definitions/graphqlResolver"
+        },
+        {
+          $ref: "#/definitions/restResolver"
+        },
+        {
+          $ref: "#/definitions/awsLambdaResolver"
+        }
+      ]
+    },
+    argsMapping: {
+      title: "ArgsMapping",
+      description: "Maps a query's input args to the input expected by the service's endpoint.",
+      oneOf: [
+        {
+          $ref: "#/definitions/directiveMappingMap"
+        },
+        {
+          $ref: "#/definitions/directiveConfig"
+        }
+      ]
+    },
+    searchParamsMapping: {
+      title: "SearchParamsMapping",
+      description: "Set or evaluate directives to generate searchParams for the service endpoint.",
+      $ref: "#/definitions/directiveMappingArray"
+    },
+    resultsMapping: {
+      title: "ResultsMapping",
+      description: "Maps a service endpoint's response results to the expected shape of the query's response.",
+      oneOf: [
+        {
+          $ref: "#/definitions/directiveMappingMap"
+        },
+        {
+          $ref: "#/definitions/directiveConfig"
+        }
+      ]
+    },
+    utilResolver: {
+      title: "UtilResolver",
+      type: "object",
+      properties: {
+        if: {
+          type: "string"
+        },
+        id: {
+          type: "string",
+          pattern: "^(?=[a-zA-Z])[-_a-zA-Z0-9]+$"
+        },
+        name: {
+          title: "UtilResolverName",
+          type: "string",
+          description: "Name of the resolver function.",
+          enum: ["util:noop", "util:wrap"]
+        },
+        options: {
+          title: "UtilResolverOptions",
+          type: "object",
+          additionalProperties: true
+        },
+        value: {
+          description: "Optional value to return from the noop resolver.",
+          type: ["number", "string", "boolean", "object", "array", "null"]
+        },
+        args: {
+          description: "Mapping and serialization configuration for args.",
+          $ref: "#/definitions/parameterConfigForJson"
+        },
+        results: {
+          description: "Mapping configuration for the results of this resolver step.",
+          $ref: "#/definitions/parameterConfigForJson"
+        },
+        argsMapping: {
+          $ref: "#/definitions/argsMapping"
+        },
+        resultsMapping: {
+          $ref: "#/definitions/resultsMapping"
+        }
+      },
+      required: ["name"],
+      additionalProperties: false
+    },
+    utilChunkResolver: {
+      title: "ChunkResolver",
+      type: "object",
+      properties: {
+        if: {
+          type: "string"
+        },
+        id: {
+          type: "string",
+          pattern: "^(?=[a-zA-Z])[-_a-zA-Z0-9]+$"
+        },
+        name: {
+          title: "UtilResolverName",
+          type: "string",
+          description: "Name of the resolver function.",
+          enum: ["util:chunk"]
+        },
+        options: {
+          $ref: "#/definitions/utilChunkResolverOptions"
+        },
+        args: {
+          description: "Mapping and serialization configuration for args.",
+          $ref: "#/definitions/parameterConfigForJson"
+        },
+        results: {
+          description: "Mapping configuration for the results of this resolver step.",
+          $ref: "#/definitions/parameterConfigForJson"
+        }
+      },
+      required: ["name", "options"],
+      additionalProperties: false
+    },
+    utilChunkResolverOptions: {
+      title: "UtilChunkResolverOptions",
+      oneOf: [
+        {
+          $ref: "#/definitions/utilChunkResolverOptionsCharacterCount"
+        },
+        {
+          $ref: "#/definitions/utilChunkResolverOptionsSeparators"
+        },
+        {
+          $ref: "#/definitions/utilChunkResolverOptionsMarkdown"
+        },
+        {
+          $ref: "#/definitions/utilChunkResolverOptionsSemantic"
+        }
+      ]
+    },
+    utilChunkResolverOptionsCharacterCount: {
+      title: "UtilChunkResolverOptionsCharacterCount",
+      type: "object",
+      properties: {
+        type: {
+          enum: ["characterCount"]
+        },
+        characterCount: {
+          type: "integer",
+          minimum: 1
+        }
+      },
+      required: ["type", "characterCount"],
+      additionalProperties: false
+    },
+    utilChunkResolverOptionsSeparators: {
+      title: "UtilChunkResolverOptionsSeparators",
+      type: "object",
+      properties: {
+        type: {
+          enum: ["separators"]
+        },
+        separators: {
+          type: "array",
+          minItems: 1,
+          items: {
+            type: "string",
+            minLength: 1
+          }
+        }
+      },
+      required: ["type", "separators"],
+      additionalProperties: false
+    },
+    utilChunkResolverOptionsMarkdown: {
+      title: "UtilChunkResolverOptionsMarkdown",
+      type: "object",
+      properties: {
+        type: {
+          enum: ["markdown"]
+        },
+        headerLevel: {
+          description: "New chunks will be created at headers for this level or lower. Default 2.",
+          type: "integer",
+          minimum: 1
+        },
+        maxCharacters: {
+          description: "A new chunk will be started when this number of characters is reached, regardless of markup.",
+          type: "integer",
+          minimum: 1
+        }
+      },
+      required: ["type"],
+      additionalProperties: false
+    },
+    utilChunkResolverOptionsSemantic: {
+      title: "UtilChunkResolverOptionsSemantic",
+      type: "object",
+      properties: {
+        type: {
+          enum: ["semantic"]
+        },
+        serviceId: {
+          type: "string"
+        },
+        modelId: {
+          type: "string"
+        },
+        similarityThreshold: {
+          description: "Similarity below which two embeddings are considered different.",
+          type: "number",
+          minimum: 0,
+          maximum: 1
+        },
+        stride: {
+          description: "Advanced. How many sentences to advance when grouping sentences to create embeddings. Default 1.",
+          type: "integer",
+          minimum: 1
+        },
+        sentenceCount: {
+          description: "Advanced. How many sentences are grouped together to create embeddings. Default 3.",
+          type: "integer",
+          minimum: 1
+        },
+        maxCharacters: {
+          description: "The maximum number of characters in a chunk.",
+          type: "integer",
+          min: 1
+        },
+        maxTokens: {
+          description: "The maximum number of tokens in a chunk.",
+          type: "integer",
+          min: 1
+        }
+      },
+      required: ["type", "serviceId", "modelId"],
+      additionalProperties: false
+    },
+    functionResolver: {
+      title: "FunctionResolver",
+      type: "object",
+      properties: {
+        if: {
+          type: "string"
+        },
+        id: {
+          type: "string",
+          pattern: "^(?=[a-zA-Z])[-_a-zA-Z0-9]+$"
+        },
+        name: {
+          title: "FunctionResolverName",
+          type: "string",
+          description: "Name of the resolver function.",
+          enum: ["function:run"]
+        },
+        options: {
+          title: "FunctionResolverOptions",
+          type: "object",
+          additionalProperties: true
+        },
+        args: {
+          description: "Mapping and serialization configuration for args.",
+          $ref: "#/definitions/parameterConfigForJson"
+        },
+        results: {
+          description: "Mapping configuration for the results of this resolver step.",
+          $ref: "#/definitions/parameterConfigForJson"
+        },
+        argsMapping: {
+          $ref: "#/definitions/argsMapping"
+        },
+        resultsMapping: {
+          $ref: "#/definitions/resultsMapping"
+        },
+        javascript: {
+          title: "FunctionResolverJavascript",
+          type: "string"
+        }
+      },
+      required: ["name"],
+      additionalProperties: false
+    },
+    delegateResolver: {
+      title: "DelegateResolver",
+      type: "object",
+      properties: {
+        if: {
+          type: "string"
+        },
+        id: {
+          type: "string",
+          pattern: "^(?=[a-zA-Z])[-_a-zA-Z0-9]+$"
+        },
+        name: {
+          title: "Delegate Resolver Name",
+          type: "string",
+          description: "Name of the resolver function.",
+          enum: ["delegate"]
+        },
+        options: {
+          title: "DelegateResolverOptions",
+          type: "object",
+          additionalProperties: true
+        },
+        argsMapping: {
+          $ref: "#/definitions/argsMapping"
+        },
+        resultsMapping: {
+          $ref: "#/definitions/resultsMapping"
+        },
+        to: {
+          description: "A ref to a query/mutation/property to delegate to.",
+          type: "string",
+          minLength: 1
+        },
+        args: {
+          description: "Mapping and serialization configuration for args.",
+          $ref: "#/definitions/parameterConfigForJson"
+        },
+        results: {
+          description: "Mapping configuration for the results of this resolver step.",
+          $ref: "#/definitions/parameterConfigForJson"
+        }
+      },
+      required: ["name", "to"],
+      additionalProperties: false
+    },
+    salsifyResolver: {
+      title: "SalsifyResolver",
+      type: "object",
+      properties: {
+        if: {
+          type: "string"
+        },
+        id: {
+          type: "string",
+          pattern: "^(?=[a-zA-Z])[-_a-zA-Z0-9]+$"
+        },
+        name: {
+          title: "Salsify Resolver Name",
+          type: "string",
+          description: "Name of the resolver function.",
+          enum: ["salsify:listChannelProducts"]
+        },
+        service: {
+          type: "string",
+          description: "Configuration for a service to use with this resolver."
+        },
+        options: {
+          title: "SalsifyResolverOptions",
+          type: "object",
+          additionalProperties: true
+        },
+        args: {
+          description: "Mapping and serialization configuration for args.",
+          $ref: "#/definitions/parameterConfigForJson"
+        },
+        results: {
+          description: "Mapping configuration for the results of this resolver step.",
+          $ref: "#/definitions/parameterConfigForJson"
+        },
+        argsMapping: {
+          $ref: "#/definitions/argsMapping"
+        },
+        resultsMapping: {
+          $ref: "#/definitions/resultsMapping"
+        }
+      },
+      required: ["name", "service"],
+      additionalProperties: false
+    },
+    syndigoResolver: {
+      title: "SyndigoResolver",
+      type: "object",
+      properties: {
+        if: {
+          type: "string"
+        },
+        id: {
+          type: "string",
+          pattern: "^(?=[a-zA-Z])[-_a-zA-Z0-9]+$"
+        },
+        name: {
+          title: "Syndigo Resolver Name",
+          type: "string",
+          description: "Name of the resolver function.",
+          enum: ["syndigo:searchProducts"]
+        },
+        service: {
+          type: "string",
+          description: "Configuration for a service to use with this resolver."
+        },
+        options: {
+          title: "SyndigoResolverOptions",
+          type: "object",
+          additionalProperties: true
+        },
+        args: {
+          description: "Mapping and serialization configuration for args.",
+          $ref: "#/definitions/parameterConfigForJson"
+        },
+        results: {
+          description: "Mapping configuration for the results of this resolver step.",
+          $ref: "#/definitions/parameterConfigForJson"
+        },
+        argsMapping: {
+          $ref: "#/definitions/argsMapping"
+        },
+        resultsMapping: {
+          $ref: "#/definitions/resultsMapping"
+        }
+      },
+      required: ["name", "service"],
+      additionalProperties: false
+    },
+    shapedbResolver: {
+      title: "ShapedbResolver",
+      type: "object",
+      properties: {
+        if: {
+          type: "string"
+        },
+        id: {
+          type: "string",
+          pattern: "^(?=[a-zA-Z])[-_a-zA-Z0-9]+$"
+        },
+        name: {
+          title: "ShapedbResolverName",
+          type: "string",
+          description: "Name of the resolver function.",
+          enum: [
+            "shapedb:get",
+            "shapedb:create",
+            "shapedb:update",
+            "shapedb:delete",
+            "shapedb:duplicate",
+            "shapedb:find"
+          ]
+        },
+        service: {
+          type: "string",
+          description: "Internal service identifier.",
+          enum: ["shapedb"]
+        },
+        options: {
+          title: "ShapedbResolverOptions",
+          type: "object",
+          additionalProperties: true
+        },
+        argsMapping: {
+          $ref: "#/definitions/argsMapping"
+        },
+        resultsMapping: {
+          $ref: "#/definitions/resultsMapping"
+        },
+        shapeName: {
+          description: "A Shape name for the resolver to use.",
+          type: "string",
+          minLength: 1
+        },
+        args: {
+          description: "Mapping and serialization configuration for args.",
+          $ref: "#/definitions/parameterConfigForJson"
+        },
+        results: {
+          description: "Mapping configuration for the results of this resolver step.",
+          $ref: "#/definitions/parameterConfigForJson"
+        }
+      },
+      required: ["name", "service", "shapeName"],
+      additionalProperties: false
+    },
+    shapedbResolverShapeNameNotRequired: {
+      title: "ShapedbResolverShapeNameNotRequired",
+      type: "object",
+      properties: {
+        if: {
+          type: "string"
+        },
+        id: {
+          type: "string",
+          pattern: "^(?=[a-zA-Z])[-_a-zA-Z0-9]+$"
+        },
+        name: {
+          title: "ShapedbResolverShapeNameNotRequiredName",
+          type: "string",
+          description: "Name of the resolver function.",
+          enum: ["shapedb:list", "shapedb:taxonomySuggest", "shapedb:getRelated"]
+        },
+        service: {
+          type: "string",
+          description: "Internal service identifier.",
+          enum: ["shapedb"]
+        },
+        options: {
+          title: "ShapedbResolverShapeNameNotRequiredOptions",
+          type: "object",
+          additionalProperties: true
+        },
+        shapeName: {
+          description: "An optional Shape name for the resolver.",
+          type: "string",
+          minLength: 1
+        },
+        args: {
+          description: "Mapping and serialization configuration for args.",
+          $ref: "#/definitions/parameterConfigForJson"
+        },
+        results: {
+          description: "Mapping configuration for the results of this resolver step.",
+          $ref: "#/definitions/parameterConfigForJson"
+        },
+        argsMapping: {
+          $ref: "#/definitions/argsMapping"
+        },
+        resultsMapping: {
+          $ref: "#/definitions/resultsMapping"
+        }
+      },
+      required: ["name", "service"],
+      additionalProperties: false
+    },
+    aiToolConfig: {
+      title: "AIToolConfig",
+      type: "object",
+      properties: {
+        ref: {
+          type: "string"
+        },
+        selectionSet: {
+          type: "string"
+        }
+      },
+      required: ["ref"],
+      additionalProperties: false
+    },
+    aiSimilarityGuardrail: {
+      title: "AISimilarityGuardrail",
+      type: "object",
+      properties: {
+        name: {
+          enum: ["similarity"]
+        },
+        shape: {
+          type: "string"
+        },
+        defaultResponse: {
+          type: "string"
+        },
+        threshold: {
+          type: "number"
+        }
+      },
+      required: ["name", "shape", "defaultResponse"],
+      additionalProperties: false
+    },
+    aiGuardrail: {
+      title: "AIGuardrail",
+      discriminator: {
+        propertyName: "name"
+      },
+      oneOf: [
+        {
+          $ref: "#/definitions/aiSimilarityGuardrail"
+        }
+      ]
+    },
+    aiGenerateTextResolverOptions: {
+      title: "AIGenerateTextResolverOptions",
+      type: "object",
+      properties: {
+        history: {
+          title: "history",
+          type: "boolean"
+        },
+        maxTokens: {
+          type: "integer",
+          title: "Maximum Tokens",
+          description: "Maximum number of tokens to generate."
+        },
+        temperature: {
+          type: "number",
+          title: "Temperature",
+          description: "This is a number between 0 (almost no randomness) and 1 (very random). It is recommended to set either `temperature` or `topP`, but not both. Defaults to 0",
+          minimum: 0,
+          maximum: 1
+        },
+        topP: {
+          type: "number",
+          title: "Top P",
+          description: "Nucleus sampling. This is a number between 0 and 1. E.g. 0.1 would mean that only tokens with the top 10% probability mass are considered. It is recommended to set either `temperature` or `topP`, but not both.",
+          minimum: 0,
+          maximum: 1
+        },
+        topK: {
+          type: "number",
+          title: "Top K",
+          description: 'Only sample from the top K options for each subsequent token. Used to remove "long tail" low probability responses. Recommended for advanced use cases only. You usually only need to use temperature.'
+        },
+        presencePenalty: {
+          type: "number",
+          title: "Presence penalty setting",
+          description: "It affects the likelihood of the model to repeat information that is already in the prompt. The presence penalty is a number between -1 (increase repetition) and 1 (maximum penalty, decrease repetition). 0 means no penalty.",
+          minimum: -1,
+          maximum: 1
+        },
+        frequencyPenalty: {
+          type: "number",
+          title: "Frequency penalty setting",
+          description: "It affects the likelihood of the model  to repeatedly use the same words or phrases. The frequency penalty is a number between -1 (increase repetition) and 1 (maximum penalty, decrease repetition). 0 means no penalty.",
+          minimum: -1,
+          maximum: 1
+        },
+        stopSequences: {
+          title: "Stop sequences",
+          description: "If set, the model will stop generating text when one of the stop sequences is generated.",
+          type: "array",
+          items: {
+            type: "string"
+          }
+        },
+        seed: {
+          type: "integer",
+          title: "Seed",
+          description: " The seed (integer) to use for random sampling. If set and supported by the model, calls will generate deterministic results."
+        },
+        maxRetries: {
+          type: "integer",
+          description: "Maximum number of retries. Set to 0 to disable retries. Defaults to 2"
+        },
+        toolChoice: {
+          type: "string",
+          description: "The tool choice strategy. Default: 'auto'",
+          anyOf: [
+            {
+              enum: ["auto", "none", "required"]
+            },
+            {
+              type: "string"
+            }
+          ]
+        },
+        maxToolRoundtrips: {
+          type: "integer",
+          description: "Maximal number of automatic roundtrips for tool calls."
+        }
+      }
+    },
+    aiGenerateTextResolver: {
+      title: "AIGenerateTextResolver",
+      type: "object",
+      properties: {
+        if: {
+          type: "string"
+        },
+        id: {
+          type: "string",
+          pattern: "^(?=[a-zA-Z])[-_a-zA-Z0-9]+$"
+        },
+        name: {
+          title: "AI Resolver Name",
+          type: "string",
+          description: "Name of the resolver function.",
+          enum: ["ai:generateText", "ai:chat"]
+        },
+        service: {
+          type: "string",
+          description: "Configuration for a service to use with this resolver."
+        },
+        options: {
+          $ref: "#/definitions/aiGenerateTextResolverOptions"
+        },
+        systemPrompt: {
+          type: "string"
+        },
+        inputTemplate: {
+          type: "string"
+        },
+        model: {
+          type: "string"
+        },
+        tools: {
+          type: "array",
+          items: {
+            oneOf: [
+              {
+                type: "string"
+              },
+              {
+                $ref: "#/definitions/aiToolConfig"
+              }
+            ]
+          }
+        },
+        guardrails: {
+          type: "array",
+          items: {
+            $ref: "#/definitions/aiGuardrail"
+          }
+        },
+        context: {
+          description: "Mapping and serialization configuration for prompt context.",
+          $ref: "#/definitions/parameterConfigForJson"
+        },
+        results: {
+          description: "Mapping configuration for the results of this resolver step.",
+          $ref: "#/definitions/parameterConfigForJson"
+        }
+      },
+      required: ["name", "service", "model", "systemPrompt"],
+      additionalProperties: false
+    },
+    aiGeneratePropertyResolver: {
+      title: "AIGeneratePropertyResolver",
+      type: "object",
+      properties: {
+        id: {
+          type: "string",
+          pattern: "^(?=[a-zA-Z])[-_a-zA-Z0-9]+$"
+        },
+        name: {
+          title: "AI Resolver Name",
+          type: "string",
+          description: "Name of the resolver function.",
+          enum: ["ai:generateProperty"]
+        },
+        service: {
+          type: "string",
+          description: "Configuration for a service to use with this resolver."
+        },
+        model: {
+          type: "string"
+        },
+        systemPrompt: {
+          type: "string"
+        }
+      },
+      required: ["name", "service", "model"],
+      additionalProperties: false
+    },
+    aiEmbeddingResolverOptions: {
+      title: "AIEmbeddingResolverOptions",
+      type: "object",
+      properties: {
+        useDependencies: {
+          type: "boolean"
+        }
+      }
+    },
+    aiEmbeddingResolver: {
+      title: "AIEmbeddingResolver",
+      type: "object",
+      properties: {
+        if: {
+          type: "string"
+        },
+        id: {
+          type: "string",
+          pattern: "^(?=[a-zA-Z])[-_a-zA-Z0-9]+$"
+        },
+        name: {
+          title: "AI Resolver Name",
+          type: "string",
+          description: "Name of the resolver function.",
+          enum: ["ai:createEmbedding"]
+        },
+        service: {
+          type: "string",
+          description: "Configuration for a service to use with this resolver."
+        },
+        options: {
+          $ref: "#/definitions/aiEmbeddingResolverOptions"
+        },
+        model: {
+          type: "string"
+        },
+        args: {
+          description: "Mapping and serialization configuration for prompt context.",
+          $ref: "#/definitions/parameterConfigForJson"
+        },
+        results: {
+          description: "Mapping configuration for the results of this resolver step.",
+          $ref: "#/definitions/parameterConfigForJson"
+        }
+      },
+      required: ["name", "service", "model"],
+      additionalProperties: false
+    },
+    aiEmbeddingSearchResolver: {
+      title: "AIEmbeddingSearchResolver",
+      type: "object",
+      properties: {
+        if: {
+          type: "string"
+        },
+        id: {
+          type: "string",
+          pattern: "^(?=[a-zA-Z])[-_a-zA-Z0-9]+$"
+        },
+        name: {
+          title: "AI Resolver Name",
+          type: "string",
+          description: "Name of the resolver function.",
+          enum: ["ai:embeddingSearch"]
+        },
+        vectorProperty: {
+          type: "string",
+          description: "A vector property ref to use for the query."
+        },
+        args: {
+          description: "Mapping and serialization configuration for prompt context.",
+          $ref: "#/definitions/parameterConfigForJson"
+        },
+        results: {
+          description: "Mapping configuration for the results of this resolver step.",
+          $ref: "#/definitions/parameterConfigForJson"
+        }
+      },
+      required: ["name", "vectorProperty"],
+      additionalProperties: false
+    },
+    aiParseFileResolverOptions: {
+      title: "AIParseFileResolverOptions",
+      type: "object"
+    },
+    aiParseFileResolver: {
+      title: "AIParseFileResolver",
+      type: "object",
+      properties: {
+        if: {
+          type: "string"
+        },
+        id: {
+          type: "string",
+          pattern: "^(?=[a-zA-Z])[-_a-zA-Z0-9]+$"
+        },
+        name: {
+          title: "AI Resolver Name",
+          type: "string",
+          description: "Name of the resolver function.",
+          enum: ["ai:parseFile"]
+        },
+        service: {
+          type: "string",
+          description: "Configuration for a service to use with this resolver."
+        },
+        options: {
+          $ref: "#/definitions/aiEmbeddingResolverOptions"
+        },
+        args: {
+          description: "Mapping and serialization configuration for prompt context.",
+          $ref: "#/definitions/parameterConfigForJson"
+        },
+        results: {
+          description: "Mapping configuration for the results of this resolver step.",
+          $ref: "#/definitions/parameterConfigForJson"
+        }
+      },
+      required: ["name", "service"],
+      additionalProperties: false
+    },
+    takeshapeResolver: {
+      title: "TakeshapeResolver",
+      type: "object",
+      properties: {
+        if: {
+          type: "string"
+        },
+        id: {
+          type: "string",
+          pattern: "^(?=[a-zA-Z])[-_a-zA-Z0-9]+$"
+        },
+        name: {
+          title: "TakeshapeResolverName",
+          type: "string",
+          description: "Name of the resolver function.",
+          enum: [
+            "takeshape:get",
+            "takeshape:getUser",
+            "takeshape:search",
+            "takeshape:vectorSearch",
+            "takeshape:queryApiIndex",
+            "takeshape:assetUrl",
+            "takeshape:assetImage",
+            "takeshape:assetImageMeta"
+          ]
+        },
+        service: {
+          type: "string",
+          description: "Internal service identifier.",
+          enum: ["takeshape"]
+        },
+        options: {
+          title: "TakeshapeResolverOptions",
+          type: "object",
+          additionalProperties: true
+        },
+        shapeName: {
+          description: "An optional Shape name for the resolver.",
+          type: "string",
+          minLength: 1
+        },
+        args: {
+          description: "Mapping and serialization configuration for args.",
+          $ref: "#/definitions/parameterConfigForJson"
+        },
+        results: {
+          description: "Mapping configuration for the results of this resolver step.",
+          $ref: "#/definitions/parameterConfigForJson"
+        },
+        argsMapping: {
+          $ref: "#/definitions/argsMapping"
+        },
+        resultsMapping: {
+          $ref: "#/definitions/resultsMapping"
+        }
+      },
+      required: ["name", "service"],
+      additionalProperties: false
+    },
+    graphqlResolver: {
+      title: "GraphqlResolver",
+      type: "object",
+      properties: {
+        if: {
+          type: "string"
+        },
+        id: {
+          type: "string",
+          pattern: "^(?=[a-zA-Z])[-_a-zA-Z0-9]+$"
+        },
+        name: {
+          title: "GraphqlResolverName",
+          type: "string",
+          description: "Name of the resolver function.",
+          enum: ["graphql:query", "graphql:mutation", "shopify:bulkQuery"]
+        },
+        service: {
+          type: "string",
+          description: "Configuration for a service to use with this resolver."
+        },
+        argsMapping: {
+          $ref: "#/definitions/argsMapping"
+        },
+        resultsMapping: {
+          $ref: "#/definitions/resultsMapping"
+        },
+        options: {
+          title: "GraphqlResolverOptions",
+          type: "object",
+          properties: {
+            selectionSet: {
+              type: "string"
+            },
+            unboxParentSelectionSet: {
+              type: "boolean"
+            },
+            ignoreErrors: {
+              type: "boolean"
+            },
+            skipWhenMissingArgs: {
+              type: "boolean"
+            },
+            ttl: {
+              type: "number"
+            },
+            timeout: {
+              type: "number"
+            },
+            allowStream: {
+              type: "boolean"
+            },
+            retry: {
+              oneOf: [
+                {
+                  type: "number"
+                },
+                {
+                  type: "object"
+                }
+              ]
+            }
+          },
+          additionalProperties: true
+        },
+        fieldName: {
+          description: "A fieldname to use in queries.",
+          type: "string"
+        },
+        headers: {
+          description: "Mapping and serialization configuration for headers.",
+          $ref: "#/definitions/parameterConfigForHeaders"
+        },
+        searchParams: {
+          description: "Mapping and serialization configuration for searchParams.",
+          $ref: "#/definitions/parameterConfigForSearchParams"
+        },
+        args: {
+          description: "Mapping and serialization configuration for args.",
+          $ref: "#/definitions/parameterConfigForJson"
+        },
+        results: {
+          description: "Mapping configuration for the results of this resolver step.",
+          $ref: "#/definitions/parameterConfigForJson"
+        }
+      },
+      required: ["name", "service", "fieldName"],
+      additionalProperties: false
+    },
+    restResolver: {
+      title: "RestResolver",
+      type: "object",
+      properties: {
+        if: {
+          type: "string"
+        },
+        id: {
+          type: "string",
+          pattern: "^(?=[a-zA-Z])[-_a-zA-Z0-9]+$"
+        },
+        name: {
+          title: "RestResolverName",
+          type: "string",
+          description: "Name of the resolver function.",
+          enum: ["rest:get", "rest:head", "rest:post", "rest:put", "rest:patch", "rest:delete"]
+        },
+        service: {
+          type: "string",
+          description: "Configuration for a service to use with this resolver."
+        },
+        argsMapping: {
+          $ref: "#/definitions/argsMapping"
+        },
+        searchParamsMapping: {
+          $ref: "#/definitions/searchParamsMapping"
+        },
+        resultsMapping: {
+          $ref: "#/definitions/resultsMapping"
+        },
+        options: {
+          title: "RestResolverOptions",
+          type: "object",
+          properties: {
+            trailingSlash: {
+              type: "boolean"
+            },
+            allowStream: {
+              type: "boolean"
+            },
+            ttl: {
+              type: "number"
+            },
+            timeout: {
+              type: "number"
+            },
+            retry: {
+              oneOf: [
+                {
+                  type: "number"
+                },
+                {
+                  type: "object"
+                }
+              ]
+            }
+          },
+          additionalProperties: true
+        },
+        body: {
+          description: "Mapping and serialization configuration for a request body.",
+          $ref: "#/definitions/parameterConfigForBody"
+        },
+        form: {
+          description: "Mapping and serialization configuration for form data.",
+          $ref: "#/definitions/parameterConfigForSearchParams"
+        },
+        headers: {
+          description: "Mapping and serialization configuration for headers.",
+          $ref: "#/definitions/parameterConfigForHeaders"
+        },
+        json: {
+          description: "Mapping and serialization configuration for a json request body.",
+          $ref: "#/definitions/parameterConfigForJson"
+        },
+        path: {
+          description: "Mapping and serialization configuration for the path, or a simple string.",
+          oneOf: [
+            {
+              $ref: "#/definitions/parameterConfigForPathParams"
+            },
+            {
+              type: "string"
+            }
+          ]
+        },
+        searchParams: {
+          description: "Mapping and serialization configuration for searchParams.",
+          $ref: "#/definitions/parameterConfigForSearchParams"
+        },
+        args: {
+          description: "Mapping and serialization configuration for args.",
+          $ref: "#/definitions/parameterConfigForJson"
+        },
+        results: {
+          description: "Mapping configuration for the results of this resolver step.",
+          $ref: "#/definitions/parameterConfigForJson"
+        }
+      },
+      required: ["name", "service", "path"],
+      additionalProperties: false
+    },
+    awsLambdaResolver: {
+      title: "AwsLambdaResolver",
+      type: "object",
+      properties: {
+        if: {
+          type: "string"
+        },
+        id: {
+          type: "string",
+          pattern: "^(?=[a-zA-Z])[-_a-zA-Z0-9]+$"
+        },
+        name: {
+          title: "AwsLambdaResolverName",
+          type: "string",
+          description: "Name of the resolver function.",
+          enum: ["awsLambda:invoke"]
+        },
+        service: {
+          type: "string",
+          description: "Configuration for a service to use with this resolver."
+        },
+        options: {
+          title: "AwsLambdaResolverOptions",
+          type: "object",
+          additionalProperties: true
+        },
+        payload: {
+          description: "Mapping configuration the Payload.",
+          $ref: "#/definitions/parameterConfigForJson"
+        },
+        functionName: {
+          description: "Mapping configuration for the FunctionName.",
+          oneOf: [
+            {
+              type: "string"
+            },
+            {
+              $ref: "#/definitions/parameterConfigForAwsLambda"
+            }
+          ]
+        },
+        clientContext: {
+          description: "Mapping configuration for the ClientContext.",
+          $ref: "#/definitions/parameterConfigForJson"
+        },
+        args: {
+          description: "Mapping and serialization configuration for args.",
+          $ref: "#/definitions/parameterConfigForJson"
+        },
+        results: {
+          description: "Mapping configuration for the results of this resolver step.",
+          $ref: "#/definitions/parameterConfigForJson"
+        },
+        argsMapping: {
+          $ref: "#/definitions/argsMapping"
+        },
+        searchParamsMapping: {
+          description: "Set or evaluate directives to generate searchParams for the service endpoint.",
+          $ref: "#/definitions/searchParamsMapping"
+        },
+        resultsMapping: {
+          $ref: "#/definitions/resultsMapping"
+        }
+      },
+      required: ["name", "service", "functionName"],
+      additionalProperties: false
+    },
+    composeResolver: {
+      title: "ComposeResolver",
+      type: "object",
+      properties: {
+        compose: {
+          type: "array",
+          items: {
+            $ref: "#/definitions/basicResolver"
+          }
+        },
+        resultsMapping: {
+          oneOf: [
+            {
+              $ref: "#/definitions/directiveMappingMap"
+            },
+            {
+              $ref: "#/definitions/directiveConfig"
+            }
+          ]
+        },
+        results: {
+          description: "Mapping configuration for final query results.",
+          $ref: "#/definitions/parameterConfigForJson"
+        }
+      },
+      required: ["compose"],
+      additionalProperties: false
+    },
+    resolver: {
+      title: "Resolver",
+      oneOf: [
+        {
+          $ref: "#/definitions/basicResolver"
+        },
+        {
+          $ref: "#/definitions/composeResolver"
+        }
+      ]
+    },
+    dependencies: {
+      title: "Dependencies",
+      type: "string"
+    },
+    ref: {
+      title: "Ref",
+      type: "string"
+    },
+    indexed: {
+      title: "Indexed",
+      type: "object",
+      properties: {
+        nested: {
+          type: "boolean"
+        }
+      },
+      additionalProperties: false
+    },
+    graphql: {
+      title: "GraphQLConfig",
+      type: "object",
+      properties: {
+        json: {
+          type: "boolean"
+        }
+      },
+      additionalProperties: false
+    },
+    query: {
+      title: "Query JSON",
+      type: "object",
+      properties: {
+        args: {
+          description: "The args field specifies the name of a Shape for the input arguments required by your resolver.",
+          $ref: "#/definitions/args"
+        },
+        resolver: {
+          description: "Configures the resolver for your query or mutation.",
+          $ref: "#/definitions/resolver"
+        },
+        shape: {
+          $ref: "#/definitions/returnShape",
+          description: `Specifies which shape is returned by the query or mutation. The shape can refer to a shape in the schema's "shapes" object or a shape that's available on a service schema.`
+        },
+        description: {
+          type: "string",
+          description: "Provides more detail about what the query or mutation is for. This will be displayed in the automatically-generated GraphQL API docs."
+        }
+      },
+      required: ["resolver", "shape"],
+      additionalProperties: false
+    },
+    propertySchema: {
+      title: "PropertySchema",
+      type: "object",
+      properties: {
+        $ref: {
+          type: "string",
+          format: "uri-reference"
+        },
+        title: {
+          type: "string"
+        },
+        description: {
+          type: "string"
+        },
+        default: {},
+        readOnly: {
+          type: "boolean",
+          default: false
+        },
+        multipleOf: {
+          type: "number",
+          exclusiveMinimum: 0
+        },
+        maximum: {
+          type: "number"
+        },
+        exclusiveMaximum: {
+          type: "number"
+        },
+        minimum: {
+          type: "number"
+        },
+        exclusiveMinimum: {
+          type: "number"
+        },
+        maxLength: {
+          $ref: "#/definitions/nonNegativeInteger"
+        },
+        minLength: {
+          $ref: "#/definitions/nonNegativeIntegerDefault0"
+        },
+        pattern: {
+          type: "string",
+          format: "regex"
+        },
+        additionalItems: {
+          $ref: "#/definitions/propertySchema"
+        },
+        items: {
+          $ref: "#/definitions/propertySchema"
+        },
+        maxItems: {
+          $ref: "#/definitions/nonNegativeInteger"
+        },
+        minItems: {
+          $ref: "#/definitions/nonNegativeIntegerDefault0"
+        },
+        uniqueItems: {
+          type: "boolean",
+          default: false
+        },
+        contains: {
+          $ref: "#/definitions/propertySchema"
+        },
+        maxProperties: {
+          $ref: "#/definitions/nonNegativeInteger"
+        },
+        minProperties: {
+          $ref: "#/definitions/nonNegativeIntegerDefault0"
+        },
+        required: {
+          $ref: "#/definitions/stringArray"
+        },
+        additionalProperties: {
+          oneOf: [
+            {
+              $ref: "#/definitions/propertySchema"
+            },
+            {
+              enum: [false]
+            }
+          ]
+        },
+        definitions: {
+          type: "object",
+          additionalProperties: {
+            $ref: "#/definitions/propertySchema"
+          },
+          default: {}
+        },
+        properties: {
+          type: "object",
+          additionalProperties: {
+            $ref: "#/definitions/propertySchema"
+          },
+          default: {}
+        },
+        const: {},
+        enum: {
+          type: "array",
+          minItems: 1,
+          uniqueItems: true
+        },
+        type: {
+          anyOf: [
+            {
+              $ref: "#/definitions/simpleTypes"
+            },
+            {
+              type: "array",
+              items: {
+                $ref: "#/definitions/simpleTypes"
+              },
+              minItems: 1,
+              uniqueItems: true
+            }
+          ]
+        },
+        format: {
+          type: "string"
+        },
+        contentMediaType: {
+          type: "string"
+        },
+        contentEncoding: {
+          type: "string"
+        },
+        allOf: {
+          $ref: "#/definitions/schemaArray"
+        },
+        discriminator: {
+          type: "object",
+          properties: {
+            propertyName: {
+              type: "string"
+            }
+          }
+        },
+        oneOf: {
+          $ref: "#/definitions/schemaArray"
+        },
+        extends: {
+          $ref: "#/definitions/objectOrRefArray"
+        },
+        "@backreference": {
+          $ref: "#/definitions/backreference"
+        },
+        "@input": {
+          description: "A PropertySchema providing an alternative shape for a GraphQL input type.",
+          $ref: "#/definitions/propertySchema"
+        },
+        "@output": {
+          description: "A PropertySchema which is original output.",
+          $ref: "#/definitions/propertySchema"
+        },
+        "@syncLocaleStructure": {
+          type: "boolean"
+        },
+        "@sensitive": {
+          type: "boolean"
+        },
+        "@draftjs": {
+          type: "boolean"
+        },
+        "@l10n": {
+          type: "boolean"
+        },
+        "@key": {
+          type: "string",
+          pattern: "^[-_a-zA-Z0-9]+$"
+        },
+        "@workflow": {
+          type: "string"
+        },
+        "@mapping": {
+          $ref: "#/definitions/fieldMapping"
+        },
+        "@tag": {
+          type: "string"
+        },
+        "@tags": {
+          type: "array",
+          items: {
+            type: "string"
+          }
+        },
+        "@deprecationReason": {
+          type: "string"
+        },
+        "@args": {
+          $ref: "#/definitions/args"
+        },
+        "@resolver": {
+          $ref: "#/definitions/resolver"
+        },
+        "@dependencies": {
+          $ref: "#/definitions/dependencies"
+        },
+        "@ref": {
+          $ref: "#/definitions/ref"
+        },
+        "@derivedFrom": {
+          type: "string"
+        },
+        "@indexed": {
+          $ref: "#/definitions/indexed"
+        },
+        "@graphql": {
+          $ref: "#/definitions/graphql"
+        }
+      },
+      additionalProperties: false
+    },
+    shape: {
+      title: "Shape JSON",
+      description: "A Shape is a schema object for structuring and storing data from one or more sources, including the TakeShape data store and connected services",
+      type: "object",
+      properties: {
+        name: {
+          type: "string",
+          pattern: "^[_a-zA-Z][_a-zA-Z0-9]*$",
+          description: "The Pascal-cased human-readable id for a Shape. This value should match the shape's key in the shapes object. This value is used in @ref and @mapping annotations"
+        },
+        id: {
+          type: "string",
+          pattern: "[0-9A-Za-z_-]+",
+          description: `The machine-readable id for a Shape which should never change. When using TakeShape's built-in database to store Shape data, this value is used  database as a stable "table name" and changing it will result in orphaning that data.`
+        },
+        title: {
+          type: "string",
+          description: "The human-readable name for a Shape for use in a UI."
+        },
+        description: {
+          type: "string"
+        },
+        type: {
+          enum: ["interface", "input", "output"]
+        },
+        interfaces: {
+          type: "array",
+          items: {
+            type: "string"
+          }
+        },
+        model: {
+          description: "Specifying a model type allows Shape data to be stored in TakeShape's built-in database",
+          type: "object",
+          properties: {
+            type: {
+              title: "Model Type",
+              type: "string",
+              enum: ["single", "multiple", "taxonomy"]
+            }
+          },
+          required: ["type"],
+          additionalProperties: false
+        },
+        workflow: {
+          type: "string"
+        },
+        loaders: {
+          $ref: "#/definitions/shapeLoaders"
+        },
+        joins: {
+          $ref: "#/definitions/shapeJoins"
+        },
+        cache: {
+          $ref: "#/definitions/shapeCacheConfig"
+        },
+        schema: {
+          $ref: "#/definitions/shapeSchema"
+        }
+      },
+      required: ["name", "title", "id", "schema"],
+      additionalProperties: false
+    },
+    shapeWithObjectSchema: {
+      title: "Shape With Object Schema",
+      type: "object",
+      allOf: [
+        {
+          $ref: "#/definitions/shape"
+        },
+        {
+          type: "object",
+          properties: {
+            schema: {
+              $ref: "#/definitions/objectSchema"
+            }
+          },
+          required: ["schema"],
+          additionalProperties: false
+        }
+      ]
+    },
+    shapeMap: {
+      title: "Shape Map",
+      type: "object",
+      patternProperties: {
+        "^[0-9A-Za-z_]+$": {
+          $ref: "#/definitions/shape"
+        }
+      },
+      additionalProperties: false
+    },
+    formMap: {
+      title: "Form Map",
+      type: "object",
+      patternProperties: {
+        "[0-9A-Za-z_-]+": {
+          $ref: "#/definitions/formsConfig"
+        }
+      }
+    },
+    shapeCacheConfig: {
+      title: "ShapeCacheConfig",
+      type: "object",
+      properties: {
+        enabled: {
+          type: "boolean"
+        },
+        idField: {
+          type: "string"
+        },
+        searchSummaryField: {
+          type: "string"
+        },
+        fragment: {
+          $ref: "#/definitions/cachedFragmentConfig"
+        },
+        triggers: {
+          type: "array",
+          items: {
+            $ref: "#/definitions/cacheTriggerConfig"
+          }
+        },
+        maxAge: {
+          description: "Number of seconds this Shape should be cached. Default 0.",
+          type: "number",
+          minimum: 0
+        },
+        staleWhileRevalidate: {
+          description: "Requests after maxAge will send a request to origin to revalidate while serving stale content for this duration in the meantime.",
+          type: "number",
+          minimum: 0
+        }
+      },
+      additionalProperties: false,
+      required: ["enabled"]
+    },
+    shapeJoin: {
+      title: "ShapeJoin",
+      type: "object",
+      properties: {
+        resolver: {
+          oneOf: [
+            {
+              $ref: "#/definitions/delegateResolver"
+            },
+            {
+              $ref: "#/definitions/shapedbResolver"
+            }
+          ]
+        },
+        dependencies: {
+          type: "string"
+        }
+      },
+      required: ["resolver"],
+      additionalProperties: false
+    },
+    shapeJoins: {
+      title: "ShapeJoins",
+      type: "object",
+      patternProperties: {
+        "[:0-9A-Za-z_-]+": {
+          $ref: "#/definitions/shapeJoin"
+        }
+      }
+    },
+    shapeLoaders: {
+      title: "ShapeLoaders",
+      type: "object",
+      properties: {
+        list: {
+          oneOf: [
+            {
+              $ref: "#/definitions/storedListQueryLoaderConfig"
+            },
+            {
+              type: "array",
+              items: {
+                $ref: "#/definitions/storedListQueryLoaderConfig"
+              }
+            }
+          ]
+        },
+        get: {
+          $ref: "#/definitions/getQueryLoaderConfig"
+        }
+      },
+      additionalProperties: false,
+      required: ["list"]
+    },
+    cachedFragmentConfig: {
+      title: "Cached Fragment Config",
+      type: "object",
+      properties: {
+        ignoreFields: {
+          type: "array",
+          items: {
+            type: "string"
+          }
+        },
+        maxDepth: {
+          type: "number"
+        },
+        selectionSet: {
+          type: "string"
+        },
+        includeDeprecated: {
+          type: "boolean"
+        }
+      },
+      additionalProperties: false
+    },
+    listQueryLoaderConfig: {
+      title: "ListQueryLoaderConfig",
+      type: "object",
+      properties: {
+        query: {
+          type: "string"
+        },
+        args: {
+          type: "object",
+          additionalProperties: true
+        },
+        pagination: {
+          $ref: "#/definitions/paginationConfig"
+        }
+      },
+      additionalProperties: false,
+      required: ["query"]
+    },
+    storedListQueryLoaderConfig: {
+      title: "StoredListQueryLoaderConfig",
+      type: "object",
+      properties: {
+        query: {
+          type: "string"
+        },
+        args: {
+          oneOf: [
+            {
+              type: "object",
+              additionalProperties: true
+            },
+            {
+              type: "array",
+              items: {
+                type: "object",
+                additionalProperties: true
+              }
+            }
+          ]
+        },
+        pagination: {
+          $ref: "#/definitions/paginationConfig"
+        }
+      },
+      additionalProperties: false,
+      required: ["query"]
+    },
+    getQueryLoaderConfig: {
+      title: "GetQueryLoaderConfig",
+      type: "object",
+      properties: {
+        query: {
+          type: "string"
+        },
+        args: {
+          type: "object",
+          additionalProperties: true
+        },
+        idArg: {
+          type: "string"
+        }
+      },
+      additionalProperties: false,
+      required: ["query"]
+    },
+    paginationConfig: {
+      title: "Pagination Config",
+      oneOf: [
+        {
+          $ref: "#/definitions/paginationCursorConfig"
+        },
+        {
+          $ref: "#/definitions/paginationPageConfig"
+        },
+        {
+          $ref: "#/definitions/paginationOffsetConfig"
+        }
+      ]
+    },
+    paginationCursorConfig: {
+      title: "Pagination Cursor Config",
+      type: "object",
+      properties: {
+        type: {
+          type: "string",
+          enum: ["cursor"]
+        },
+        cursorArg: {
+          type: "string"
+        },
+        cursorPath: {
+          type: "string"
+        },
+        pageSize: {
+          type: "number"
+        },
+        pageSizeArg: {
+          type: "string"
+        },
+        hasMorePath: {
+          type: "string"
+        },
+        itemsPath: {
+          type: "string"
+        }
+      },
+      additionalProperties: false,
+      required: ["type", "cursorArg", "cursorPath", "pageSizeArg", "hasMorePath", "itemsPath"]
+    },
+    paginationPageConfig: {
+      title: "Pagination Page Config",
+      type: "object",
+      properties: {
+        type: {
+          type: "string",
+          enum: ["page"]
+        },
+        pageArg: {
+          type: "string"
+        },
+        pageSize: {
+          type: "number"
+        },
+        pageSizeArg: {
+          type: "string"
+        },
+        itemsPath: {
+          type: "string"
+        },
+        pageTotalPath: {
+          type: "string"
+        }
+      },
+      additionalProperties: false,
+      required: ["type", "pageArg", "itemsPath", "pageTotalPath"]
+    },
+    paginationOffsetConfig: {
+      title: "Pagination Offset Config",
+      type: "object",
+      properties: {
+        type: {
+          type: "string",
+          enum: ["offset"]
+        },
+        offsetArg: {
+          type: "string"
+        },
+        pageSize: {
+          type: "number"
+        },
+        pageSizeArg: {
+          type: "string"
+        },
+        itemsPath: {
+          type: "string"
+        },
+        itemTotalPath: {
+          type: "string"
+        }
+      },
+      additionalProperties: false,
+      required: ["type", "offsetArg", "itemsPath", "itemTotalPath"]
+    },
+    cacheTriggerConfig: {
+      title: "CacheTriggerConfig",
+      oneOf: [
+        {
+          $ref: "#/definitions/cacheScheduleTriggerConfig"
+        },
+        {
+          $ref: "#/definitions/cacheWebhookTriggerConfig"
+        }
+      ]
+    },
+    cacheScheduleTriggerConfig: {
+      title: "CacheScheduleTriggerConfig",
+      type: "object",
+      properties: {
+        type: {
+          type: "string",
+          enum: ["schedule"]
+        },
+        loader: {
+          enum: ["get", "list"]
+        },
+        interval: {
+          type: "number"
+        }
+      },
+      additionalProperties: false,
+      required: ["type", "loader", "interval"]
+    },
+    cacheWebhookTriggerConfig: {
+      title: "CacheWebhookTriggerConfig",
+      type: "object",
+      properties: {
+        type: {
+          type: "string",
+          enum: ["webhook"]
+        },
+        loader: {
+          enum: ["get", "list"]
+        },
+        service: {
+          type: "string"
+        },
+        events: {
+          type: "array",
+          items: {
+            type: "string"
+          }
+        }
+      },
+      additionalProperties: false,
+      required: ["type", "loader", "service", "events"]
+    },
+    formScalarConfig: {
+      title: "Form Scalar Config",
+      type: "object",
+      properties: {
+        widget: {
+          type: "string"
+        }
+      },
+      additionalProperties: false,
+      required: ["widget"]
+    },
+    formObjectConfig: {
+      title: "Form Object Config",
+      type: "object",
+      properties: {
+        widget: {
+          type: "string"
+        },
+        order: {
+          type: "array",
+          items: {
+            type: "string"
+          }
+        },
+        properties: {
+          patternProperties: {
+            "[0-9A-Za-z_-]+": {
+              $ref: "#/definitions/formConfig"
+            }
+          }
+        }
+      },
+      additionalProperties: false
+    },
+    formArrayConfig: {
+      title: "Form Array Config",
+      type: "object",
+      properties: {
+        widget: {
+          type: "string"
+        },
+        items: {
+          $ref: "#/definitions/formConfig"
+        }
+      },
+      additionalProperties: false,
+      required: ["widget", "items"]
+    },
+    customAuthentication: {
+      title: "Custom Authentication",
+      description: "For use with a custom auth handler on a service provider.",
+      type: "object",
+      properties: {
+        type: {
+          type: "string",
+          enum: ["custom"]
+        }
+      },
+      additionalProperties: true,
+      required: ["type"]
+    },
+    searchParamsAuthentication: {
+      title: "Search Params Authentication",
+      type: "object",
+      properties: {
+        type: {
+          type: "string",
+          enum: ["searchParams"]
+        },
+        params: {
+          type: "array",
+          items: {
+            properties: {
+              name: {
+                type: "string"
+              },
+              value: {
+                type: "string"
+              }
+            },
+            required: ["name", "value"],
+            additionalProperties: false
+          }
+        }
+      },
+      additionalProperties: false,
+      required: ["type", "params"]
+    },
+    bearerAuthentication: {
+      title: "Bearer Authentication",
+      type: "object",
+      properties: {
+        type: {
+          type: "string",
+          enum: ["bearer"]
+        },
+        token: {
+          type: "string"
+        },
+        prefix: {
+          type: "string"
+        },
+        header: {
+          type: "string"
+        }
+      },
+      additionalProperties: false,
+      required: ["type", "token"]
+    },
+    oauth2BearerAuthentication: {
+      title: "OAuth 2 Bearer Authentication",
+      type: "object",
+      properties: {
+        type: {
+          type: "string",
+          enum: ["oauth2Bearer"]
+        },
+        token: {
+          type: "string"
+        },
+        prefix: {
+          type: "string"
+        },
+        header: {
+          type: "string"
+        },
+        scope: {
+          type: "string"
+        },
+        expiresAt: {
+          type: "string"
+        }
+      },
+      additionalProperties: false,
+      required: ["type", "token"]
+    },
+    basicAuthentication: {
+      title: "Basic Authentication",
+      type: "object",
+      properties: {
+        type: {
+          type: "string",
+          enum: ["basic"]
+        },
+        username: {
+          type: "string"
+        },
+        password: {
+          type: "string"
+        },
+        useIso8859: {
+          type: "boolean"
+        }
+      },
+      additionalProperties: false,
+      required: ["type", "username", "password"]
+    },
+    oauth2Authentication: {
+      title: "OAuth 2 Authentication",
+      type: "object",
+      properties: {
+        type: {
+          type: "string",
+          enum: ["oauth2"]
+        },
+        grantType: {
+          type: "string",
+          enum: ["authorizationCode", "clientCredentials"]
+        },
+        authorizationUrl: {
+          type: "string"
+        },
+        accessTokenUrl: {
+          type: "string"
+        },
+        clientId: {
+          type: "string"
+        },
+        clientSecret: {
+          type: "string"
+        },
+        scope: {
+          type: "string"
+        },
+        usePkce: {
+          type: "boolean"
+        },
+        redirectUrl: {
+          type: "string"
+        },
+        headerPrefix: {
+          type: "string"
+        },
+        audience: {
+          type: "string"
+        },
+        resource: {
+          type: "string"
+        }
+      },
+      additionalProperties: false,
+      required: ["type", "grantType", "clientId"]
+    },
+    awsAuthentication: {
+      title: "AWS Authentication",
+      type: "object",
+      properties: {
+        type: {
+          type: "string",
+          enum: ["aws"]
+        },
+        awsAccessKeyId: {
+          type: "string"
+        },
+        awsSecretAccessKey: {
+          type: "string"
+        }
+      },
+      additionalProperties: false,
+      required: ["type", "awsAccessKeyId", "awsSecretAccessKey"]
+    },
+    googleAuthentication: {
+      title: "Google Authentication",
+      type: "object",
+      properties: {
+        type: {
+          type: "string",
+          enum: ["google"]
+        },
+        clientEmail: {
+          type: "string"
+        },
+        privateKey: {
+          type: "string"
+        }
+      },
+      additionalProperties: false,
+      required: ["type", "clientEmail", "privateKey"]
+    },
+    serviceAuthentication: {
+      title: "Service Authentication",
+      oneOf: [
+        {
+          $ref: "#/definitions/oauth2Authentication"
+        },
+        {
+          $ref: "#/definitions/oauth2BearerAuthentication"
+        },
+        {
+          $ref: "#/definitions/bearerAuthentication"
+        },
+        {
+          $ref: "#/definitions/basicAuthentication"
+        },
+        {
+          $ref: "#/definitions/searchParamsAuthentication"
+        },
+        {
+          $ref: "#/definitions/awsAuthentication"
+        },
+        {
+          $ref: "#/definitions/googleAuthentication"
+        },
+        {
+          $ref: "#/definitions/customAuthentication"
+        }
+      ]
+    },
+    serviceHealthCheckTrigger: {
+      title: "Service Health Check Trigger",
+      enum: ["manual", "schedule"]
+    },
+    serviceHealthCheck: {
+      title: "Service Health Check",
+      description: "Configuration for ping health checks.",
+      type: "object",
+      properties: {
+        checkName: {
+          title: "Check Name",
+          description: "The name of a health check to run",
+          type: "string",
+          enum: ["graphqlIntrospection", "ping", "none"]
+        },
+        endpoint: {
+          title: "Endpoint",
+          description: "The endpoint to use when checking the service health.",
+          type: "string"
+        },
+        requestMethod: {
+          title: "Request Method",
+          description: "A custom method to use for the health check request.",
+          type: "string",
+          enum: ["GET", "POST", "PUT", "PATCH", "DELETE"]
+        },
+        requestHeaders: {
+          title: "Request Headers",
+          description: "Any custom headers to set with the health check request.",
+          type: "object",
+          propertyNames: {
+            pattern: "[0-9A-Za-z_-]+"
+          }
+        },
+        requestSearchParams: {
+          title: "Request Search Params",
+          description: "Any custom search params to set with the health check request.",
+          type: "object",
+          propertyNames: {
+            pattern: "[0-9A-Za-z_-]+"
+          }
+        },
+        requestBody: {
+          title: "Request Body",
+          description: "A custom body to send along with the ping request.",
+          type: "string"
+        },
+        requestBodyFormat: {
+          title: "Request Body Format",
+          description: "A custom body to send along with the ping request.",
+          type: "string",
+          enum: ["string", "form", "json", "form-data"]
+        },
+        requestTimeout: {
+          title: "Request Timeout",
+          description: "The amount of time to wait when receiving a response from the health check, in seconds.",
+          type: "number",
+          minimum: 2,
+          maximum: 60
+        },
+        healthyResponseStatusCode: {
+          title: "Healthy Response Status Code",
+          description: "The response status code that qualifies as healthy.",
+          type: "number",
+          minimum: 200,
+          maximum: 399
+        },
+        triggers: {
+          type: "array",
+          items: {
+            $ref: "#/definitions/serviceHealthCheckTrigger"
+          }
+        }
+      },
+      required: ["checkName"],
+      additionalProperties: false
+    },
+    serviceType: {
+      title: "Service Type",
+      description: "The general type of this service, specifying how and where it will be utilized.",
+      type: "string",
+      enum: ["deployment", "authentication", "takeshape", "rest", "graphql", "openapi", "aws", "unknown"]
+    },
+    serviceConfig: {
+      title: "Service Config",
+      type: "object",
+      properties: {
+        id: {
+          type: "string",
+          description: "Machine-readable identifier, should typically be the same as the property name on the services object."
+        },
+        title: {
+          type: "string",
+          description: "Human-readable name for this service."
+        },
+        provider: {
+          description: "The service provider id.",
+          type: "string"
+        },
+        namespace: {
+          type: "string",
+          description: "A namespace to use for the imported types tied to this service."
+        },
+        serviceType: {
+          $ref: "#/definitions/serviceType"
+        },
+        authenticationType: {
+          type: "string",
+          enum: [
+            "oauth2",
+            "basic",
+            "bearer",
+            "searchParams",
+            "oauth2Bearer",
+            "custom",
+            "aws",
+            "google",
+            "none",
+            "unknown"
+          ]
+        },
+        authentication: {
+          $ref: "#/definitions/serviceAuthentication"
+        },
+        healthCheck: {
+          $ref: "#/definitions/serviceHealthCheck"
+        },
+        webhookId: {
+          type: "string"
+        },
+        options: {
+          type: "object",
+          description: "Configuration options passed to and handled by the provider."
+        }
+      },
+      required: ["id", "title", "provider", "serviceType", "authenticationType"],
+      additionalProperties: false
+    },
+    storedServiceConfig: {
+      title: "Service Config JSON",
+      type: "object",
+      properties: {
+        id: {
+          type: "string",
+          description: "Machine-readable identifier, should typically be the same as the property name on the services object."
+        },
+        title: {
+          type: "string",
+          description: "Human-readable name for this service."
+        },
+        provider: {
+          type: "string",
+          description: "The service provider id."
+        },
+        namespace: {
+          type: "string",
+          description: "A namespace to use for the imported types tied to this service."
+        },
+        serviceType: {
+          $ref: "#/definitions/serviceType"
+        },
+        authenticationType: {
+          type: "string",
+          enum: [
+            "oauth2",
+            "basic",
+            "bearer",
+            "searchParams",
+            "oauth2Bearer",
+            "custom",
+            "aws",
+            "google",
+            "none",
+            "unknown"
+          ]
+        },
+        authentication: {
+          type: "string"
+        },
+        healthCheck: {
+          $ref: "#/definitions/serviceHealthCheck"
+        },
+        webhookId: {
+          type: "string"
+        },
+        options: {
+          type: "object",
+          description: "Configuration options passed to and handled by the provider."
+        }
+      },
+      required: ["id", "title", "provider", "serviceType", "authenticationType"],
+      additionalProperties: false
+    },
+    anyServiceConfig: {
+      title: "Any Service Config",
+      oneOf: [
+        {
+          $ref: "#/definitions/storedServiceConfig"
+        },
+        {
+          $ref: "#/definitions/serviceConfig"
+        }
+      ]
+    },
+    storedServiceMap: {
+      title: "Service Map JSON",
+      type: "object",
+      patternProperties: {
+        "[0-9A-Za-z_-]+": {
+          $ref: "#/definitions/storedServiceConfig"
+        }
+      }
+    },
+    workflowStep: {
+      title: "Workflow Step",
+      type: "object",
+      properties: {
+        name: {
+          type: "string",
+          title: "Name",
+          pattern: "^[_a-zA-Z][_a-zA-Z0-9]*$",
+          description: "machine-readable slug"
+        },
+        title: {
+          title: "Title",
+          type: "string",
+          description: "Human-readable id for use in the UI"
+        },
+        description: {
+          title: "Description",
+          type: "string"
+        },
+        color: {
+          title: "Color",
+          type: "string",
+          description: "Hex color code"
+        },
+        live: {
+          title: "Live",
+          type: "boolean",
+          description: "Value to indicate whether items in the state should be returned in list queries"
+        },
+        key: {
+          title: "Key",
+          type: "string",
+          description: "machine-readable id"
+        }
+      },
+      required: ["name", "title", "color", "live", "key"],
+      additionalProperties: false
+    },
+    workflow: {
+      title: "Workflow",
+      type: "object",
+      properties: {
+        name: {
+          type: "string",
+          pattern: "^[_a-zA-Z][_a-zA-Z0-9]*$",
+          description: "machine-readable id"
+        },
+        title: {
+          type: "string",
+          title: "Workflow Name",
+          minLength: 1,
+          description: "Human-readable id for use in the UI"
+        },
+        steps: {
+          type: "array",
+          title: "Steps",
+          items: {
+            $ref: "#/definitions/workflowStep"
+          },
+          minItems: 1
+        }
+      },
+      required: ["name", "title", "steps"]
+    },
+    workflowMap: {
+      title: "Workflow Map",
+      type: "object",
+      patternProperties: {
+        "[0-9A-Za-z_-]+": {
+          $ref: "#/definitions/workflow"
+        }
+      }
+    },
+    formConfig: {
+      title: "Form Config",
+      type: "object"
+    },
+    formsConfig: {
+      title: "Forms Config",
+      type: "object",
+      properties: {
+        default: {
+          $ref: "#/definitions/formConfig"
+        }
+      },
+      patternProperties: {
+        "[0-9A-Za-z_-]+": {
+          $ref: "#/definitions/formConfig"
+        }
+      },
+      required: ["default"]
+    },
+    agent: {
+      title: "Agent JSON",
+      description: "An Agent is a configuration for an AI service such as a chat bot or a search engine.",
+      type: "object",
+      properties: {
+        description: {
+          type: "string"
+        },
+        systemPrompt: {
+          type: "string"
+        },
+        api: {
+          $ref: "#/definitions/agentApi"
+        },
+        memory: {
+          $ref: "#/definitions/agentMemory"
+        },
+        start: {
+          $ref: "#/definitions/agentStart"
+        },
+        states: {
+          $ref: "#/definitions/agentStateMap"
+        },
+        guards: {
+          type: "array",
+          items: {
+            $ref: "#/definitions/agentGuard"
+          }
+        },
+        historyStrategies: {
+          $ref: "#/definitions/historyStrategyMap"
+        }
+      },
+      required: ["start", "states", "api"],
+      additionalProperties: false
+    },
+    historyStrategyMap: {
+      title: "History Strategy Map",
+      type: "object",
+      patternProperties: {
+        "^[0-9A-Za-z_]+$": {
+          $ref: "#/definitions/historyStrategy"
+        }
+      },
+      additionalProperties: false
+    },
+    historyStrategy: {
+      title: "History Strategy",
+      type: "object",
+      properties: {
+        name: {
+          type: "string"
+        },
+        variables: {
+          title: "Variables",
+          type: "array",
+          items: {
+            $ref: "#/definitions/agentVariable"
+          }
+        },
+        filter: {
+          $ref: "#/definitions/historyStrategyFilter"
+        },
+        transform: {
+          $ref: "#/definitions/historyStrategyTransform"
+        }
+      },
+      required: ["name", "transform"],
+      additionalProperties: false
+    },
+    historyStrategyFilter: {
+      title: "History Strategy Filter",
+      type: "object",
+      properties: {
+        toolCalls: {
+          enum: ["retain", "clear"]
+        }
+      },
+      additionalProperties: false
+    },
+    historyStrategyTransform: {
+      title: "History Strategy Transform",
+      discriminator: {
+        propertyName: "type"
+      },
+      oneOf: [
+        {
+          $ref: "#/definitions/historyStrategyTransformNone"
+        },
+        {
+          $ref: "#/definitions/historyStrategyTransformReplace"
+        },
+        {
+          $ref: "#/definitions/historyStrategyTransformSummarize"
+        }
+      ]
+    },
+    historyStrategyTransformNone: {
+      title: "History Strategy Transform None",
+      type: "object",
+      properties: {
+        type: {
+          enum: ["none"]
+        }
+      },
+      required: ["type"],
+      additionalProperties: false
+    },
+    historyStrategyTransformReplace: {
+      title: "History Strategy Transform Replace",
+      type: "object",
+      properties: {
+        type: {
+          enum: ["replace"]
+        },
+        template: {
+          type: "string"
+        }
+      },
+      required: ["type", "template"],
+      additionalProperties: false
+    },
+    historyStrategyTransformSummarize: {
+      title: "History Strategy Transform Summarize",
+      type: "object",
+      properties: {
+        type: {
+          enum: ["generate"]
+        },
+        service: {
+          type: "string"
+        },
+        model: {
+          type: "string"
+        },
+        systemPrompt: {
+          type: "string"
+        },
+        tools: {
+          type: "array",
+          items: {
+            $ref: "#/definitions/agentToolConfig"
+          }
+        },
+        options: {
+          $ref: "#/definitions/agentGenerateOptions"
+        }
+      },
+      required: ["type", "service", "model", "systemPrompt"],
+      additionalProperties: false
+    },
+    tool: {
+      title: "Tool JSON",
+      type: "object",
+      properties: {
+        name: {
+          type: "string"
+        },
+        ref: {
+          type: "string"
+        },
+        description: {
+          type: "string"
+        },
+        args: {
+          type: "array",
+          items: {
+            $ref: "#/definitions/toolArg"
+          }
+        },
+        selectionSet: {
+          type: "string"
+        }
+      },
+      required: ["name", "ref"],
+      additionalProperties: false
+    },
+    toolArg: {
+      title: "Tool Arg",
+      type: "object",
+      discriminator: {
+        propertyName: "type"
+      },
+      oneOf: [
+        {
+          $ref: "#/definitions/agentToolConfigArgAgent"
+        }
+      ]
+    },
+    agentApi: {
+      title: "Agent API",
+      type: "object",
+      properties: {
+        inputs: {
+          type: "array",
+          items: {
+            $ref: "#/definitions/agentApiInput"
+          }
+        }
+      },
+      required: ["inputs"],
+      additionalProperties: false
+    },
+    agentMemory: {
+      title: "Agent Memory",
+      type: "object",
+      properties: {
+        sessionMemory: {
+          $ref: "#/definitions/agentSessionMemory"
+        }
+      },
+      required: ["sessionMemory"],
+      additionalProperties: false
+    },
+    agentSessionMemory: {
+      title: "Agent Session Memory",
+      type: "object",
+      properties: {
+        shape: {
+          type: "string"
+        }
+      },
+      required: [],
+      additionalProperties: false
+    },
+    agentVariable: {
+      title: "Agent Variable",
+      type: "object",
+      properties: {
+        name: {
+          type: "string"
+        },
+        steps: {
+          description: "These are evaluated in order until a value is found.",
+          type: "array",
+          items: {
+            $ref: "#/definitions/agentVariableStep"
+          }
+        }
+      },
+      required: ["name", "steps"],
+      additionalProperties: false
+    },
+    agentVariableStep: {
+      title: "Agent Variable Step",
+      type: "object",
+      properties: {
+        condition: {
+          type: "string"
+        },
+        expression: {
+          type: "string"
+        }
+      },
+      required: ["expression"],
+      additionalProperties: false
+    },
+    agentStart: {
+      title: "Agent Start",
+      description: "Configuration for the start of an agent's execution",
+      type: "object",
+      properties: {
+        transitions: {
+          type: "array",
+          items: {
+            $ref: "#/definitions/agentTransitionSuspend"
+          }
+        }
+      },
+      required: ["transitions"],
+      additionalProperties: false
+    },
+    agentStateMap: {
+      title: "Agent States",
+      description: "States that are traversed during the execution of an agent.",
+      type: "object",
+      patternProperties: {
+        "^[0-9A-Za-z_]+$": {
+          $ref: "#/definitions/agentState"
+        }
+      },
+      additionalProperties: false
+    },
+    agentState: {
+      title: "Agent State",
+      description: "One step of an agent's execution.",
+      type: "object",
+      properties: {
+        name: {
+          type: "string",
+          pattern: "^[a-zA-Z][0-9A-Za-z_]*$"
+        },
+        variables: {
+          title: "Variables",
+          type: "array",
+          items: {
+            $ref: "#/definitions/agentVariable"
+          }
+        },
+        execution: {
+          $ref: "#/definitions/agentExecution"
+        },
+        transitions: {
+          type: "array",
+          items: {
+            $ref: "#/definitions/agentTransition"
+          }
+        }
+      },
+      required: ["name", "execution"],
+      additionalProperties: false
+    },
+    agentExecution: {
+      title: "Agent Execution",
+      discriminator: {
+        propertyName: "type"
+      },
+      oneOf: [
+        {
+          $ref: "#/definitions/agentExecutionGraphql"
+        },
+        {
+          $ref: "#/definitions/agentExecutionGenerate"
+        },
+        {
+          $ref: "#/definitions/agentExecutionChat"
+        }
+      ]
+    },
+    agentApiInput: {
+      title: "Agent API Input",
+      discriminator: {
+        propertyName: "type"
+      },
+      oneOf: [
+        {
+          $ref: "#/definitions/agentApiMutationInput"
+        }
+      ]
+    },
+    agentApiMutationInput: {
+      title: "Agent API Mutation Input",
+      type: "object",
+      properties: {
+        type: {
+          enum: ["mutation"]
+        },
+        name: {
+          type: "string",
+          pattern: "^[0-9A-Za-z_]+$"
+        },
+        args: {
+          type: "string"
+        },
+        interactionTimeout: {
+          title: "Interaction Timeout (milliseconds)",
+          type: "integer"
+        }
+      },
+      required: ["type", "name", "args"],
+      additionalProperties: false
+    },
+    agentExecutionGraphql: {
+      title: "Agent Execution GraphQL",
+      type: "object",
+      properties: {
+        type: {
+          enum: ["graphql"]
+        },
+        query: {
+          type: "string"
+        },
+        path: {
+          type: "string"
+        }
+      },
+      required: ["type", "query"],
+      additionalProperties: false
+    },
+    agentStateSessionMemoryAssignment: {
+      title: "Agent State Session Memory Assignment",
+      type: "object",
+      properties: {
+        memoryPath: {
+          type: "string"
+        },
+        expression: {
+          type: "string"
+        }
+      },
+      required: ["expression"],
+      additionalProperties: false
+    },
+    agentAiStateInputArg: {
+      title: "Agent AI State Input Argument",
+      type: "object",
+      properties: {
+        type: {
+          enum: ["arg"]
+        }
+      },
+      required: ["type"],
+      additionalProperties: false
+    },
+    agentAiStateInputTemplate: {
+      title: "Agent AI State Input Template",
+      type: "object",
+      properties: {
+        type: {
+          enum: ["template"]
+        },
+        inputTemplate: {
+          type: "string"
+        }
+      },
+      required: ["type", "inputTemplate"],
+      additionalProperties: false
+    },
+    agentAiStateInput: {
+      title: "Agent AI State Input",
+      type: "object",
+      discriminator: {
+        propertyName: "type"
+      },
+      oneOf: [
+        {
+          $ref: "#/definitions/agentAiStateInputArg"
+        },
+        {
+          $ref: "#/definitions/agentAiStateInputTemplate"
+        }
+      ]
+    },
+    agentGenerateOptions: {
+      title: "AgentGenerateOptions",
+      type: "object",
+      properties: {
+        history: {
+          title: "history",
+          type: "boolean"
+        },
+        maxTokens: {
+          type: "integer",
+          title: "Maximum Tokens",
+          description: "Maximum number of tokens to generate. Defaults to 1024"
+        },
+        temperature: {
+          type: "number",
+          title: "Temperature",
+          description: "This is a number between 0 (almost no randomness) and 1 (very random). It is recommended to set either `temperature` or `topP`, but not both. Defaults to 0",
+          minimum: 0,
+          maximum: 1
+        },
+        topP: {
+          type: "number",
+          title: "Top P",
+          description: "Nucleus sampling. This is a number between 0 and 1. E.g. 0.1 would mean that only tokens with the top 10% probability mass are considered. It is recommended to set either `temperature` or `topP`, but not both.",
+          minimum: 0,
+          maximum: 1
+        },
+        topK: {
+          type: "number",
+          title: "Top K",
+          description: 'Only sample from the top K options for each subsequent token. Used to remove "long tail" low probability responses. Recommended for advanced use cases only. You usually only need to use temperature.'
+        },
+        presencePenalty: {
+          type: "number",
+          title: "Presence penalty setting",
+          description: "It affects the likelihood of the model to repeat information that is already in the prompt. The presence penalty is a number between -1 (increase repetition) and 1 (maximum penalty, decrease repetition). 0 means no penalty.",
+          minimum: -1,
+          maximum: 1
+        },
+        frequencyPenalty: {
+          type: "number",
+          title: "Frequency penalty setting",
+          description: "It affects the likelihood of the model  to repeatedly use the same words or phrases. The frequency penalty is a number between -1 (increase repetition) and 1 (maximum penalty, decrease repetition). 0 means no penalty.",
+          minimum: -1,
+          maximum: 1
+        },
+        stopSequences: {
+          title: "Stop sequences",
+          description: "If set, the model will stop generating text when one of the stop sequences is generated.",
+          type: "array",
+          items: {
+            type: "string"
+          }
+        },
+        seed: {
+          type: "integer",
+          title: "Seed",
+          description: " The seed (integer) to use for random sampling. If set and supported by the model, calls will generate deterministic results."
+        },
+        maxRetries: {
+          type: "integer",
+          description: "Maximum number of retries. Set to 0 to disable retries. Defaults to 2"
+        },
+        toolChoice: {
+          type: "string",
+          description: "The tool choice strategy. Default: 'auto'",
+          anyOf: [
+            {
+              enum: ["auto", "none", "required"]
+            },
+            {
+              type: "string"
+            }
+          ]
+        },
+        maxToolRoundtrips: {
+          type: "integer",
+          title: "Max Tool Roundtrips",
+          description: "Maximal number of automatic roundtrips for tool calls."
+        },
+        structuredOutputs: {
+          type: "boolean",
+          title: "Structured Outputs",
+          description: "If true, structured outputs will be enabled on the model for non-text requests."
+        },
+        enableOpenAIFormat: {
+          type: "boolean",
+          title: "Enable OpenAI Schema Format",
+          description: "Enable OpenAI schema format. Must be enabled if `structuredOutputs` is enabled."
+        },
+        removePropertyKeyPatterns: {
+          $ref: "#/definitions/removePropertyKeyPatterns"
+        },
+        stripMarkdown: {
+          type: "boolean",
+          title: "Strip Markdown",
+          description: "Remove Markdown formatting from the LLM response"
+        }
+      },
+      additionalProperties: false
+    },
+    agentGuard: {
+      title: "Agent Guard",
+      type: "object",
+      properties: {
+        guardId: {
+          title: "Guard ID",
+          type: "string"
+        }
+      },
+      required: ["guardId"],
+      additionalProperties: false
+    },
+    agentToolConfig: {
+      title: "AgentToolConfig",
+      type: "object",
+      properties: {
+        name: {
+          type: "string"
+        },
+        ref: {
+          type: "string"
+        },
+        description: {
+          type: "string"
+        },
+        args: {
+          type: "array",
+          items: {
+            $ref: "#/definitions/agentToolConfigArg"
+          }
+        },
+        selectionSet: {
+          type: "string"
+        }
+      },
+      required: ["name", "ref"],
+      additionalProperties: false
+    },
+    agentToolConfigArg: {
+      title: "Agent Tool Config Arg",
+      type: "object",
+      discriminator: {
+        propertyName: "type"
+      },
+      oneOf: [
+        {
+          $ref: "#/definitions/agentToolConfigArgAgent"
+        },
+        {
+          $ref: "#/definitions/agentToolConfigArgVariable"
+        }
+      ]
+    },
+    agentToolConfigArgAgent: {
+      title: "Agent-Controlled",
+      type: "object",
+      properties: {
+        type: {
+          enum: ["agent"]
+        },
+        argName: {
+          title: "Tool Argument Name",
+          type: "string",
+          description: "The argument name that will be exposed by the tool for the LLM to use."
+        }
+      },
+      required: ["type", "argName"],
+      additionalProperties: false
+    },
+    agentToolConfigArgVariable: {
+      title: "Variable Value",
+      type: "object",
+      properties: {
+        type: {
+          enum: ["variable"]
+        },
+        argName: {
+          title: "Tool Argument Name",
+          type: "string",
+          description: "Name of argument to pass value to. This prevents the LLM from setting the argument."
+        },
+        variableName: {
+          title: "State Variable Name",
+          type: "string",
+          description: "Name of variable to pull value from."
+        }
+      },
+      required: ["type", "argName", "variableName"],
+      additionalProperties: false
+    },
+    agentExecutionGenerate: {
+      title: "Agent Execution Generate",
+      type: "object",
+      properties: {
+        type: {
+          enum: ["generate"]
+        },
+        service: {
+          type: "string"
+        },
+        model: {
+          type: "string"
+        },
+        systemPrompt: {
+          type: "string"
+        },
+        input: {
+          $ref: "#/definitions/agentAiStateInput"
+        },
+        outputShape: {
+          type: "string"
+        },
+        tools: {
+          type: "array",
+          items: {
+            $ref: "#/definitions/agentToolConfig"
+          }
+        },
+        options: {
+          $ref: "#/definitions/agentGenerateOptions"
+        }
+      },
+      required: ["type", "service", "model", "input"],
+      additionalProperties: false
+    },
+    agentExecutionChat: {
+      title: "Agent Execution Chat",
+      type: "object",
+      properties: {
+        type: {
+          enum: ["chat"]
+        },
+        service: {
+          type: "string"
+        },
+        model: {
+          type: "string"
+        },
+        systemPrompt: {
+          type: "string"
+        },
+        input: {
+          $ref: "#/definitions/agentAiStateInput"
+        },
+        artifact: {
+          type: "string"
+        },
+        tools: {
+          type: "array",
+          items: {
+            $ref: "#/definitions/agentToolConfig"
+          }
+        },
+        options: {
+          $ref: "#/definitions/agentGenerateOptions"
+        }
+      },
+      required: ["type", "service", "model", "input"],
+      additionalProperties: false
+    },
+    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_]+$"
+        },
+        input: {
+          type: "string"
+        },
+        condition: {
+          type: "string"
+        },
+        limit: {
+          type: "integer"
+        },
+        sessionMemory: {
+          title: "Agent State Session Memory",
+          type: "array",
+          items: {
+            $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: {
+            $ref: "#/definitions/agentStateSessionMemoryAssignment"
+          }
+        },
+        historyStrategy: {
+          type: "string"
+        }
+      },
+      additionalProperties: false,
+      required: ["type", "destination"]
+    },
+    agentMap: {
+      title: "Agent Map",
+      type: "object",
+      patternProperties: {
+        "^[0-9A-Za-z_]+$": {
+          $ref: "#/definitions/agent"
+        }
+      },
+      additionalProperties: false
+    },
+    toolMap: {
+      title: "Tool Map",
+      type: "object",
+      patternProperties: {
+        "^[0-9A-Za-z_]+$": {
+          $ref: "#/definitions/tool"
+        }
+      },
+      additionalProperties: false
+    },
+    mcpConfig: {
+      title: "MCP Server Configuration",
+      type: "object",
+      properties: {
+        tools: {
+          $ref: "#/definitions/toolMap",
+          description: "A Tool is a configuration for an AI tool which can query or mutate data."
+        }
+      },
+      additionalProperties: false
+    },
+    aiRunAgentResolver: {
+      title: "AISendAgentMessageResolver",
+      type: "object",
+      properties: {
+        id: {
+          type: "string",
+          pattern: "^(?=[a-zA-Z])[-_a-zA-Z0-9]+$"
+        },
+        name: {
+          title: "AI Resolver Name",
+          type: "string",
+          description: "Name of the resolver function.",
+          enum: ["ai:sendAgentMessage"]
+        },
+        agentName: {
+          type: "string",
+          pattern: "^[0-9A-Za-z_]+$"
+        },
+        inputName: {
+          type: "string",
+          pattern: "^[0-9A-Za-z_]+$"
+        }
+      },
+      required: ["name", "agentName", "inputName"],
+      additionalProperties: false
+    },
+    aiGetAgentMessageResolver: {
+      title: "AIGetAgentMessageResolver",
+      type: "object",
+      properties: {
+        id: {
+          type: "string",
+          pattern: "^(?=[a-zA-Z])[-_a-zA-Z0-9]+$"
+        },
+        name: {
+          title: "AI Resolver Name",
+          type: "string",
+          description: "Name of the resolver function.",
+          enum: ["ai:getAgentMessage"]
+        },
+        agentName: {
+          type: "string",
+          pattern: "^[0-9A-Za-z_]+$"
+        }
+      },
+      required: ["name", "agentName"],
+      additionalProperties: false
+    },
+    aiAbortAgentMessageResolver: {
+      title: "AIAbortAgentMessageResolver",
+      type: "object",
+      properties: {
+        id: {
+          type: "string",
+          pattern: "^(?=[a-zA-Z])[-_a-zA-Z0-9]+$"
+        },
+        name: {
+          title: "AI Resolver Name",
+          type: "string",
+          description: "Name of the resolver function.",
+          enum: ["ai:abortAgentMessage"]
+        },
+        agentName: {
+          type: "string",
+          pattern: "^[0-9A-Za-z_]+$"
+        }
+      },
+      required: ["name", "agentName"],
+      additionalProperties: false
+    },
+    aiSendAgentFeedbackResolver: {
+      title: "AISendAgentFeedbackResolver",
+      type: "object",
+      properties: {
+        id: {
+          type: "string",
+          pattern: "^(?=[a-zA-Z])[-_a-zA-Z0-9]+$"
+        },
+        name: {
+          title: "AI Resolver Name",
+          type: "string",
+          description: "Name of the resolver function.",
+          enum: ["ai:sendAgentFeedback"]
+        },
+        agentName: {
+          type: "string",
+          pattern: "^[0-9A-Za-z_]+$"
+        }
+      },
+      required: ["name", "agentName"],
+      additionalProperties: false
+    },
+    guard: {
+      title: "GuardJSON",
+      description: "A Guard is a configuration for an AI guardrail that can check inputs and outputs and provide safety and compliance.",
+      type: "object",
+      properties: {
+        name: {
+          type: "string",
+          title: "Name",
+          description: "The human-readable name of the Guard."
+        },
+        description: {
+          type: "string",
+          title: "Description",
+          description: "A description of the Guard."
+        },
+        enabled: {
+          type: "boolean",
+          title: "Enabled",
+          description: "Guards will not run unless enabled.",
+          default: true
+        },
+        guardrailIdentifier: {
+          type: "string",
+          title: "Guardrail Identifier",
+          description: "The remote id of the Guardrail."
+        },
+        guardrailVersion: {
+          type: "string",
+          title: "Guardrail Version",
+          description: "The remote version of the Guardrail."
+        },
+        blockedInputMessaging: {
+          type: "string",
+          title: "Blocked Input Messaging",
+          description: "A message to return when the input message is blocked by the Guard."
+        },
+        blockedOutputsMessaging: {
+          type: "string",
+          title: "Blocked Outputs Messaging",
+          description: "A message to return when the output message is blocked by the Guard."
+        },
+        topicPolicyConfig: {
+          type: "object",
+          title: "Topic Policy",
+          description: "Topics to identify and block.",
+          properties: {
+            topicsConfig: {
+              title: "Topic",
+              description: "A topic to block.",
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  name: {
+                    type: "string"
+                  },
+                  definition: {
+                    type: "string"
+                  },
+                  examples: {
+                    description: "Examples of the topic that can hint the LLM.",
+                    type: "array",
+                    items: {
+                      title: "Example",
+                      type: "string"
+                    },
+                    minItems: 1
+                  },
+                  type: {
+                    type: "string",
+                    enum: ["DENY"]
+                  }
+                },
+                required: ["name", "definition", "type"],
+                additionalProperties: false
+              },
+              minItems: 1
+            }
+          },
+          required: ["topicsConfig"],
+          additionalProperties: false
+        },
+        contentPolicyConfig: {
+          type: "object",
+          title: "Content Policy",
+          description: "Types of content to filter and strength configuration.",
+          properties: {
+            filtersConfig: {
+              title: "Filter",
+              description: "Types of content to filter.",
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  type: {
+                    type: "string",
+                    enum: ["HATE", "INSULTS", "MICONDUCT", "PROMPT_ATTACK", "SEXUAL", "VIOLENCE"]
+                  },
+                  inputStrength: {
+                    title: "Input Strength",
+                    type: "string",
+                    enum: ["NONE", "LOW", "MEDIUM", "HIGH"]
+                  },
+                  outputStrength: {
+                    title: "Output Strength",
+                    type: "string",
+                    enum: ["NONE", "LOW", "MEDIUM", "HIGH"]
+                  },
+                  inputModalities: {
+                    title: "Input Modalities",
+                    description: "Whether to filter images or text",
+                    type: "array",
+                    items: {
+                      $ref: "#/definitions/guardrailModality"
+                    },
+                    minItems: 1
+                  },
+                  outputModalities: {
+                    title: "Output Modalities",
+                    description: "Whether to filter images or text",
+                    type: "array",
+                    items: {
+                      $ref: "#/definitions/guardrailModality"
+                    },
+                    minItems: 1
+                  }
+                },
+                required: ["type", "inputStrength", "outputStrength"],
+                additionalProperties: false
+              },
+              minItems: 1
+            }
+          },
+          required: ["filtersConfig"],
+          additionalProperties: false
+        },
+        wordPolicyConfig: {
+          type: "object",
+          title: "Word Policy",
+          description: "Specific words to identify and block.",
+          properties: {
+            wordsConfig: {
+              title: "Word List",
+              description: "Specific words to block.",
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  text: {
+                    type: "string"
+                  }
+                },
+                required: ["text"],
+                additionalProperties: false
+              },
+              minItems: 1
+            },
+            managedWordListsConfig: {
+              title: "Managed Word List",
+              description: "This is solely used for blocking profanity.",
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  type: {
+                    type: "string",
+                    enum: ["PROFANITY"]
+                  }
+                },
+                required: ["type"],
+                additionalProperties: false
+              },
+              minItems: 1
+            }
+          },
+          additionalProperties: false
+        },
+        sensitiveInformationPolicyConfig: {
+          title: "Sensitive Information Policy",
+          description: "Filter out and block or obscure sensitive information. Matching text will be handled per the policy.",
+          type: "object",
+          properties: {
+            piiEntitiesConfig: {
+              title: "PII Entity",
+              description: "PII entity to infer from the text.",
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  type: {
+                    type: "string",
+                    enum: [
+                      "ADDRESS",
+                      "AGE",
+                      "AWS_ACCESS_KEY",
+                      "AWS_SECRET_KEY",
+                      "CA_HEALTH_NUMBER",
+                      "CA_SOCIAL_INSURANCE_NUMBER",
+                      "CREDIT_DEBIT_CARD_CVV",
+                      "CREDIT_DEBIT_CARD_EXPIRY",
+                      "CREDIT_DEBIT_CARD_NUMBER",
+                      "DRIVER_ID",
+                      "EMAIL",
+                      "INTERNATIONAL_BANK_ACCOUNT_NUMBER",
+                      "IP_ADDRESS",
+                      "LICENSE_PLATE",
+                      "MAC_ADDRESS",
+                      "NAME",
+                      "PASSWORD",
+                      "PHONE",
+                      "PIN",
+                      "SWIFT_CODE",
+                      "UK_NATIONAL_HEALTH_SERVICE_NUMBER",
+                      "UK_NATIONAL_INSURANCE_NUMBER",
+                      "UK_UNIQUE_TAXPAYER_REFERENCE_NUMBER",
+                      "URL",
+                      "USERNAME",
+                      "US_BANK_ACCOUNT_NUMBER",
+                      "US_BANK_ROUTING_NUMBER",
+                      "US_INDIVIDUAL_TAX_IDENTIFICATION_NUMBER",
+                      "US_PASSPORT_NUMBER",
+                      "US_SOCIAL_SECURITY_NUMBER",
+                      "VEHICLE_IDENTIFICATION_NUMBER"
+                    ]
+                  },
+                  action: {
+                    $ref: "#/definitions/guardrailSensitiveInformationAction"
+                  }
+                },
+                required: ["type", "action"],
+                additionalProperties: false
+              },
+              minItems: 1
+            },
+            regexesConfig: {
+              title: "Regular Expression",
+              description: "A regular expression to match sensitive information.",
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  name: {
+                    type: "string"
+                  },
+                  description: {
+                    type: "string"
+                  },
+                  pattern: {
+                    type: "string"
+                  },
+                  action: {
+                    $ref: "#/definitions/guardrailSensitiveInformationAction"
+                  }
+                },
+                required: ["name", "pattern", "action"],
+                additionalProperties: false
+              },
+              minItems: 1
+            }
+          },
+          additionalProperties: false
+        },
+        contextualGroundingPolicyConfig: {
+          title: "Contextual Grounding Policy",
+          description: "Provides evaluations based on grounding text supplied by your in-context agent variables. Off-topic conversations can then be blocked.",
+          type: "object",
+          properties: {
+            filtersConfig: {
+              title: "Filter",
+              description: "Filter to evaluate grounding text.",
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  type: {
+                    title: "Type",
+                    description: "The type of filter.",
+                    type: "string",
+                    enum: ["GROUNDING", "RELEVANCE"]
+                  },
+                  threshold: {
+                    title: "Threshold",
+                    description: "The threshold for the filter as a floating point value greater than 0.0 and less than 1.0.",
+                    type: "number",
+                    multipleOf: 0.01,
+                    exclusiveMinimum: 0,
+                    exclusiveMaximum: 1
+                  }
+                },
+                required: ["type", "threshold"],
+                additionalProperties: false
+              },
+              minItems: 1
+            }
+          },
+          required: ["filtersConfig"],
+          additionalProperties: false
+        }
+      },
+      required: ["name"],
+      additionalProperties: false
+    },
+    guardMap: {
+      title: "GuardMap",
+      type: "object",
+      patternProperties: {
+        "^[0-9A-Za-z_]+$": {
+          $ref: "#/definitions/guard"
+        }
+      },
+      additionalProperties: false
+    },
+    guardrailModality: {
+      title: "Guardrail Modality",
+      type: "string",
+      enum: ["TEXT", "IMAGE"]
+    },
+    guardrailSensitiveInformationAction: {
+      title: "Guardrail Sensitive Information Action",
+      type: "string",
+      enum: ["ANONYMIZE", "BLOCK"]
+    },
+    aiInspectAgentResolver: {
+      title: "AIInspectAgentResolver",
+      type: "object",
+      properties: {
+        id: {
+          type: "string",
+          pattern: "^(?=[a-zA-Z])[-_a-zA-Z0-9]+$"
+        },
+        name: {
+          title: "AI Resolver Name",
+          type: "string",
+          description: "Name of the resolver function.",
+          enum: ["ai:inspectAgent"]
+        },
+        agentName: {
+          type: "string",
+          pattern: "^[0-9A-Za-z_]+$"
+        }
+      },
+      required: ["name", "agentName"],
+      additionalProperties: false
+    },
+    aiCreateAgentSessionResolver: {
+      title: "AICreateAgentSessionResolver",
+      type: "object",
+      properties: {
+        id: {
+          type: "string",
+          pattern: "^(?=[a-zA-Z])[-_a-zA-Z0-9]+$"
+        },
+        name: {
+          title: "AI Resolver Name",
+          type: "string",
+          description: "Name of the resolver function.",
+          enum: ["ai:createAgentSession"]
+        },
+        agentName: {
+          type: "string",
+          pattern: "^[0-9A-Za-z_]+$"
+        }
+      },
+      required: ["name", "agentName"],
+      additionalProperties: false
+    },
+    removePropertyKeyPatterns: {
+      type: "array",
+      items: {
+        title: "Minimatch Pattern",
+        type: "string"
+      },
+      title: "Remove Property Key Patterns",
+      description: "Remove properties from the schema sent to the model with keys matching these minimatch glob patterns."
+    }
+  },
+  properties: {
+    $schema: {
+      type: "string"
+    },
+    apiVersion: {
+      type: "string",
+      description: "The version of the TakeShape API your project is using. We increase the version as we make breaking changes to the API endpoints."
+    },
+    schemaVersion: {
+      type: "string",
+      enum: ["3.57.0"],
+      description: "The version of the schema format your project is using. We increase the version as we make breaking changes to the schema format."
+    },
+    projectId: {
+      type: "string",
+      description: "The ID of the TakeShape project this schema belongs to."
+    },
+    author: {
+      type: "string",
+      description: "The ID of the TakeShape user who created the schema."
+    },
+    deactivated: {
+      type: "number"
+    },
+    defaultLocale: {
+      type: "string",
+      minLength: 1,
+      pattern: "^[a-zA-Z]{2,3}(-[a-zA-Z]{2,3})?$",
+      description: "The locale that should be preferred when creating new Shape items. This must be an entry in the locales array."
+    },
+    locales: {
+      type: "array",
+      minItems: 1,
+      items: {
+        type: "string",
+        minLength: 1,
+        pattern: "^[a-zA-Z]{2,3}(-[a-zA-Z]{2,3})?$"
+      }
+    },
+    queries: {
+      $ref: "#/definitions/queryMap",
+      description: "Queries map directly to queries your project's GraphQL API"
+    },
+    mutations: {
+      $ref: "#/definitions/queryMap",
+      description: "Mutations map directly to mutations your project's GraphQL API"
+    },
+    shapes: {
+      $ref: "#/definitions/shapeMap",
+      description: "A Shape is a schema object for structuring and storing data from one or more sources, including the TakeShape data store and connected services."
+    },
+    forms: {
+      $ref: "#/definitions/formMap",
+      description: "Forms define a visual interface for editing Shapes in the TakeShape UI."
+    },
+    workflows: {
+      $ref: "#/definitions/workflowMap",
+      description: "Workflows describe the status of a shape item. Every schema starts with a default workflow with two steps, Disabled and Enabled"
+    },
+    services: {
+      $ref: "#/definitions/storedServiceMap",
+      description: "By connecting new Services to your project schema, you can add shapes, queries, and mutations from 3rd party sources to your API in TakeShape. This allows you to mesh together exactly the API you need to interact with all of the services your app or business depends upon. Services use an encrypted configuration to keep auth tokens secret. For this reason, services can only be added to a schema through the web client or through the Admin API."
+    },
+    agents: {
+      $ref: "#/definitions/agentMap",
+      description: "An Agent is a configuration for an AI service such as a chat bot or a search engine."
+    },
+    guards: {
+      $ref: "#/definitions/guardMap",
+      description: "A Guard is a configuration for an AI guardrail that can check inputs and outputs and provide safety and compliance."
+    },
+    mcp: {
+      $ref: "#/definitions/mcpConfig",
+      description: "MCP server configuration"
+    }
+  },
+  additionalProperties: false,
+  required: [
+    "projectId",
+    "apiVersion",
+    "schemaVersion",
+    "defaultLocale",
+    "locales",
+    "shapes",
+    "queries",
+    "mutations",
+    "workflows"
+  ]
+};
+
 // ../schema/dist/schemas/project-schema/v4.0.0.json
 var v4_0_0_default = {
   $schema: "http://json-schema.org/draft-07/schema#",
@@ -387648,7 +392470,7 @@ var v4_0_0_default = {
 };
 
 // ../schema/dist/schemas/index.js
-var CURRENT_SCHEMA_VERSION = "3.57.0";
+var CURRENT_SCHEMA_VERSION = "3.58.0";
 var allProjectSchemas = [
   experimental_2025_07_default,
   meta_schema_v1_0_0_default,
@@ -387729,6 +392551,7 @@ var allProjectSchemas = [
   v3_55_0_default,
   v3_56_0_default,
   v3_57_0_default,
+  v3_58_0_default,
   v4_0_0_default
 ];
 
@@ -387739,7 +392562,7 @@ function isBasicResolver(resolver) {
 function isComposeResolver(resolver) {
   return Boolean((0, import_isArray.default)(resolver?.compose) && resolver.compose.length && resolver.compose.every(isBasicResolver));
 }
-var { definitions: { takeshapeResolver, shapedbResolver, utilResolver, graphqlResolver, restResolver, awsLambdaResolver } } = v3_57_0_default;
+var { definitions: { takeshapeResolver, shapedbResolver, utilResolver, graphqlResolver, restResolver, awsLambdaResolver } } = v3_58_0_default;
 var aiResolverNames = ["ai:generateText", "ai:chat"];
 function isAIResolverName(name) {
   return name ? aiResolverNames.includes(name) : false;
@@ -387747,7 +392570,7 @@ function isAIResolverName(name) {
 function isAIResolver(resolver) {
   return isBasicResolver(resolver) && isAIResolverName(resolver.name);
 }
-var { definitions: { parameterSerializeStyleOptionsForSearchParams, parameterSerializeStyleOptionsForPathParams } } = v3_57_0_default;
+var { definitions: { parameterSerializeStyleOptionsForSearchParams, parameterSerializeStyleOptionsForPathParams } } = v3_58_0_default;
 function isRefSchema(propertySchema2) {
   return (0, import_isString3.default)(propertySchema2["@ref"]) || (0, import_isString3.default)(propertySchema2.$ref);
 }
@@ -389197,7 +394020,7 @@ function formatError5(error) {
 // ../schema/dist/services/services.js
 function createServiceConfigValidator() {
   const validator = createAjv();
-  const { serviceConfig, ...definitions } = v3_57_0_default.definitions;
+  const { serviceConfig, ...definitions } = v3_58_0_default.definitions;
   return validator.compile({
     $id: "ServiceConfig",
     definitions,
@@ -390980,7 +395803,8 @@ var isProjectSchemaJSONV3_54_0 = createVersionPredicate2("3.54.0");
 var isProjectSchemaJSONV3_55_0 = createVersionPredicate2("3.55.0");
 var isProjectSchemaJSONV3_56_0 = createVersionPredicate2("3.56.0");
 var isProjectSchemaJSONV3_57_0 = createVersionPredicate2("3.57.0");
-var isLatestProjectSchemaJSON = createVersionPredicate2("3.57.0");
+var isProjectSchemaJSONV3_58_0 = createVersionPredicate2("3.58.0");
+var isLatestProjectSchemaJSON = createVersionPredicate2("3.58.0");
 var isProjectSchemaJSONV4_0_0 = createVersionPredicate2("4.0.0");
 
 // ../schema/dist/relationships.js
@@ -393739,7 +398563,7 @@ async function validateSchema(context, obj2) {
     return invalidVersionResult;
   }
   const structuralValidation = validateStructure(schemaVersion, contextWithDefaults, obj2);
-  if (!structuralValidation.valid) {
+  if (!structuralValidation.valid || context.structureOnly) {
     return structuralValidation;
   }
   const { schema: schema22 } = structuralValidation;