339 lines
12 KiB
C#
339 lines
12 KiB
C#
using System.Text;
|
||
using System.Text.Json;
|
||
|
||
namespace MiaoJiZhang.Api.Services;
|
||
|
||
public partial class OpenAiVisionClient
|
||
{
|
||
public async Task<AgentRunResponse> RunAgentAsync(
|
||
string systemPrompt,
|
||
string userText,
|
||
IReadOnlyList<AgentToolDefinition> tools,
|
||
Func<AgentToolCall, CancellationToken, Task<string>> executeTool,
|
||
Func<string, CancellationToken, Task>? onToken = null,
|
||
Func<string, CancellationToken, Task>? onToolRunning = null,
|
||
CancellationToken ct = default)
|
||
{
|
||
Load();
|
||
if (string.IsNullOrWhiteSpace(_apiKey))
|
||
throw new InvalidOperationException("AI 功能尚未配置");
|
||
if (_protocol != "responses")
|
||
throw new InvalidOperationException("AI Agent 记账要求使用 Responses 协议");
|
||
|
||
var providerTools = tools.Select(tool => new
|
||
{
|
||
type = "function",
|
||
name = tool.Name,
|
||
description = tool.Description,
|
||
parameters = tool.Parameters,
|
||
}).ToArray();
|
||
var input = new object[]
|
||
{
|
||
new { role = "system", content = systemPrompt },
|
||
new { role = "user", content = userText },
|
||
};
|
||
|
||
string? previousResponseId = null;
|
||
IReadOnlyList<object>? toolOutputs = null;
|
||
var text = new StringBuilder();
|
||
var toolCallCount = 0;
|
||
|
||
for (var round = 0; round < 4; round++)
|
||
{
|
||
object body = previousResponseId is null
|
||
? new
|
||
{
|
||
model = _model,
|
||
input,
|
||
tools = providerTools,
|
||
tool_choice = "auto",
|
||
max_output_tokens = _maxTokens,
|
||
temperature = 0.3,
|
||
thinking = new { type = "disabled" },
|
||
store = true,
|
||
stream = true,
|
||
}
|
||
: new
|
||
{
|
||
model = _model,
|
||
previous_response_id = previousResponseId,
|
||
input = toolOutputs,
|
||
tools = providerTools,
|
||
tool_choice = "auto",
|
||
max_output_tokens = _maxTokens,
|
||
temperature = 0.3,
|
||
thinking = new { type = "disabled" },
|
||
store = true,
|
||
stream = true,
|
||
};
|
||
|
||
var turn = await StreamAgentTurnAsync(
|
||
body,
|
||
async (token, tokenCt) =>
|
||
{
|
||
text.Append(token);
|
||
if (onToken is not null) await onToken(token, tokenCt);
|
||
},
|
||
ct);
|
||
previousResponseId = turn.ResponseId;
|
||
|
||
if (turn.Calls.Count == 0)
|
||
return new AgentRunResponse(text.ToString().Trim(), toolCallCount);
|
||
if (string.IsNullOrWhiteSpace(previousResponseId))
|
||
throw new InvalidOperationException("AI 工具调用缺少响应 ID");
|
||
|
||
var outputs = new List<object>();
|
||
foreach (var call in turn.Calls)
|
||
{
|
||
toolCallCount++;
|
||
if (toolCallCount > 12)
|
||
throw new InvalidOperationException("AI 工具调用次数过多，请重新描述需求");
|
||
if (onToolRunning is not null)
|
||
await onToolRunning(call.Name, ct);
|
||
|
||
string output;
|
||
try
|
||
{
|
||
output = await executeTool(call, ct);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger.LogWarning(
|
||
ex,
|
||
"Agent tool failed. tool={Tool} callId={CallId}",
|
||
call.Name,
|
||
call.CallId);
|
||
output = JsonSerializer.Serialize(new
|
||
{
|
||
ok = false,
|
||
error = ex.Message,
|
||
});
|
||
}
|
||
outputs.Add(new
|
||
{
|
||
type = "function_call_output",
|
||
call_id = call.CallId,
|
||
output,
|
||
});
|
||
}
|
||
toolOutputs = outputs;
|
||
}
|
||
|
||
throw new InvalidOperationException("AI 工具调用轮次过多，请重新描述需求");
|
||
}
|
||
|
||
private async Task<AgentProviderTurn> StreamAgentTurnAsync(
|
||
object body,
|
||
Func<string, CancellationToken, Task> onToken,
|
||
CancellationToken ct)
|
||
{
|
||
var request = new HttpRequestMessage(
|
||
HttpMethod.Post,
|
||
_baseUrl + "/responses")
|
||
{
|
||
Content = new StringContent(
|
||
JsonSerializer.Serialize(body),
|
||
Encoding.UTF8,
|
||
"application/json"),
|
||
};
|
||
request.Headers.Add("Authorization", "Bearer " + _apiKey);
|
||
|
||
using var response = await _http.SendAsync(
|
||
request,
|
||
HttpCompletionOption.ResponseHeadersRead,
|
||
ct);
|
||
if (!response.IsSuccessStatusCode)
|
||
{
|
||
var detail = await response.Content.ReadAsStringAsync(ct);
|
||
throw new HttpRequestException(
|
||
$"AI Agent 请求失败 ({(int)response.StatusCode})：{ReadAgentError(detail)}");
|
||
}
|
||
|
||
using var stream = await response.Content.ReadAsStreamAsync(ct);
|
||
using var reader = new StreamReader(stream);
|
||
var calls = new Dictionary<string, AgentCallBuilder>();
|
||
string? responseId = null;
|
||
var emittedText = false;
|
||
|
||
while (!reader.EndOfStream && !ct.IsCancellationRequested)
|
||
{
|
||
var line = await reader.ReadLineAsync(ct);
|
||
if (string.IsNullOrWhiteSpace(line) || line == "data: [DONE]") continue;
|
||
if (!line.StartsWith("data:", StringComparison.Ordinal)) continue;
|
||
|
||
var payload = line[5..].TrimStart();
|
||
if (payload.Length == 0 || payload == "[DONE]") continue;
|
||
using var document = JsonDocument.Parse(payload);
|
||
var root = document.RootElement;
|
||
var eventType = TryGetProperty(root, "type", out var typeNode)
|
||
? typeNode.GetString()
|
||
: null;
|
||
|
||
if (eventType is "response.failed" or "error")
|
||
throw new InvalidOperationException(ReadAgentError(payload));
|
||
|
||
if (TryGetProperty(root, "response", out var responseNode) &&
|
||
responseNode.ValueKind == JsonValueKind.Object &&
|
||
TryGetProperty(responseNode, "id", out var responseIdNode))
|
||
{
|
||
responseId = responseIdNode.GetString() ?? responseId;
|
||
}
|
||
|
||
if (eventType == "response.output_text.delta" &&
|
||
TryGetProperty(root, "delta", out var deltaNode) &&
|
||
deltaNode.ValueKind == JsonValueKind.String)
|
||
{
|
||
var token = deltaNode.GetString();
|
||
if (!string.IsNullOrEmpty(token))
|
||
{
|
||
emittedText = true;
|
||
await onToken(token, ct);
|
||
}
|
||
continue;
|
||
}
|
||
|
||
if (eventType == "response.output_item.added" &&
|
||
TryGetProperty(root, "item", out var itemNode))
|
||
{
|
||
AddFunctionCall(itemNode, calls);
|
||
continue;
|
||
}
|
||
|
||
if (eventType == "response.function_call_arguments.delta")
|
||
{
|
||
var key = ReadCallKey(root);
|
||
if (key is not null && calls.TryGetValue(key, out var builder) &&
|
||
TryGetProperty(root, "delta", out var argumentDelta))
|
||
{
|
||
builder.Arguments.Append(argumentDelta.GetString());
|
||
}
|
||
continue;
|
||
}
|
||
|
||
if (eventType == "response.function_call_arguments.done")
|
||
{
|
||
var key = ReadCallKey(root);
|
||
if (key is not null && calls.TryGetValue(key, out var builder) &&
|
||
TryGetProperty(root, "arguments", out var argumentsNode))
|
||
{
|
||
builder.Arguments.Clear();
|
||
builder.Arguments.Append(argumentsNode.GetString());
|
||
}
|
||
continue;
|
||
}
|
||
|
||
if (eventType == "response.completed" &&
|
||
TryGetProperty(root, "response", out var completedResponse))
|
||
{
|
||
AddFunctionCallsFromResponse(completedResponse, calls);
|
||
if (!emittedText)
|
||
{
|
||
var completeText = ExtractResponseText(completedResponse);
|
||
if (!string.IsNullOrWhiteSpace(completeText))
|
||
{
|
||
emittedText = true;
|
||
await onToken(completeText, ct);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return new AgentProviderTurn(
|
||
responseId,
|
||
calls.Values
|
||
.Where(call => !string.IsNullOrWhiteSpace(call.CallId) &&
|
||
!string.IsNullOrWhiteSpace(call.Name))
|
||
.Select(call => new AgentToolCall(
|
||
call.CallId,
|
||
call.Name,
|
||
call.Arguments.ToString()))
|
||
.ToList());
|
||
}
|
||
|
||
private static void AddFunctionCallsFromResponse(
|
||
JsonElement response,
|
||
Dictionary<string, AgentCallBuilder> calls)
|
||
{
|
||
if (!TryGetProperty(response, "output", out var output) ||
|
||
output.ValueKind != JsonValueKind.Array) return;
|
||
foreach (var item in output.EnumerateArray()) AddFunctionCall(item, calls);
|
||
}
|
||
|
||
private static void AddFunctionCall(
|
||
JsonElement item,
|
||
Dictionary<string, AgentCallBuilder> calls)
|
||
{
|
||
if (!TryGetProperty(item, "type", out var type) ||
|
||
type.GetString() != "function_call") return;
|
||
|
||
var itemId = TryGetProperty(item, "id", out var idNode)
|
||
? idNode.GetString()
|
||
: null;
|
||
var callId = TryGetProperty(item, "call_id", out var callIdNode)
|
||
? callIdNode.GetString()
|
||
: null;
|
||
var name = TryGetProperty(item, "name", out var nameNode)
|
||
? nameNode.GetString()
|
||
: null;
|
||
var key = itemId ?? callId;
|
||
if (string.IsNullOrWhiteSpace(key) || string.IsNullOrWhiteSpace(callId)) return;
|
||
|
||
if (!calls.TryGetValue(key, out var builder))
|
||
{
|
||
builder = new AgentCallBuilder(callId!, name ?? "");
|
||
calls[key] = builder;
|
||
}
|
||
if (!string.IsNullOrWhiteSpace(name)) builder.Name = name!;
|
||
if (TryGetProperty(item, "arguments", out var arguments) &&
|
||
arguments.ValueKind == JsonValueKind.String &&
|
||
!string.IsNullOrWhiteSpace(arguments.GetString()))
|
||
{
|
||
builder.Arguments.Clear();
|
||
builder.Arguments.Append(arguments.GetString());
|
||
}
|
||
}
|
||
|
||
private static string? ReadCallKey(JsonElement root)
|
||
{
|
||
if (TryGetProperty(root, "item_id", out var itemId))
|
||
return itemId.GetString();
|
||
if (TryGetProperty(root, "call_id", out var callId))
|
||
return callId.GetString();
|
||
return null;
|
||
}
|
||
|
||
private static string ReadAgentError(string raw)
|
||
{
|
||
try
|
||
{
|
||
using var document = JsonDocument.Parse(raw);
|
||
var root = document.RootElement;
|
||
if (TryGetProperty(root, "error", out var error))
|
||
{
|
||
if (error.ValueKind == JsonValueKind.String)
|
||
return error.GetString() ?? "AI 服务返回错误";
|
||
if (TryGetProperty(error, "message", out var message))
|
||
return message.GetString() ?? error.ToString();
|
||
return error.ToString();
|
||
}
|
||
if (TryGetProperty(root, "message", out var directMessage))
|
||
return directMessage.GetString() ?? "AI 服务返回错误";
|
||
}
|
||
catch (JsonException)
|
||
{
|
||
}
|
||
return raw.Length > 300 ? raw[..300] : raw;
|
||
}
|
||
|
||
private sealed record AgentProviderTurn(
|
||
string? ResponseId,
|
||
IReadOnlyList<AgentToolCall> Calls);
|
||
|
||
private sealed class AgentCallBuilder(string callId, string name)
|
||
{
|
||
public string CallId { get; } = callId;
|
||
public string Name { get; set; } = name;
|
||
public StringBuilder Arguments { get; } = new();
|
||
}
|
||
}
|