Class: OCI::GenerativeAiInference::Models::CohereChatRequestV2

Inherits:
BaseChatRequest
  • Object
show all
Defined in:
lib/oci/generative_ai_inference/models/cohere_chat_request_v2.rb

Overview

Details for the chat request for Cohere models.

Constant Summary collapse

TOOLS_CHOICE_ENUM = 
[
  TOOLS_CHOICE_REQUIRED = 'REQUIRED'.freeze,
  TOOLS_CHOICE_NONE = 'NONE'.freeze
].freeze
SAFETY_MODE_ENUM = 
[
  SAFETY_MODE_CONTEXTUAL = 'CONTEXTUAL'.freeze,
  SAFETY_MODE_STRICT = 'STRICT'.freeze,
  SAFETY_MODE_OFF = 'OFF'.freeze
].freeze

Constants inherited from BaseChatRequest

BaseChatRequest::API_FORMAT_ENUM

Instance Attribute Summary collapse

Attributes inherited from BaseChatRequest

#api_format

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from BaseChatRequest

get_subtype

Constructor Details

#initialize(attributes = {}) ⇒ CohereChatRequestV2

Initializes the object

Parameters:

  • attributes (Hash) (defaults to: {}) —

    Model attributes in the form of hash

Options Hash (attributes):



226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
 
# File 'lib/oci/generative_ai_inference/models/cohere_chat_request_v2.rb', line 226

def initialize(attributes = {})
  return unless attributes.is_a?(Hash)

  attributes['apiFormat'] = 'COHEREV2'

  super(attributes)

  # convert string to symbol for hash key
  attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }

  self.messages = attributes[:'messages'] if attributes[:'messages']

  self.documents = attributes[:'documents'] if attributes[:'documents']

  self.citation_options = attributes[:'citationOptions'] if attributes[:'citationOptions']

  raise 'You cannot provide both :citationOptions and :citation_options' if attributes.key?(:'citationOptions') && attributes.key?(:'citation_options')

  self.citation_options = attributes[:'citation_options'] if attributes[:'citation_options']

  self.tools_choice = attributes[:'toolsChoice'] if attributes[:'toolsChoice']

  raise 'You cannot provide both :toolsChoice and :tools_choice' if attributes.key?(:'toolsChoice') && attributes.key?(:'tools_choice')

  self.tools_choice = attributes[:'tools_choice'] if attributes[:'tools_choice']

  self.tools = attributes[:'tools'] if attributes[:'tools']

  self.is_strict_tools_enabled = attributes[:'isStrictToolsEnabled'] unless attributes[:'isStrictToolsEnabled'].nil?
  self.is_strict_tools_enabled = false if is_strict_tools_enabled.nil? && !attributes.key?(:'isStrictToolsEnabled') # rubocop:disable Style/StringLiterals

  raise 'You cannot provide both :isStrictToolsEnabled and :is_strict_tools_enabled' if attributes.key?(:'isStrictToolsEnabled') && attributes.key?(:'is_strict_tools_enabled')

  self.is_strict_tools_enabled = attributes[:'is_strict_tools_enabled'] unless attributes[:'is_strict_tools_enabled'].nil?
  self.is_strict_tools_enabled = false if is_strict_tools_enabled.nil? && !attributes.key?(:'isStrictToolsEnabled') && !attributes.key?(:'is_strict_tools_enabled') # rubocop:disable Style/StringLiterals

  self.is_log_probs_enabled = attributes[:'isLogProbsEnabled'] unless attributes[:'isLogProbsEnabled'].nil?
  self.is_log_probs_enabled = false if is_log_probs_enabled.nil? && !attributes.key?(:'isLogProbsEnabled') # rubocop:disable Style/StringLiterals

  raise 'You cannot provide both :isLogProbsEnabled and :is_log_probs_enabled' if attributes.key?(:'isLogProbsEnabled') && attributes.key?(:'is_log_probs_enabled')

  self.is_log_probs_enabled = attributes[:'is_log_probs_enabled'] unless attributes[:'is_log_probs_enabled'].nil?
  self.is_log_probs_enabled = false if is_log_probs_enabled.nil? && !attributes.key?(:'isLogProbsEnabled') && !attributes.key?(:'is_log_probs_enabled') # rubocop:disable Style/StringLiterals

  self.thinking = attributes[:'thinking'] if attributes[:'thinking']

  self.response_format = attributes[:'responseFormat'] if attributes[:'responseFormat']

  raise 'You cannot provide both :responseFormat and :response_format' if attributes.key?(:'responseFormat') && attributes.key?(:'response_format')

  self.response_format = attributes[:'response_format'] if attributes[:'response_format']

  self.is_search_queries_only = attributes[:'isSearchQueriesOnly'] unless attributes[:'isSearchQueriesOnly'].nil?
  self.is_search_queries_only = false if is_search_queries_only.nil? && !attributes.key?(:'isSearchQueriesOnly') # rubocop:disable Style/StringLiterals

  raise 'You cannot provide both :isSearchQueriesOnly and :is_search_queries_only' if attributes.key?(:'isSearchQueriesOnly') && attributes.key?(:'is_search_queries_only')

  self.is_search_queries_only = attributes[:'is_search_queries_only'] unless attributes[:'is_search_queries_only'].nil?
  self.is_search_queries_only = false if is_search_queries_only.nil? && !attributes.key?(:'isSearchQueriesOnly') && !attributes.key?(:'is_search_queries_only') # rubocop:disable Style/StringLiterals

  self.stream_options = attributes[:'streamOptions'] if attributes[:'streamOptions']

  raise 'You cannot provide both :streamOptions and :stream_options' if attributes.key?(:'streamOptions') && attributes.key?(:'stream_options')

  self.stream_options = attributes[:'stream_options'] if attributes[:'stream_options']

  self.is_stream = attributes[:'isStream'] unless attributes[:'isStream'].nil?
  self.is_stream = false if is_stream.nil? && !attributes.key?(:'isStream') # rubocop:disable Style/StringLiterals

  raise 'You cannot provide both :isStream and :is_stream' if attributes.key?(:'isStream') && attributes.key?(:'is_stream')

  self.is_stream = attributes[:'is_stream'] unless attributes[:'is_stream'].nil?
  self.is_stream = false if is_stream.nil? && !attributes.key?(:'isStream') && !attributes.key?(:'is_stream') # rubocop:disable Style/StringLiterals

  self.max_tokens = attributes[:'maxTokens'] if attributes[:'maxTokens']

  raise 'You cannot provide both :maxTokens and :max_tokens' if attributes.key?(:'maxTokens') && attributes.key?(:'max_tokens')

  self.max_tokens = attributes[:'max_tokens'] if attributes[:'max_tokens']

  self.temperature = attributes[:'temperature'] if attributes[:'temperature']
  self.temperature = 0.3 if temperature.nil? && !attributes.key?(:'temperature') # rubocop:disable Style/StringLiterals

  self.top_k = attributes[:'topK'] if attributes[:'topK']

  raise 'You cannot provide both :topK and :top_k' if attributes.key?(:'topK') && attributes.key?(:'top_k')

  self.top_k = attributes[:'top_k'] if attributes[:'top_k']

  self.top_p = attributes[:'topP'] if attributes[:'topP']
  self.top_p = 0.75 if top_p.nil? && !attributes.key?(:'topP') # rubocop:disable Style/StringLiterals

  raise 'You cannot provide both :topP and :top_p' if attributes.key?(:'topP') && attributes.key?(:'top_p')

  self.top_p = attributes[:'top_p'] if attributes[:'top_p']
  self.top_p = 0.75 if top_p.nil? && !attributes.key?(:'topP') && !attributes.key?(:'top_p') # rubocop:disable Style/StringLiterals

  self.frequency_penalty = attributes[:'frequencyPenalty'] if attributes[:'frequencyPenalty']
  self.frequency_penalty = 0.0 if frequency_penalty.nil? && !attributes.key?(:'frequencyPenalty') # rubocop:disable Style/StringLiterals

  raise 'You cannot provide both :frequencyPenalty and :frequency_penalty' if attributes.key?(:'frequencyPenalty') && attributes.key?(:'frequency_penalty')

  self.frequency_penalty = attributes[:'frequency_penalty'] if attributes[:'frequency_penalty']
  self.frequency_penalty = 0.0 if frequency_penalty.nil? && !attributes.key?(:'frequencyPenalty') && !attributes.key?(:'frequency_penalty') # rubocop:disable Style/StringLiterals

  self.presence_penalty = attributes[:'presencePenalty'] if attributes[:'presencePenalty']
  self.presence_penalty = 0.0 if presence_penalty.nil? && !attributes.key?(:'presencePenalty') # rubocop:disable Style/StringLiterals

  raise 'You cannot provide both :presencePenalty and :presence_penalty' if attributes.key?(:'presencePenalty') && attributes.key?(:'presence_penalty')

  self.presence_penalty = attributes[:'presence_penalty'] if attributes[:'presence_penalty']
  self.presence_penalty = 0.0 if presence_penalty.nil? && !attributes.key?(:'presencePenalty') && !attributes.key?(:'presence_penalty') # rubocop:disable Style/StringLiterals

  self.seed = attributes[:'seed'] if attributes[:'seed']

  self.stop_sequences = attributes[:'stopSequences'] if attributes[:'stopSequences']

  raise 'You cannot provide both :stopSequences and :stop_sequences' if attributes.key?(:'stopSequences') && attributes.key?(:'stop_sequences')

  self.stop_sequences = attributes[:'stop_sequences'] if attributes[:'stop_sequences']

  self.priority = attributes[:'priority'] if attributes[:'priority']

  self.is_raw_prompting = attributes[:'isRawPrompting'] unless attributes[:'isRawPrompting'].nil?
  self.is_raw_prompting = false if is_raw_prompting.nil? && !attributes.key?(:'isRawPrompting') # rubocop:disable Style/StringLiterals

  raise 'You cannot provide both :isRawPrompting and :is_raw_prompting' if attributes.key?(:'isRawPrompting') && attributes.key?(:'is_raw_prompting')

  self.is_raw_prompting = attributes[:'is_raw_prompting'] unless attributes[:'is_raw_prompting'].nil?
  self.is_raw_prompting = false if is_raw_prompting.nil? && !attributes.key?(:'isRawPrompting') && !attributes.key?(:'is_raw_prompting') # rubocop:disable Style/StringLiterals

  self.safety_mode = attributes[:'safetyMode'] if attributes[:'safetyMode']
  self.safety_mode = "CONTEXTUAL" if safety_mode.nil? && !attributes.key?(:'safetyMode') # rubocop:disable Style/StringLiterals

  raise 'You cannot provide both :safetyMode and :safety_mode' if attributes.key?(:'safetyMode') && attributes.key?(:'safety_mode')

  self.safety_mode = attributes[:'safety_mode'] if attributes[:'safety_mode']
  self.safety_mode = "CONTEXTUAL" if safety_mode.nil? && !attributes.key?(:'safetyMode') && !attributes.key?(:'safety_mode') # rubocop:disable Style/StringLiterals
end

Instance Attribute Details

#citation_options ⇒ OCI::GenerativeAiInference::Models::CitationOptionsV2

Returns:



34
35
36
 
# File 'lib/oci/generative_ai_inference/models/cohere_chat_request_v2.rb', line 34

def citation_options
  @citation_options
end

#documents ⇒ Array<Object>

A list of relevant documents that the model can refer to for generating grounded responses to the user's requests. Some example keys that you can add to the dictionary are "text", "author", and "date". Keep the total word count of the strings in the dictionary to 300 words or less.

Returns:

  • (Array<Object>) 


31
32
33
 
# File 'lib/oci/generative_ai_inference/models/cohere_chat_request_v2.rb', line 31

def documents
  @documents
end

#frequency_penalty ⇒ Float

To reduce repetitiveness of generated tokens, this number penalizes new tokens based on their frequency in the generated text so far. Greater numbers encourage the model to use new tokens, while lower numbers encourage the model to repeat the tokens. Set to 0 to disable.

Returns:

  • (Float) 


98
99
100
 
# File 'lib/oci/generative_ai_inference/models/cohere_chat_request_v2.rb', line 98

def frequency_penalty
  @frequency_penalty
end

#is_log_probs_enabled ⇒ BOOLEAN

The log probabilities of the generated tokens will be included in the response.

Returns:

  • (BOOLEAN) 


50
51
52
 
# File 'lib/oci/generative_ai_inference/models/cohere_chat_request_v2.rb', line 50

def is_log_probs_enabled
  @is_log_probs_enabled
end

#is_raw_prompting ⇒ BOOLEAN

When enabled, the useru2019s message will be sent to the model without any preprocessing.

Returns:

  • (BOOLEAN) 


122
123
124
 
# File 'lib/oci/generative_ai_inference/models/cohere_chat_request_v2.rb', line 122

def is_raw_prompting
  @is_raw_prompting
end

#is_search_queries_only ⇒ BOOLEAN

When set to true, the response contains only a list of generated search queries without the search results and the model will not respond to the user's message.

Returns:

  • (BOOLEAN) 


61
62
63
 
# File 'lib/oci/generative_ai_inference/models/cohere_chat_request_v2.rb', line 61

def is_search_queries_only
  @is_search_queries_only
end

#is_stream ⇒ BOOLEAN

Whether to stream the partial progress of the model's response. When set to true, as tokens become available, they are sent as data-only server-sent events.

Returns:

  • (BOOLEAN) 


68
69
70
 
# File 'lib/oci/generative_ai_inference/models/cohere_chat_request_v2.rb', line 68

def is_stream
  @is_stream
end

#is_strict_tools_enabled ⇒ BOOLEAN

When set to true, tool calls in the Assistant message will be forced to follow the tool definition strictly. Note:The first few requests with a new set of tools will take longer to process.

Returns:

  • (BOOLEAN) 


46
47
48
 
# File 'lib/oci/generative_ai_inference/models/cohere_chat_request_v2.rb', line 46

def is_strict_tools_enabled
  @is_strict_tools_enabled
end

#max_tokens ⇒ Integer

The maximum number of output tokens that the model will generate for the response. The token count of your prompt plus maxTokens must not exceed the model's context length. For on-demand inferencing, the response length is capped at 4,000 tokens for each run.

Returns:

  • (Integer) 


73
74
75
 
# File 'lib/oci/generative_ai_inference/models/cohere_chat_request_v2.rb', line 73

def max_tokens
  @max_tokens
end

#messages ⇒ Array<OCI::GenerativeAiInference::Models::CohereMessageV2>

[Required] A list of chat messages in chronological order, representing a conversation between the user and the model.

Returns:



25
26
27
 
# File 'lib/oci/generative_ai_inference/models/cohere_chat_request_v2.rb', line 25

def messages
  @messages
end

#presence_penalty ⇒ Float

To reduce repetitiveness of generated tokens, this number penalizes new tokens based on whether they've appeared in the generated text so far. Greater numbers encourage the model to use new tokens, while lower numbers encourage the model to repeat the tokens.

Similar to frequency penalty, a penalty is applied to previously present tokens, except that this penalty is applied equally to all tokens that have already appeared, regardless of how many times they've appeared. Set to 0 to disable.

Returns:

  • (Float) 


105
106
107
 
# File 'lib/oci/generative_ai_inference/models/cohere_chat_request_v2.rb', line 105

def presence_penalty
  @presence_penalty
end

#priority ⇒ Integer

The priority of the request (lower means earlier handling; default 0 highest priority). Higher priority requests are handled first, and dropped last when the system is under load.

Returns:

  • (Integer) 


118
119
120
 
# File 'lib/oci/generative_ai_inference/models/cohere_chat_request_v2.rb', line 118

def priority
  @priority
end

#response_format ⇒ OCI::GenerativeAiInference::Models::CohereResponseFormat

Returns:



56
57
58
 
# File 'lib/oci/generative_ai_inference/models/cohere_chat_request_v2.rb', line 56

def response_format
  @response_format
end

#safety_mode ⇒ String

Safety mode: Adds a safety instruction for the model to use when generating responses. Contextual: (Default) Puts fewer constraints on the output. It maintains core protections by aiming to reject harmful or illegal suggestions, but it allows profanity and some toxic content, sexually explicit and violent content, and content that contains medical, financial, or legal information. Contextual mode is suited for entertainment, creative, or academic use. Strict: Aims to avoid sensitive topics, such as violent or sexual acts and profanity. This mode aims to provide a safer experience by prohibiting responses or recommendations that it finds inappropriate. Strict mode is suited for corporate use, such as for corporate communications and customer service. Off: No safety mode is applied. Note: This parameter is only compatible with models cohere.command-r-08-2024, cohere.command-r-plus-08-2024 and Cohere models released after these models. See release dates.

Returns:

  • (String) 


131
132
133
 
# File 'lib/oci/generative_ai_inference/models/cohere_chat_request_v2.rb', line 131

def safety_mode
  @safety_mode
end

#seed ⇒ Integer

If specified, the backend will make a best effort to sample tokens deterministically, so that repeated requests with the same seed and parameters yield the same result. However, determinism cannot be fully guaranteed.

Returns:

  • (Integer) 


110
111
112
 
# File 'lib/oci/generative_ai_inference/models/cohere_chat_request_v2.rb', line 110

def seed
  @seed
end

#stop_sequences ⇒ Array<String>

Stop the model generation when it reaches a stop sequence defined in this parameter.

Returns:

  • (Array<String>) 


114
115
116
 
# File 'lib/oci/generative_ai_inference/models/cohere_chat_request_v2.rb', line 114

def stop_sequences
  @stop_sequences
end

#stream_options ⇒ OCI::GenerativeAiInference::Models::StreamOptions

Returns:



64
65
66
 
# File 'lib/oci/generative_ai_inference/models/cohere_chat_request_v2.rb', line 64

def stream_options
  @stream_options
end

#temperature ⇒ Float

A number that sets the randomness of the generated output. A lower temperature means less random generations. Use lower numbers for tasks such as question answering or summarizing. High temperatures can generate hallucinations or factually incorrect information. Start with temperatures lower than 1.0 and increase the temperature for more creative outputs, as you regenerate the prompts to refine the outputs.

Returns:

  • (Float) 


79
80
81
 
# File 'lib/oci/generative_ai_inference/models/cohere_chat_request_v2.rb', line 79

def temperature
  @temperature
end

#thinking ⇒ OCI::GenerativeAiInference::Models::CohereThinkingV2

Returns:



53
54
55
 
# File 'lib/oci/generative_ai_inference/models/cohere_chat_request_v2.rb', line 53

def thinking
  @thinking
end

#tools ⇒ Array<OCI::GenerativeAiInference::Models::CohereToolV2>

A list of available tools (functions) that the model may suggest invoking before producing a text response.

Returns:



42
43
44
 
# File 'lib/oci/generative_ai_inference/models/cohere_chat_request_v2.rb', line 42

def tools
  @tools
end

#tools_choice ⇒ String

Used to control whether or not the model will be forced to use a tool when answering. When REQUIRED is specified, the model will be forced to use at least one of the user-defined tools, and the tools parameter must be passed in the request. When NONE is specified, the model will be forced not to use one of the specified tools, and give a direct response. If tool_choice isnu2019t specified, then the model is free to choose whether to use the specified tools or not. Note:This parameter is only compatible with models Command-r7b and newer.

Returns:

  • (String) 


38
39
40
 
# File 'lib/oci/generative_ai_inference/models/cohere_chat_request_v2.rb', line 38

def tools_choice
  @tools_choice
end

#top_k ⇒ Integer

A sampling method in which the model chooses the next token randomly from the top k most likely tokens. A higher value for k generates more random output, which makes the output text sound more natural. The default value for k is 0 which disables this method and considers all tokens. To set a number for the likely tokens, choose an integer between 1 and 500.

If also using top p, then the model considers only the top tokens whose probabilities add up to p percent and ignores the rest of the k tokens. For example, if k is 20 but only the probabilities of the top 10 add up to the value of p, then only the top 10 tokens are chosen.

Returns:

  • (Integer) 


86
87
88
 
# File 'lib/oci/generative_ai_inference/models/cohere_chat_request_v2.rb', line 86

def top_k
  @top_k
end

#top_p ⇒ Float

If set to a probability 0.0 < p < 1.0, it ensures that only the most likely tokens, with total probability mass of p, are considered for generation at each step.

To eliminate tokens with low likelihood, assign p a minimum percentage for the next token's likelihood. For example, when p is set to 0.75, the model eliminates the bottom 25 percent for the next token. Set to 1.0 to consider all tokens and set to 0 to disable. If both k and p are enabled, p acts after k.

Returns:

  • (Float) 


93
94
95
 
# File 'lib/oci/generative_ai_inference/models/cohere_chat_request_v2.rb', line 93

def top_p
  @top_p
end

Class Method Details

.attribute_map ⇒ Object

Attribute mapping from ruby-style variable name to JSON key.



134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
 
# File 'lib/oci/generative_ai_inference/models/cohere_chat_request_v2.rb', line 134

def self.attribute_map
  {
    # rubocop:disable Style/SymbolLiteral
    'api_format': :'apiFormat',
    'messages': :'messages',
    'documents': :'documents',
    'citation_options': :'citationOptions',
    'tools_choice': :'toolsChoice',
    'tools': :'tools',
    'is_strict_tools_enabled': :'isStrictToolsEnabled',
    'is_log_probs_enabled': :'isLogProbsEnabled',
    'thinking': :'thinking',
    'response_format': :'responseFormat',
    'is_search_queries_only': :'isSearchQueriesOnly',
    'stream_options': :'streamOptions',
    'is_stream': :'isStream',
    'max_tokens': :'maxTokens',
    'temperature': :'temperature',
    'top_k': :'topK',
    'top_p': :'topP',
    'frequency_penalty': :'frequencyPenalty',
    'presence_penalty': :'presencePenalty',
    'seed': :'seed',
    'stop_sequences': :'stopSequences',
    'priority': :'priority',
    'is_raw_prompting': :'isRawPrompting',
    'safety_mode': :'safetyMode'
    # rubocop:enable Style/SymbolLiteral
  }
end

.swagger_types ⇒ Object

Attribute type mapping.



166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
 
# File 'lib/oci/generative_ai_inference/models/cohere_chat_request_v2.rb', line 166

def self.swagger_types
  {
    # rubocop:disable Style/SymbolLiteral
    'api_format': :'String',
    'messages': :'Array<OCI::GenerativeAiInference::Models::CohereMessageV2>',
    'documents': :'Array<Object>',
    'citation_options': :'OCI::GenerativeAiInference::Models::CitationOptionsV2',
    'tools_choice': :'String',
    'tools': :'Array<OCI::GenerativeAiInference::Models::CohereToolV2>',
    'is_strict_tools_enabled': :'BOOLEAN',
    'is_log_probs_enabled': :'BOOLEAN',
    'thinking': :'OCI::GenerativeAiInference::Models::CohereThinkingV2',
    'response_format': :'OCI::GenerativeAiInference::Models::CohereResponseFormat',
    'is_search_queries_only': :'BOOLEAN',
    'stream_options': :'OCI::GenerativeAiInference::Models::StreamOptions',
    'is_stream': :'BOOLEAN',
    'max_tokens': :'Integer',
    'temperature': :'Float',
    'top_k': :'Integer',
    'top_p': :'Float',
    'frequency_penalty': :'Float',
    'presence_penalty': :'Float',
    'seed': :'Integer',
    'stop_sequences': :'Array<String>',
    'priority': :'Integer',
    'is_raw_prompting': :'BOOLEAN',
    'safety_mode': :'String'
    # rubocop:enable Style/SymbolLiteral
  }
end

Instance Method Details

#==(other) ⇒ Object

Checks equality by comparing each attribute.

Parameters:

  • other (Object) —

    the other object to be compared



389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
 
# File 'lib/oci/generative_ai_inference/models/cohere_chat_request_v2.rb', line 389

def ==(other)
  return true if equal?(other)

  self.class == other.class &&
    api_format == other.api_format &&
    messages == other.messages &&
    documents == other.documents &&
    citation_options == other.citation_options &&
    tools_choice == other.tools_choice &&
    tools == other.tools &&
    is_strict_tools_enabled == other.is_strict_tools_enabled &&
    is_log_probs_enabled == other.is_log_probs_enabled &&
    thinking == other.thinking &&
    response_format == other.response_format &&
    is_search_queries_only == other.is_search_queries_only &&
    stream_options == other.stream_options &&
    is_stream == other.is_stream &&
    max_tokens == other.max_tokens &&
    temperature == other.temperature &&
    top_k == other.top_k &&
    top_p == other.top_p &&
    frequency_penalty == other.frequency_penalty &&
    presence_penalty == other.presence_penalty &&
    seed == other.seed &&
    stop_sequences == other.stop_sequences &&
    priority == other.priority &&
    is_raw_prompting == other.is_raw_prompting &&
    safety_mode == other.safety_mode
end

#build_from_hash(attributes) ⇒ Object

Builds the object from hash

Parameters:

  • attributes (Hash) —

    Model attributes in the form of hash

Returns:

  • (Object) —

    Returns the model itself



442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
 
# File 'lib/oci/generative_ai_inference/models/cohere_chat_request_v2.rb', line 442

def build_from_hash(attributes)
  return nil unless attributes.is_a?(Hash)

  self.class.swagger_types.each_pair do |key, type|
    if type =~ /^Array<(.*)>/i
      # check to ensure the input is an array given that the the attribute
      # is documented as an array but the input is not
      if attributes[self.class.attribute_map[key]].is_a?(Array)
        public_method("#{key}=").call(
          attributes[self.class.attribute_map[key]]
            .map { |v| OCI::Internal::Util.convert_to_type(Regexp.last_match(1), v) }
        )
      end
    elsif !attributes[self.class.attribute_map[key]].nil?
      public_method("#{key}=").call(
        OCI::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]])
      )
    end
    # or else data not found in attributes(hash), not an issue as the data can be optional
  end

  self
end

#eql?(other) ⇒ Boolean

Parameters:

  • other (Object) —

    the other object to be compared

Returns:

  • (Boolean)

See Also:

  • `==` method


422
423
424
 
# File 'lib/oci/generative_ai_inference/models/cohere_chat_request_v2.rb', line 422

def eql?(other)
  self == other
end

#hash ⇒ Fixnum

Calculates hash code according to all attributes.

Returns:

  • (Fixnum) —

    Hash code



431
432
433
 
# File 'lib/oci/generative_ai_inference/models/cohere_chat_request_v2.rb', line 431

def hash
  [api_format, messages, documents, citation_options, tools_choice, tools, is_strict_tools_enabled, is_log_probs_enabled, thinking, response_format, is_search_queries_only, stream_options, is_stream, max_tokens, temperature, top_k, top_p, frequency_penalty, presence_penalty, seed, stop_sequences, priority, is_raw_prompting, safety_mode].hash
end

#to_hash ⇒ Hash

Returns the object in the form of hash

Returns:

  • (Hash) —

    Returns the object in the form of hash



475
476
477
478
479
480
481
482
483
484
 
# File 'lib/oci/generative_ai_inference/models/cohere_chat_request_v2.rb', line 475

def to_hash
  hash = {}
  self.class.attribute_map.each_pair do |attr, param|
    value = public_method(attr).call
    next if value.nil? && !instance_variable_defined?("@#{attr}")

    hash[param] = _to_hash(value)
  end
  hash
end

#to_s ⇒ String

Returns the string representation of the object

Returns:

  • (String) —

    String presentation of the object



469
470
471
 
# File 'lib/oci/generative_ai_inference/models/cohere_chat_request_v2.rb', line 469

def to_s
  to_hash.to_s
end