403 lines
14 KiB
C#
403 lines
14 KiB
C#
using AxCopilot.Models;
|
|
using AxCopilot.Services;
|
|
|
|
namespace AxCopilot.Services.Agent;
|
|
|
|
/// <summary>
|
|
/// AX Agent execution-prep engine.
|
|
/// Inspired by the `claw-code` split between input preparation and session execution,
|
|
/// so the UI layer stops owning message assembly and final assistant commit logic.
|
|
/// </summary>
|
|
public sealed class AxAgentExecutionEngine
|
|
{
|
|
public sealed record PreparedTurn(List<ChatMessage> Messages);
|
|
public sealed record ExecutionMode(bool UseAgentLoop, bool UseStreamingTransport, string? TaskSystemPrompt);
|
|
public sealed record PreparedExecution(
|
|
ExecutionMode Mode,
|
|
IReadOnlyList<string> PromptStack,
|
|
List<ChatMessage> Messages);
|
|
public sealed record FinalizedContent(string Content, bool Cancelled, string? FailureReason);
|
|
public sealed record SessionMutationResult(
|
|
ChatConversation CurrentConversation,
|
|
ChatConversation UpdatedConversation);
|
|
|
|
public IReadOnlyList<string> BuildPromptStack(
|
|
string? conversationSystem,
|
|
string? slashSystem,
|
|
string? taskSystem = null)
|
|
{
|
|
var prompts = new List<string>();
|
|
if (!string.IsNullOrWhiteSpace(conversationSystem))
|
|
prompts.Add(conversationSystem.Trim());
|
|
if (!string.IsNullOrWhiteSpace(slashSystem))
|
|
prompts.Add(slashSystem.Trim());
|
|
if (!string.IsNullOrWhiteSpace(taskSystem))
|
|
prompts.Add(taskSystem.Trim());
|
|
return prompts;
|
|
}
|
|
|
|
public ExecutionMode ResolveExecutionMode(
|
|
string runTab,
|
|
bool streamingEnabled,
|
|
string resolvedService,
|
|
string? coworkSystemPrompt,
|
|
string? codeSystemPrompt)
|
|
{
|
|
if (string.Equals(runTab, "Cowork", StringComparison.OrdinalIgnoreCase))
|
|
return new ExecutionMode(true, false, coworkSystemPrompt);
|
|
|
|
if (string.Equals(runTab, "Code", StringComparison.OrdinalIgnoreCase))
|
|
return new ExecutionMode(true, false, codeSystemPrompt);
|
|
|
|
return new ExecutionMode(false, false, null);
|
|
}
|
|
|
|
public PreparedExecution PrepareExecution(
|
|
ChatConversation conversation,
|
|
string runTab,
|
|
bool streamingEnabled,
|
|
string resolvedService,
|
|
string? conversationSystem,
|
|
string? slashSystem,
|
|
string? coworkSystemPrompt,
|
|
string? codeSystemPrompt,
|
|
string? fileContext = null,
|
|
IReadOnlyList<ImageAttachment>? images = null)
|
|
{
|
|
var mode = ResolveExecutionMode(
|
|
runTab,
|
|
streamingEnabled,
|
|
resolvedService,
|
|
coworkSystemPrompt,
|
|
codeSystemPrompt);
|
|
var promptStack = BuildPromptStack(
|
|
conversationSystem,
|
|
slashSystem,
|
|
mode.TaskSystemPrompt);
|
|
var preparedTurn = PrepareTurn(conversation, promptStack, fileContext, images);
|
|
return new PreparedExecution(mode, promptStack, preparedTurn.Messages);
|
|
}
|
|
|
|
public Task<string> ExecutePreparedAsync(
|
|
PreparedExecution prepared,
|
|
Func<IReadOnlyList<ChatMessage>, CancellationToken, Task<string>> agentLoopRunner,
|
|
Func<IReadOnlyList<ChatMessage>, CancellationToken, Task<string>> llmRunner,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
return prepared.Mode.UseAgentLoop
|
|
? agentLoopRunner(prepared.Messages, cancellationToken)
|
|
: llmRunner(prepared.Messages, cancellationToken);
|
|
}
|
|
|
|
public PreparedTurn PrepareTurn(
|
|
ChatConversation conversation,
|
|
IEnumerable<string?> systemPrompts,
|
|
string? fileContext = null,
|
|
IReadOnlyList<ImageAttachment>? images = null)
|
|
{
|
|
var outbound = conversation.Messages
|
|
.Select(CloneMessage)
|
|
.ToList();
|
|
|
|
if (!string.IsNullOrWhiteSpace(fileContext))
|
|
{
|
|
var lastUserIndex = outbound.FindLastIndex(m => string.Equals(m.Role, "user", StringComparison.OrdinalIgnoreCase));
|
|
if (lastUserIndex >= 0)
|
|
outbound[lastUserIndex].Content = (outbound[lastUserIndex].Content ?? string.Empty) + fileContext;
|
|
}
|
|
|
|
if (images is { Count: > 0 })
|
|
{
|
|
var lastUserIndex = outbound.FindLastIndex(m => string.Equals(m.Role, "user", StringComparison.OrdinalIgnoreCase));
|
|
if (lastUserIndex >= 0)
|
|
outbound[lastUserIndex].Images = images.Select(CloneImage).ToList();
|
|
}
|
|
|
|
var promptList = systemPrompts
|
|
.Where(prompt => !string.IsNullOrWhiteSpace(prompt))
|
|
.Select(prompt => prompt!.Trim())
|
|
.ToList();
|
|
|
|
for (var i = promptList.Count - 1; i >= 0; i--)
|
|
outbound.Insert(0, new ChatMessage { Role = "system", Content = promptList[i] });
|
|
|
|
return new PreparedTurn(outbound);
|
|
}
|
|
|
|
public ChatMessage CommitAssistantMessage(
|
|
ChatSessionStateService? session,
|
|
ChatConversation conversation,
|
|
string tab,
|
|
string content,
|
|
int promptTokens = 0,
|
|
int completionTokens = 0,
|
|
long? responseElapsedMs = null,
|
|
string? metaRunId = null,
|
|
ChatStorageService? storage = null)
|
|
{
|
|
var assistant = new ChatMessage
|
|
{
|
|
Role = "assistant",
|
|
Content = content,
|
|
PromptTokens = Math.Max(0, promptTokens),
|
|
CompletionTokens = Math.Max(0, completionTokens),
|
|
ResponseElapsedMs = responseElapsedMs is > 0 ? responseElapsedMs : null,
|
|
MetaRunId = string.IsNullOrWhiteSpace(metaRunId) ? null : metaRunId,
|
|
};
|
|
|
|
if (session != null)
|
|
{
|
|
session.AppendMessage(tab, assistant, storage);
|
|
return assistant;
|
|
}
|
|
|
|
conversation.Messages.Add(assistant);
|
|
conversation.UpdatedAt = DateTime.Now;
|
|
return assistant;
|
|
}
|
|
|
|
public string FinalizeAssistantTurn(
|
|
ChatSessionStateService? session,
|
|
ChatConversation conversation,
|
|
string tab,
|
|
string? content,
|
|
int promptTokens = 0,
|
|
int completionTokens = 0,
|
|
long? responseElapsedMs = null,
|
|
string? metaRunId = null,
|
|
ChatStorageService? storage = null)
|
|
{
|
|
var normalized = NormalizeAssistantContentForUi(conversation, tab, content);
|
|
if (tab is "Cowork" or "Code")
|
|
conversation.ShowExecutionHistory = false;
|
|
|
|
CommitAssistantMessage(session, conversation, tab, normalized, promptTokens, completionTokens, responseElapsedMs, metaRunId, storage);
|
|
return normalized;
|
|
}
|
|
|
|
public FinalizedContent FinalizeExecutionContentForUi(string? currentContent, Exception? error = null, bool cancelled = false)
|
|
{
|
|
if (cancelled)
|
|
{
|
|
var content = string.IsNullOrWhiteSpace(currentContent) ? "(취소됨)" : currentContent!;
|
|
return new FinalizedContent(content, true, "사용자가 작업을 중단했습니다.");
|
|
}
|
|
|
|
if (error != null)
|
|
return new FinalizedContent($"오류: {error.Message}", false, error.Message);
|
|
|
|
return new FinalizedContent(currentContent ?? string.Empty, false, null);
|
|
}
|
|
|
|
public string NormalizeAssistantContentForUi(
|
|
ChatConversation conversation,
|
|
string runTab,
|
|
string? content)
|
|
{
|
|
if (!string.IsNullOrWhiteSpace(content))
|
|
return content;
|
|
|
|
var latestEventSummary = conversation.ExecutionEvents?
|
|
.Where(evt => !string.IsNullOrWhiteSpace(evt.Summary))
|
|
.OrderByDescending(evt => evt.Timestamp)
|
|
.Select(evt => evt.Summary.Trim())
|
|
.FirstOrDefault();
|
|
|
|
if (!string.IsNullOrWhiteSpace(latestEventSummary))
|
|
{
|
|
return runTab switch
|
|
{
|
|
"Cowork" => $"코워크 작업이 완료되었습니다.\n\n{latestEventSummary}",
|
|
"Code" => $"코드 작업이 완료되었습니다.\n\n{latestEventSummary}",
|
|
_ => latestEventSummary,
|
|
};
|
|
}
|
|
|
|
return "(빈 응답)";
|
|
}
|
|
|
|
public FinalizedContent FinalizeExecutionContent(string? currentContent, Exception? error = null, bool cancelled = false)
|
|
{
|
|
if (cancelled)
|
|
{
|
|
var content = string.IsNullOrWhiteSpace(currentContent) ? "(취소됨)" : currentContent!;
|
|
return new FinalizedContent(content, true, "사용자가 작업을 중단했습니다.");
|
|
}
|
|
|
|
if (error != null)
|
|
{
|
|
return new FinalizedContent($"⚠ 오류: {error.Message}", false, error.Message);
|
|
}
|
|
|
|
return new FinalizedContent(currentContent ?? string.Empty, false, null);
|
|
}
|
|
|
|
public SessionMutationResult AppendExecutionEvent(
|
|
ChatSessionStateService session,
|
|
ChatStorageService storage,
|
|
ChatConversation? activeConversation,
|
|
string activeTab,
|
|
string targetTab,
|
|
AgentEvent evt)
|
|
{
|
|
return ApplyConversationMutation(
|
|
session,
|
|
storage,
|
|
activeConversation,
|
|
activeTab,
|
|
targetTab,
|
|
normalizedTarget => session.AppendExecutionEvent(normalizedTarget, evt, null));
|
|
}
|
|
|
|
public SessionMutationResult AppendAgentRun(
|
|
ChatSessionStateService session,
|
|
ChatStorageService storage,
|
|
ChatConversation? activeConversation,
|
|
string activeTab,
|
|
string targetTab,
|
|
AgentEvent evt,
|
|
string status,
|
|
string summary)
|
|
{
|
|
return ApplyConversationMutation(
|
|
session,
|
|
storage,
|
|
activeConversation,
|
|
activeTab,
|
|
targetTab,
|
|
normalizedTarget => session.AppendAgentRun(normalizedTarget, evt, status, summary, null));
|
|
}
|
|
|
|
public string NormalizeAssistantContent(
|
|
ChatConversation conversation,
|
|
string runTab,
|
|
string? content)
|
|
{
|
|
if (!string.IsNullOrWhiteSpace(content))
|
|
return content;
|
|
|
|
var latestEventSummary = conversation.ExecutionEvents?
|
|
.Where(evt => !string.IsNullOrWhiteSpace(evt.Summary))
|
|
.OrderByDescending(evt => evt.Timestamp)
|
|
.Select(evt => evt.Summary.Trim())
|
|
.FirstOrDefault();
|
|
|
|
if (!string.IsNullOrWhiteSpace(latestEventSummary))
|
|
{
|
|
return runTab switch
|
|
{
|
|
"Cowork" => $"코워크 작업이 완료되었습니다.\n\n{latestEventSummary}",
|
|
"Code" => $"코드 작업이 완료되었습니다.\n\n{latestEventSummary}",
|
|
_ => latestEventSummary,
|
|
};
|
|
}
|
|
|
|
return "(빈 응답)";
|
|
}
|
|
|
|
private static ChatMessage CloneMessage(ChatMessage source)
|
|
{
|
|
return new ChatMessage
|
|
{
|
|
Role = source.Role,
|
|
Content = source.Content,
|
|
Timestamp = source.Timestamp,
|
|
MetaRunId = source.MetaRunId,
|
|
AttachedFiles = source.AttachedFiles?.ToList(),
|
|
Images = source.Images?.Select(CloneImage).ToList(),
|
|
};
|
|
}
|
|
|
|
private static ImageAttachment CloneImage(ImageAttachment source)
|
|
{
|
|
return new ImageAttachment
|
|
{
|
|
Base64 = source.Base64,
|
|
MimeType = source.MimeType,
|
|
FileName = source.FileName,
|
|
};
|
|
}
|
|
|
|
private static SessionMutationResult ApplyConversationMutation(
|
|
ChatSessionStateService session,
|
|
ChatStorageService storage,
|
|
ChatConversation? activeConversation,
|
|
string activeTab,
|
|
string targetTab,
|
|
Func<string, ChatConversation> mutate)
|
|
{
|
|
var normalizedTarget = NormalizeTabName(targetTab);
|
|
var normalizedActive = NormalizeTabName(activeTab);
|
|
ChatConversation updatedConversation;
|
|
|
|
if (string.Equals(normalizedTarget, normalizedActive, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
session.CurrentConversation = updatedConversation = mutate(normalizedTarget);
|
|
return new SessionMutationResult(updatedConversation, updatedConversation);
|
|
}
|
|
|
|
var activeSnapshot = activeConversation;
|
|
var previousSessionConversation = session.CurrentConversation;
|
|
updatedConversation = mutate(normalizedTarget);
|
|
|
|
if (activeSnapshot != null
|
|
&& string.Equals(NormalizeTabName(activeSnapshot.Tab), normalizedActive, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
session.CurrentConversation = activeSnapshot;
|
|
return new SessionMutationResult(activeSnapshot, updatedConversation);
|
|
}
|
|
|
|
if (previousSessionConversation != null
|
|
&& string.Equals(NormalizeTabName(previousSessionConversation.Tab), normalizedActive, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
session.CurrentConversation = previousSessionConversation;
|
|
return new SessionMutationResult(previousSessionConversation, updatedConversation);
|
|
}
|
|
|
|
var activeId = session.GetConversationId(normalizedActive);
|
|
var restoredConversation = string.IsNullOrWhiteSpace(activeId)
|
|
? null
|
|
: storage.Load(activeId);
|
|
|
|
if (restoredConversation != null)
|
|
{
|
|
session.CurrentConversation = restoredConversation;
|
|
return new SessionMutationResult(restoredConversation, updatedConversation);
|
|
}
|
|
|
|
var fallbackConversation = session.LoadOrCreateConversation(normalizedActive, storage, GetFallbackSettings());
|
|
session.CurrentConversation = fallbackConversation;
|
|
return new SessionMutationResult(fallbackConversation, updatedConversation);
|
|
}
|
|
|
|
private static SettingsService GetFallbackSettings()
|
|
{
|
|
return (System.Windows.Application.Current as App)?.SettingsService
|
|
?? new SettingsService();
|
|
}
|
|
|
|
private static string NormalizeTabName(string? tab)
|
|
{
|
|
var normalized = (tab ?? "").Trim();
|
|
if (string.IsNullOrEmpty(normalized))
|
|
return "Chat";
|
|
|
|
if (normalized.Contains("코워크", StringComparison.OrdinalIgnoreCase))
|
|
return "Cowork";
|
|
|
|
var canonical = new string(normalized
|
|
.Where(char.IsLetterOrDigit)
|
|
.ToArray())
|
|
.ToLowerInvariant();
|
|
|
|
if (canonical is "cowork" or "coworkcode" or "coworkcodetab")
|
|
return "Cowork";
|
|
|
|
if (normalized.Contains("코드", StringComparison.OrdinalIgnoreCase)
|
|
|| canonical is "code" or "codetab")
|
|
return "Code";
|
|
|
|
return "Chat";
|
|
}
|
|
}
|