OpenAI DotNet下载 - OpenAI DotNet源代码下载

Openai-Dotnet

一个简单的C＃.NET客户端库，用于OpenAi，可以使用其静止的API使用。独立发展，这不是一个官方图书馆，我不隶属于Openai。需要一个OpenAI API帐户。

最初是从Openai-Api-Dotnet分配的。有关罗杰·宾科姆（Roger Pincombe）博客的更多上下文。

要求

该库的目标.NET 8.0及更高版本。
它应该跨控制台应用程序，Winforms，WPF，ASP.NET等工作。
它也应在Windows，Linux和Mac上使用。

入门

从Nuget安装

从Nuget安装OpenAI-DotNet 。这是通过命令行的方式：

Powershell：

 Install-Package OpenAI-DotNet

dotnet：

 dotnet add package OpenAI-DotNet

想要在Unity游戏引擎中使用OpenAi-Dotnet？在OpenUpm上查看我们的Unity软件包：

文档

查看我们的新API文档！

https://rageagainstthepixel.github.io/openai-dotnet

验证
Azure Openai
- Azure Active Directory身份验证
Openai API代理
型号
- 列表模型
- 检索模型
- 删除微调模型
即时的？
- 创建实时会话？
- 客户事件？
  - 发送客户事件？
- 服务器事件？
  - 接收服务器事件？
助手
- 列出助手
- 创建助手
- 检索助手
- 修改助手
- 删除助手
- 助理流媒体
- 线程
  - 创建线程
  - 创建线程并运行
    - 流
  - 检索线程
  - 修改线程
  - 删除线程
  - 线程消息
    - 列表消息
    - 创建消息
    - 检索消息
    - 修改消息
  - 线程运行
    - 列表运行
    - 创建运行
      - 流
    - 检索运行
    - 修改运行
    - 提交工具输出以运行
    - 结构化输出
    - 列表运行步骤
    - 检索运行步骤
    - 取消运行
- 向量存储
  - 列表向量商店
  - 创建向量存储
  - 检索矢量商店
  - 修改向量存储
  - 删除矢量商店
  - 向量存储文件
    - 列出矢量存储文件
    - 创建向量存储文件
    - 检索矢量存储文件
    - 删除矢量存储文件
  - 向量商店文件批次
    - 创建矢量存储文件批处理
    - 检索矢量商店文件批处理
    - 列出矢量商店批处理中的文件
    - 取消矢量商店文件批处理
聊天
- 聊天完成
- 流
- 工具
- 想象
- 声音的？
- 结构化输出
- JSON模式
声音的
- 创建演讲
- 创建转录
- 创建翻译
图像
- 创建图像
- 编辑图像
- 创建图像变化
文件
- 列表文件
- 上传文件
- 删除文件
- 检索文件
- 下载文件内容
微调
- 创建微调工作
- 列出微调作业
- 检索微调工作信息
- 取消微调工作
- 列出微调工作活动
批次
- 列表
- 创建批处理
- 检索批处理
- 取消批次
嵌入
- 创建嵌入
适中
- 创建节制

验证

有3种提供您的API键的方法，按优先顺序：

警告

我们建议使用环境变量加载API密钥，而不是将其硬编码在您的源中。不建议在生产中使用此方法，而仅用于接受用户凭据，本地测试和快速启动方案。

直接使用构造函数传递键配x
从配置文件加载密钥
使用系统环境变量

直接使用构造函数传递键

警告

我们建议使用环境变量加载API密钥，而不是将其硬编码在您的源中。不建议在生产中使用此方法，而仅用于接受用户凭据，本地测试和快速启动方案。

 using var api = new OpenAIClient ( " sk-apiKey " ) ;

或手动创建一个OpenAIAuthentication对象

 using var api = new OpenAIClient ( new OpenAIAuthentication ( " sk-apiKey " , " org-yourOrganizationId " , " proj_yourProjectId " ) ) ;

从配置文件加载密钥

尝试从当前目录中的配置文件加载API键，默认情况下.openai

要创建一个配置文件，请创建一个名为.openai的新文本文件，并包含该行：

笔记

组织和项目ID条目是可选的。

JSON格式

{
  "apiKey" : " sk-aaaabbbbbccccddddd " ,
  "organizationId" : " org-yourOrganizationId " ,
  "projectId" : " proj_yourProjectId "
}

弃用格式

OPENAI_API_KEY=sk-aaaabbbbbccccddddd
OPENAI_ORGANIZATION_ID=org-yourOrganizationId
OPENAI_PROJECT_ID=proj_yourProjectId

您还可以通过在OpenAIAuthentication中调用静态方法直接加载配置文件：

在指定目录中加载默认的.openai配置：

 using var api = new OpenAIClient ( OpenAIAuthentication . LoadFromDirectory ( " path/to/your/directory " ) ) ;

从特定路径加载配置文件。只要文件符合JSON格式，就不需要.openai 。

 using var api = new OpenAIClient ( OpenAIAuthentication . LoadFromPath ( " path/to/your/file.json " ) ) ;

使用系统环境变量

使用系统的环境变量指定API密钥和组织要使用。

将OPENAI_API_KEY用于API密钥。
使用OPENAI_ORGANIZATION_ID指定组织。
使用OPENAI_PROJECT_ID指定项目。

 using var api = new OpenAIClient ( OpenAIAuthentication . LoadFromEnv ( ) ) ;

处理OpenAiClient和HTTPCLCLIENT生命周期

OpenAIClient实现IDisposable ，可管理其使用的资源的生命周期，包括HttpClient 。当您初始化OpenAIClient时，如果不提供一个内部的HTTPCLCLIENT实例，它将创建一个内部的HttpClient实例。当处理OpenAIClient时，将处置该内部HttpClient 。如果您为OpenAIClient提供外部HttpClient实例，则负责管理其处置。

如果OpenAIClient创建了自己的HttpClient ，则当您处置OpenAIClient时，它也会处理它。
如果将外部HttpClient传递给OpenAIClient ，则不会由OpenAIClient处置。您必须自己管理HttpClient的处置。

请确保适当地处理OpenAIClient ，以及时发布资源，并防止应用程序中的任何潜在内存或资源泄漏。

内部HttpClient的典型用法：

 using var api = new OpenAIClient ( ) ;

自定义HttpClient （您必须处置自己）：

 using var customHttpClient = new HttpClient ( ) ;
// set custom http client properties here
var api = new OpenAIClient ( client : customHttpClient ) ;

Azure Openai

您也可以选择使用Microsoft的Azure OpenAI部署。

您可以通过单击View Code按钮并查看这样的URL来在Azure Playground中找到所需的信息：

https://{your-resource-name}.openai.azure.com/openai/deployments/{deployment-id}/chat/completions?api-version={api-version}

your-resource-name您的Azure Openai资源的名称。
deployment-id部署模型时选择的部署名称。
api-version用于此操作的API版本。这遵循Yyyy-MM-DD格式。

要设置客户端以使用您的部署，您需要将OpenAIClientSettings传递到客户端构造函数中。

 var auth = new OpenAIAuthentication ( " sk-apiKey " ) ;
var settings = new OpenAIClientSettings ( resourceName : " your-resource-name " , deploymentId : " deployment-id " , apiVersion : " api-version " ) ;
using var api = new OpenAIClient ( auth , settings ) ;

Azure Active Directory身份验证

像往常一样与MSAL进行身份验证并获取访问令牌，然后在创建OpenAIAuthentication时使用访问令牌。然后，请确保在创建OpenAIClientSettings时将UseazureActiveDirectory设置为true。

教程：调用Web API的桌面应用程序：获取令牌

 // get your access token using any of the MSAL methods
var accessToken = result . AccessToken ;
var auth = new OpenAIAuthentication ( accessToken ) ;
var settings = new OpenAIClientSettings ( resourceName : " your-resource " , deploymentId : " deployment-id " , apiVersion : " api-version " , useActiveDirectoryAuthentication : true ) ;
using var api = new OpenAIClient ( auth , settings ) ;

Openai API代理

直接在前端应用程序中使用openai-dotnet或com.openai。为了减轻这种风险，建议建立一个中间API，该API代表您的前端应用程序向OpenAI提出请求。该库可以用于前端和中间主机配置，以确保与OpenAI API的安全通信。

前端示例

在前端示例中，您需要使用首选的OAuth提供商对用户进行安全身份验证。对用户进行身份验证后，将您的自定义验证令牌与后端上的API密钥交换。

请按照以下步骤：

使用openai-dotnet或com.openai.Unity软件包设置一个新项目。
使用您的OAuth提供商对用户进行身份验证。
成功身份验证后，创建一个新的OpenAIAuthentication对象，并使用前缀sess-传递自定义令牌。
创建一个新的OpenAIClientSettings对象，并指定中间API所在的域。
创建客户端实例时，将新的auth和settings对象传递到OpenAIClient构造函数。

这是如何设置前端的一个示例：

 var authToken = await LoginAsync ( ) ;
var auth = new OpenAIAuthentication ( $" sess- { authToken } " ) ;
var settings = new OpenAIClientSettings ( domain : " api.your-custom-domain.com " ) ;
using var api = new OpenAIClient ( auth , settings ) ;

此设置允许您的前端应用程序与您的后端安全通信，该后端将使用OpenAi-Dotnet-Proxy，然后将请求转发到OpenAI API。这样可以确保您的OpenAI API密钥和其他敏感信息在整个过程中保持安全。

后端示例

在此示例中，我们演示了如何在新的ASP.NET Core Web应用程序中设置和使用OpenAIProxy 。代理服务器将处理身份验证和转发请求到OpenAI API，以确保您的API键和其他敏感信息保持安全。

创建一个新的ASP.NET核心最小Web API项目。
将OpenAi-Dotnet Nuget软件包添加到您的项目中。
- PowerShell安装： Install-Package OpenAI-DotNet-Proxy
- dotnet安装： dotnet add package OpenAI-DotNet-Proxy
- 手动编辑.csproj： <PackageReference Include="OpenAI-DotNet-Proxy" />
创建一个从AbstractAuthenticationFilter继承的新类，并覆盖ValidateAuthentication方法。这将实现您将用于检查内部服务器的用户IAuthenticationFilter令牌。
在Program.cs中，通过调用OpenAIProxy.CreateWebApplication方法创建一个新的代理Web应用程序，将您的自定义AuthenticationFilter作为类型参数传递。
像通常使用API键，ORG ID或Azure设置一样，创建OpenAIAuthentication和OpenAIClientSettings 。

 public partial class Program
{
    private class AuthenticationFilter : AbstractAuthenticationFilter
    {
        public override async Task ValidateAuthenticationAsync ( IHeaderDictionary request )
        {
            await Task . CompletedTask ; // remote resource call to verify token

            // You will need to implement your own class to properly test
            // custom issued tokens you've setup for your end users.
            if ( ! request . Authorization . ToString ( ) . Contains ( TestUserToken ) )
            {
                throw new AuthenticationException ( " User is not authorized " ) ;
            }
        }
    }

    public static void Main ( string [ ] args )
    {
        var auth = OpenAIAuthentication . LoadFromEnv ( ) ;
        var settings = new OpenAIClientSettings ( /* your custom settings if using Azure OpenAI */ ) ;
        using var openAIClient = new OpenAIClient ( auth , settings ) ;
        OpenAIProxy . CreateWebApplication < AuthenticationFilter > ( args , openAIClient ) . Run ( ) ;
    }
}

设置代理服务器后，您的最终用户现在可以向代理API而不是直接向OpenAI API提出身份验证的请求。代理服务器将处理身份验证和转发请求到OpenAI API，以确保您的API键和其他敏感信息保持安全。

型号

列出并描述API中可用的各种模型。您可以参考模型文档，以了解可用的模型以及它们之间的差异。

还要结帐模型端点兼容性，以了解哪些模型与哪些端点有效。

为了指定本库中未预定义的自定义模型：

 var model = new Model ( " model-id " ) ;

通过OpenAIClient.ModelsEndpoint访问型号API

列表模型

列出当前可用的模型，并提供有关每个模型的基本信息，例如所有者和可用性。

 using var api = new OpenAIClient ( ) ;
var models = await api . ModelsEndpoint . GetModelsAsync ( ) ;

foreach ( var model in models )
{
    Console . WriteLine ( model . ToString ( ) ) ;
}

检索模型

检索模型实例，提供有关该模型的基本信息，例如所有者和权限。

 using var api = new OpenAIClient ( ) ;
var model = await api . ModelsEndpoint . GetModelDetailsAsync ( " gpt-4o " ) ;
Console . WriteLine ( model . ToString ( ) ) ;

删除微调模型

删除微型模型。您必须在组织中扮演所有者角色。

 using var api = new OpenAIClient ( ) ;
var isDeleted = await api . ModelsEndpoint . DeleteFineTuneModelAsync ( " your-fine-tuned-model " ) ;
Assert . IsTrue ( isDeleted ) ;

即时的

警告

Beta功能。 API可能会破裂。

实时指南

实时API使您能够构建低延迟，多模式的对话体验。它目前支持文本和音频作为输入和输出，以及功能调用。

通过OpenAIClient.RealtimeEndpoint访问助手API

创建实时会话

这是如何创建实时会话以及从模型发送和接收消息的简单示例。

 using var api = new OpenAIClient ( ) ;
var cancellationTokenSource = new CancellationTokenSource ( ) ;
var tools = new List < Tool >
{
    Tool . FromFunc ( " goodbye " , ( ) =>
    {
        cancellationTokenSource . Cancel ( ) ;
        return " Goodbye! " ;
    } )
} ;
var options = new Options ( Model . GPT4oRealtime , tools : tools ) ;
using var session = await api . RealtimeEndpoint . CreateSessionAsync ( options ) ;
var responseTask = session . ReceiveUpdatesAsync < IServerEvent > ( ServerEvents , cancellationTokenSource . Token ) ;
await session . SendAsync ( new ConversationItemCreateRequest ( " Hello! " ) ) ;
await session . SendAsync ( new CreateResponseRequest ( ) ) ;
await session . SendAsync ( new InputAudioBufferAppendRequest ( new ReadOnlyMemory < byte > ( new byte [ 1024 * 4 ] ) ) , cancellationTokenSource . Token ) ;
await session . SendAsync ( new ConversationItemCreateRequest ( " GoodBye! " ) ) ;
await session . SendAsync ( new CreateResponseRequest ( ) ) ;
await responseTask ;

void ServerEvents ( IServerEvent @event )
{
    switch ( @event )
    {
        case ResponseAudioTranscriptResponse transcriptResponse :
            Console . WriteLine ( transcriptResponse . ToString ( ) ) ;
            break ;
        case ResponseFunctionCallArgumentsResponse functionCallResponse :
            if ( functionCallResponse . IsDone )
            {
                ToolCall toolCall = functionCallResponse ;
                toolCall . InvokeFunction ( ) ;
            }

            break ;
    }
}

客户事件

该库实现了IClientEvent接口，用于传出客户端发送事件。

UpdateSessionRequest ：使用新的会话选项更新会话。
InputAudioBufferAppendRequest ：将音频附加到输入音频缓冲区。（与进行其他客户端事件不同，服务器不会对此事件发送确认响应）。
InputAudioBufferCommitRequest ：提交输入音频缓冲区。（在服务器VAD模式下，客户端无需发送此事件）。
InputAudioBufferClearRequest ：清除输入音频缓冲区。
ConversationItemCreateRequest ：创建一个新的对话项。这是将用户内容发送到模型的主要方法。
ConversationItemTruncateRequest ：发送此事件以截断以前的助手消息的音频。
ConversationItemDeleteRequest ：删除对话项。当您想从对话历史记录中删除消息时，这很有用。
CreateResponseRequest ：从模型中创建响应。创建新的对话项目或调用工具调用后，发送此事件。这将触发模型生成响应。
ResponseCancelRequest要求该事件取消过程中的响应。

发送客户端事件

您可以随时调用RealtimeSession.SendAsync方法在会话对象上，将客户端事件随时发送到服务器。发送呼叫将返回一个IServerEvent句柄，最能代表该事件服务器的适当响应。如果您想以更精细的方式处理服务器响应，这将很有用。

不过，理想情况下，您可能需要使用RealtimeSession.ReceiveUpdatesAsync处理所有服务器响应。

笔记

该服务器不会向InputAudioBufferAppendRequest事件发送确认响应。

重要的

您还需要发送CreateResponseRequest以触发模型以生成响应。

 var serverEvent = await session . SendAsync ( new ConversationItemCreateRequest ( " Hello! " ) ) ;
Console . WriteLine ( serverEvent . ToJsonString ( ) ) ;
serverEvent = await session . SendAsync ( new CreateResponseRequest ( ) ) ;
Console . WriteLine ( serverEvent . ToJsonString ( ) ) ;

服务器事件

该库实现了用于传入服务器的IServerEvent接口发送事件。

RealtimeEventError ：发生错误时返回，这可能是客户端问题或服务器问题。
SessionResponse ：返回的session.created和session.updated 。
RealtimeConversationResponse ：创建新的对话项时返回。
ConversationItemCreatedResponse ：创建新的对话项时返回。
ConversationItemInputAudioTranscriptionResponse ：输入音频转录完成或失败后返回。
ConversationItemTruncatedResponse ：截断对话项时返回。
ConversationItemDeletedResponse ：删除对话项时返回。
InputAudioBufferCommittedResponse ：当客户端或在服务器VAD模式下自动实施输入音频缓冲区时返回。
InputAudioBufferClearedResponse ：清除输入音频缓冲区时返回。
InputAudioBufferStartedResponse ：在Server_vad模式下，服务器发送，以指示在音频缓冲区中检测到的语音。这种情况可能会在任何音频添加到缓冲区中时发生（除非已经检测到语音）。客户可能希望使用此事件中断音频播放或向用户提供视觉反馈。
InputAudioBufferStoppedResponse ：当服务器检测到音频缓冲区中的语音结束时，以server_vad模式返回。
RealtimeResponse ：创建或完成响应时返回。
ResponseOutputItemResponse ：添加或完成响应输出项时返回。
ResponseContentPartResponse ：添加或完成响应内容零件时返回。
ResponseTextResponse ：返回响应文本时返回或完成时返回。
ResponseAudioTranscriptResponse ：响应音频成绩单更新或完成时返回。
ResponseAudioResponse ：更新响应音频或完成时返回。
ResponseFunctionCallArgumentsResponse ：返回响应功能调用参数被更新或完成时返回。
RateLimitsResponse ：更新速率限制时返回。

接收服务器事件

要接收服务器事件，您需要在会话对象上调用RealtimeSession.ReceiveUpdatesAsync方法。此方法将返回一个Task或IAsyncEnumerable<T> ，该任务将在会话关闭或触发取消令牌时完成。理想情况下，应调用此方法一次并在会话期间运行。

笔记

您也可以通过使用IRealtimeEvent接口而不是IServerEvent来发送IClientEvent回调。

 await foreach ( var @event in session . ReceiveUpdatesAsync < IServerEvent > ( cts . Token ) )
{
    switch ( @event )
    {
        case RealtimeEventError error :
            // raised anytime an error occurs
            break ;
        case SessionResponse sessionResponse :
            // raised when a session is created or updated
            break ;
        case RealtimeConversationResponse conversationResponse :
            // raised when a new conversation is created
            break ;
        case ConversationItemCreatedResponse conversationItemCreated :
            // raised when a new conversation item is created
            break ;
        case ConversationItemInputAudioTranscriptionResponse conversationItemTranscription :
            // raised when the input audio transcription is completed or failed
            break ;
        case ConversationItemTruncatedResponse conversationItemTruncated :
            // raised when a conversation item is truncated
            break ;
        case ConversationItemDeletedResponse conversationItemDeleted :
            // raised when a conversation item is deleted
            break ;
        case InputAudioBufferCommittedResponse committedResponse :
            // raised when an input audio buffer is committed
            break ;
        case InputAudioBufferClearedResponse clearedResponse :
            // raised when an input audio buffer is cleared
            break ;
        case InputAudioBufferStartedResponse startedResponse :
            // raised when speech is detected in the audio buffer
            break ;
        case InputAudioBufferStoppedResponse stoppedResponse :
            // raised when speech stops in the audio buffer
            break ;
        case RealtimeResponse realtimeResponse :
            // raised when a response is created or done
            break ;
        case ResponseOutputItemResponse outputItemResponse :
            // raised when a response output item is added or done
            break ;
        case ResponseContentPartResponse contentPartResponse :
            // raised when a response content part is added or done
            break ;
        case ResponseTextResponse textResponse :
            // raised when a response text is updated or done
            break ;
        case ResponseAudioTranscriptResponse transcriptResponse :
            // raised when a response audio transcript is updated or done
            break ;
        case ResponseFunctionCallArgumentsResponse functionCallResponse :
            // raised when a response function call arguments are updated or done
            break ;
        case RateLimitsResponse rateLimitsResponse :
            // raised when rate limits are updated
            break ;
    }
}

助手

警告

Beta功能。 API可能会破裂。

建立可以调用模型并使用工具执行任务的助手。

助手指南
Openai助手食谱

通过OpenAIClient.AssistantsEndpoint访问助手API。

列出助手

返回助手名单。

 using var api = new OpenAIClient ( ) ;
var assistantsList = await api . AssistantsEndpoint . ListAssistantsAsync ( ) ;

foreach ( var assistant in assistantsList . Items )
{
    Console . WriteLine ( $" { assistant } -> { assistant . CreatedAt } " ) ;
}

创建助手

创建一个具有模型和说明的助手。

 using var api = new OpenAIClient ( ) ;
var request = new CreateAssistantRequest ( Model . GPT4o ) ;
var assistant = await api . AssistantsEndpoint . CreateAssistantAsync ( request ) ;

检索助手

检索助手。

 using var api = new OpenAIClient ( ) ;
var assistant = await api . AssistantsEndpoint . RetrieveAssistantAsync ( " assistant-id " ) ;
Console . WriteLine ( $" { assistant } -> { assistant . CreatedAt } " ) ;

修改助手

修改助手。

 using var api = new OpenAIClient ( ) ;
var createRequest = new CreateAssistantRequest ( Model . GPT4_Turbo ) ;
var assistant = await api . AssistantsEndpoint . CreateAssistantAsync ( createRequest ) ;
var modifyRequest = new CreateAssistantRequest ( Model . GPT4o ) ;
var modifiedAssistant = await api . AssistantsEndpoint . ModifyAssistantAsync ( assistant . Id , modifyRequest ) ;
// OR AssistantExtension for easier use!
var modifiedAssistantEx = await assistant . ModifyAsync ( modifyRequest ) ;

删除助手

删除助手。

 using var api = new OpenAIClient ( ) ;
var isDeleted = await api . AssistantsEndpoint . DeleteAssistantAsync ( " assistant-id " ) ;
// OR AssistantExtension for easier use!
var isDeleted = await assistant . DeleteAsync ( ) ;
Assert . IsTrue ( isDeleted ) ;

助理流媒体

笔记

可以通过传递Func<IServerSentEvent, Task> streamEventHandler回调来轻松添加到现有线程呼叫中的助手流动事件。

线程

创建助手可以与之互动的线程。

线程API可通过OpenAIClient.ThreadsEndpoint访问

创建线程

创建一个线程。

 using var api = new OpenAIClient ( ) ;
var thread = await api . ThreadsEndpoint . CreateThreadAsync ( ) ;
Console . WriteLine ( $" Create thread { thread . Id } -> { thread . CreatedAt } " ) ;

创建线程并运行

创建一个线程并在一个请求中运行。

另请参阅：线程运行

 using var api = new OpenAIClient ( ) ;
var assistant = await api . AssistantsEndpoint . CreateAssistantAsync (
    new CreateAssistantRequest (
        name : " Math Tutor " ,
        instructions : " You are a personal math tutor. Answer questions briefly, in a sentence or less. " ,
        model : Model . GPT4o ) ) ;
var messages = new List < Message > { " I need to solve the equation `3x + 11 = 14`. Can you help me? " } ;
var threadRequest = new CreateThreadRequest ( messages ) ;
var run = await assistant . CreateThreadAndRunAsync ( threadRequest ) ;
Console . WriteLine ( $" Created thread and run: { run . ThreadId } -> { run . Id } -> { run . CreatedAt } " ) ;

创建线程并运行流

在流媒体事件时创建线程并在一个请求中运行它。

 using var api = new OpenAIClient ( ) ;
var tools = new List < Tool >
{
    Tool . GetOrCreateTool ( typeof ( WeatherService ) , nameof ( WeatherService . GetCurrentWeatherAsync ) )
} ;
var assistantRequest = new CreateAssistantRequest ( tools : tools , instructions : " You are a helpful weather assistant. Use the appropriate unit based on geographical location. " ) ;
var assistant = await api . AssistantsEndpoint . CreateAssistantAsync ( assistantRequest ) ;
ThreadResponse thread = null ;
async Task StreamEventHandler ( IServerSentEvent streamEvent )
{
    switch ( streamEvent )
    {
        case ThreadResponse threadResponse :
            thread = threadResponse ;
            break ;
        case RunResponse runResponse :
            if ( runResponse . Status == RunStatus . RequiresAction )
            {
                var toolOutputs = await assistant . GetToolOutputsAsync ( runResponse ) ;

                foreach ( var toolOutput in toolOutputs )
                {
                    Console . WriteLine ( $" Tool Output: { toolOutput } " ) ;
                }

                await runResponse . SubmitToolOutputsAsync ( toolOutputs , StreamEventHandler ) ;
            }
            break ;
        default :
            Console . WriteLine ( streamEvent . ToJsonString ( ) ) ;
            break ;
    }
}

var run = await assistant . CreateThreadAndRunAsync ( " I'm in Kuala-Lumpur, please tell me what's the temperature now? " , StreamEventHandler ) ;
run = await run . WaitForStatusChangeAsync ( ) ;
var messages = await thread . ListMessagesAsync ( ) ;
foreach ( var response in messages . Items . Reverse ( ) )
{
    Console . WriteLine ( $" { response . Role } : { response . PrintContent ( ) } " ) ;
}

检索线程

检索线程。

 using var api = new OpenAIClient ( ) ;
var thread = await api . ThreadsEndpoint . RetrieveThreadAsync ( " thread-id " ) ;
// OR if you simply wish to get the latest state of a thread
thread = await thread . UpdateAsync ( ) ;
Console . WriteLine ( $" Retrieve thread { thread . Id } -> { thread . CreatedAt } " ) ;

修改线程

修改线程。

注意：只能修改元数据。

 using var api = new OpenAIClient ( ) ;
var thread = await api . ThreadsEndpoint . CreateThreadAsync ( ) ;
var metadata = new Dictionary < string , string >
{
    { " key " , " custom thread metadata " }
}
thread = await api . ThreadsEndpoint . ModifyThreadAsync ( thread . Id , metadata ) ;
// OR use extension method for convenience!
thread = await thread . ModifyAsync ( metadata ) ;
Console . WriteLine ( $" Modify thread { thread . Id } -> { thread . Metadata [ " key " ] } " ) ;

删除线程

删除线程。

 using var api = new OpenAIClient ( ) ;
var isDeleted = await api . ThreadsEndpoint . DeleteThreadAsync ( " thread-id " ) ;
// OR use extension method for convenience!
var isDeleted = await thread . DeleteAsync ( ) ;
Assert . IsTrue ( isDeleted ) ;

线程消息

在线程中创建消息。

列出线程消息

返回给定线程的消息列表。

 using var api = new OpenAIClient ( ) ;
var messageList = await api . ThreadsEndpoint . ListMessagesAsync ( " thread-id " ) ;
// OR use extension method for convenience!
var messageList = await thread . ListMessagesAsync ( ) ;

foreach ( var message in messageList . Items )
{
    Console . WriteLine ( $" { message . Id } : { message . Role } : { message . PrintContent ( ) } " ) ;
}

创建线程消息

创建消息。

 using var api = new OpenAIClient ( ) ;
var thread = await api . ThreadsEndpoint . CreateThreadAsync ( ) ;
var request = new CreateMessageRequest ( " Hello world! " ) ;
var message = await api . ThreadsEndpoint . CreateMessageAsync ( thread . Id , request ) ;
// OR use extension method for convenience!
var message = await thread . CreateMessageAsync ( " Hello World! " ) ;
Console . WriteLine ( $" { message . Id } : { message . Role } : { message . PrintContent ( ) } " ) ;

检索线程消息

检索消息。

 using var api = new OpenAIClient ( ) ;
var message = await api . ThreadsEndpoint . RetrieveMessageAsync ( " thread-id " , " message-id " ) ;
// OR use extension methods for convenience!
var message = await thread . RetrieveMessageAsync ( " message-id " ) ;
var message = await message . UpdateAsync ( ) ;
Console . WriteLine ( $" { message . Id } : { message . Role } : { message . PrintContent ( ) } " ) ;

修改线程消息

修改消息。

注意：只能修改消息元数据。

 using var api = new OpenAIClient ( ) ;
var metadata = new Dictionary < string , string >
{
    { " key " , " custom message metadata " }
} ;
var message = await api . ThreadsEndpoint . ModifyMessageAsync ( " thread-id " , " message-id " , metadata ) ;
// OR use extension method for convenience!
var message = await message . ModifyAsync ( metadata ) ;
Console . WriteLine ( $" Modify message metadata: { message . Id } -> { message . Metadata [ " key " ] } " ) ;

线程运行

表示在线程上运行执行。

列表线程运行

返回属于线程的运行列表。

 using var api = new OpenAIClient ( ) ;
var runList = await api . ThreadsEndpoint . ListRunsAsync ( " thread-id " ) ;
// OR use extension method for convenience!
var runList = await thread . ListRunsAsync ( ) ;

foreach ( var run in runList . Items )
{
    Console . WriteLine ( $" [ { run . Id } ] { run . Status } | { run . CreatedAt } " ) ;
}

创建线程运行

创建一个运行。

 using var api = new OpenAIClient ( ) ;
var assistant = await api . AssistantsEndpoint . CreateAssistantAsync (
    new CreateAssistantRequest (
        name : " Math Tutor " ,
        instructions : " You are a personal math tutor. Answer questions briefly, in a sentence or less. " ,
        model : Model . GPT4o ) ) ;
var thread = await api . ThreadsEndpoint . CreateThreadAsync ( ) ;
var message = await thread . CreateMessageAsync ( " I need to solve the equation `3x + 11 = 14`. Can you help me? " ) ;
var run = await thread . CreateRunAsync ( assistant ) ;
Console . WriteLine ( $" [ { run . Id } ] { run . Status } | { run . CreatedAt } " ) ;

创建线程运行流

创建运行并流式传输事件。

 using var api = new OpenAIClient ( ) ;
var assistant = await api . AssistantsEndpoint . CreateAssistantAsync (
    new CreateAssistantRequest (
        name : " Math Tutor " ,
        instructions : " You are a personal math tutor. Answer questions briefly, in a sentence or less. Your responses should be formatted in JSON. " ,
        model : Model . GPT4o ,
        responseFormat : ChatResponseFormat . Json ) ) ;
var thread = await api . ThreadsEndpoint . CreateThreadAsync ( ) ;
var message = await thread . CreateMessageAsync ( " I need to solve the equation `3x + 11 = 14`. Can you help me? " ) ;
var run = await thread . CreateRunAsync ( assistant , async streamEvent =>
{
    Console . WriteLine ( streamEvent . ToJsonString ( ) ) ;
    await Task . CompletedTask ;
} ) ;
var messages = await thread . ListMessagesAsync ( ) ;

foreach ( var response in messages . Items . Reverse ( ) )
{
    Console . WriteLine ( $" { response . Role } : { response . PrintContent ( ) } " ) ;
}

检索线程运行

检索跑步。

 using var api = new OpenAIClient ( ) ;
var run = await api . ThreadsEndpoint . RetrieveRunAsync ( " thread-id " , " run-id " ) ;
// OR use extension method for convenience!
var run = await thread . RetrieveRunAsync ( " run-id " ) ;
var run = await run . UpdateAsync ( ) ;
Console . WriteLine ( $" [ { run . Id } ] { run . Status } | { run . CreatedAt } " ) ;

修改线程运行

修改运行。

注意：只能修改元数据。

 using var api = new OpenAIClient ( ) ;
var metadata = new Dictionary < string , string >
{
    { " key " , " custom run metadata " }
} ;
var run = await api . ThreadsEndpoint . ModifyRunAsync ( " thread-id " , " run-id " , metadata ) ;
// OR use extension method for convenience!
var run = await run . ModifyAsync ( metadata ) ;
Console . WriteLine ( $" Modify run { run . Id } -> { run . Metadata [ " key " ] } " ) ;

线程提交工具输出以运行

当运行具有状态： requires_action和required_action.type是submit_tool_outputs时，该端点可用于在工具调用完成后从工具调用中提交输出。所有输出必须在一个请求中提交。

笔记

请参阅“创建线程”和“运行流”示例，介绍如何流动工具输出事件。

 using var api = new OpenAIClient ( ) ;
var tools = new List < Tool >
{
    // Use a predefined tool
    Tool . Retrieval , Tool . CodeInterpreter ,
    // Or create a tool from a type and the name of the method you want to use for function calling
    Tool . GetOrCreateTool ( typeof ( WeatherService ) , nameof ( WeatherService . GetCurrentWeatherAsync ) ) ,
    // Pass in an instance of an object to call a method on it
    Tool . GetOrCreateTool ( api . ImagesEndPoint , nameof ( ImagesEndpoint . GenerateImageAsync ) ) ,
    // Define func<,> callbacks
    Tool . FromFunc ( " name_of_func " , ( ) => { /* callback function */ } ) ,
    Tool . FromFunc < T1 , T2 , TResult > ( " func_with_multiple_params " , ( t1 , t2 ) => { /* logic that calculates return value */ return tResult ; } )
} ;
var assistantRequest = new CreateAssistantRequest ( tools : tools , instructions : " You are a helpful weather assistant. Use the appropriate unit based on geographical location. " ) ;
var testAssistant = await api . AssistantsEndpoint . CreateAssistantAsync ( assistantRequest ) ;
var run = await testAssistant . CreateThreadAndRunAsync ( " I'm in Kuala-Lumpur, please tell me what's the temperature now? " ) ;
// waiting while run is Queued and InProgress
run = await run . WaitForStatusChangeAsync ( ) ;

// Invoke all of the tool call functions and return the tool outputs.
var toolOutputs = await testAssistant . GetToolOutputsAsync ( run . RequiredAction . SubmitToolOutputs . ToolCalls ) ;

foreach ( var toolOutput in toolOutputs )
{
    Console . WriteLine ( $" tool call output: { toolOutput . Output } " ) ;
}
// submit the tool outputs
run = await run . SubmitToolOutputsAsync ( toolOutputs ) ;
// waiting while run in Queued and InProgress
run = await run . WaitForStatusChangeAsync ( ) ;
var messages = await run . ListMessagesAsync ( ) ;

foreach ( var message in messages . Items . OrderBy ( response => response . CreatedAt ) )
{
    Console . WriteLine ( $" { message . Role } : { message . PrintContent ( ) } " ) ;
}

线程结构化输出

结构化输出是JSON模式的演变。虽然两者都确保产生有效的JSON，但仅结构化输出确保了模式依从性。

重要的

使用JSON模式时，请始终指示模型通过对话中的一些消息（例如通过系统消息）产生JSON。如果您不包含生成JSON的显式指令，则该模型可能会生成无效的空格流，并且请求可能会不断运行，直到达到令牌限制为止。为了帮助您确保您不要忘记，如果字符串“ JSON”在上下文中没有出现，API将丢弃错误。
消息中的JSON如果finish_reason为长度，则模型返回可能是部分（即切断），这表明发电超过max_tokens或对话超过令牌限制。为了防止这种情况，请在解析响应之前检查finish_reason 。

首先定义响应的结构。这些将用作您的模式。这些是您应列出的对象，因此请确保使用标准的JSON对象模型。

 public class MathResponse
{
    [ JsonInclude ]
    [ JsonPropertyName ( " steps " ) ]
    public IReadOnlyList < MathStep > Steps { get ; private set ; }

    [ JsonInclude ]
    [ JsonPropertyName ( " final_answer " ) ]
    public string FinalAnswer { get ; private set ; }
}

public class MathStep
{
    [ JsonInclude ]
    [ JsonPropertyName ( " explanation " ) ]
    public string Explanation { get ; private set ; }

    [ JsonInclude ]
    [ JsonPropertyName ( " output " ) ]
    public string Output { get ; private set ; }
}

要使用，只需将MathResponse类型指定为CreateAssistantAsync ， CreateRunAsync或CreateThreadAndRunAsync通用约束即可。

 using var api = new OpenAIClient ( ) ;
var assistant = await api . AssistantsEndpoint . CreateAssistantAsync < MathResponse > (
    new CreateAssistantRequest (
        name : " Math Tutor " ,
        instructions : " You are a helpful math tutor. Guide the user through the solution step by step. " ,
        model : " gpt-4o-2024-08-06 " ) ) ;
ThreadResponse thread = null ;

try
{
    async Task StreamEventHandler ( IServerSentEvent @event )
    {
        try
        {
            switch ( @event )
            {
                case MessageResponse message :
                    if ( message . Status != MessageStatus . Completed )
                    {
                        Console . WriteLine ( @event . ToJsonString ( ) ) ;
                        break ;
                    }

                    var mathResponse = message . FromSchema < MathResponse > ( ) ;

                    for ( var i = 0 ; i < mathResponse . Steps . Count ; i ++ )
                    {
                        var step = mathResponse . Steps [ i ] ;
                        Console . WriteLine ( $" Step { i } : { step . Explanation } " ) ;
                        Console . WriteLine ( $" Result: { step . Output } " ) ;
                    }

                    Console . WriteLine ( $" Final Answer: { mathResponse . FinalAnswer } " ) ;
                    break ;
                default :
                    Console . WriteLine ( @event . ToJsonString ( ) ) ;
                    break ;
            }
        }
        catch ( Exception e )
        {
            Console . WriteLine ( e ) ;
            throw ;
        }

        await Task . CompletedTask ;
    }

    var run = await assistant . CreateThreadAndRunAsync ( " how can I solve 8x + 7 = -23 " , StreamEventHandler ) ;
    thread = await run . GetThreadAsync ( ) ;
    run = await run . WaitForStatusChangeAsync ( ) ;
    Console . WriteLine ( $" Created thread and run: { run . ThreadId } -> { run . Id } -> { run . CreatedAt } " ) ;
    var messages = await thread . ListMessagesAsync ( ) ;

    foreach ( var response in messages . Items . OrderBy ( response => response . CreatedAt ) )
    {
        Console . WriteLine ( $" { response . Role } : { response . PrintContent ( ) } " ) ;
    }
}
finally
{
    await assistant . DeleteAsync ( deleteToolResources : thread == null ) ;

    if ( thread != null )
    {
        var isDeleted = await thread . DeleteAsync ( deleteToolResources : true ) ;
    }
}

您也可以手动创建JSON Schema JSON字符串，但是您将负责估算您的响应数据：

 using var api = new OpenAIClient ( ) ;
var mathSchema = new JsonSchema ( " math_response " , @"
{
  ""type"": ""object"",
  ""properties"": {
    ""steps"": {
      ""type"": ""array"",
      ""items"": {
        ""type"": ""object"",
        ""properties"": {
          ""explanation"": {
            ""type"": ""string""
          },
          ""output"": {
            ""type"": ""string""
          }
        },
        ""required"": [
          ""explanation"",
          ""output""
        ],
        ""additionalProperties"": false
      }
    },
    ""final_answer"": {
      ""type"": ""string""
    }
  },
  ""required"": [
    ""steps"",
    ""final_answer""
  ],
  ""additionalProperties"": false
}" ) ;
var assistant = await api . AssistantsEndpoint . CreateAssistantAsync (
    new CreateAssistantRequest (
        name : " Math Tutor " ,
        instructions : " You are a helpful math tutor. Guide the user through the solution step by step. " ,
        model : " gpt-4o-2024-08-06 " ,
        jsonSchema : mathSchema ) ) ;
ThreadResponse thread = null ;

try
{
    var run = await assistant . CreateThreadAndRunAsync ( " how can I solve 8x + 7 = -23 " ,
        async @event =>
        {
            Console . WriteLine ( @event . ToJsonString ( ) ) ;
            await Task . CompletedTask ;
        } ) ;
    thread = await run . GetThreadAsync ( ) ;
    run = await run . WaitForStatusChangeAsync ( ) ;
    Console . WriteLine ( $" Created thread and run: { run . ThreadId } -> { run . Id } -> { run . CreatedAt } " ) ;
    var messages = await thread . ListMessagesAsync ( ) ;

    foreach ( var response in messages . Items )
    {
        Console . WriteLine ( $" { response . Role } : { response . PrintContent ( ) } " ) ;
    }
}
finally
{
    await assistant . DeleteAsync ( deleteToolResources : thread == null ) ;

    if ( thread != null )
    {
        var isDeleted = await thread . DeleteAsync ( deleteToolResources : true ) ;
        Assert . IsTrue ( isDeleted ) ;
    }
}

列表线程运行步骤

返回属于运行的运行步骤列表。

 using var api = new OpenAIClient ( ) ;
var runStepList = await api . ThreadsEndpoint . ListRunStepsAsync ( " thread-id " , " run-id " ) ;
// OR use extension method for convenience!
var runStepList = await run . ListRunStepsAsync ( ) ;

foreach ( var runStep in runStepList . Items )
{
    Console . WriteLine ( $" [ { runStep . Id } ] { runStep . Status } { runStep . CreatedAt } -> { runStep . ExpiresAt } " ) ;
}

检索线程运行步骤

检索运行步骤。

 using var api = new OpenAIClient ( ) ;
var runStep = await api . ThreadsEndpoint . RetrieveRunStepAsync ( " thread-id " , " run-id " , " step-id " ) ;
// OR use extension method for convenience!
var runStep = await run . RetrieveRunStepAsync ( " step-id " ) ;
var runStep = await runStep . UpdateAsync ( ) ;
Console . WriteLine ( $" [ { runStep . Id } ] { runStep . Status } { runStep . CreatedAt } -> { runStep . ExpiresAt } " ) ;

取消线程运行

取消in_progress的运行。

 using var api = new OpenAIClient ( ) ;
var isCancelled = await api . ThreadsEndpoint . CancelRunAsync ( " thread-id " , " run-id " ) ;
// OR use extension method for convenience!
var isCancelled = await run . CancelAsync ( ) ;
Assert . IsTrue ( isCancelled ) ;

向量存储

向量存储用于存储文件file_search工具的文件。

文件搜索指南

Vector Stores API通过OpenAIClient.VectorStoresEndpoint访问

列表向量商店

返回矢量商店列表。

 using var api = new OpenAIClient ( ) ;
var vectorStores = await api . VectorStoresEndpoint . ListVectorStoresAsync ( ) ;

foreach ( var vectorStore in vectorStores . Items )
{
    Console . WriteLine ( vectorStore ) ;
}

创建向量存储

创建一个矢量存储。

 using var api = new OpenAIClient ( ) ;
var createVectorStoreRequest = new CreateVectorStoreRequest ( " test-vector-store " ) ;
var vectorStore = await api . VectorStoresEndpoint . CreateVectorStoreAsync ( createVectorStoreRequest ) ;
Console . WriteLine ( vectorStore ) ;

检索矢量商店

检索矢量商店。

 using var api = new OpenAIClient ( ) ;
var vectorStore = await api . VectorStoresEndpoint . GetVectorStoreAsync ( " vector-store-id " ) ;
Console . WriteLine ( vectorStore ) ;

修改向量存储

修改矢量存储。

 using var api = new OpenAIClient ( ) ;
var metadata = new Dictionary < string , object > { { " Test " , DateTime . UtcNow } } ;
var vectorStore = await api . VectorStoresEndpoint . ModifyVectorStoreAsync ( " vector-store-id " , metadata : metadata ) ;
Console . WriteLine ( vectorStore ) ;

删除矢量商店

删除矢量商店。

 using var api = new OpenAIClient ( ) ;
var isDeleted = await api . VectorStoresEndpoint . DeleteVectorStoreAsync ( " vector-store-id " ) ;
Assert . IsTrue ( isDeleted ) ;

向量存储文件

向量存储文件表示矢量存储中的文件。

文件搜索指南

列出矢量存储文件

返回矢量存储文件列表。

 using var api = new OpenAIClient ( ) ;
var files = await api . VectorStoresEndpoint . ListVectorStoreFilesAsync ( " vector-store-id " ) ;

foreach ( var file in vectorStoreFiles . Items )
{
    Console . WriteLine ( file ) ;
}

创建向量存储文件

通过将文件连接到矢量存储来创建矢量存储文件。

 using var api = new OpenAIClient ( ) ;
var file = await api . VectorStoresEndpoint . CreateVectorStoreFileAsync ( " vector-store-id " , " file-id " , new ChunkingStrategy ( ChunkingStrategyType . Static ) ) ;
Console . WriteLine ( file ) ;

检索矢量存储文件

检索矢量存储文件。

 using var api = new OpenAIClient ( ) ;
var file = await api . VectorStoresEndpoint . GetVectorStoreFileAsync ( " vector-store-id " , " vector-store-file-id " ) ;
Console . WriteLine ( file ) ;

删除矢量存储文件

删除矢量存储文件。这将从矢量存储中删除文件，但不会删除文件本身。要删除文件，请使用删除文件端点。

 using var api = new OpenAIClient ( ) ;
var isDeleted = await api . VectorStoresEndpoint . DeleteVectorStoreFileAsync ( " vector-store-id " , vectorStoreFile ) ;
Assert . IsTrue ( isDeleted ) ;

向量商店文件批次

向量存储文件表示矢量存储中的文件。

文件搜索指南

创建矢量存储文件批处理

创建一个矢量存储文件批次。

 using var api = new OpenAIClient ( ) ;
var files = new List < string > { " file_id_1 " , " file_id_2 " } ;
var vectorStoreFileBatch = await api . VectorStoresEndpoint . CreateVectorStoreFileBatchAsync ( " vector-store-id " , files ) ;
Console . WriteLine ( vectorStoreFileBatch ) ;

检索矢量商店文件批处理

检索矢量商店文件批次。

 using var api = new OpenAIClient ( ) ;
var vectorStoreFileBatch = await api . VectorStoresEndpoint . GetVectorStoreFileBatchAsync ( " vector-store-id " , " vector-store-file-batch-id " ) ;
// you can also use convenience methods!
vectorStoreFileBatch = await vectorStoreFileBatch . UpdateAsync ( ) ;
vectorStoreFileBatch = await vectorStoreFileBatch . WaitForStatusChangeAsync ( ) ;

列出矢量商店批处理中的文件

在批处理中返回矢量存储文件列表。

 using var api = new OpenAIClient ( ) ;
var files = await api . VectorStoresEndpoint . ListVectorStoreBatchFilesAsync ( " vector-store-id " , " vector-store-file-batch-id " ) ;

foreach ( var file in files . Items )
{
    Console . WriteLine ( file ) ;
}

取消矢量商店文件批处理

取消矢量存储文件批次。这试图尽快取消本批次的文件处理。

 using var api = new OpenAIClient ( ) ;
var isCancelled = await api . VectorStoresEndpoint . CancelVectorStoreFileBatchAsync ( " vector-store-id " , " vector-store-file-batch-id " ) ;

聊天

给定聊天对话，该模型将返回聊天完成响应。

聊天API可通过OpenAIClient.ChatEndpoint访问

聊天完成

为聊天消息创建一个完成

 using var api = new OpenAIClient ( ) ;
var messages = new List < Message >
{
    new Message ( Role . System , " You are a helpful assistant. " ) ,
    new Message ( Role . User , " Who won the world series in 2020? " ) ,
    new Message ( Role . Assistant , " The Los Angeles Dodgers won the World Series in 2020. " ) ,
    new Message ( Role . User , " Where was it played? " ) ,
} ;
var chatRequest = new ChatRequest ( messages , Model . GPT4o ) ;
var response = await api . ChatEndpoint . GetCompletionAsync ( chatRequest ) ;
var choice = response . FirstChoice ;
Console . WriteLine ( $" [ { choice . Index } ] { choice . Message . Role } : { choice . Message } | Finish Reason: { choice . FinishReason } " ) ;

聊天流

 using var api = new OpenAIClient ( ) ;
var messages = new List < Message >
{
    new Message ( Role . System , " You are a helpful assistant. " ) ,
    new Message ( Role . User , " Who won the world series in 2020? " ) ,
    new Message ( Role . Assistant , " The Los Angeles Dodgers won the World Series in 2020. " ) ,
    new Message ( Role . User , " Where was it played? " ) ,
} ;
var chatRequest = new ChatRequest ( messages ) ;
var response = await api . ChatEndpoint . StreamCompletionAsync ( chatRequest , async partialResponse =>
{
    Console . Write ( partialResponse . FirstChoice . Delta . ToString ( ) ) ;
    await Task . CompletedTask ;
} ) ;
var choice = response . FirstChoice ;
Console . WriteLine ( $" [ { choice . Index } ] { choice . Message . Role } : { choice . Message } | Finish Reason: { choice . FinishReason } " ) ;

或者如果使用IAsyncEnumerable{T} （c＃8.0+）

 using var api = new OpenAIClient ( ) ;
var messages = new List < Message >
{
    new Message ( Role . System , " You are a helpful assistant. " ) ,
    new Message ( Role . User , " Who won the world series in 2020? " ) ,
    new Message ( Role . Assistant , " The Los Angeles Dodgers won the World Series in 2020. " ) ,
    new Message ( Role . User , " Where was it played? " ) ,
} ;
var cumulativeDelta = string . Empty ;
var chatRequest = new ChatRequest ( messages ) ;
await foreach ( var partialResponse in api . ChatEndpoint . StreamCompletionEnumerableAsync ( chatRequest ) )
{
    foreach ( var choice in partialResponse . Choices . Where ( choice => choice . Delta ? . Content != null ) )
    {
        cumulativeDelta += choice . Delta . Content ;
    }
}

Console . WriteLine ( cumulativeDelta ) ;

聊天工具

 using var api = new OpenAIClient ( ) ;
var messages = new List < Message >
{
    new ( Role . System , " You are a helpful weather assistant. Always prompt the user for their location. " ) ,
    new Message ( Role . User , " What's the weather like today? " ) ,
} ;

foreach ( var message in messages )
{
    Console . WriteLine ( $" { message . Role } : { message } " ) ;
}

// Define the tools that the assistant is able to use:
// 1. Get a list of all the static methods decorated with FunctionAttribute
var tools = Tool . GetAllAvailableTools ( includeDefaults : false , forceUpdate : true , clearCache : true ) ;
// 2. Define a custom list of tools:
var tools = new List < Tool >
{
    Tool . GetOrCreateTool ( objectInstance , " TheNameOfTheMethodToCall " ) ,
    Tool . FromFunc ( " a_custom_name_for_your_function " , ( ) => { /* Some logic to run */ } )
} ;
var chatRequest = new ChatRequest ( messages , tools : tools , toolChoice : " auto " ) ;
var response = await api . ChatEndpoint . GetCompletionAsync ( chatRequest ) ;
messages . Add ( response . FirstChoice . Message ) ;

Console . WriteLine ( $" { response . FirstChoice . Message . Role } : { response . FirstChoice } | Finish Reason: { response . FirstChoice . FinishReason } " ) ;

var locationMessage = new Message ( Role . User , " I'm in Glasgow, Scotland " ) ;
messages . Add ( locationMessage ) ;
Console . WriteLine ( $" { locationMessage . Role } : { locationMessage . Content } " ) ;
chatRequest = new ChatRequest ( messages , tools : tools , toolChoice : " auto " ) ;
response = await api . ChatEndpoint . GetCompletionAsync ( chatRequest ) ;

messages . Add ( response . FirstChoice . Message ) ;

if ( response . FirstChoice . FinishReason == " stop " )
{
    Console . WriteLine ( $" { response . FirstChoice . Message . Role } : { response . FirstChoice } | Finish Reason: { response . FirstChoice . FinishReason } " ) ;

    var unitMessage = new Message ( Role . User , " Fahrenheit " ) ;
    messages . Add ( unitMessage ) ;
    Console . WriteLine ( $" { unitMessage . Role } : { unitMessage . Content } " ) ;
    chatRequest = new ChatRequest ( messages , tools : tools , toolChoice : " auto " ) ;
    response = await api . ChatEndpoint . GetCompletionAsync ( chatRequest ) ;
}

// iterate over all tool calls and invoke them
foreach ( var toolCall in response . FirstChoice . Message . ToolCalls )
{
    Console . WriteLine ( $" { response . FirstChoice . Message . Role } : { toolCall . Function . Name } | Finish Reason: { response . FirstChoice . FinishReason } " ) ;
    Console . WriteLine ( $" { toolCall . Function . Arguments } " ) ;
    // Invokes function to get a generic json result to return for tool call.
    var functionResult = await toolCall . InvokeFunctionAsync ( ) ;
    // If you know the return type and do additional processing you can use generic overload
    var functionResult = await toolCall . InvokeFunctionAsync < string > ( ) ;
    messages . Add ( new Message ( toolCall , functionResult ) ) ;
    Console . WriteLine ( $" { Role . Tool } : { functionResult } " ) ;
}
// System: You are a helpful weather assistant.
// User: What's the weather like today?
// Assistant: Sure, may I know your current location? | Finish Reason: stop
// User: I'm in Glasgow, Scotland
// Assistant: GetCurrentWeather | Finish Reason: tool_calls
// {
//   "location": "Glasgow, Scotland",
//   "unit": "celsius"
// }
// Tool: The current weather in Glasgow, Scotland is 39°C.

聊天视觉

警告

Beta功能。 API可能会破裂。

 using var api = new OpenAIClient ( ) ;
var messages = new List < Message >
{
    new Message ( Role . System , " You are a helpful assistant. " ) ,
    new Message ( Role . User , new List < Content >
    {
        " What's in this image? " ,
        new ImageUrl ( " https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg " , ImageDetail . Low )
    } )
} ;
var chatRequest = new ChatRequest ( messages , model : Model . GPT4o ) ;
var response = await api . ChatEndpoint . GetCompletionAsync ( chatRequest ) ;
Console . WriteLine ( $" { response . FirstChoice . Message . Role } : { response . FirstChoice . Message . Content } | Finish Reason: { response . FirstChoice . FinishDetails } " ) ;

聊天音频

 using var api = new OpenAIClient ( ) ;
var messages = new List < Message >
{
    new Message ( Role . System , " You are a helpful assistant. " ) ,
    new Message ( Role . User , " Is a golden retriever a good family dog? " )
} ;
var chatRequest = new ChatRequest ( messages , Model . GPT4oAudio , audioConfig : Voice . Alloy ) ;
var response = await api . ChatEndpoint . GetCompletionAsync ( chatRequest ) ;
Console . WriteLine ( $" { response . FirstChoice . Message . Role } : { response . FirstChoice } | Finish Reason: { response . FirstChoice . FinishDetails } " ) ;
// todo play response.FirstChoice.Message.AudioOutput.Data

聊天结构化输出

JSON模式的演变。虽然两者都确保产生有效的JSON，但仅结构化输出确保了模式依从性。

重要的

使用JSON模式时，请始终指示模型通过对话中的一些消息（例如通过系统消息）产生JSON。如果您不包含生成JSON的显式指令，则该模型可能会生成无效的空格流，并且请求可能会不断运行，直到达到令牌限制为止。为了帮助您确保您不要忘记，如果字符串“ JSON”在上下文中没有出现，API将丢弃错误。
消息中的JSON如果finish_reason为长度，则模型返回可能是部分（即切断），这表明发电超过max_tokens或对话超过令牌限制。为了防止这种情况，请在解析响应之前检查finish_reason 。

首先定义响应的结构。这些将用作您的模式。这些是您应列出的对象，因此请确保使用标准的JSON对象模型。

 public class MathResponse
{
    [ JsonInclude ]
    [ JsonPropertyName ( " steps " ) ]
    public IReadOnlyList < MathStep > Steps { get ; private set ; }

    [ JsonInclude ]
    [ JsonPropertyName ( " final_answer " ) ]
    public string FinalAnswer { get ; private set ; }
}

public class MathStep
{
    [ JsonInclude ]
    [ JsonPropertyName ( " explanation " ) ]
    public string Explanation { get ; private set ; }

    [ JsonInclude ]
    [ JsonPropertyName ( " output " ) ]
    public string Output { get ; private set ; }
}

要使用，请在请求完成时只需将MathResponse类型指定为通用约束即可。

 using var api = new OpenAIClient ( ) ;
var messages = new List < Message >
{
    new ( Role . System , " You are a helpful math tutor. Guide the user through the solution step by step. " ) ,
    new ( Role . User , " how can I solve 8x + 7 = -23 " )
} ;

var chatRequest = new ChatRequest ( messages , model : " gpt-4o-2024-08-06 " ) ;
var ( mathResponse , chatResponse ) = await api . ChatEndpoint . GetCompletionAsync < MathResponse > ( chatRequest ) ;

for ( var i = 0 ; i < mathResponse . Steps . Count ; i ++ )
{
    var step = mathResponse . Steps [ i ] ;
    Console . WriteLine ( $" Step { i } : { step . Explanation } " ) ;
    Console . WriteLine ( $" Result: { step . Output } " ) ;
}

Console . WriteLine ( $" Final Answer: { mathResponse . FinalAnswer } " ) ;
chatResponse . GetUsage ( ) ;

聊天JSON模式

重要的

使用JSON模式时，请始终指示模型通过对话中的一些消息（例如通过系统消息）产生JSON。如果您不包含生成JSON的显式指令，则该模型可能会生成无效的空格流，并且请求可能会不断运行，直到达到令牌限制为止。为了帮助您确保您不要忘记，如果字符串“ JSON”在上下文中没有出现，API将丢弃错误。
消息中的JSON如果finish_reason为长度，则模型返回可能是部分（即切断），这表明发电超过max_tokens或对话超过令牌限制。为了防止这种情况，请在解析响应之前检查finish_reason 。
JSON模式不会保证输出匹配任何特定模式，只是它是有效的，并且没有错误。

 var messages = new List < Message >
{
    new Message ( Role . System , " You are a helpful assistant designed to output JSON. " ) ,
    new Message ( Role . User , " Who won the world series in 2020? " ) ,
} ;
var chatRequest = new ChatRequest ( messages , Model . GPT4o , responseFormat : ChatResponseFormat . Json ) ;
var response = await api . ChatEndpoint . GetCompletionAsync ( chatRequest ) ;

foreach ( var choice in response . Choices )
{
    Console . WriteLine ( $" [ { choice . Index } ] { choice . Message . Role } : { choice } | Finish Reason: { choice . FinishReason } " ) ;
}

response . GetUsage ( ) ;

声音的

将音频转换为文本。

通过OpenAIClient.AudioEndpoint访问音频API

创建演讲

从输入文本生成音频。

 using var api = new OpenAIClient ( ) ;
var request = new SpeechRequest ( " Hello World! " ) ;
async Task ChunkCallback ( ReadOnlyMemory < byte > chunkCallback )
{
    // TODO Implement audio playback as chunks arrive
    await Task . CompletedTask ;
}

var response = await api . AudioEndpoint . CreateSpeechAsync ( request , ChunkCallback ) ;
await File . WriteAllBytesAsync ( " ../../../Assets/HelloWorld.mp3 " , response . ToArray ( ) ) ;

创建转录

将音频转录为输入语言。

 using var api = new OpenAIClient ( ) ;
using var request = new AudioTranscriptionRequest ( Path . GetFullPath ( audioAssetPath ) , language : " en " ) ;
var response = await api . AudioEndpoint . CreateTranscriptionTextAsync ( request ) ;
Console . WriteLine ( response ) ;

您还可以使用verbose_json获取详细信息以获得时间戳粒度：

 using var api = new OpenAIClient ( ) ;
using var request = new AudioTranscriptionRequest ( transcriptionAudio , responseFormat : AudioResponseFormat . Verbose_Json , timestampGranularity : TimestampGranularity . Word , temperature : 0.1f , language : " en " ) ;
var response = await api . AudioEndpoint . CreateTranscriptionTextAsync ( request ) ;

foreach ( var word in response . Words )
{
    Console . WriteLine ( $" [ { word . Start } - { word . End } ] " { word . Word } " " ) ;
}

创建翻译

将音频翻译成英文。

 using var api = new OpenAIClient ( ) ;
using var request = new AudioTranslationRequest ( Path . GetFullPath ( audioAssetPath ) ) ;
var response = await api . AudioEndpoint . CreateTranslationTextAsync ( request ) ;
Console . WriteLine ( response ) ;

图像

给定提示和/或输入图像，该模型将生成新图像。

通过OpenAIClient.ImagesEndpoint访问图像API

创建图像

创建给定提示的图像。

 using var api = new OpenAIClient ( ) ;
var request = new ImageGenerationRequest ( " A house riding a velociraptor " , Models . Model . DallE_3 ) ;
var imageResults = await api . ImagesEndPoint . GenerateImageAsync ( request ) ;

foreach ( var image in imageResults )
{
    Console . WriteLine ( image ) ;
    // image == url or b64_string
}

编辑图像

给定原始图像和提示，创建编辑或扩展的图像。

 using var api = new OpenAIClient ( ) ;
var request = new ImageEditRequest ( imageAssetPath , maskAssetPath , " A sunlit indoor lounge area with a pool containing a flamingo " , size : ImageSize . Small ) ;
var imageResults = await api . ImagesEndPoint . CreateImageEditAsync ( request ) ;

foreach ( var image in imageResults )
{
    Console . WriteLine ( image ) ;
    // image == url or b64_string
}

创建图像变化

创建给定图像的变体。

 using var api = new OpenAIClient ( ) ;
var request = new ImageVariationRequest ( imageAssetPath , size : ImageSize . Small ) ;
var imageResults = await api . ImagesEndPoint . CreateImageVariationAsync ( request ) ;

foreach ( var image in imageResults )
{
    Console . WriteLine ( image ) ;
    // image == url or b64_string
}

文件

文件用于上传可以与微调之类的功能一起使用的文档。

文件API可通过OpenAIClient.FilesEndpoint访问

列表文件

返回属于用户组织的文件列表。

 using var api = new OpenAIClient ( ) ;
var fileList = await api . FilesEndpoint . ListFilesAsync ( ) ;

foreach ( var file in fileList )
{
    Console . WriteLine ( $" { file . Id } -> { file . Object } : { file . FileName } | { file . Size } bytes " ) ;
}

上传文件

上传可以在各个端点上使用的文件。一个组织上传的所有文件的大小最多可高达100 GB。

单个文件的大小最多可以为512 MB。请参阅《助手工具指南》，以了解有关支持的文件类型的更多信息。微调API仅支持.jsonl文件。

 using var api = new OpenAIClient ( ) ;
var file = await api . FilesEndpoint . UploadFileAsync ( " path/to/your/file.jsonl " , FilePurpose . FineTune ) ;
Console . WriteLine ( file . Id ) ;

删除文件

删除文件。

 using var api = new OpenAIClient ( ) ;
var isDeleted = await api . FilesEndpoint . DeleteFileAsync ( fileId ) ;
Assert . IsTrue ( isDeleted ) ;

检索文件信息

返回有关特定文件的信息。

 using var api = new OpenAIClient ( ) ;
var file = await api . FilesEndpoint . GetFileInfoAsync ( fileId ) ;
Console . WriteLine ( $" { file . Id } -> { file . Object } : { file . FileName } | { file . Size } bytes " ) ;

下载文件内容

将文件内容下载到指定的目录。

 using var api = new OpenAIClient ( ) ;
var downloadedFilePath = await api . FilesEndpoint . DownloadFileAsync ( fileId , " path/to/your/save/directory " ) ;
Console . WriteLine ( downloadedFilePath ) ;
Assert . IsTrue ( File . Exists ( downloadedFilePath ) ) ;

微调

管理微调工作，以根据您的特定培训数据量身定制模型。

创建微调工作

创建一个从给定数据集微调指定模型的作业。

响应包括临时作业的详细信息，包括工作状态，以及完成的微调模型的名称。

 using var api = new OpenAIClient ( ) ;
var fileId = " file-abc123 " ;
var request = new CreateFineTuneRequest ( fileId ) ;
var job = await api . FineTuningEndpoint . CreateJobAsync ( Model . GPT3_5_Turbo , request ) ;
Console . WriteLine ( $" Started { job . Id } | Status: { job . Status } " ) ;

列出微调作业

列出您组织的微调工作。

 using var api = new OpenAIClient ( ) ;
var jobList = await api . FineTuningEndpoint . ListJobsAsync ( ) ;

foreach ( var job in jobList . Items . OrderByDescending ( job => job . CreatedAt ) )
{
    Console . WriteLine ( $" { job . Id } -> { job . CreatedAt } | { job . Status } " ) ;
}

检索微调工作信息

获取有关微调工作的信息。

 using var api = new OpenAIClient ( ) ;
var job = await api . FineTuningEndpoint . GetJobInfoAsync ( fineTuneJob ) ;
Console . WriteLine ( $" { job . Id } -> { job . CreatedAt } | { job . Status } " ) ;

取消微调工作

立即取消微调工作。

 using var api = new OpenAIClient ( ) ;
var isCancelled = await api . FineTuningEndpoint . CancelFineTuneJobAsync ( fineTuneJob ) ;
Assert . IsTrue ( isCancelled ) ;

列出微调工作活动

获取微调工作的状态更新。

 using var api = new OpenAIClient ( ) ;
var eventList = await api . FineTuningEndpoint . ListJobEventsAsync ( fineTuneJob ) ;
Console . WriteLine ( $" { fineTuneJob . Id } -> status: { fineTuneJob . Status } | event count: { eventList . Events . Count } " ) ;

foreach ( var @event in eventList . Items . OrderByDescending ( @event => @event . CreatedAt ) )
{
    Console . WriteLine ( $"  { @event . CreatedAt } [ { @event . Level } ] { @event . Message } " ) ;
}

批次

创建大量的API请求，以进行异步处理。批处理API在24小时内返回完成，以50％的折扣。

批处理指南

批次API可通过OpenAIClient.BatchesEndpoint访问

列表

列出您组织的批次。

 using var api = new OpenAIClient ( ) ;
var batches = await api . BatchEndpoint . ListBatchesAsync ( ) ;

foreach ( var batch in listResponse . Items )
{
    Console . WriteLine ( batch ) ;
}

创建批处理

从上传的请求文件中创建并执行批量

 using var api = new OpenAIClient ( ) ;
var batchRequest = new CreateBatchRequest ( " file-id " , Endpoint . ChatCompletions ) ;
var batch = await api . BatchEndpoint . CreateBatchAsync ( batchRequest ) ;

检索批处理

检索一批。

 using var api = new OpenAIClient ( ) ;
var batch = await api . BatchEndpoint . RetrieveBatchAsync ( " batch-id " ) ;
// you can also use convenience methods!
batch = await batch . UpdateAsync ( ) ;
batch = await batch . WaitForStatusChangeAsync ( ) ;

取消批次

取消过程内批处理。该批次将在状态取消长达10分钟，然后更改为取消，在此将在输出文件中具有部分结果（如果有）。

 using var api = new OpenAIClient ( ) ;
var isCancelled = await api . BatchEndpoint . CancelBatchAsync ( batch ) ;
Assert . IsTrue ( isCancelled ) ;

嵌入

获取给定输入的矢量表示，该输入可以通过机器学习模型和算法轻松消耗。

创建嵌入

创建代表输入文本的嵌入向量。

 using var api = new OpenAIClient ( ) ;
var response = await api . EmbeddingsEndpoint . CreateEmbeddingAsync ( " The food was delicious and the waiter... " , Models . Embedding_Ada_002 ) ;
Console . WriteLine ( response ) ;

适中

给定输入文本，如果模型将其分类为违反OpenAI的内容策略，则输出。

创建节制

如果文本违反了Openai的内容政策，则分类。

 using var api = new OpenAIClient ( ) ;
var isViolation = await api . ModerationsEndpoint . GetModerationAsync ( " I want to kill them. " ) ;
Assert . IsTrue ( isViolation ) ;

此外，您还可以获得给定输入的分数。

 using var api = new OpenAIClient ( ) ;
var response = await api . ModerationsEndpoint . CreateModerationAsync ( new ModerationsRequest ( " I love you " ) ) ;
Assert . IsNotNull ( response ) ;
Console . WriteLine ( response . Results ? [ 0 ] ? . Scores ? . ToString ( ) ) ;

展开