openai 0.92.0 → 0.93.0

data/sig/openai/models/vector_store_list_params.rbs

@@ -13,24 +13,64 @@ module OpenAI
       extend OpenAI::Internal::Type::RequestParameters::Converter
       include OpenAI::Internal::Type::RequestParameters
 
+      # A cursor for use in pagination. `after` is an object ID that defines your place
+      # in the list. For instance, if you make a list request and receive 100 objects,
+      # ending with obj_foo, your subsequent call can include after=obj_foo in order to
+      # fetch the next page of the list.
       attr_reader after: String?
 
+      # A cursor for use in pagination. `after` is an object ID that defines your place
+      # in the list. For instance, if you make a list request and receive 100 objects,
+      # ending with obj_foo, your subsequent call can include after=obj_foo in order to
+      # fetch the next page of the list.
       def after=: (String) -> String
 
+      # A cursor for use in pagination. `before` is an object ID that defines your place
+      # in the list. For instance, if you make a list request and receive 100 objects,
+      # starting with obj_foo, your subsequent call can include before=obj_foo in order
+      # to fetch the previous page of the list.
       attr_reader before: String?
 
+      # A cursor for use in pagination. `before` is an object ID that defines your place
+      # in the list. For instance, if you make a list request and receive 100 objects,
+      # starting with obj_foo, your subsequent call can include before=obj_foo in order
+      # to fetch the previous page of the list.
       def before=: (String) -> String
 
+      # A limit on the number of objects to be returned. Limit can range between 1 and
+      # 100, and the default is 20.
       attr_reader limit: Integer?
 
+      # A limit on the number of objects to be returned. Limit can range between 1 and
+      # 100, and the default is 20.
       def limit=: (Integer) -> Integer
 
+      # Sort order by the `created_at` timestamp of the objects. `asc` for ascending
+      # order and `desc` for descending order.
       attr_reader order: OpenAI::Models::VectorStoreListParams::order?
 
+      # Sort order by the `created_at` timestamp of the objects. `asc` for ascending
+      # order and `desc` for descending order.
       def order=: (
         OpenAI::Models::VectorStoreListParams::order
       ) -> OpenAI::Models::VectorStoreListParams::order
 
+      # @param after
+      #   A cursor for use in pagination. `after` is an object ID that defines your place
+      #   in the list. For instance, if you make a list request and receive 100 objects,
+      #   ending with obj_foo, your subsequent call can include after=obj_foo in order to
+      #   fetch the next page of the list.
+      # @param before
+      #   A cursor for use in pagination. `before` is an object ID that defines your place
+      #   in the list. For instance, if you make a list request and receive 100 objects,
+      #   starting with obj_foo, your subsequent call can include before=obj_foo in order
+      #   to fetch the previous page of the list.
+      # @param limit
+      #   A limit on the number of objects to be returned. Limit can range between 1 and
+      #   100, and the default is 20.
+      # @param order
+      #   Sort order by the `created_at` timestamp of the objects. `asc` for ascending
+      #   order and `desc` for descending order.
       def initialize: (
         ?after: String,
         ?before: String,

data/sig/openai/models/vector_store_search_params.rbs

@@ -17,28 +17,50 @@ module OpenAI
 
       attr_accessor vector_store_id: String
 
+      # A query string for a search
       attr_accessor query: OpenAI::Models::VectorStoreSearchParams::query
 
+      # A filter to apply based on file attributes.
       attr_reader filters: OpenAI::Models::VectorStoreSearchParams::filters?
 
+      # A filter to apply based on file attributes.
       def filters=: (
         OpenAI::Models::VectorStoreSearchParams::filters
       ) -> OpenAI::Models::VectorStoreSearchParams::filters
 
+      # The maximum number of results to return. This number should be between 1 and 50
+      # inclusive.
       attr_reader max_num_results: Integer?
 
+      # The maximum number of results to return. This number should be between 1 and 50
+      # inclusive.
       def max_num_results=: (Integer) -> Integer
 
+      # Ranking options for search.
       attr_reader ranking_options: OpenAI::VectorStoreSearchParams::RankingOptions?
 
+      # Ranking options for search.
       def ranking_options=: (
         OpenAI::VectorStoreSearchParams::RankingOptions
       ) -> OpenAI::VectorStoreSearchParams::RankingOptions
 
+      # Whether to rewrite the natural language query for vector search.
       attr_reader rewrite_query: bool?
 
+      # Whether to rewrite the natural language query for vector search.
       def rewrite_query=: (bool) -> bool
 
+      # @param query
+      #   A query string for a search
+      # @param filters
+      #   A filter to apply based on file attributes.
+      # @param max_num_results
+      #   The maximum number of results to return. This number should be between 1 and 50
+      #   inclusive.
+      # @param ranking_options
+      #   Ranking options for search.
+      # @param rewrite_query
+      #   Whether to rewrite the natural language query for vector search.
       def initialize: (
         vector_store_id: String,
         query: OpenAI::Models::VectorStoreSearchParams::query,
@@ -84,8 +106,10 @@ module OpenAI
         }
 
       class RankingOptions < OpenAI::Internal::Type::BaseModel
+        # Enable re-ranking; set to `none` to disable, which can help reduce latency.
         attr_reader ranker: OpenAI::Models::VectorStoreSearchParams::RankingOptions::ranker?
 
+        # Enable re-ranking; set to `none` to disable, which can help reduce latency.
         def ranker=: (
           OpenAI::Models::VectorStoreSearchParams::RankingOptions::ranker
         ) -> OpenAI::Models::VectorStoreSearchParams::RankingOptions::ranker
@@ -94,6 +118,8 @@ module OpenAI
 
         def score_threshold=: (Float) -> Float
 
+        # @param ranker
+        #   Enable re-ranking; set to `none` to disable, which can help reduce latency.
         def initialize: (
           ?ranker: OpenAI::Models::VectorStoreSearchParams::RankingOptions::ranker,
           ?score_threshold: Float

data/sig/openai/models/vector_store_search_response.rbs

@@ -10,16 +10,39 @@ module OpenAI
       }
 
     class VectorStoreSearchResponse < OpenAI::Internal::Type::BaseModel
+      # Set of 16 key-value pairs that can be attached to an object. This can be useful
+      # for storing additional information about the object in a structured format, and
+      # querying for objects via API or the dashboard. Keys are strings with a maximum
+      # length of 64 characters. Values are strings with a maximum length of 512
+      # characters, booleans, or numbers.
       attr_accessor attributes: ::Hash[Symbol, OpenAI::Models::VectorStoreSearchResponse::attribute]?
 
+      # Content chunks from the file.
       attr_accessor content: ::Array[OpenAI::Models::VectorStoreSearchResponse::Content]
 
+      # The ID of the vector store file.
       attr_accessor file_id: String
 
+      # The name of the vector store file.
       attr_accessor filename: String
 
+      # The similarity score for the result.
       attr_accessor score: Float
 
+      # @param attributes
+      #   Set of 16 key-value pairs that can be attached to an object. This can be useful
+      #   for storing additional information about the object in a structured format, and
+      #   querying for objects via API or the dashboard. Keys are strings with a maximum
+      #   length of 64 characters. Values are strings with a maximum length of 512
+      #   characters, booleans, or numbers.
+      # @param content
+      #   Content chunks from the file.
+      # @param file_id
+      #   The ID of the vector store file.
+      # @param filename
+      #   The name of the vector store file.
+      # @param score
+      #   The similarity score for the result.
       def initialize: (
         attributes: ::Hash[Symbol, OpenAI::Models::VectorStoreSearchResponse::attribute]?,
         content: ::Array[OpenAI::Models::VectorStoreSearchResponse::Content],
@@ -51,10 +74,16 @@ module OpenAI
         }
 
       class Content < OpenAI::Internal::Type::BaseModel
+        # The text content returned from search.
         attr_accessor text: String
 
+        # The type of content.
         attr_accessor type: OpenAI::Models::VectorStoreSearchResponse::Content::type_
 
+        # @param text
+        #   The text content returned from search.
+        # @param type
+        #   The type of content.
         def initialize: (
           text: String,
           type: OpenAI::Models::VectorStoreSearchResponse::Content::type_

data/sig/openai/models/vector_store_update_params.rbs

@@ -15,12 +15,31 @@ module OpenAI
 
       attr_accessor vector_store_id: String
 
+      # The expiration policy for a vector store.
       attr_accessor expires_after: OpenAI::VectorStoreUpdateParams::ExpiresAfter?
 
+      # Set of 16 key-value pairs that can be attached to an object. This can be useful
+      # for storing additional information about the object in a structured format, and
+      # querying for objects via API or the dashboard.
+      #
+      # Keys are strings with a maximum length of 64 characters. Values are strings with
+      # a maximum length of 512 characters.
       attr_accessor metadata: OpenAI::Models::metadata?
 
+      # The name of the vector store.
       attr_accessor name: String?
 
+      # @param expires_after
+      #   The expiration policy for a vector store.
+      # @param metadata
+      #   Set of 16 key-value pairs that can be attached to an object. This can be useful
+      #   for storing additional information about the object in a structured format, and
+      #   querying for objects via API or the dashboard.
+      #
+      #   Keys are strings with a maximum length of 64 characters. Values are strings with
+      #   a maximum length of 512 characters.
+      # @param name
+      #   The name of the vector store.
       def initialize: (
         vector_store_id: String,
         ?expires_after: OpenAI::VectorStoreUpdateParams::ExpiresAfter?,
@@ -40,10 +59,18 @@ module OpenAI
       type expires_after = { ?anchor: :last_active_at, days: Integer }
 
       class ExpiresAfter < OpenAI::Internal::Type::BaseModel
+        # Anchor timestamp after which the expiration policy applies. Supported anchors:
+        # `last_active_at`.
         attr_accessor anchor: :last_active_at
 
+        # The number of days after the anchor time that the vector store will expire.
         attr_accessor days: Integer
 
+        # @param days
+        #   The number of days after the anchor time that the vector store will expire.
+        # @param anchor
+        #   Anchor timestamp after which the expiration policy applies. Supported anchors:
+        #   `last_active_at`.
         def initialize: (days: Integer, ?anchor: :last_active_at) -> void
 
         def to_hash: -> { ?anchor: :last_active_at, days: Integer }

data/sig/openai/models/vector_stores/file_batch_create_params.rbs

@@ -17,24 +17,80 @@ module OpenAI
 
         attr_accessor vector_store_id: String
 
+        # Set of 16 key-value pairs that can be attached to an object. This can be useful
+        # for storing additional information about the object in a structured format, and
+        # querying for objects via API or the dashboard. Keys are strings with a maximum
+        # length of 64 characters. Values are strings with a maximum length of 512
+        # characters, booleans, or numbers.
         attr_accessor attributes: ::Hash[Symbol, OpenAI::Models::VectorStores::FileBatchCreateParams::attribute]?
 
+        # The chunking strategy used to chunk the file(s). If not set, will use the `auto`
+        # strategy. Only applicable if `file_ids` is non-empty.
         attr_reader chunking_strategy: OpenAI::Models::file_chunking_strategy_param?
 
+        # The chunking strategy used to chunk the file(s). If not set, will use the `auto`
+        # strategy. Only applicable if `file_ids` is non-empty.
         def chunking_strategy=: (
           OpenAI::Models::file_chunking_strategy_param
         ) -> OpenAI::Models::file_chunking_strategy_param
 
+        # A list of [File](https://developers.openai.com/api/reference/resources/files)
+        # IDs that the vector store should use. Useful for tools like `file_search` that
+        # can access files. If `attributes` or `chunking_strategy` are provided, they will
+        # be applied to all files in the batch. The maximum batch size is 2000 files. This
+        # endpoint is recommended for multi-file ingestion and helps reduce
+        # per-vector-store write request pressure. Mutually exclusive with `files`.
         attr_reader file_ids: ::Array[String]?
 
+        # A list of [File](https://developers.openai.com/api/reference/resources/files)
+        # IDs that the vector store should use. Useful for tools like `file_search` that
+        # can access files. If `attributes` or `chunking_strategy` are provided, they will
+        # be applied to all files in the batch. The maximum batch size is 2000 files. This
+        # endpoint is recommended for multi-file ingestion and helps reduce
+        # per-vector-store write request pressure. Mutually exclusive with `files`.
         def file_ids=: (::Array[String]) -> ::Array[String]
 
+        # A list of objects that each include a `file_id` plus optional `attributes` or
+        # `chunking_strategy`. Use this when you need to override metadata for specific
+        # files. The global `attributes` or `chunking_strategy` will be ignored and must
+        # be specified for each file. The maximum batch size is 2000 files. This endpoint
+        # is recommended for multi-file ingestion and helps reduce per-vector-store write
+        # request pressure. Mutually exclusive with `file_ids`.
         attr_reader files: ::Array[OpenAI::VectorStores::FileBatchCreateParams::File]?
 
+        # A list of objects that each include a `file_id` plus optional `attributes` or
+        # `chunking_strategy`. Use this when you need to override metadata for specific
+        # files. The global `attributes` or `chunking_strategy` will be ignored and must
+        # be specified for each file. The maximum batch size is 2000 files. This endpoint
+        # is recommended for multi-file ingestion and helps reduce per-vector-store write
+        # request pressure. Mutually exclusive with `file_ids`.
         def files=: (
           ::Array[OpenAI::VectorStores::FileBatchCreateParams::File]
         ) -> ::Array[OpenAI::VectorStores::FileBatchCreateParams::File]
 
+        # @param attributes
+        #   Set of 16 key-value pairs that can be attached to an object. This can be useful
+        #   for storing additional information about the object in a structured format, and
+        #   querying for objects via API or the dashboard. Keys are strings with a maximum
+        #   length of 64 characters. Values are strings with a maximum length of 512
+        #   characters, booleans, or numbers.
+        # @param chunking_strategy
+        #   The chunking strategy used to chunk the file(s). If not set, will use the `auto`
+        #   strategy. Only applicable if `file_ids` is non-empty.
+        # @param file_ids
+        #   A list of [File](https://developers.openai.com/api/reference/resources/files)
+        #   IDs that the vector store should use. Useful for tools like `file_search` that
+        #   can access files. If `attributes` or `chunking_strategy` are provided, they will
+        #   be applied to all files in the batch. The maximum batch size is 2000 files. This
+        #   endpoint is recommended for multi-file ingestion and helps reduce
+        #   per-vector-store write request pressure. Mutually exclusive with `files`.
+        # @param files
+        #   A list of objects that each include a `file_id` plus optional `attributes` or
+        #   `chunking_strategy`. Use this when you need to override metadata for specific
+        #   files. The global `attributes` or `chunking_strategy` will be ignored and must
+        #   be specified for each file. The maximum batch size is 2000 files. This endpoint
+        #   is recommended for multi-file ingestion and helps reduce per-vector-store write
+        #   request pressure. Mutually exclusive with `file_ids`.
         def initialize: (
           vector_store_id: String,
           ?attributes: ::Hash[Symbol, OpenAI::Models::VectorStores::FileBatchCreateParams::attribute]?,
@@ -69,16 +125,45 @@ module OpenAI
           }
 
         class File < OpenAI::Internal::Type::BaseModel
+          # A [File](https://developers.openai.com/api/reference/resources/files) ID that
+          # the vector store should use. Useful for tools like `file_search` that can access
+          # files. For multi-file ingestion, we recommend
+          # [`file_batches`](https://developers.openai.com/api/reference/resources/vector_stores/subresources/file_batches/methods/create)
+          # to minimize per-vector-store write requests.
           attr_accessor file_id: String
 
+          # Set of 16 key-value pairs that can be attached to an object. This can be useful
+          # for storing additional information about the object in a structured format, and
+          # querying for objects via API or the dashboard. Keys are strings with a maximum
+          # length of 64 characters. Values are strings with a maximum length of 512
+          # characters, booleans, or numbers.
           attr_accessor attributes: ::Hash[Symbol, OpenAI::Models::VectorStores::FileBatchCreateParams::File::attribute]?
 
+          # The chunking strategy used to chunk the file(s). If not set, will use the `auto`
+          # strategy. Only applicable if `file_ids` is non-empty.
           attr_reader chunking_strategy: OpenAI::Models::file_chunking_strategy_param?
 
+          # The chunking strategy used to chunk the file(s). If not set, will use the `auto`
+          # strategy. Only applicable if `file_ids` is non-empty.
           def chunking_strategy=: (
             OpenAI::Models::file_chunking_strategy_param
           ) -> OpenAI::Models::file_chunking_strategy_param
 
+          # @param file_id
+          #   A [File](https://developers.openai.com/api/reference/resources/files) ID that
+          #   the vector store should use. Useful for tools like `file_search` that can access
+          #   files. For multi-file ingestion, we recommend
+          #   [`file_batches`](https://developers.openai.com/api/reference/resources/vector_stores/subresources/file_batches/methods/create)
+          #   to minimize per-vector-store write requests.
+          # @param attributes
+          #   Set of 16 key-value pairs that can be attached to an object. This can be useful
+          #   for storing additional information about the object in a structured format, and
+          #   querying for objects via API or the dashboard. Keys are strings with a maximum
+          #   length of 64 characters. Values are strings with a maximum length of 512
+          #   characters, booleans, or numbers.
+          # @param chunking_strategy
+          #   The chunking strategy used to chunk the file(s). If not set, will use the `auto`
+          #   strategy. Only applicable if `file_ids` is non-empty.
           def initialize: (
             file_id: String,
             ?attributes: ::Hash[Symbol, OpenAI::Models::VectorStores::FileBatchCreateParams::File::attribute]?,

data/sig/openai/models/vector_stores/file_batch_list_files_params.rbs

@@ -21,30 +21,74 @@ module OpenAI
 
         attr_accessor batch_id: String
 
+        # A cursor for use in pagination. `after` is an object ID that defines your place
+        # in the list. For instance, if you make a list request and receive 100 objects,
+        # ending with obj_foo, your subsequent call can include after=obj_foo in order to
+        # fetch the next page of the list.
         attr_reader after: String?
 
+        # A cursor for use in pagination. `after` is an object ID that defines your place
+        # in the list. For instance, if you make a list request and receive 100 objects,
+        # ending with obj_foo, your subsequent call can include after=obj_foo in order to
+        # fetch the next page of the list.
         def after=: (String) -> String
 
+        # A cursor for use in pagination. `before` is an object ID that defines your place
+        # in the list. For instance, if you make a list request and receive 100 objects,
+        # starting with obj_foo, your subsequent call can include before=obj_foo in order
+        # to fetch the previous page of the list.
         attr_reader before: String?
 
+        # A cursor for use in pagination. `before` is an object ID that defines your place
+        # in the list. For instance, if you make a list request and receive 100 objects,
+        # starting with obj_foo, your subsequent call can include before=obj_foo in order
+        # to fetch the previous page of the list.
         def before=: (String) -> String
 
+        # Filter by file status. One of `in_progress`, `completed`, `failed`, `cancelled`.
         attr_reader filter: OpenAI::Models::VectorStores::FileBatchListFilesParams::filter?
 
+        # Filter by file status. One of `in_progress`, `completed`, `failed`, `cancelled`.
         def filter=: (
           OpenAI::Models::VectorStores::FileBatchListFilesParams::filter
         ) -> OpenAI::Models::VectorStores::FileBatchListFilesParams::filter
 
+        # A limit on the number of objects to be returned. Limit can range between 1 and
+        # 100, and the default is 20.
         attr_reader limit: Integer?
 
+        # A limit on the number of objects to be returned. Limit can range between 1 and
+        # 100, and the default is 20.
         def limit=: (Integer) -> Integer
 
+        # Sort order by the `created_at` timestamp of the objects. `asc` for ascending
+        # order and `desc` for descending order.
         attr_reader order: OpenAI::Models::VectorStores::FileBatchListFilesParams::order?
 
+        # Sort order by the `created_at` timestamp of the objects. `asc` for ascending
+        # order and `desc` for descending order.
         def order=: (
           OpenAI::Models::VectorStores::FileBatchListFilesParams::order
         ) -> OpenAI::Models::VectorStores::FileBatchListFilesParams::order
 
+        # @param after
+        #   A cursor for use in pagination. `after` is an object ID that defines your place
+        #   in the list. For instance, if you make a list request and receive 100 objects,
+        #   ending with obj_foo, your subsequent call can include after=obj_foo in order to
+        #   fetch the next page of the list.
+        # @param before
+        #   A cursor for use in pagination. `before` is an object ID that defines your place
+        #   in the list. For instance, if you make a list request and receive 100 objects,
+        #   starting with obj_foo, your subsequent call can include before=obj_foo in order
+        #   to fetch the previous page of the list.
+        # @param filter
+        #   Filter by file status. One of `in_progress`, `completed`, `failed`, `cancelled`.
+        # @param limit
+        #   A limit on the number of objects to be returned. Limit can range between 1 and
+        #   100, and the default is 20.
+        # @param order
+        #   Sort order by the `created_at` timestamp of the objects. `asc` for ascending
+        #   order and `desc` for descending order.
         def initialize: (
           vector_store_id: String,
           batch_id: String,

data/sig/openai/models/vector_stores/file_content_response.rbs

@@ -4,14 +4,22 @@ module OpenAI
       type file_content_response = { ?text: String, ?type: String }
 
       class FileContentResponse < OpenAI::Internal::Type::BaseModel
+        # The text content
         attr_reader text: String?
 
+        # The text content
         def text=: (String) -> String
 
+        # The content type (currently only `"text"`)
         attr_reader type: String?
 
+        # The content type (currently only `"text"`)
         def type=: (String) -> String
 
+        # @param text
+        #   The text content
+        # @param type
+        #   The content type (currently only `"text"`)
         def initialize: (?text: String, ?type: String) -> void
 
         def to_hash: -> { ?text: String, ?type: String }

data/sig/openai/models/vector_stores/file_create_params.rbs

@@ -16,16 +16,45 @@ module OpenAI
 
         attr_accessor vector_store_id: String
 
+        # A [File](https://developers.openai.com/api/reference/resources/files) ID that
+        # the vector store should use. Useful for tools like `file_search` that can access
+        # files. For multi-file ingestion, we recommend
+        # [`file_batches`](https://developers.openai.com/api/reference/resources/vector_stores/subresources/file_batches/methods/create)
+        # to minimize per-vector-store write requests.
         attr_accessor file_id: String
 
+        # Set of 16 key-value pairs that can be attached to an object. This can be useful
+        # for storing additional information about the object in a structured format, and
+        # querying for objects via API or the dashboard. Keys are strings with a maximum
+        # length of 64 characters. Values are strings with a maximum length of 512
+        # characters, booleans, or numbers.
         attr_accessor attributes: ::Hash[Symbol, OpenAI::Models::VectorStores::FileCreateParams::attribute]?
 
+        # The chunking strategy used to chunk the file(s). If not set, will use the `auto`
+        # strategy. Only applicable if `file_ids` is non-empty.
         attr_reader chunking_strategy: OpenAI::Models::file_chunking_strategy_param?
 
+        # The chunking strategy used to chunk the file(s). If not set, will use the `auto`
+        # strategy. Only applicable if `file_ids` is non-empty.
         def chunking_strategy=: (
           OpenAI::Models::file_chunking_strategy_param
         ) -> OpenAI::Models::file_chunking_strategy_param
 
+        # @param file_id
+        #   A [File](https://developers.openai.com/api/reference/resources/files) ID that
+        #   the vector store should use. Useful for tools like `file_search` that can access
+        #   files. For multi-file ingestion, we recommend
+        #   [`file_batches`](https://developers.openai.com/api/reference/resources/vector_stores/subresources/file_batches/methods/create)
+        #   to minimize per-vector-store write requests.
+        # @param attributes
+        #   Set of 16 key-value pairs that can be attached to an object. This can be useful
+        #   for storing additional information about the object in a structured format, and
+        #   querying for objects via API or the dashboard. Keys are strings with a maximum
+        #   length of 64 characters. Values are strings with a maximum length of 512
+        #   characters, booleans, or numbers.
+        # @param chunking_strategy
+        #   The chunking strategy used to chunk the file(s). If not set, will use the `auto`
+        #   strategy. Only applicable if `file_ids` is non-empty.
         def initialize: (
           vector_store_id: String,
           file_id: String,

data/sig/openai/models/vector_stores/file_list_params.rbs

@@ -18,30 +18,74 @@ module OpenAI
 
         attr_accessor vector_store_id: String
 
+        # A cursor for use in pagination. `after` is an object ID that defines your place
+        # in the list. For instance, if you make a list request and receive 100 objects,
+        # ending with obj_foo, your subsequent call can include after=obj_foo in order to
+        # fetch the next page of the list.
         attr_reader after: String?
 
+        # A cursor for use in pagination. `after` is an object ID that defines your place
+        # in the list. For instance, if you make a list request and receive 100 objects,
+        # ending with obj_foo, your subsequent call can include after=obj_foo in order to
+        # fetch the next page of the list.
         def after=: (String) -> String
 
+        # A cursor for use in pagination. `before` is an object ID that defines your place
+        # in the list. For instance, if you make a list request and receive 100 objects,
+        # starting with obj_foo, your subsequent call can include before=obj_foo in order
+        # to fetch the previous page of the list.
         attr_reader before: String?
 
+        # A cursor for use in pagination. `before` is an object ID that defines your place
+        # in the list. For instance, if you make a list request and receive 100 objects,
+        # starting with obj_foo, your subsequent call can include before=obj_foo in order
+        # to fetch the previous page of the list.
         def before=: (String) -> String
 
+        # Filter by file status. One of `in_progress`, `completed`, `failed`, `cancelled`.
         attr_reader filter: OpenAI::Models::VectorStores::FileListParams::filter?
 
+        # Filter by file status. One of `in_progress`, `completed`, `failed`, `cancelled`.
         def filter=: (
           OpenAI::Models::VectorStores::FileListParams::filter
         ) -> OpenAI::Models::VectorStores::FileListParams::filter
 
+        # A limit on the number of objects to be returned. Limit can range between 1 and
+        # 100, and the default is 20.
         attr_reader limit: Integer?
 
+        # A limit on the number of objects to be returned. Limit can range between 1 and
+        # 100, and the default is 20.
         def limit=: (Integer) -> Integer
 
+        # Sort order by the `created_at` timestamp of the objects. `asc` for ascending
+        # order and `desc` for descending order.
         attr_reader order: OpenAI::Models::VectorStores::FileListParams::order?
 
+        # Sort order by the `created_at` timestamp of the objects. `asc` for ascending
+        # order and `desc` for descending order.
         def order=: (
           OpenAI::Models::VectorStores::FileListParams::order
         ) -> OpenAI::Models::VectorStores::FileListParams::order
 
+        # @param after
+        #   A cursor for use in pagination. `after` is an object ID that defines your place
+        #   in the list. For instance, if you make a list request and receive 100 objects,
+        #   ending with obj_foo, your subsequent call can include after=obj_foo in order to
+        #   fetch the next page of the list.
+        # @param before
+        #   A cursor for use in pagination. `before` is an object ID that defines your place
+        #   in the list. For instance, if you make a list request and receive 100 objects,
+        #   starting with obj_foo, your subsequent call can include before=obj_foo in order
+        #   to fetch the previous page of the list.
+        # @param filter
+        #   Filter by file status. One of `in_progress`, `completed`, `failed`, `cancelled`.
+        # @param limit
+        #   A limit on the number of objects to be returned. Limit can range between 1 and
+        #   100, and the default is 20.
+        # @param order
+        #   Sort order by the `created_at` timestamp of the objects. `asc` for ascending
+        #   order and `desc` for descending order.
         def initialize: (
           vector_store_id: String,
           ?after: String,

data/sig/openai/models/vector_stores/file_update_params.rbs

@@ -17,8 +17,19 @@ module OpenAI
 
         attr_accessor file_id: String
 
+        # Set of 16 key-value pairs that can be attached to an object. This can be useful
+        # for storing additional information about the object in a structured format, and
+        # querying for objects via API or the dashboard. Keys are strings with a maximum
+        # length of 64 characters. Values are strings with a maximum length of 512
+        # characters, booleans, or numbers.
         attr_accessor attributes: ::Hash[Symbol, OpenAI::Models::VectorStores::FileUpdateParams::attribute]?
 
+        # @param attributes
+        #   Set of 16 key-value pairs that can be attached to an object. This can be useful
+        #   for storing additional information about the object in a structured format, and
+        #   querying for objects via API or the dashboard. Keys are strings with a maximum
+        #   length of 64 characters. Values are strings with a maximum length of 512
+        #   characters, booleans, or numbers.
         def initialize: (
           vector_store_id: String,
           file_id: String,