GitVita
New repositoryImport repositoryNew issue
Your repositories Your dashboard Sign in

openai/openai-dotnet

Public

mirrored from https://github.com/openai/openai-dotnetAvailable

Watch0Fork0Star0
CodeCommitsIssuesPull requestsActionsInsightsSecurity
OpenAI_2.0.0-beta.1

Branches

Tags

  • No tags available.
0Branches0Tags
Go to file
Add file
Code

Clone

HTTPS

Download ZIP

openai-dotnet/api

api/api.md

1602lines · modecode

RawDownload
Latest commit unavailable.
1```csharp
2namespace OpenAI {
3 public class OpenAIClient {
4 public OpenAIClient(ApiKeyCredential credential, OpenAIClientOptions options = null);
5 public OpenAIClient(OpenAIClientOptions options = null);
6 protected OpenAIClient(ClientPipeline pipeline, Uri endpoint, OpenAIClientOptions options);
7 protected OpenAIClient();
8 public virtual ClientPipeline Pipeline { get; }
9 protected Uri Endpoint { get; }
10 internal [Experimental("OPENAI001")]
11 public virtual AssistantClient GetAssistantClient();
12 public virtual AudioClient GetAudioClient(string model);
13 public virtual BatchClient GetBatchClient();
14 public virtual ChatClient GetChatClient(string model);
15 public virtual EmbeddingClient GetEmbeddingClient(string model);
16 public virtual FileClient GetFileClient();
17 public virtual FineTuningClient GetFineTuningClient();
18 public virtual ImageClient GetImageClient(string model);
19 public virtual ModelClient GetModelClient();
20 public virtual ModerationClient GetModerationClient(string model);
21 internal [Experimental("OPENAI001")]
22 public virtual VectorStoreClient GetVectorStoreClient();
23 }
24 public class OpenAIClientOptions : ClientPipelineOptions {
25 public OpenAIClientOptions();
26 public string ApplicationId { get; init; }
27 public Uri Endpoint { get; init; }
28 }
29 public readonly struct ListOrder : IEquatable<ListOrder> {
30 public ListOrder(string value);
31 public static ListOrder NewestFirst { get; }
32 public static ListOrder OldestFirst { get; }
33 public static bool operator ==(ListOrder left, ListOrder right);
34 public static implicit operator ListOrder(string value);
35 public static bool operator !=(ListOrder left, ListOrder right);
36 public bool Equals(ListOrder other);
37 public override bool Equals(object obj);
38 public override int GetHashCode();
39 public override string ToString();
40 }
41}
42namespace OpenAI.Assistants {
43 internal [Experimental("OPENAI001")]
44 public class AssistantClient {
45 public AssistantClient(ApiKeyCredential credential, OpenAIClientOptions options = null);
46 public AssistantClient(OpenAIClientOptions options = null);
47 protected AssistantClient(ClientPipeline pipeline, Uri endpoint, OpenAIClientOptions options);
48 protected AssistantClient();
49 public virtual ClientPipeline Pipeline { get; }
50 public virtual ClientResult<ThreadRun> CancelRun(ThreadRun run);
51 public virtual ClientResult<ThreadRun> CancelRun(string threadId, string runId);
52 public virtual ClientResult CancelRun(string threadId, string runId, RequestOptions options);
53 public virtual Task<ClientResult<ThreadRun>> CancelRunAsync(ThreadRun run);
54 public virtual Task<ClientResult<ThreadRun>> CancelRunAsync(string threadId, string runId);
55 public virtual Task<ClientResult> CancelRunAsync(string threadId, string runId, RequestOptions options);
56 public virtual ClientResult<Assistant> CreateAssistant(string model, AssistantCreationOptions options = null);
57 public virtual ClientResult CreateAssistant(BinaryContent content, RequestOptions options = null);
58 public virtual Task<ClientResult<Assistant>> CreateAssistantAsync(string model, AssistantCreationOptions options = null);
59 public virtual Task<ClientResult> CreateAssistantAsync(BinaryContent content, RequestOptions options = null);
60 public virtual ClientResult<ThreadMessage> CreateMessage(AssistantThread thread, IEnumerable<MessageContent> content, MessageCreationOptions options = null);
61 public virtual ClientResult<ThreadMessage> CreateMessage(string threadId, IEnumerable<MessageContent> content, MessageCreationOptions options = null);
62 public virtual ClientResult CreateMessage(string threadId, BinaryContent content, RequestOptions options = null);
63 public virtual Task<ClientResult<ThreadMessage>> CreateMessageAsync(AssistantThread thread, IEnumerable<MessageContent> content, MessageCreationOptions options = null);
64 public virtual Task<ClientResult<ThreadMessage>> CreateMessageAsync(string threadId, IEnumerable<MessageContent> content, MessageCreationOptions options = null);
65 public virtual Task<ClientResult> CreateMessageAsync(string threadId, BinaryContent content, RequestOptions options = null);
66 public virtual ClientResult<ThreadRun> CreateRun(AssistantThread thread, Assistant assistant, RunCreationOptions options = null);
67 public virtual ClientResult<ThreadRun> CreateRun(string threadId, string assistantId, RunCreationOptions options = null);
68 public virtual ClientResult CreateRun(string threadId, BinaryContent content, RequestOptions options = null);
69 public virtual Task<ClientResult<ThreadRun>> CreateRunAsync(AssistantThread thread, Assistant assistant, RunCreationOptions options = null);
70 public virtual Task<ClientResult<ThreadRun>> CreateRunAsync(string threadId, string assistantId, RunCreationOptions options = null);
71 public virtual Task<ClientResult> CreateRunAsync(string threadId, BinaryContent content, RequestOptions options = null);
72 public virtual ResultCollection<StreamingUpdate> CreateRunStreaming(AssistantThread thread, Assistant assistant, RunCreationOptions options = null);
73 public virtual ResultCollection<StreamingUpdate> CreateRunStreaming(string threadId, string assistantId, RunCreationOptions options = null);
74 public virtual AsyncResultCollection<StreamingUpdate> CreateRunStreamingAsync(AssistantThread thread, Assistant assistant, RunCreationOptions options = null);
75 public virtual AsyncResultCollection<StreamingUpdate> CreateRunStreamingAsync(string threadId, string assistantId, RunCreationOptions options = null);
76 public virtual ClientResult<AssistantThread> CreateThread(ThreadCreationOptions options = null);
77 public virtual ClientResult CreateThread(BinaryContent content, RequestOptions options = null);
78 public virtual ClientResult<ThreadRun> CreateThreadAndRun(Assistant assistant, ThreadCreationOptions threadOptions = null, RunCreationOptions runOptions = null);
79 public virtual ClientResult<ThreadRun> CreateThreadAndRun(string assistantId, ThreadCreationOptions threadOptions = null, RunCreationOptions runOptions = null);
80 public virtual ClientResult CreateThreadAndRun(BinaryContent content, RequestOptions options = null);
81 public virtual Task<ClientResult<ThreadRun>> CreateThreadAndRunAsync(Assistant assistant, ThreadCreationOptions threadOptions = null, RunCreationOptions runOptions = null);
82 public virtual Task<ClientResult<ThreadRun>> CreateThreadAndRunAsync(string assistantId, ThreadCreationOptions threadOptions = null, RunCreationOptions runOptions = null);
83 public virtual Task<ClientResult> CreateThreadAndRunAsync(BinaryContent content, RequestOptions options = null);
84 public virtual ResultCollection<StreamingUpdate> CreateThreadAndRunStreaming(Assistant assistant, ThreadCreationOptions threadOptions = null, RunCreationOptions runOptions = null);
85 public virtual ResultCollection<StreamingUpdate> CreateThreadAndRunStreaming(string assistantId, ThreadCreationOptions threadOptions = null, RunCreationOptions runOptions = null);
86 public virtual AsyncResultCollection<StreamingUpdate> CreateThreadAndRunStreamingAsync(Assistant assistant, ThreadCreationOptions threadOptions = null, RunCreationOptions runOptions = null);
87 public virtual AsyncResultCollection<StreamingUpdate> CreateThreadAndRunStreamingAsync(string assistantId, ThreadCreationOptions threadOptions = null, RunCreationOptions runOptions = null);
88 public virtual Task<ClientResult<AssistantThread>> CreateThreadAsync(ThreadCreationOptions options = null);
89 public virtual Task<ClientResult> CreateThreadAsync(BinaryContent content, RequestOptions options = null);
90 public virtual ClientResult<bool> DeleteAssistant(Assistant assistant);
91 public virtual ClientResult<bool> DeleteAssistant(string assistantId);
92 public virtual ClientResult DeleteAssistant(string assistantId, RequestOptions options);
93 public virtual Task<ClientResult<bool>> DeleteAssistantAsync(Assistant assistant);
94 public virtual Task<ClientResult<bool>> DeleteAssistantAsync(string assistantId);
95 public virtual Task<ClientResult> DeleteAssistantAsync(string assistantId, RequestOptions options);
96 public virtual ClientResult<bool> DeleteMessage(ThreadMessage message);
97 public virtual ClientResult<bool> DeleteMessage(string threadId, string messageId);
98 public virtual ClientResult DeleteMessage(string threadId, string messageId, RequestOptions options);
99 public virtual Task<ClientResult<bool>> DeleteMessageAsync(ThreadMessage message);
100 public virtual Task<ClientResult<bool>> DeleteMessageAsync(string threadId, string messageId);
101 public virtual Task<ClientResult> DeleteMessageAsync(string threadId, string messageId, RequestOptions options);
102 public virtual ClientResult<bool> DeleteThread(AssistantThread thread);
103 public virtual ClientResult<bool> DeleteThread(string threadId);
104 public virtual ClientResult DeleteThread(string threadId, RequestOptions options);
105 public virtual Task<ClientResult<bool>> DeleteThreadAsync(AssistantThread thread);
106 public virtual Task<ClientResult<bool>> DeleteThreadAsync(string threadId);
107 public virtual Task<ClientResult> DeleteThreadAsync(string threadId, RequestOptions options);
108 public virtual ClientResult GetAssistant(string assistantId, RequestOptions options);
109 public virtual ClientResult<Assistant> GetAssistant(string assistantId);
110 public virtual Task<ClientResult> GetAssistantAsync(string assistantId, RequestOptions options);
111 public virtual Task<ClientResult<Assistant>> GetAssistantAsync(string assistantId);
112 public virtual PageableCollection<Assistant> GetAssistants(ListOrder? resultOrder = null);
113 public virtual ClientResult GetAssistants(int? limit, string order, string after, string before, RequestOptions options);
114 public virtual AsyncPageableCollection<Assistant> GetAssistantsAsync(ListOrder? resultOrder = null);
115 public virtual Task<ClientResult> GetAssistantsAsync(int? limit, string order, string after, string before, RequestOptions options);
116 public virtual ClientResult<ThreadMessage> GetMessage(ThreadMessage message);
117 public virtual ClientResult<ThreadMessage> GetMessage(string threadId, string messageId);
118 public virtual ClientResult GetMessage(string threadId, string messageId, RequestOptions options);
119 public virtual Task<ClientResult<ThreadMessage>> GetMessageAsync(ThreadMessage message);
120 public virtual Task<ClientResult<ThreadMessage>> GetMessageAsync(string threadId, string messageId);
121 public virtual Task<ClientResult> GetMessageAsync(string threadId, string messageId, RequestOptions options);
122 public virtual PageableCollection<ThreadMessage> GetMessages(AssistantThread thread, ListOrder? resultOrder = null);
123 public virtual PageableCollection<ThreadMessage> GetMessages(string threadId, ListOrder? resultOrder = null);
124 public virtual ClientResult GetMessages(string threadId, int? limit, string order, string after, string before, RequestOptions options);
125 public virtual AsyncPageableCollection<ThreadMessage> GetMessagesAsync(AssistantThread thread, ListOrder? resultOrder = null);
126 public virtual AsyncPageableCollection<ThreadMessage> GetMessagesAsync(string threadId, ListOrder? resultOrder = null);
127 public virtual Task<ClientResult> GetMessagesAsync(string threadId, int? limit, string order, string after, string before, RequestOptions options);
128 public virtual ClientResult<ThreadRun> GetRun(ThreadRun run);
129 public virtual ClientResult<ThreadRun> GetRun(string threadId, string runId);
130 public virtual ClientResult GetRun(string threadId, string runId, RequestOptions options);
131 public virtual Task<ClientResult<ThreadRun>> GetRunAsync(ThreadRun run);
132 public virtual Task<ClientResult<ThreadRun>> GetRunAsync(string threadId, string runId);
133 public virtual Task<ClientResult> GetRunAsync(string threadId, string runId, RequestOptions options);
134 public virtual PageableCollection<ThreadRun> GetRuns(AssistantThread thread, ListOrder? resultOrder = null);
135 public virtual PageableCollection<ThreadRun> GetRuns(string threadId, ListOrder? resultOrder = null);
136 public virtual ClientResult GetRuns(string threadId, int? limit, string order, string after, string before, RequestOptions options);
137 public virtual AsyncPageableCollection<ThreadRun> GetRunsAsync(AssistantThread thread, ListOrder? resultOrder = null);
138 public virtual AsyncPageableCollection<ThreadRun> GetRunsAsync(string threadId, ListOrder? resultOrder = null);
139 public virtual Task<ClientResult> GetRunsAsync(string threadId, int? limit, string order, string after, string before, RequestOptions options);
140 public virtual ClientResult<RunStep> GetRunStep(string threadId, string runId, string stepId);
141 public virtual ClientResult GetRunStep(string threadId, string runId, string stepId, RequestOptions options);
142 public virtual Task<ClientResult<RunStep>> GetRunStepAsync(string threadId, string runId, string stepId);
143 public virtual Task<ClientResult> GetRunStepAsync(string threadId, string runId, string stepId, RequestOptions options);
144 public virtual PageableCollection<RunStep> GetRunSteps(ThreadRun run, ListOrder? resultOrder = null);
145 public virtual PageableCollection<RunStep> GetRunSteps(string threadId, string runId, ListOrder? resultOrder = null);
146 public virtual ClientResult GetRunSteps(string threadId, string runId, int? limit, string order, string after, string before, RequestOptions options);
147 public virtual AsyncPageableCollection<RunStep> GetRunStepsAsync(ThreadRun run, ListOrder? resultOrder = null);
148 public virtual AsyncPageableCollection<RunStep> GetRunStepsAsync(string threadId, string runId, ListOrder? resultOrder = null);
149 public virtual Task<ClientResult> GetRunStepsAsync(string threadId, string runId, int? limit, string order, string after, string before, RequestOptions options);
150 public virtual ClientResult<AssistantThread> GetThread(AssistantThread thread);
151 public virtual ClientResult<AssistantThread> GetThread(string threadId);
152 public virtual ClientResult GetThread(string threadId, RequestOptions options);
153 public virtual Task<ClientResult<AssistantThread>> GetThreadAsync(AssistantThread thread);
154 public virtual Task<ClientResult<AssistantThread>> GetThreadAsync(string threadId);
155 public virtual Task<ClientResult> GetThreadAsync(string threadId, RequestOptions options);
156 public virtual ClientResult<Assistant> ModifyAssistant(Assistant assistant, AssistantModificationOptions options);
157 public virtual ClientResult ModifyAssistant(string assistantId, BinaryContent content, RequestOptions options = null);
158 public virtual ClientResult<Assistant> ModifyAssistant(string assistantId, AssistantModificationOptions assistant);
159 public virtual Task<ClientResult<Assistant>> ModifyAssistantAsync(Assistant assistant, AssistantModificationOptions options);
160 public virtual Task<ClientResult> ModifyAssistantAsync(string assistantId, BinaryContent content, RequestOptions options = null);
161 public virtual Task<ClientResult<Assistant>> ModifyAssistantAsync(string assistantId, AssistantModificationOptions assistant);
162 public virtual ClientResult<ThreadMessage> ModifyMessage(ThreadMessage message, MessageModificationOptions options);
163 public virtual ClientResult<ThreadMessage> ModifyMessage(string threadId, string messageId, MessageModificationOptions options);
164 public virtual ClientResult ModifyMessage(string threadId, string messageId, BinaryContent content, RequestOptions options = null);
165 public virtual Task<ClientResult<ThreadMessage>> ModifyMessageAsync(ThreadMessage message, MessageModificationOptions options);
166 public virtual Task<ClientResult<ThreadMessage>> ModifyMessageAsync(string threadId, string messageId, MessageModificationOptions options);
167 public virtual Task<ClientResult> ModifyMessageAsync(string threadId, string messageId, BinaryContent content, RequestOptions options = null);
168 public virtual ClientResult ModifyRun(string threadId, string runId, BinaryContent content, RequestOptions options = null);
169 public virtual Task<ClientResult> ModifyRunAsync(string threadId, string runId, BinaryContent content, RequestOptions options = null);
170 public virtual ClientResult<AssistantThread> ModifyThread(AssistantThread thread, ThreadModificationOptions options);
171 public virtual ClientResult<AssistantThread> ModifyThread(string threadId, ThreadModificationOptions options);
172 public virtual ClientResult ModifyThread(string threadId, BinaryContent content, RequestOptions options = null);
173 public virtual Task<ClientResult<AssistantThread>> ModifyThreadAsync(AssistantThread thread, ThreadModificationOptions options);
174 public virtual Task<ClientResult<AssistantThread>> ModifyThreadAsync(string threadId, ThreadModificationOptions options);
175 public virtual Task<ClientResult> ModifyThreadAsync(string threadId, BinaryContent content, RequestOptions options = null);
176 public virtual ClientResult<ThreadRun> SubmitToolOutputsToRun(ThreadRun run, IEnumerable<ToolOutput> toolOutputs);
177 public virtual ClientResult<ThreadRun> SubmitToolOutputsToRun(string threadId, string runId, IEnumerable<ToolOutput> toolOutputs);
178 public virtual ClientResult SubmitToolOutputsToRun(string threadId, string runId, BinaryContent content, RequestOptions options = null);
179 public virtual Task<ClientResult<ThreadRun>> SubmitToolOutputsToRunAsync(ThreadRun run, IEnumerable<ToolOutput> toolOutputs);
180 public virtual Task<ClientResult<ThreadRun>> SubmitToolOutputsToRunAsync(string threadId, string runId, IEnumerable<ToolOutput> toolOutputs);
181 public virtual Task<ClientResult> SubmitToolOutputsToRunAsync(string threadId, string runId, BinaryContent content, RequestOptions options = null);
182 public virtual ResultCollection<StreamingUpdate> SubmitToolOutputsToRunStreaming(ThreadRun run, IEnumerable<ToolOutput> toolOutputs);
183 public virtual ResultCollection<StreamingUpdate> SubmitToolOutputsToRunStreaming(string threadId, string runId, IEnumerable<ToolOutput> toolOutputs);
184 public virtual AsyncResultCollection<StreamingUpdate> SubmitToolOutputsToRunStreamingAsync(ThreadRun run, IEnumerable<ToolOutput> toolOutputs);
185 public virtual AsyncResultCollection<StreamingUpdate> SubmitToolOutputsToRunStreamingAsync(string threadId, string runId, IEnumerable<ToolOutput> toolOutputs);
186 }
187 public class AssistantCreationOptions {
188 public AssistantCreationOptions();
189 public string Description { get; init; }
190 public string Instructions { get; init; }
191 public IDictionary<string, string> Metadata { get; }
192 public string Name { get; init; }
193 public float? NucleusSamplingFactor { get; init; }
194 public AssistantResponseFormat ResponseFormat { get; init; }
195 public float? Temperature { get; init; }
196 public ToolResources ToolResources { get; init; }
197 public IList<ToolDefinition> Tools { get; }
198 }
199 public class AssistantModificationOptions {
200 public AssistantModificationOptions();
201 public IList<ToolDefinition> DefaultTools { get; init; }
202 public string Description { get; init; }
203 public string Instructions { get; init; }
204 public IDictionary<string, string> Metadata { get; }
205 public string Model { get; init; }
206 public string Name { get; init; }
207 public float? NucleusSamplingFactor { get; init; }
208 public AssistantResponseFormat ResponseFormat { get; init; }
209 public float? Temperature { get; init; }
210 public ToolResources ToolResources { get; init; }
211 }
212 public class MessageCreationOptions {
213 public MessageCreationOptions();
214 public IList<MessageCreationAttachment> Attachments { get; }
215 public IDictionary<string, string> Metadata { get; }
216 public MessageRole Role { get; }
217 }
218 public class MessageModificationOptions {
219 public MessageModificationOptions();
220 public IDictionary<string, string> Metadata { get; }
221 }
222 public class RunCreationOptions {
223 public RunCreationOptions();
224 public string AdditionalInstructions { get; init; }
225 public IList<ThreadInitializationMessage> AdditionalMessages { get; }
226 public string InstructionsOverride { get; init; }
227 public int? MaxCompletionTokens { get; init; }
228 public int? MaxPromptTokens { get; init; }
229 public IDictionary<string, string> Metadata { get; }
230 public string ModelOverride { get; init; }
231 public float? NucleusSamplingFactor { get; init; }
232 public AssistantResponseFormat ResponseFormat { get; init; }
233 public float? Temperature { get; init; }
234 public ToolConstraint ToolConstraint { get; init; }
235 public IList<ToolDefinition> ToolsOverride { get; }
236 public RunTruncationStrategy TruncationStrategy { get; init; }
237 }
238 public class RunModificationOptions {
239 public RunModificationOptions();
240 public IDictionary<string, string> Metadata { get; }
241 }
242 public class ThreadCreationOptions {
243 public ThreadCreationOptions();
244 public IList<ThreadInitializationMessage> InitialMessages { get; }
245 public IDictionary<string, string> Metadata { get; }
246 public ToolResources ToolResources { get; init; }
247 }
248 public class ThreadModificationOptions {
249 public ThreadModificationOptions();
250 public IDictionary<string, string> Metadata { get; }
251 public ToolResources ToolResources { get; init; }
252 }
253 public class Assistant {
254 public DateTimeOffset CreatedAt { get; }
255 public string Description { get; }
256 public string Id { get; }
257 public string Instructions { get; }
258 public IReadOnlyDictionary<string, string> Metadata { get; }
259 public string Model { get; }
260 public string Name { get; }
261 public float? NucleusSamplingFactor { get; }
262 public AssistantResponseFormat ResponseFormat { get; }
263 public float? Temperature { get; }
264 public ToolResources ToolResources { get; }
265 public IReadOnlyList<ToolDefinition> Tools { get; }
266 }
267 public class AssistantResponseFormat {
268 protected AssistantResponseFormat();
269 public static AssistantResponseFormat Auto { get; }
270 public static AssistantResponseFormat JsonObject { get; }
271 public static AssistantResponseFormat Text { get; }
272 public static bool operator ==(AssistantResponseFormat left, AssistantResponseFormat right);
273 public static implicit operator AssistantResponseFormat(string value);
274 public static bool operator !=(AssistantResponseFormat left, AssistantResponseFormat right);
275 public bool Equals(AssistantResponseFormat other);
276 public override bool Equals(object obj);
277 public override int GetHashCode();
278 public override string ToString();
279 }
280 public class AssistantThread {
281 public DateTimeOffset CreatedAt { get; }
282 public string Id { get; }
283 public IReadOnlyDictionary<string, string> Metadata { get; }
284 public ToolResources ToolResources { get; }
285 }
286 public class CodeInterpreterToolDefinition : ToolDefinition {
287 public CodeInterpreterToolDefinition();
288 }
289 public class CodeInterpreterToolResources {
290 public CodeInterpreterToolResources();
291 public IList<string> FileIds { get; init; }
292 }
293 public class FileSearchToolDefinition : ToolDefinition {
294 public FileSearchToolDefinition();
295 }
296 public class FileSearchToolResources {
297 public FileSearchToolResources();
298 public IList<VectorStoreCreationHelper> NewVectorStores { get; }
299 public IList<string> VectorStoreIds { get; init; }
300 }
301 public class FunctionToolDefinition : ToolDefinition {
302 internal [SetsRequiredMembers]
303 public FunctionToolDefinition(string name, string description = null, BinaryData parameters = null);
304 public FunctionToolDefinition();
305 public string Description { get; init; }
306 public required string FunctionName { get; init; }
307 public BinaryData Parameters { get; init; }
308 }
309 public abstract class MessageContent {
310 protected MessageContent();
311 public MessageImageDetail? ImageDetail { get; }
312 public string ImageFileId { get; }
313 public Uri ImageUrl { get; }
314 public string Text { get; }
315 public IReadOnlyList<TextAnnotation> TextAnnotations { get; }
316 public static MessageContent FromImageFileId(string imageFileId, MessageImageDetail? detail = null);
317 public static MessageContent FromImageUrl(Uri imageUri, MessageImageDetail? detail = null);
318 public static MessageContent FromText(string text);
319 public static implicit operator MessageContent(string value);
320 }
321 public class MessageContentUpdate : StreamingUpdate {
322 public MessageImageDetail? ImageDetail { get; }
323 public string ImageFileId { get; }
324 public string MessageId { get; }
325 public int MessageIndex { get; }
326 public MessageRole? Role { get; }
327 public string Text { get; }
328 public TextAnnotationUpdate TextAnnotation { get; }
329 }
330 public class MessageCreationAttachment {
331 public MessageCreationAttachment(string fileId, IEnumerable<ToolDefinition> tools);
332 public string FileId { get; }
333 public IReadOnlyList<ToolDefinition> Tools { get; }
334 }
335 public class MessageFailureDetails {
336 public MessageFailureReason Reason { get; }
337 }
338 public readonly struct MessageFailureReason : IEquatable<MessageFailureReason> {
339 public MessageFailureReason(string value);
340 public static MessageFailureReason ContentFilter { get; }
341 public static MessageFailureReason MaxTokens { get; }
342 public static MessageFailureReason RunCancelled { get; }
343 public static MessageFailureReason RunExpired { get; }
344 public static MessageFailureReason RunFailed { get; }
345 public static bool operator ==(MessageFailureReason left, MessageFailureReason right);
346 public static implicit operator MessageFailureReason(string value);
347 public static bool operator !=(MessageFailureReason left, MessageFailureReason right);
348 public bool Equals(MessageFailureReason other);
349 public override bool Equals(object obj);
350 public override int GetHashCode();
351 public override string ToString();
352 }
353 public readonly struct MessageStatus : IEquatable<MessageStatus> {
354 public MessageStatus(string value);
355 public static MessageStatus Completed { get; }
356 public static MessageStatus Incomplete { get; }
357 public static MessageStatus InProgress { get; }
358 public static bool operator ==(MessageStatus left, MessageStatus right);
359 public static implicit operator MessageStatus(string value);
360 public static bool operator !=(MessageStatus left, MessageStatus right);
361 public bool Equals(MessageStatus other);
362 public override bool Equals(object obj);
363 public override int GetHashCode();
364 public override string ToString();
365 }
366 public class MessageStatusUpdate : StreamingUpdate<ThreadMessage> {
367 }
368 public class MessageTextContentAnnotation {
369 public int EndIndex { get; }
370 public string InputFileId { get; }
371 public string InputQuote { get; }
372 public string OutputFileId { get; }
373 public int StartIndex { get; }
374 public string TextToReplace { get; }
375 }
376 public abstract class RequiredAction {
377 protected RequiredAction();
378 public string FunctionArguments { get; }
379 public string FunctionName { get; }
380 public string ToolCallId { get; }
381 }
382 public class RequiredActionUpdate : StreamingUpdate {
383 public string FunctionArguments { get; }
384 public string FunctionName { get; }
385 public string ToolCallId { get; }
386 public ThreadRun GetThreadRun();
387 }
388 public class RunError {
389 public RunErrorCode Code { get; }
390 public string Message { get; }
391 }
392 public readonly struct RunErrorCode : IEquatable<RunErrorCode> {
393 public RunErrorCode(string value);
394 public static RunErrorCode InvalidPrompt { get; }
395 public static RunErrorCode RateLimitExceeded { get; }
396 public static RunErrorCode ServerError { get; }
397 public static bool operator ==(RunErrorCode left, RunErrorCode right);
398 public static implicit operator RunErrorCode(string value);
399 public static bool operator !=(RunErrorCode left, RunErrorCode right);
400 public bool Equals(RunErrorCode other);
401 public override bool Equals(object obj);
402 public override int GetHashCode();
403 public override string ToString();
404 }
405 public class RunIncompleteDetails {
406 public RunIncompleteReason? Reason { get; }
407 }
408 public readonly struct RunIncompleteReason : IEquatable<RunIncompleteReason> {
409 public RunIncompleteReason(string value);
410 public static RunIncompleteReason MaxCompletionTokens { get; }
411 public static RunIncompleteReason MaxPromptTokens { get; }
412 public static bool operator ==(RunIncompleteReason left, RunIncompleteReason right);
413 public static implicit operator RunIncompleteReason(string value);
414 public static bool operator !=(RunIncompleteReason left, RunIncompleteReason right);
415 public bool Equals(RunIncompleteReason other);
416 public override bool Equals(object obj);
417 public override int GetHashCode();
418 public override string ToString();
419 }
420 public readonly struct RunStatus : IEquatable<RunStatus> {
421 public RunStatus(string value);
422 public static RunStatus Cancelled { get; }
423 public static RunStatus Cancelling { get; }
424 public static RunStatus Completed { get; }
425 public static RunStatus Expired { get; }
426 public static RunStatus Failed { get; }
427 public static RunStatus Incomplete { get; }
428 public static RunStatus InProgress { get; }
429 public bool IsTerminal { get; }
430 public static RunStatus Queued { get; }
431 public static RunStatus RequiresAction { get; }
432 public static bool operator ==(RunStatus left, RunStatus right);
433 public static implicit operator RunStatus(string value);
434 public static bool operator !=(RunStatus left, RunStatus right);
435 public bool Equals(RunStatus other);
436 public override bool Equals(object obj);
437 public override int GetHashCode();
438 public override string ToString();
439 }
440 public class RunStep {
441 public string AssistantId { get; }
442 public DateTimeOffset? CancelledAt { get; }
443 public DateTimeOffset? CompletedAt { get; }
444 public DateTimeOffset CreatedAt { get; }
445 public RunStepDetails Details { get; }
446 public DateTimeOffset? ExpiredAt { get; }
447 public DateTimeOffset? FailedAt { get; }
448 public string Id { get; }
449 public RunStepError LastError { get; }
450 public IReadOnlyDictionary<string, string> Metadata { get; }
451 public string RunId { get; }
452 public RunStepStatus Status { get; }
453 public string ThreadId { get; }
454 public RunStepType Type { get; }
455 public RunStepTokenUsage Usage { get; }
456 }
457 public abstract class RunStepCodeInterpreterOutput {
458 protected RunStepCodeInterpreterOutput();
459 public string ImageFileId { get; }
460 public string Logs { get; }
461 }
462 public abstract class RunStepDetails {
463 protected RunStepDetails();
464 public string CreatedMessageId { get; }
465 public IReadOnlyList<RunStepToolCall> ToolCalls { get; }
466 }
467 public class RunStepDetailsUpdate : StreamingUpdate {
468 public string CodeInterpreterInput { get; }
469 public IReadOnlyList<RunStepUpdateCodeInterpreterOutput> CodeInterpreterOutputs { get; }
470 public string CreatedMessageId { get; }
471 public string FunctionArguments { get; }
472 public string FunctionName { get; }
473 public string FunctionOutput { get; }
474 public string StepId { get; }
475 public string ToolCallId { get; }
476 public int? ToolCallIndex { get; }
477 }
478 public class RunStepError {
479 public RunStepErrorCode Code { get; }
480 public string Message { get; }
481 }
482 public readonly struct RunStepErrorCode : IEquatable<RunStepErrorCode> {
483 public RunStepErrorCode(string value);
484 public static RunStepErrorCode RateLimitExceeded { get; }
485 public static RunStepErrorCode ServerError { get; }
486 public static bool operator ==(RunStepErrorCode left, RunStepErrorCode right);
487 public static implicit operator RunStepErrorCode(string value);
488 public static bool operator !=(RunStepErrorCode left, RunStepErrorCode right);
489 public bool Equals(RunStepErrorCode other);
490 public override bool Equals(object obj);
491 public override int GetHashCode();
492 public override string ToString();
493 }
494 public readonly struct RunStepStatus : IEquatable<RunStepStatus> {
495 public RunStepStatus(string value);
496 public static RunStepStatus Cancelled { get; }
497 public static RunStepStatus Completed { get; }
498 public static RunStepStatus Expired { get; }
499 public static RunStepStatus Failed { get; }
500 public static RunStepStatus InProgress { get; }
501 public static bool operator ==(RunStepStatus left, RunStepStatus right);
502 public static implicit operator RunStepStatus(string value);
503 public static bool operator !=(RunStepStatus left, RunStepStatus right);
504 public bool Equals(RunStepStatus other);
505 public override bool Equals(object obj);
506 public override int GetHashCode();
507 public override string ToString();
508 }
509 public class RunStepTokenUsage {
510 public int CompletionTokens { get; }
511 public int PromptTokens { get; }
512 public int TotalTokens { get; }
513 }
514 public abstract class RunStepToolCall {
515 protected RunStepToolCall();
516 public string CodeInterpreterInput { get; }
517 public IReadOnlyList<RunStepCodeInterpreterOutput> CodeInterpreterOutputs { get; }
518 public string FunctionArguments { get; }
519 public string FunctionName { get; }
520 public string FunctionOutput { get; }
521 public string ToolCallId { get; }
522 public RunStepToolCallKind ToolKind { get; }
523 }
524 public readonly struct RunStepType : IEquatable<RunStepType> {
525 public RunStepType(string value);
526 public static RunStepType MessageCreation { get; }
527 public static RunStepType ToolCalls { get; }
528 public static bool operator ==(RunStepType left, RunStepType right);
529 public static implicit operator RunStepType(string value);
530 public static bool operator !=(RunStepType left, RunStepType right);
531 public bool Equals(RunStepType other);
532 public override bool Equals(object obj);
533 public override int GetHashCode();
534 public override string ToString();
535 }
536 public class RunStepUpdate : StreamingUpdate<RunStep> {
537 }
538 public abstract class RunStepUpdateCodeInterpreterOutput {
539 protected RunStepUpdateCodeInterpreterOutput();
540 public string ImageFileId { get; }
541 public string Logs { get; }
542 public int OutputIndex { get; }
543 }
544 public class RunTokenUsage {
545 public int CompletionTokens { get; }
546 public int PromptTokens { get; }
547 public int TotalTokens { get; }
548 }
549 public class RunTruncationStrategy {
550 public static RunTruncationStrategy Auto { get; }
551 public int? LastMessages { get; }
552 public static RunTruncationStrategy CreateLastMessagesStrategy(int lastMessageCount);
553 }
554 public class RunUpdate : StreamingUpdate<ThreadRun> {
555 }
556 public abstract class StreamingUpdate {
557 public StreamingUpdateReason UpdateKind { get; }
558 }
559 public class StreamingUpdate<T> where T : class : StreamingUpdate {
560 public T Value { get; }
561 public static implicit operator T(StreamingUpdate<T> update);
562 }
563 public class TextAnnotation {
564 public int EndIndex { get; }
565 public string InputFileId { get; }
566 public string InputQuote { get; }
567 public string OutputFileId { get; }
568 public int StartIndex { get; }
569 public string TextToReplace { get; }
570 }
571 public class TextAnnotationUpdate {
572 public int ContentIndex { get; }
573 public int? EndIndex { get; }
574 public string InputFileId { get; }
575 public string InputQuote { get; }
576 public string OutputFileId { get; }
577 public int? StartIndex { get; }
578 public string TextToReplace { get; }
579 }
580 public class ThreadInitializationMessage : MessageCreationOptions {
581 public ThreadInitializationMessage(IEnumerable<MessageContent> content);
582 }
583 public class ThreadMessage {
584 public string AssistantId { get; }
585 public IReadOnlyList<MessageCreationAttachment> Attachments { get; }
586 public DateTimeOffset? CompletedAt { get; }
587 public IReadOnlyList<MessageContent> Content { get; }
588 public DateTimeOffset CreatedAt { get; }
589 public string Id { get; }
590 public DateTimeOffset? IncompleteAt { get; }
591 public MessageFailureDetails IncompleteDetails { get; }
592 public IReadOnlyDictionary<string, string> Metadata { get; }
593 public MessageRole Role { get; }
594 public string RunId { get; }
595 public MessageStatus Status { get; }
596 public string ThreadId { get; }
597 }
598 public class ThreadRun {
599 public string AssistantId { get; }
600 public DateTimeOffset? CancelledAt { get; }
601 public DateTimeOffset? CompletedAt { get; }
602 public DateTimeOffset CreatedAt { get; }
603 public DateTimeOffset? ExpiresAt { get; }
604 public DateTimeOffset? FailedAt { get; }
605 public string Id { get; }
606 public RunIncompleteDetails IncompleteDetails { get; }
607 public string Instructions { get; }
608 public RunError LastError { get; }
609 public int? MaxCompletionTokens { get; }
610 public int? MaxPromptTokens { get; }
611 public IReadOnlyDictionary<string, string> Metadata { get; }
612 public string Model { get; }
613 public float? NucleusSamplingFactor { get; }
614 public IReadOnlyList<RequiredAction> RequiredActions { get; }
615 public AssistantResponseFormat ResponseFormat { get; }
616 public DateTimeOffset? StartedAt { get; }
617 public RunStatus Status { get; }
618 public float? Temperature { get; }
619 public string ThreadId { get; }
620 public ToolConstraint ToolConstraint { get; }
621 public IReadOnlyList<ToolDefinition> Tools { get; }
622 public RunTruncationStrategy TruncationStrategy { get; }
623 public RunTokenUsage Usage { get; }
624 }
625 public class ThreadUpdate : StreamingUpdate<AssistantThread> {
626 public DateTimeOffset CreatedAt { get; }
627 public string Id { get; }
628 public IReadOnlyDictionary<string, string> Metadata { get; }
629 public ToolResources ToolResources { get; }
630 }
631 public class ToolConstraint {
632 public ToolConstraint(ToolDefinition toolDefinition);
633 public static ToolConstraint Auto { get; }
634 public static ToolConstraint None { get; }
635 public static ToolConstraint Required { get; }
636 }
637 public abstract class ToolDefinition {
638 protected ToolDefinition();
639 public static CodeInterpreterToolDefinition CreateCodeInterpreter();
640 public static FileSearchToolDefinition CreateFileSearch();
641 public static FunctionToolDefinition CreateFunction(string name, string description = null, BinaryData parameters = null);
642 }
643 public class ToolOutput {
644 public ToolOutput(string toolCallId, string output);
645 public ToolOutput();
646 public string Output { get; init; }
647 public string ToolCallId { get; init; }
648 }
649 public class ToolResources {
650 public ToolResources();
651 public CodeInterpreterToolResources CodeInterpreter { get; init; }
652 public FileSearchToolResources FileSearch { get; init; }
653 }
654 public class VectorStoreCreationHelper {
655 public VectorStoreCreationHelper(IEnumerable<string> fileIds, IDictionary<string, string> metadata = null);
656 public VectorStoreCreationHelper(IEnumerable<OpenAIFileInfo> files, IDictionary<string, string> metadata = null);
657 public VectorStoreCreationHelper();
658 public IList<string> FileIds { get; }
659 public IDictionary<string, string> Metadata { get; }
660 }
661 public enum MessageImageDetail {
662 Auto = 0,
663 Low = 1,
664 High = 2,
665 }
666 public enum MessageRole {
667 User = 0,
668 Assistant = 1,
669 }
670 public enum RunStepToolCallKind {
671 Unknown = 0,
672 CodeInterpreter = 1,
673 FileSearch = 2,
674 Function = 3,
675 }
676 public enum StreamingUpdateReason {
677 Unknown = 0,
678 ThreadCreated = 1,
679 RunCreated = 2,
680 RunQueued = 3,
681 RunInProgress = 4,
682 RunRequiresAction = 5,
683 RunCompleted = 6,
684 RunIncomplete = 7,
685 RunFailed = 8,
686 RunCancelling = 9,
687 RunCancelled = 10,
688 RunExpired = 11,
689 RunStepCreated = 12,
690 RunStepInProgress = 13,
691 RunStepUpdated = 14,
692 RunStepCompleted = 15,
693 RunStepFailed = 16,
694 RunStepCancelled = 17,
695 RunStepExpired = 18,
696 MessageCreated = 19,
697 MessageInProgress = 20,
698 MessageUpdated = 21,
699 MessageCompleted = 22,
700 MessageFailed = 23,
701 Error = 24,
702 Done = 25,
703 }
704}
705namespace OpenAI.Audio {
706 public class AudioClient {
707 public AudioClient(string model, ApiKeyCredential credential, OpenAIClientOptions options = null);
708 public AudioClient(string model, OpenAIClientOptions options = null);
709 protected AudioClient(ClientPipeline pipeline, string model, Uri endpoint, OpenAIClientOptions options);
710 protected AudioClient();
711 public virtual ClientPipeline Pipeline { get; }
712 public virtual ClientResult<BinaryData> GenerateSpeechFromText(string text, GeneratedSpeechVoice voice, SpeechGenerationOptions options = null);
713 public virtual ClientResult GenerateSpeechFromText(BinaryContent content, RequestOptions options = null);
714 public virtual Task<ClientResult<BinaryData>> GenerateSpeechFromTextAsync(string text, GeneratedSpeechVoice voice, SpeechGenerationOptions options = null);
715 public virtual Task<ClientResult> GenerateSpeechFromTextAsync(BinaryContent content, RequestOptions options = null);
716 public virtual ClientResult<AudioTranscription> TranscribeAudio(Stream audio, string audioFilename, AudioTranscriptionOptions options = null);
717 public virtual ClientResult<AudioTranscription> TranscribeAudio(string audioFilePath, AudioTranscriptionOptions options = null);
718 public virtual ClientResult TranscribeAudio(BinaryContent content, string contentType, RequestOptions options = null);
719 public virtual Task<ClientResult<AudioTranscription>> TranscribeAudioAsync(Stream audio, string audioFilename, AudioTranscriptionOptions options = null);
720 public virtual Task<ClientResult<AudioTranscription>> TranscribeAudioAsync(string audioFilePath, AudioTranscriptionOptions options = null);
721 public virtual Task<ClientResult> TranscribeAudioAsync(BinaryContent content, string contentType, RequestOptions options = null);
722 public virtual ClientResult<AudioTranslation> TranslateAudio(Stream audio, string audioFilename, AudioTranslationOptions options = null);
723 public virtual ClientResult<AudioTranslation> TranslateAudio(string audioFilePath, AudioTranslationOptions options = null);
724 public virtual ClientResult TranslateAudio(BinaryContent content, string contentType, RequestOptions options = null);
725 public virtual Task<ClientResult<AudioTranslation>> TranslateAudioAsync(Stream audio, string audioFilename, AudioTranslationOptions options = null);
726 public virtual Task<ClientResult<AudioTranslation>> TranslateAudioAsync(string audioFilePath, AudioTranslationOptions options = null);
727 public virtual Task<ClientResult> TranslateAudioAsync(BinaryContent content, string contentType, RequestOptions options = null);
728 }
729 public class AudioTranscriptionOptions {
730 public AudioTranscriptionOptions();
731 public AudioTimestampGranularities Granularities { get; init; }
732 public string Language { get; init; }
733 public string Prompt { get; init; }
734 public AudioTranscriptionFormat? ResponseFormat { get; init; }
735 public float? Temperature { get; init; }
736 }
737 public class AudioTranslationOptions {
738 public AudioTranslationOptions();
739 public string Prompt { get; init; }
740 public AudioTranslationFormat? ResponseFormat { get; init; }
741 public float? Temperature { get; init; }
742 }
743 public class SpeechGenerationOptions {
744 public SpeechGenerationOptions();
745 public GeneratedSpeechFormat? ResponseFormat { get; init; }
746 public float? Speed { get; init; }
747 }
748 public class AudioTranscription {
749 public TimeSpan? Duration { get; }
750 public string Language { get; }
751 public IReadOnlyList<TranscribedSegment> Segments { get; }
752 public string Text { get; }
753 public IReadOnlyList<TranscribedWord> Words { get; }
754 }
755 public class AudioTranslation {
756 public TimeSpan? Duration { get; }
757 public string Language { get; }
758 public IReadOnlyList<TranscribedSegment> Segments { get; }
759 public string Text { get; }
760 }
761 public readonly struct TranscribedSegment {
762 public TranscribedSegment();
763 public double AverageLogProbability { get; }
764 public float CompressionRatio { get; }
765 public TimeSpan End { get; }
766 public int Id { get; }
767 public double NoSpeechProbability { get; }
768 public long SeekOffset { get; }
769 public TimeSpan Start { get; }
770 public float Temperature { get; }
771 public string Text { get; }
772 public IReadOnlyList<long> TokenIds { get; }
773 }
774 public readonly struct TranscribedWord {
775 public TranscribedWord();
776 public TimeSpan End { get; }
777 public TimeSpan Start { get; }
778 public string Word { get; }
779 }
780 [Flags]
781 public enum AudioTimestampGranularities {
782 Default = 0,
783 Word = 1,
784 Segment = 2,
785 }
786 public enum AudioTranscriptionFormat {
787 Text = 0,
788 Simple = 1,
789 Verbose = 2,
790 Srt = 3,
791 Vtt = 4,
792 }
793 public enum AudioTranslationFormat {
794 Text = 0,
795 Simple = 1,
796 Verbose = 2,
797 Srt = 3,
798 Vtt = 4,
799 }
800 public enum GeneratedSpeechFormat {
801 Mp3 = 0,
802 Opus = 1,
803 Aac = 2,
804 Flac = 3,
805 Wav = 4,
806 Pcm = 5,
807 }
808 public enum GeneratedSpeechVoice {
809 Alloy = 0,
810 Echo = 1,
811 Fable = 2,
812 Onyx = 3,
813 Nova = 4,
814 Shimmer = 5,
815 }
816}
817namespace OpenAI.Batch {
818 public class BatchClient {
819 public BatchClient(ApiKeyCredential credential, OpenAIClientOptions options = null);
820 public BatchClient(OpenAIClientOptions options = null);
821 protected BatchClient(ClientPipeline pipeline, Uri endpoint, OpenAIClientOptions options);
822 protected BatchClient();
823 public virtual ClientPipeline Pipeline { get; }
824 public virtual ClientResult CancelBatch(string batchId, RequestOptions options);
825 public virtual Task<ClientResult> CancelBatchAsync(string batchId, RequestOptions options);
826 public virtual ClientResult CreateBatch(BinaryContent content, RequestOptions options = null);
827 public virtual Task<ClientResult> CreateBatchAsync(BinaryContent content, RequestOptions options = null);
828 public virtual ClientResult GetBatch(string batchId, RequestOptions options);
829 public virtual Task<ClientResult> GetBatchAsync(string batchId, RequestOptions options);
830 public virtual ClientResult GetBatches(string after, int? limit, RequestOptions options);
831 public virtual Task<ClientResult> GetBatchesAsync(string after, int? limit, RequestOptions options);
832 }
833}
834namespace OpenAI.Chat {
835 public class ChatClient {
836 public ChatClient(string model, ApiKeyCredential credential, OpenAIClientOptions options = null);
837 public ChatClient(string model, OpenAIClientOptions options = null);
838 protected ChatClient(ClientPipeline pipeline, string model, Uri endpoint, OpenAIClientOptions options);
839 protected ChatClient();
840 public virtual ClientPipeline Pipeline { get; }
841 public virtual ClientResult<ChatCompletion> CompleteChat(IEnumerable<ChatMessage> messages, ChatCompletionOptions options = null);
842 public virtual ClientResult CompleteChat(BinaryContent content, RequestOptions options = null);
843 public virtual Task<ClientResult<ChatCompletion>> CompleteChatAsync(IEnumerable<ChatMessage> messages, ChatCompletionOptions options = null);
844 public virtual Task<ClientResult> CompleteChatAsync(BinaryContent content, RequestOptions options = null);
845 public virtual ResultCollection<StreamingChatCompletionUpdate> CompleteChatStreaming(IEnumerable<ChatMessage> messages, ChatCompletionOptions options = null);
846 public virtual AsyncResultCollection<StreamingChatCompletionUpdate> CompleteChatStreamingAsync(IEnumerable<ChatMessage> messages, ChatCompletionOptions options = null);
847 }
848 public class ChatCompletionOptions {
849 public ChatCompletionOptions();
850 public float? FrequencyPenalty { get; init; }
851 public ChatFunctionChoice FunctionChoice { get; init; }
852 public IList<ChatFunction> Functions { get; }
853 public bool? IncludeLogProbabilities { get; init; }
854 public IDictionary<int, int> LogitBiases { get; }
855 public int? MaxTokens { get; init; }
856 public float? PresencePenalty { get; init; }
857 public ChatResponseFormat ResponseFormat { get; init; }
858 public long? Seed { get; init; }
859 public IList<string> StopSequences { get; }
860 public float? Temperature { get; init; }
861 public ChatToolChoice ToolChoice { get; init; }
862 public IList<ChatTool> Tools { get; }
863 public int? TopLogProbabilityCount { get; init; }
864 public float? TopP { get; init; }
865 public string User { get; init; }
866 }
867 public class AssistantChatMessage : ChatMessage {
868 public AssistantChatMessage(string content);
869 public AssistantChatMessage(IEnumerable<ChatToolCall> toolCalls, string content = null);
870 public AssistantChatMessage(ChatFunctionCall functionCall, string content = null);
871 public AssistantChatMessage(ChatCompletion chatCompletion);
872 public ChatFunctionCall FunctionCall { get; init; }
873 public string ParticipantName { get; init; }
874 public IList<ChatToolCall> ToolCalls { get; }
875 }
876 public class ChatCompletion {
877 public IReadOnlyList<ChatMessageContentPart> Content { get; }
878 public IReadOnlyList<ChatTokenLogProbabilityInfo> ContentTokenLogProbabilities { get; }
879 public DateTimeOffset CreatedAt { get; }
880 public ChatFinishReason FinishReason { get; }
881 public ChatFunctionCall FunctionCall { get; }
882 public string Id { get; }
883 public string Model { get; }
884 public ChatMessageRole Role { get; }
885 public string SystemFingerprint { get; }
886 public IReadOnlyList<ChatToolCall> ToolCalls { get; }
887 public ChatTokenUsage Usage { get; }
888 }
889 [Obsolete("This field is marked as deprecated.")]
890 public class ChatFunction {
891 public ChatFunction(string functionName, string functionDescription = null, BinaryData functionParameters = null);
892 public string FunctionDescription { get; init; }
893 public string FunctionName { get; }
894 public BinaryData FunctionParameters { get; init; }
895 }
896 public class ChatFunctionCall {
897 public ChatFunctionCall(string functionName, string functionArguments);
898 public string FunctionArguments { get; }
899 public string FunctionName { get; }
900 }
901 public class ChatFunctionChoice {
902 public ChatFunctionChoice(ChatFunction chatFunction);
903 public static ChatFunctionChoice Auto { get; }
904 public static ChatFunctionChoice None { get; }
905 }
906 public abstract class ChatMessage {
907 protected ChatMessage();
908 public IList<ChatMessageContentPart> Content { get; protected init; }
909 public static AssistantChatMessage CreateAssistantMessage(string content);
910 public static AssistantChatMessage CreateAssistantMessage(IEnumerable<ChatToolCall> toolCalls, string content = null);
911 public static AssistantChatMessage CreateAssistantMessage(ChatFunctionCall functionCall, string content = null);
912 public static AssistantChatMessage CreateAssistantMessage(ChatCompletion chatCompletion);
913 public static FunctionChatMessage CreateFunctionMessage(string functionName, string content);
914 public static SystemChatMessage CreateSystemMessage(string content);
915 public static ToolChatMessage CreateToolChatMessage(string toolCallId, string content);
916 public static UserChatMessage CreateUserMessage(string content);
917 public static UserChatMessage CreateUserMessage(IEnumerable<ChatMessageContentPart> contentParts);
918 public static UserChatMessage CreateUserMessage(params ChatMessageContentPart[] contentParts);
919 }
920 public class ChatMessageContentPart {
921 public BinaryData ImageBytes { get; }
922 public string ImageBytesMediaType { get; }
923 public ImageChatMessageContentPartDetail? ImageDetail { get; }
924 public Uri ImageUri { get; }
925 public ChatMessageContentPartKind Kind { get; }
926 public string Text { get; }
927 public static ChatMessageContentPart CreateImageMessageContentPart(Uri imageUri, ImageChatMessageContentPartDetail? imageDetail = null);
928 public static ChatMessageContentPart CreateImageMessageContentPart(BinaryData imageBytes, string imageBytesMediaType, ImageChatMessageContentPartDetail? imageDetail = null);
929 public static ChatMessageContentPart CreateTextMessageContentPart(string text);
930 }
931 public readonly struct ChatMessageContentPartKind : IEquatable<ChatMessageContentPartKind> {
932 public ChatMessageContentPartKind(string value);
933 public static ChatMessageContentPartKind Image { get; }
934 public static ChatMessageContentPartKind Text { get; }
935 public static bool operator ==(ChatMessageContentPartKind left, ChatMessageContentPartKind right);
936 public static implicit operator ChatMessageContentPartKind(string value);
937 public static bool operator !=(ChatMessageContentPartKind left, ChatMessageContentPartKind right);
938 public bool Equals(ChatMessageContentPartKind other);
939 public override bool Equals(object obj);
940 public override int GetHashCode();
941 public override string ToString();
942 }
943 public class ChatResponseFormat {
944 public static ChatResponseFormat JsonObject { get; }
945 public static ChatResponseFormat Text { get; }
946 }
947 public class ChatTokenLogProbabilityInfo {
948 public float LogProbability { get; }
949 public string Token { get; }
950 public IReadOnlyList<ChatTokenTopLogProbabilityInfo> TopLogProbabilities { get; }
951 public IReadOnlyList<int> Utf8ByteValues { get; }
952 }
953 public class ChatTokenTopLogProbabilityInfo {
954 public float LogProbability { get; }
955 public string Token { get; }
956 public IReadOnlyList<int> Utf8ByteValues { get; }
957 }
958 public class ChatTokenUsage {
959 public int InputTokens { get; }
960 public int OutputTokens { get; }
961 public int TotalTokens { get; }
962 }
963 public class ChatTool {
964 public string FunctionDescription { get; }
965 public string FunctionName { get; }
966 public BinaryData FunctionParameters { get; }
967 public ChatToolKind Kind { get; }
968 public static ChatTool CreateFunctionTool(string functionName, string functionDescription = null, BinaryData functionParameters = null);
969 }
970 public class ChatToolCall {
971 public string FunctionArguments { get; }
972 public string FunctionName { get; }
973 public string Id { get; init; }
974 public ChatToolCallKind Kind { get; }
975 public static ChatToolCall CreateFunctionToolCall(string toolCallId, string functionName, string functionArguments);
976 }
977 public readonly struct ChatToolCallKind : IEquatable<ChatToolCallKind> {
978 public ChatToolCallKind(string value);
979 public static ChatToolCallKind Function { get; }
980 public static bool operator ==(ChatToolCallKind left, ChatToolCallKind right);
981 public static implicit operator ChatToolCallKind(string value);
982 public static bool operator !=(ChatToolCallKind left, ChatToolCallKind right);
983 public bool Equals(ChatToolCallKind other);
984 public override bool Equals(object obj);
985 public override int GetHashCode();
986 public override string ToString();
987 }
988 public class ChatToolChoice {
989 public ChatToolChoice(ChatTool tool);
990 public static ChatToolChoice Auto { get; }
991 public static ChatToolChoice None { get; }
992 public static ChatToolChoice Required { get; }
993 }
994 public readonly struct ChatToolKind : IEquatable<ChatToolKind> {
995 public ChatToolKind(string value);
996 public static ChatToolKind Function { get; }
997 public static bool operator ==(ChatToolKind left, ChatToolKind right);
998 public static implicit operator ChatToolKind(string value);
999 public static bool operator !=(ChatToolKind left, ChatToolKind right);
1000 public bool Equals(ChatToolKind other);
1001 public override bool Equals(object obj);
1002 public override int GetHashCode();
1003 public override string ToString();
1004 }
1005 [Obsolete("This field is marked as deprecated.")]
1006 public class FunctionChatMessage : ChatMessage {
1007 public FunctionChatMessage(string functionName, string content = null);
1008 public string FunctionName { get; }
1009 }
1010 public readonly struct ImageChatMessageContentPartDetail : IEquatable<ImageChatMessageContentPartDetail> {
1011 public ImageChatMessageContentPartDetail(string value);
1012 public static ImageChatMessageContentPartDetail Auto { get; }
1013 public static ImageChatMessageContentPartDetail High { get; }
1014 public static ImageChatMessageContentPartDetail Low { get; }
1015 public static bool operator ==(ImageChatMessageContentPartDetail left, ImageChatMessageContentPartDetail right);
1016 public static implicit operator ImageChatMessageContentPartDetail(string value);
1017 public static bool operator !=(ImageChatMessageContentPartDetail left, ImageChatMessageContentPartDetail right);
1018 public bool Equals(ImageChatMessageContentPartDetail other);
1019 public override bool Equals(object obj);
1020 public override int GetHashCode();
1021 public override string ToString();
1022 }
1023 public class StreamingChatCompletionUpdate {
1024 public IReadOnlyList<ChatTokenLogProbabilityInfo> ContentTokenLogProbabilities { get; }
1025 public IReadOnlyList<ChatMessageContentPart> ContentUpdate { get; }
1026 public DateTimeOffset CreatedAt { get; }
1027 public ChatFinishReason? FinishReason { get; }
1028 public StreamingChatFunctionCallUpdate FunctionCallUpdate { get; }
1029 public string Id { get; }
1030 public string Model { get; }
1031 public ChatMessageRole? Role { get; }
1032 public string SystemFingerprint { get; }
1033 public IReadOnlyList<StreamingChatToolCallUpdate> ToolCallUpdates { get; }
1034 public ChatTokenUsage Usage { get; }
1035 }
1036 public class StreamingChatFunctionCallUpdate {
1037 public string FunctionArgumentsUpdate { get; }
1038 public string FunctionName { get; }
1039 }
1040 public class StreamingChatToolCallUpdate {
1041 public string FunctionArgumentsUpdate { get; }
1042 public string FunctionName { get; }
1043 public string Id { get; }
1044 public int Index { get; }
1045 public ChatToolCallKind Kind { get; }
1046 }
1047 public class SystemChatMessage : ChatMessage {
1048 public SystemChatMessage(string content);
1049 public string ParticipantName { get; init; }
1050 }
1051 public class ToolChatMessage : ChatMessage {
1052 public ToolChatMessage(string toolCallId, string content);
1053 public string ToolCallId { get; }
1054 }
1055 public class UserChatMessage : ChatMessage {
1056 public UserChatMessage(string content);
1057 public UserChatMessage(IEnumerable<ChatMessageContentPart> content);
1058 public UserChatMessage(params ChatMessageContentPart[] content);
1059 public string ParticipantName { get; init; }
1060 }
1061 public enum ChatFinishReason {
1062 Stop = 0,
1063 Length = 1,
1064 ContentFilter = 2,
1065 ToolCalls = 3,
1066 FunctionCall = 4,
1067 }
1068 public enum ChatMessageRole {
1069 System = 0,
1070 User = 1,
1071 Assistant = 2,
1072 Tool = 3,
1073 Function = 4,
1074 }
1075}
1076namespace OpenAI.Embeddings {
1077 public class EmbeddingClient {
1078 public EmbeddingClient(string model, ApiKeyCredential credential, OpenAIClientOptions options = null);
1079 public EmbeddingClient(string model, OpenAIClientOptions options = null);
1080 protected EmbeddingClient(ClientPipeline pipeline, string model, Uri endpoint, OpenAIClientOptions options);
1081 protected EmbeddingClient();
1082 public virtual ClientPipeline Pipeline { get; }
1083 public virtual ClientResult<Embedding> GenerateEmbedding(string input, EmbeddingGenerationOptions options = null);
1084 public virtual Task<ClientResult<Embedding>> GenerateEmbeddingAsync(string input, EmbeddingGenerationOptions options = null);
1085 public virtual ClientResult<EmbeddingCollection> GenerateEmbeddings(IEnumerable<string> inputs, EmbeddingGenerationOptions options = null);
1086 public virtual ClientResult<EmbeddingCollection> GenerateEmbeddings(IEnumerable<IEnumerable<int>> inputs, EmbeddingGenerationOptions options = null);
1087 public virtual ClientResult GenerateEmbeddings(BinaryContent content, RequestOptions options = null);
1088 public virtual Task<ClientResult<EmbeddingCollection>> GenerateEmbeddingsAsync(IEnumerable<string> inputs, EmbeddingGenerationOptions options = null);
1089 public virtual Task<ClientResult<EmbeddingCollection>> GenerateEmbeddingsAsync(IEnumerable<IEnumerable<int>> inputs, EmbeddingGenerationOptions options = null);
1090 public virtual Task<ClientResult> GenerateEmbeddingsAsync(BinaryContent content, RequestOptions options = null);
1091 }
1092 public class EmbeddingGenerationOptions {
1093 public EmbeddingGenerationOptions();
1094 public int? Dimensions { get; init; }
1095 public string User { get; init; }
1096 }
1097 public class Embedding {
1098 public int Index { get; }
1099 public ReadOnlyMemory<float> Vector { get; }
1100 }
1101 public class EmbeddingCollection : ReadOnlyCollection<Embedding> {
1102 public string Model { get; }
1103 public EmbeddingTokenUsage Usage { get; }
1104 }
1105 public class EmbeddingTokenUsage {
1106 public int InputTokens { get; }
1107 public int TotalTokens { get; }
1108 }
1109}
1110namespace OpenAI.Files {
1111 public class FileClient {
1112 public FileClient(ApiKeyCredential credential, OpenAIClientOptions options = null);
1113 public FileClient(OpenAIClientOptions options = null);
1114 protected FileClient(ClientPipeline pipeline, Uri endpoint, OpenAIClientOptions options);
1115 protected FileClient();
1116 public virtual ClientPipeline Pipeline { get; }
1117 public virtual ClientResult<bool> DeleteFile(string fileId);
1118 public virtual ClientResult<bool> DeleteFile(OpenAIFileInfo file);
1119 public virtual ClientResult DeleteFile(string fileId, RequestOptions options);
1120 public virtual Task<ClientResult<bool>> DeleteFileAsync(string fileId);
1121 public virtual Task<ClientResult<bool>> DeleteFileAsync(OpenAIFileInfo file);
1122 public virtual Task<ClientResult> DeleteFileAsync(string fileId, RequestOptions options);
1123 public virtual ClientResult<BinaryData> DownloadFile(string fileId);
1124 public virtual ClientResult<BinaryData> DownloadFile(OpenAIFileInfo file);
1125 public virtual ClientResult DownloadFile(string fileId, RequestOptions options);
1126 public virtual Task<ClientResult<BinaryData>> DownloadFileAsync(string fileId);
1127 public virtual Task<ClientResult<BinaryData>> DownloadFileAsync(OpenAIFileInfo file);
1128 public virtual Task<ClientResult> DownloadFileAsync(string fileId, RequestOptions options);
1129 public virtual ClientResult<OpenAIFileInfo> GetFile(string fileId);
1130 public virtual ClientResult GetFile(string fileId, RequestOptions options);
1131 public virtual Task<ClientResult<OpenAIFileInfo>> GetFileAsync(string fileId);
1132 public virtual Task<ClientResult> GetFileAsync(string fileId, RequestOptions options);
1133 public virtual ClientResult<OpenAIFileInfoCollection> GetFiles(OpenAIFilePurpose? purpose = null);
1134 public virtual ClientResult GetFiles(string purpose, RequestOptions options);
1135 public virtual Task<ClientResult<OpenAIFileInfoCollection>> GetFilesAsync(OpenAIFilePurpose? purpose = null);
1136 public virtual Task<ClientResult> GetFilesAsync(string purpose, RequestOptions options);
1137 public virtual ClientResult<OpenAIFileInfo> UploadFile(Stream file, string filename, FileUploadPurpose purpose);
1138 public virtual ClientResult<OpenAIFileInfo> UploadFile(BinaryData file, string filename, FileUploadPurpose purpose);
1139 public virtual ClientResult<OpenAIFileInfo> UploadFile(string filePath, FileUploadPurpose purpose);
1140 public virtual ClientResult UploadFile(BinaryContent content, string contentType, RequestOptions options = null);
1141 public virtual Task<ClientResult<OpenAIFileInfo>> UploadFileAsync(Stream file, string filename, FileUploadPurpose purpose);
1142 public virtual Task<ClientResult<OpenAIFileInfo>> UploadFileAsync(BinaryData file, string filename, FileUploadPurpose purpose);
1143 public virtual Task<ClientResult<OpenAIFileInfo>> UploadFileAsync(string filePath, FileUploadPurpose purpose);
1144 public virtual Task<ClientResult> UploadFileAsync(BinaryContent content, string contentType, RequestOptions options = null);
1145 }
1146 public readonly struct FileUploadPurpose : IEquatable<FileUploadPurpose> {
1147 public FileUploadPurpose(string value);
1148 public static FileUploadPurpose Assistants { get; }
1149 public static FileUploadPurpose Batch { get; }
1150 public static FileUploadPurpose FineTune { get; }
1151 public static FileUploadPurpose Vision { get; }
1152 public static bool operator ==(FileUploadPurpose left, FileUploadPurpose right);
1153 public static implicit operator FileUploadPurpose(string value);
1154 public static bool operator !=(FileUploadPurpose left, FileUploadPurpose right);
1155 public bool Equals(FileUploadPurpose other);
1156 public override bool Equals(object obj);
1157 public override int GetHashCode();
1158 public override string ToString();
1159 }
1160 public class OpenAIFileInfo {
1161 public DateTimeOffset CreatedAt { get; }
1162 public string Filename { get; }
1163 public string Id { get; }
1164 public OpenAIFilePurpose Purpose { get; }
1165 public long? SizeInBytes { get; }
1166 public OpenAIFileStatus Status { get; }
1167 public string StatusDetails { get; }
1168 }
1169 public class OpenAIFileInfoCollection : ReadOnlyCollection<OpenAIFileInfo> {
1170 }
1171 public readonly struct OpenAIFilePurpose : IEquatable<OpenAIFilePurpose> {
1172 public OpenAIFilePurpose(string value);
1173 public static OpenAIFilePurpose Assistants { get; }
1174 public static OpenAIFilePurpose AssistantsOutput { get; }
1175 public static OpenAIFilePurpose Batch { get; }
1176 public static OpenAIFilePurpose BatchOutput { get; }
1177 public static OpenAIFilePurpose FineTune { get; }
1178 public static OpenAIFilePurpose FineTuneResults { get; }
1179 public static OpenAIFilePurpose Vision { get; }
1180 public static bool operator ==(OpenAIFilePurpose left, OpenAIFilePurpose right);
1181 public static implicit operator OpenAIFilePurpose(string value);
1182 public static bool operator !=(OpenAIFilePurpose left, OpenAIFilePurpose right);
1183 public bool Equals(OpenAIFilePurpose other);
1184 public override bool Equals(object obj);
1185 public override int GetHashCode();
1186 public override string ToString();
1187 }
1188 public readonly struct OpenAIFileStatus : IEquatable<OpenAIFileStatus> {
1189 public OpenAIFileStatus(string value);
1190 public static OpenAIFileStatus Error { get; }
1191 public static OpenAIFileStatus Processed { get; }
1192 public static OpenAIFileStatus Uploaded { get; }
1193 public static bool operator ==(OpenAIFileStatus left, OpenAIFileStatus right);
1194 public static implicit operator OpenAIFileStatus(string value);
1195 public static bool operator !=(OpenAIFileStatus left, OpenAIFileStatus right);
1196 public bool Equals(OpenAIFileStatus other);
1197 public override bool Equals(object obj);
1198 public override int GetHashCode();
1199 public override string ToString();
1200 }
1201}
1202namespace OpenAI.FineTuning {
1203 public class FineTuningClient {
1204 public FineTuningClient(ApiKeyCredential credential, OpenAIClientOptions options = null);
1205 public FineTuningClient(OpenAIClientOptions options = null);
1206 protected FineTuningClient(ClientPipeline pipeline, Uri endpoint, OpenAIClientOptions options);
1207 protected FineTuningClient();
1208 public virtual ClientPipeline Pipeline { get; }
1209 public virtual ClientResult CancelJob(string jobId, RequestOptions options);
1210 public virtual Task<ClientResult> CancelJobAsync(string jobId, RequestOptions options);
1211 public virtual ClientResult CreateJob(BinaryContent content, RequestOptions options = null);
1212 public virtual Task<ClientResult> CreateJobAsync(BinaryContent content, RequestOptions options = null);
1213 public virtual ClientResult GetJob(string jobId, RequestOptions options);
1214 public virtual Task<ClientResult> GetJobAsync(string jobId, RequestOptions options);
1215 public virtual ClientResult GetJobCheckpoints(string fineTuningJobId, string after, int? limit, RequestOptions options);
1216 public virtual Task<ClientResult> GetJobCheckpointsAsync(string fineTuningJobId, string after, int? limit, RequestOptions options);
1217 public virtual ClientResult GetJobEvents(string jobId, string after, int? limit, RequestOptions options);
1218 public virtual Task<ClientResult> GetJobEventsAsync(string jobId, string after, int? limit, RequestOptions options);
1219 public virtual ClientResult GetJobs(string after, int? limit, RequestOptions options);
1220 public virtual Task<ClientResult> GetJobsAsync(string after, int? limit, RequestOptions options);
1221 }
1222}
1223namespace OpenAI.Images {
1224 public class ImageClient {
1225 public ImageClient(string model, ApiKeyCredential credential, OpenAIClientOptions options = null);
1226 public ImageClient(string model, OpenAIClientOptions options = null);
1227 protected ImageClient(ClientPipeline pipeline, string model, Uri endpoint, OpenAIClientOptions options);
1228 protected ImageClient();
1229 public virtual ClientPipeline Pipeline { get; }
1230 public virtual ClientResult<GeneratedImage> GenerateImage(string prompt, ImageGenerationOptions options = null);
1231 public virtual Task<ClientResult<GeneratedImage>> GenerateImageAsync(string prompt, ImageGenerationOptions options = null);
1232 public virtual ClientResult<GeneratedImage> GenerateImageEdit(Stream image, string imageFilename, string prompt, ImageEditOptions options = null);
1233 public virtual ClientResult<GeneratedImage> GenerateImageEdit(string imageFilePath, string prompt, ImageEditOptions options = null);
1234 public virtual ClientResult<GeneratedImage> GenerateImageEdit(Stream image, string imageFilename, string prompt, Stream mask, string maskFilename, ImageEditOptions options = null);
1235 public virtual ClientResult<GeneratedImage> GenerateImageEdit(string imageFilePath, string prompt, string maskFilePath, ImageEditOptions options = null);
1236 public virtual Task<ClientResult<GeneratedImage>> GenerateImageEditAsync(Stream image, string imageFilename, string prompt, ImageEditOptions options = null);
1237 public virtual Task<ClientResult<GeneratedImage>> GenerateImageEditAsync(string imageFilePath, string prompt, ImageEditOptions options = null);
1238 public virtual Task<ClientResult<GeneratedImage>> GenerateImageEditAsync(Stream image, string imageFilename, string prompt, Stream mask, string maskFilename, ImageEditOptions options = null);
1239 public virtual Task<ClientResult<GeneratedImage>> GenerateImageEditAsync(string imageFilePath, string prompt, string maskFilePath, ImageEditOptions options = null);
1240 public virtual ClientResult<GeneratedImageCollection> GenerateImageEdits(Stream image, string imageFilename, string prompt, int imageCount, ImageEditOptions options = null);
1241 public virtual ClientResult<GeneratedImageCollection> GenerateImageEdits(string imageFilePath, string prompt, int imageCount, ImageEditOptions options = null);
1242 public virtual ClientResult<GeneratedImageCollection> GenerateImageEdits(Stream image, string imageFilename, string prompt, Stream mask, string maskFilename, int imageCount, ImageEditOptions options = null);
1243 public virtual ClientResult<GeneratedImageCollection> GenerateImageEdits(string imageFilePath, string prompt, string maskFilePath, int imageCount, ImageEditOptions options = null);
1244 public virtual ClientResult GenerateImageEdits(BinaryContent content, string contentType, RequestOptions options = null);
1245 public virtual Task<ClientResult<GeneratedImageCollection>> GenerateImageEditsAsync(Stream image, string imageFilename, string prompt, int imageCount, ImageEditOptions options = null);
1246 public virtual Task<ClientResult<GeneratedImageCollection>> GenerateImageEditsAsync(string imageFilePath, string prompt, int imageCount, ImageEditOptions options = null);
1247 public virtual Task<ClientResult<GeneratedImageCollection>> GenerateImageEditsAsync(Stream image, string imageFilename, string prompt, Stream mask, string maskFilename, int imageCount, ImageEditOptions options = null);
1248 public virtual Task<ClientResult<GeneratedImageCollection>> GenerateImageEditsAsync(string imageFilePath, string prompt, string maskFilePath, int imageCount, ImageEditOptions options = null);
1249 public virtual Task<ClientResult> GenerateImageEditsAsync(BinaryContent content, string contentType, RequestOptions options = null);
1250 public virtual ClientResult<GeneratedImageCollection> GenerateImages(string prompt, int imageCount, ImageGenerationOptions options = null);
1251 public virtual ClientResult GenerateImages(BinaryContent content, RequestOptions options = null);
1252 public virtual Task<ClientResult<GeneratedImageCollection>> GenerateImagesAsync(string prompt, int imageCount, ImageGenerationOptions options = null);
1253 public virtual Task<ClientResult> GenerateImagesAsync(BinaryContent content, RequestOptions options = null);
1254 public virtual ClientResult<GeneratedImage> GenerateImageVariation(Stream image, string imageFilename, ImageVariationOptions options = null);
1255 public virtual ClientResult<GeneratedImage> GenerateImageVariation(string imageFilePath, ImageVariationOptions options = null);
1256 public virtual Task<ClientResult<GeneratedImage>> GenerateImageVariationAsync(Stream image, string imageFilename, ImageVariationOptions options = null);
1257 public virtual Task<ClientResult<GeneratedImage>> GenerateImageVariationAsync(string imageFilePath, ImageVariationOptions options = null);
1258 public virtual ClientResult<GeneratedImageCollection> GenerateImageVariations(Stream image, string imageFilename, int imageCount, ImageVariationOptions options = null);
1259 public virtual ClientResult<GeneratedImageCollection> GenerateImageVariations(string imageFilePath, int imageCount, ImageVariationOptions options = null);
1260 public virtual ClientResult GenerateImageVariations(BinaryContent content, string contentType, RequestOptions options = null);
1261 public virtual Task<ClientResult<GeneratedImageCollection>> GenerateImageVariationsAsync(Stream image, string imageFilename, int imageCount, ImageVariationOptions options = null);
1262 public virtual Task<ClientResult<GeneratedImageCollection>> GenerateImageVariationsAsync(string imageFilePath, int imageCount, ImageVariationOptions options = null);
1263 public virtual Task<ClientResult> GenerateImageVariationsAsync(BinaryContent content, string contentType, RequestOptions options = null);
1264 }
1265 public class ImageEditOptions {
1266 public ImageEditOptions();
1267 public GeneratedImageFormat? ResponseFormat { get; init; }
1268 public GeneratedImageSize? Size { get; init; }
1269 public string User { get; init; }
1270 }
1271 public class ImageGenerationOptions {
1272 public ImageGenerationOptions();
1273 public GeneratedImageQuality? Quality { get; init; }
1274 public GeneratedImageFormat? ResponseFormat { get; init; }
1275 public GeneratedImageSize? Size { get; init; }
1276 public GeneratedImageStyle? Style { get; init; }
1277 public string User { get; init; }
1278 }
1279 public class ImageVariationOptions {
1280 public ImageVariationOptions();
1281 public GeneratedImageFormat? ResponseFormat { get; init; }
1282 public GeneratedImageSize? Size { get; init; }
1283 public string User { get; init; }
1284 }
1285 public class GeneratedImage {
1286 public BinaryData ImageBytes { get; }
1287 public Uri ImageUri { get; }
1288 public string RevisedPrompt { get; }
1289 }
1290 public class GeneratedImageCollection : ReadOnlyCollection<GeneratedImage> {
1291 public DateTimeOffset Created { get; }
1292 public DateTimeOffset CreatedAt { get; }
1293 }
1294 public readonly struct GeneratedImageSize : IEquatable<GeneratedImageSize> {
1295 public GeneratedImageSize(int width, int height);
1296 public static readonly GeneratedImageSize W1024xH1024;
1297 public static readonly GeneratedImageSize W1024xH1792;
1298 public static readonly GeneratedImageSize W1792xH1024;
1299 public static readonly GeneratedImageSize W256xH256;
1300 public static readonly GeneratedImageSize W512xH512;
1301 public static bool operator ==(GeneratedImageSize left, GeneratedImageSize right);
1302 public static bool operator !=(GeneratedImageSize left, GeneratedImageSize right);
1303 public bool Equals(GeneratedImageSize other);
1304 public override bool Equals(object obj);
1305 public override int GetHashCode();
1306 public override string ToString();
1307 }
1308 public enum GeneratedImageFormat {
1309 Bytes = 0,
1310 Uri = 1,
1311 }
1312 public enum GeneratedImageQuality {
1313 High = 0,
1314 Standard = 1,
1315 }
1316 public enum GeneratedImageStyle {
1317 Vivid = 0,
1318 Natural = 1,
1319 }
1320}
1321namespace OpenAI.Models {
1322 public class ModelClient {
1323 public ModelClient(ApiKeyCredential credential, OpenAIClientOptions options = null);
1324 public ModelClient(OpenAIClientOptions options = null);
1325 protected ModelClient(ClientPipeline pipeline, Uri endpoint, OpenAIClientOptions options);
1326 protected ModelClient();
1327 public virtual ClientPipeline Pipeline { get; }
1328 public virtual ClientResult<bool> DeleteModel(string model);
1329 public virtual ClientResult DeleteModel(string model, RequestOptions options);
1330 public virtual Task<ClientResult<bool>> DeleteModelAsync(string model);
1331 public virtual Task<ClientResult> DeleteModelAsync(string model, RequestOptions options);
1332 public virtual ClientResult<OpenAIModelInfo> GetModel(string model);
1333 public virtual ClientResult GetModel(string model, RequestOptions options);
1334 public virtual Task<ClientResult<OpenAIModelInfo>> GetModelAsync(string model);
1335 public virtual Task<ClientResult> GetModelAsync(string model, RequestOptions options);
1336 public virtual ClientResult<OpenAIModelInfoCollection> GetModels();
1337 public virtual ClientResult GetModels(RequestOptions options);
1338 public virtual Task<ClientResult<OpenAIModelInfoCollection>> GetModelsAsync();
1339 public virtual Task<ClientResult> GetModelsAsync(RequestOptions options);
1340 }
1341 public class OpenAIModelInfo {
1342 public DateTimeOffset CreatedAt { get; }
1343 public string Id { get; }
1344 public string OwnedBy { get; }
1345 }
1346 public class OpenAIModelInfoCollection : ReadOnlyCollection<OpenAIModelInfo> {
1347 }
1348}
1349namespace OpenAI.Moderations {
1350 public class ModerationClient {
1351 public ModerationClient(string model, ApiKeyCredential credential, OpenAIClientOptions options = null);
1352 public ModerationClient(string model, OpenAIClientOptions options = null);
1353 protected ModerationClient(ClientPipeline pipeline, string model, Uri endpoint, OpenAIClientOptions options);
1354 protected ModerationClient();
1355 public virtual ClientPipeline Pipeline { get; }
1356 public virtual ClientResult<ModerationResult> ClassifyTextInput(string input);
1357 public virtual Task<ClientResult<ModerationResult>> ClassifyTextInputAsync(string input);
1358 public virtual ClientResult<ModerationCollection> ClassifyTextInputs(IEnumerable<string> inputs);
1359 public virtual ClientResult ClassifyTextInputs(BinaryContent content, RequestOptions options = null);
1360 public virtual Task<ClientResult<ModerationCollection>> ClassifyTextInputsAsync(IEnumerable<string> inputs);
1361 public virtual Task<ClientResult> ClassifyTextInputsAsync(BinaryContent content, RequestOptions options = null);
1362 }
1363 public class ModerationCategories {
1364 public bool Harassment { get; }
1365 public bool HarassmentThreatening { get; }
1366 public bool Hate { get; }
1367 public bool HateThreatening { get; }
1368 public bool SelfHarm { get; }
1369 public bool SelfHarmInstructions { get; }
1370 public bool SelfHarmIntent { get; }
1371 public bool Sexual { get; }
1372 public bool SexualMinors { get; }
1373 public bool Violence { get; }
1374 public bool ViolenceGraphic { get; }
1375 }
1376 public class ModerationCategoryScores {
1377 public float Harassment { get; }
1378 public float HarassmentThreatening { get; }
1379 public float Hate { get; }
1380 public float HateThreatening { get; }
1381 public float SelfHarm { get; }
1382 public float SelfHarmInstructions { get; }
1383 public float SelfHarmIntent { get; }
1384 public float Sexual { get; }
1385 public float SexualMinors { get; }
1386 public float Violence { get; }
1387 public float ViolenceGraphic { get; }
1388 }
1389 public class ModerationCollection : ReadOnlyCollection<ModerationResult> {
1390 public string Id { get; }
1391 public string Model { get; }
1392 }
1393 public class ModerationResult {
1394 public ModerationCategories Categories { get; }
1395 public ModerationCategoryScores CategoryScores { get; }
1396 public bool Flagged { get; }
1397 }
1398}
1399namespace OpenAI.VectorStores {
1400 internal [Experimental("OPENAI001")]
1401 public class VectorStoreClient {
1402 public VectorStoreClient(ApiKeyCredential credential, OpenAIClientOptions options = null);
1403 public VectorStoreClient(OpenAIClientOptions options = null);
1404 protected VectorStoreClient(ClientPipeline pipeline, Uri endpoint, OpenAIClientOptions options);
1405 protected VectorStoreClient();
1406 public virtual ClientPipeline Pipeline { get; }
1407 public virtual ClientResult<VectorStoreFileAssociation> AddFileToVectorStore(VectorStore vectorStore, OpenAIFileInfo file);
1408 public virtual ClientResult<VectorStoreFileAssociation> AddFileToVectorStore(string vectorStoreId, string fileId);
1409 public virtual ClientResult AddFileToVectorStore(string vectorStoreId, BinaryContent content, RequestOptions options = null);
1410 public virtual Task<ClientResult<VectorStoreFileAssociation>> AddFileToVectorStoreAsync(VectorStore vectorStore, OpenAIFileInfo file);
1411 public virtual Task<ClientResult<VectorStoreFileAssociation>> AddFileToVectorStoreAsync(string vectorStoreId, string fileId);
1412 public virtual Task<ClientResult> AddFileToVectorStoreAsync(string vectorStoreId, BinaryContent content, RequestOptions options = null);
1413 public virtual ClientResult<VectorStoreBatchFileJob> CancelBatchFileJob(VectorStoreBatchFileJob batchJob);
1414 public virtual ClientResult<VectorStoreBatchFileJob> CancelBatchFileJob(string vectorStoreId, string batchJobId);
1415 public virtual ClientResult CancelBatchFileJob(string vectorStoreId, string batchId, RequestOptions options);
1416 public virtual Task<ClientResult<VectorStoreBatchFileJob>> CancelBatchFileJobAsync(VectorStoreBatchFileJob batchJob);
1417 public virtual Task<ClientResult<VectorStoreBatchFileJob>> CancelBatchFileJobAsync(string vectorStoreId, string batchJobId);
1418 public virtual Task<ClientResult> CancelBatchFileJobAsync(string vectorStoreId, string batchId, RequestOptions options);
1419 public virtual ClientResult<VectorStoreBatchFileJob> CreateBatchFileJob(VectorStore vectorStore, IEnumerable<OpenAIFileInfo> files);
1420 public virtual ClientResult<VectorStoreBatchFileJob> CreateBatchFileJob(string vectorStoreId, IEnumerable<string> fileIds);
1421 public virtual ClientResult CreateBatchFileJob(string vectorStoreId, BinaryContent content, RequestOptions options = null);
1422 public virtual Task<ClientResult<VectorStoreBatchFileJob>> CreateBatchFileJobAsync(VectorStore vectorStore, IEnumerable<OpenAIFileInfo> files);
1423 public virtual Task<ClientResult<VectorStoreBatchFileJob>> CreateBatchFileJobAsync(string vectorStoreId, IEnumerable<string> fileIds);
1424 public virtual Task<ClientResult> CreateBatchFileJobAsync(string vectorStoreId, BinaryContent content, RequestOptions options = null);
1425 public virtual ClientResult<VectorStore> CreateVectorStore(VectorStoreCreationOptions vectorStore = null);
1426 public virtual ClientResult CreateVectorStore(BinaryContent content, RequestOptions options = null);
1427 public virtual Task<ClientResult<VectorStore>> CreateVectorStoreAsync(VectorStoreCreationOptions vectorStore = null);
1428 public virtual Task<ClientResult> CreateVectorStoreAsync(BinaryContent content, RequestOptions options = null);
1429 public virtual ClientResult<bool> DeleteVectorStore(VectorStore vectorStore);
1430 public virtual ClientResult<bool> DeleteVectorStore(string vectorStoreId);
1431 public virtual ClientResult DeleteVectorStore(string vectorStoreId, RequestOptions options);
1432 public virtual Task<ClientResult<bool>> DeleteVectorStoreAsync(VectorStore vectorStore);
1433 public virtual Task<ClientResult<bool>> DeleteVectorStoreAsync(string vectorStoreId);
1434 public virtual Task<ClientResult> DeleteVectorStoreAsync(string vectorStoreId, RequestOptions options);
1435 public virtual ClientResult<VectorStoreBatchFileJob> GetBatchFileJob(VectorStoreBatchFileJob batchJob);
1436 public virtual ClientResult<VectorStoreBatchFileJob> GetBatchFileJob(string vectorStoreId, string batchJobId);
1437 public virtual ClientResult GetBatchFileJob(string vectorStoreId, string batchId, RequestOptions options);
1438 public virtual Task<ClientResult<VectorStoreBatchFileJob>> GetBatchFileJobAsync(VectorStoreBatchFileJob batchJob);
1439 public virtual Task<ClientResult<VectorStoreBatchFileJob>> GetBatchFileJobAsync(string vectorStoreId, string batchJobId);
1440 public virtual Task<ClientResult> GetBatchFileJobAsync(string vectorStoreId, string batchId, RequestOptions options);
1441 public virtual ClientResult<VectorStoreFileAssociation> GetFileAssociation(VectorStore vectorStore, OpenAIFileInfo file);
1442 public virtual ClientResult<VectorStoreFileAssociation> GetFileAssociation(string vectorStoreId, string fileId);
1443 public virtual ClientResult GetFileAssociation(string vectorStoreId, string fileId, RequestOptions options);
1444 public virtual Task<ClientResult<VectorStoreFileAssociation>> GetFileAssociationAsync(VectorStore vectorStore, OpenAIFileInfo file);
1445 public virtual Task<ClientResult<VectorStoreFileAssociation>> GetFileAssociationAsync(string vectorStoreId, string fileId);
1446 public virtual Task<ClientResult> GetFileAssociationAsync(string vectorStoreId, string fileId, RequestOptions options);
1447 public virtual PageableCollection<VectorStoreFileAssociation> GetFileAssociations(VectorStore vectorStore, ListOrder? resultOrder = null, VectorStoreFileStatusFilter? filter = null);
1448 public virtual PageableCollection<VectorStoreFileAssociation> GetFileAssociations(VectorStoreBatchFileJob batchJob, ListOrder? resultOrder = null, VectorStoreFileStatusFilter? filter = null);
1449 public virtual PageableCollection<VectorStoreFileAssociation> GetFileAssociations(string vectorStoreId, ListOrder? resultOrder = null, VectorStoreFileStatusFilter? filter = null);
1450 public virtual PageableCollection<VectorStoreFileAssociation> GetFileAssociations(string vectorStoreId, string batchJobId, ListOrder? resultOrder = null, VectorStoreFileStatusFilter? filter = null);
1451 public virtual ClientResult GetFileAssociations(string vectorStoreId, int? limit, string order, string after, string before, string filter, RequestOptions options);
1452 public virtual ClientResult GetFileAssociations(string vectorStoreId, string batchId, int? limit, string order, string after, string before, string filter, RequestOptions options);
1453 public virtual AsyncPageableCollection<VectorStoreFileAssociation> GetFileAssociationsAsync(VectorStore vectorStore, ListOrder? resultOrder = null, VectorStoreFileStatusFilter? filter = null);
1454 public virtual AsyncPageableCollection<VectorStoreFileAssociation> GetFileAssociationsAsync(VectorStoreBatchFileJob batchJob, ListOrder? resultOrder = null, VectorStoreFileStatusFilter? filter = null);
1455 public virtual AsyncPageableCollection<VectorStoreFileAssociation> GetFileAssociationsAsync(string vectorStoreId, ListOrder? resultOrder = null, VectorStoreFileStatusFilter? filter = null);
1456 public virtual AsyncPageableCollection<VectorStoreFileAssociation> GetFileAssociationsAsync(string vectorStoreId, string batchJobId, ListOrder? resultOrder = null, VectorStoreFileStatusFilter? filter = null);
1457 public virtual Task<ClientResult> GetFileAssociationsAsync(string vectorStoreId, int? limit, string order, string after, string before, string filter, RequestOptions options);
1458 public virtual Task<ClientResult> GetFileAssociationsAsync(string vectorStoreId, string batchId, int? limit, string order, string after, string before, string filter, RequestOptions options);
1459 public virtual ClientResult<VectorStore> GetVectorStore(VectorStore vectorStore);
1460 public virtual ClientResult GetVectorStore(string vectorStoreId, RequestOptions options);
1461 public virtual ClientResult<VectorStore> GetVectorStore(string vectorStoreId);
1462 public virtual Task<ClientResult<VectorStore>> GetVectorStoreAsync(VectorStore vectorStore);
1463 public virtual Task<ClientResult> GetVectorStoreAsync(string vectorStoreId, RequestOptions options);
1464 public virtual Task<ClientResult<VectorStore>> GetVectorStoreAsync(string vectorStoreId);
1465 public virtual PageableCollection<VectorStore> GetVectorStores(ListOrder? resultOrder = null);
1466 public virtual ClientResult GetVectorStores(int? limit, string order, string after, string before, RequestOptions options);
1467 public virtual AsyncPageableCollection<VectorStore> GetVectorStoresAsync(ListOrder? resultOrder = null);
1468 public virtual Task<ClientResult> GetVectorStoresAsync(int? limit, string order, string after, string before, RequestOptions options);
1469 public virtual ClientResult<VectorStore> ModifyVectorStore(VectorStore vectorStore, VectorStoreModificationOptions options);
1470 public virtual ClientResult ModifyVectorStore(string vectorStoreId, BinaryContent content, RequestOptions options = null);
1471 public virtual ClientResult<VectorStore> ModifyVectorStore(string vectorStoreId, VectorStoreModificationOptions vectorStore);
1472 public virtual Task<ClientResult<VectorStore>> ModifyVectorStoreAsync(VectorStore vectorStore, VectorStoreModificationOptions options);
1473 public virtual Task<ClientResult> ModifyVectorStoreAsync(string vectorStoreId, BinaryContent content, RequestOptions options = null);
1474 public virtual Task<ClientResult<VectorStore>> ModifyVectorStoreAsync(string vectorStoreId, VectorStoreModificationOptions vectorStore);
1475 public virtual ClientResult<bool> RemoveFileFromStore(VectorStore vectorStore, OpenAIFileInfo file);
1476 public virtual ClientResult<bool> RemoveFileFromStore(string vectorStoreId, string fileId);
1477 public virtual ClientResult RemoveFileFromStore(string vectorStoreId, string fileId, RequestOptions options);
1478 public virtual Task<ClientResult<bool>> RemoveFileFromStoreAsync(VectorStore vectorStore, OpenAIFileInfo file);
1479 public virtual Task<ClientResult<bool>> RemoveFileFromStoreAsync(string vectorStoreId, string fileId);
1480 public virtual Task<ClientResult> RemoveFileFromStoreAsync(string vectorStoreId, string fileId, RequestOptions options);
1481 }
1482 public class VectorStoreCreationOptions {
1483 public VectorStoreCreationOptions();
1484 public VectorStoreExpirationPolicy ExpirationPolicy { get; init; }
1485 public IList<string> FileIds { get; init; }
1486 public IDictionary<string, string> Metadata { get; }
1487 public string Name { get; init; }
1488 }
1489 public class VectorStoreModificationOptions {
1490 public VectorStoreModificationOptions();
1491 public VectorStoreExpirationPolicy ExpirationPolicy { get; init; }
1492 public IDictionary<string, string> Metadata { get; }
1493 public string Name { get; init; }
1494 }
1495 public class VectorStore {
1496 public DateTimeOffset CreatedAt { get; }
1497 public VectorStoreExpirationPolicy ExpirationPolicy { get; }
1498 public DateTimeOffset? ExpiresAt { get; }
1499 public VectorStoreFileCounts FileCounts { get; }
1500 public string Id { get; }
1501 public DateTimeOffset? LastActiveAt { get; }
1502 public IReadOnlyDictionary<string, string> Metadata { get; }
1503 public string Name { get; }
1504 public VectorStoreStatus Status { get; }
1505 public int UsageBytes { get; }
1506 }
1507 public class VectorStoreBatchFileJob {
1508 public string BatchId { get; }
1509 public DateTimeOffset CreatedAt { get; }
1510 public VectorStoreFileCounts FileCounts { get; }
1511 public VectorStoreBatchFileJobStatus Status { get; }
1512 public string VectorStoreId { get; }
1513 }
1514 public readonly struct VectorStoreBatchFileJobStatus : IEquatable<VectorStoreBatchFileJobStatus> {
1515 public VectorStoreBatchFileJobStatus(string value);
1516 public static VectorStoreBatchFileJobStatus Cancelled { get; }
1517 public static VectorStoreBatchFileJobStatus Completed { get; }
1518 public static VectorStoreBatchFileJobStatus Failed { get; }
1519 public static VectorStoreBatchFileJobStatus InProgress { get; }
1520 public static bool operator ==(VectorStoreBatchFileJobStatus left, VectorStoreBatchFileJobStatus right);
1521 public static implicit operator VectorStoreBatchFileJobStatus(string value);
1522 public static bool operator !=(VectorStoreBatchFileJobStatus left, VectorStoreBatchFileJobStatus right);
1523 public bool Equals(VectorStoreBatchFileJobStatus other);
1524 public override bool Equals(object obj);
1525 public override int GetHashCode();
1526 public override string ToString();
1527 }
1528 public class VectorStoreExpirationPolicy {
1529 internal [SetsRequiredMembers]
1530 public VectorStoreExpirationPolicy(VectorStoreExpirationAnchor anchor, int days);
1531 public VectorStoreExpirationPolicy();
1532 public required VectorStoreExpirationAnchor Anchor { get; init; }
1533 public required int Days { get; init; }
1534 }
1535 public class VectorStoreFileAssociation {
1536 public DateTimeOffset CreatedAt { get; }
1537 public string FileId { get; }
1538 public VectorStoreFileAssociationError? LastError { get; }
1539 public int Size { get; }
1540 public VectorStoreFileAssociationStatus Status { get; }
1541 public string VectorStoreId { get; }
1542 }
1543 public readonly struct VectorStoreFileAssociationError {
1544 public VectorStoreFileAssociationError();
1545 public VectorStoreFileAssociationErrorCode Code { get; }
1546 public string Message { get; }
1547 }
1548 public readonly struct VectorStoreFileAssociationErrorCode : IEquatable<VectorStoreFileAssociationErrorCode> {
1549 public VectorStoreFileAssociationErrorCode(string value);
1550 public static VectorStoreFileAssociationErrorCode FileNotFound { get; }
1551 public static VectorStoreFileAssociationErrorCode InternalError { get; }
1552 public static VectorStoreFileAssociationErrorCode ParsingError { get; }
1553 public static VectorStoreFileAssociationErrorCode UnhandledMimeType { get; }
1554 public static bool operator ==(VectorStoreFileAssociationErrorCode left, VectorStoreFileAssociationErrorCode right);
1555 public static implicit operator VectorStoreFileAssociationErrorCode(string value);
1556 public static bool operator !=(VectorStoreFileAssociationErrorCode left, VectorStoreFileAssociationErrorCode right);
1557 public bool Equals(VectorStoreFileAssociationErrorCode other);
1558 public override bool Equals(object obj);
1559 public override int GetHashCode();
1560 public override string ToString();
1561 }
1562 public readonly struct VectorStoreFileCounts {
1563 public VectorStoreFileCounts();
1564 public int Cancelled { get; }
1565 public int Completed { get; }
1566 public int Failed { get; }
1567 public int InProgress { get; }
1568 public int Total { get; }
1569 }
1570 public readonly struct VectorStoreFileStatusFilter : IEquatable<VectorStoreFileStatusFilter> {
1571 public VectorStoreFileStatusFilter(string value);
1572 public static VectorStoreFileStatusFilter Cancelled { get; }
1573 public static VectorStoreFileStatusFilter Completed { get; }
1574 public static VectorStoreFileStatusFilter Failed { get; }
1575 public static VectorStoreFileStatusFilter InProgress { get; }
1576 public static bool operator ==(VectorStoreFileStatusFilter left, VectorStoreFileStatusFilter right);
1577 public static implicit operator VectorStoreFileStatusFilter(string value);
1578 public static bool operator !=(VectorStoreFileStatusFilter left, VectorStoreFileStatusFilter right);
1579 public bool Equals(VectorStoreFileStatusFilter other);
1580 public override bool Equals(object obj);
1581 public override int GetHashCode();
1582 public override string ToString();
1583 }
1584 public enum VectorStoreExpirationAnchor {
1585 Unknown = 0,
1586 LastActiveAt = 1,
1587 }
1588 public enum VectorStoreFileAssociationStatus {
1589 Unknown = 0,
1590 InProgress = 1,
1591 Completed = 2,
1592 Cancelled = 3,
1593 Failed = 4,
1594 }
1595 public enum VectorStoreStatus {
1596 Unknown = 0,
1597 InProgress = 1,
1598 Completed = 2,
1599 Expired = 3,
1600 }
1601}
1602```