일반 LLM(펑션콜만 가능한 모델)을 “스스로 생각하고, 행동하고, 기다리고, 판단하는” 워크 에이전트로 변신시킬 수 있는가?

사용자 입력 → RunFunctionCallLoopAsync (최대 10라운드)
               ├── LLM → tool call → 실행 → 결과 → LLM → ...
               └── return ← LLM이 tool call을 멈추면 종료

               이후 터미널에서 "작업 완료" 시그널 도착
               → 세션 메모리에만 기록
               → LLM은 다음 사용자 입력까지 비활성

Thought 1: 사용자가 npm test를 요청했다. 먼저 터미널에 명령을 보내야 한다.
Action 1:  term_send("npm test")
Observation 1: "Sent to term-0" (즉시 반환)

Thought 2: 테스트가 실행 중이다. 결과가 나올 때까지 기다려야 한다.
Action 2:  [대기 — 완료 시그널 수신]
Observation 2: "TaskComplete: 15 passed, 2 failed"

Thought 3: 2개 실패했다. 실패 로그를 확인하자.
Action 3:  term_read("term-0")
Observation 3: "FAIL: auth.test.js — Expected 200, got 401..."

Thought 4: 인증 테스트 실패다. 결과를 사용자에게 보고한다.
Action 4:  [최종 응답 생성]

public class ReActActor : UntypedActor
{
    private int _round = 0;
    private const int MaxRounds = 10;

    // 초기 상태: Thinking
    protected override void OnReceive(object message) => Thinking(message);

    private void Thinking(object msg)
    {
        switch (msg)
        {
            case StartReAct start:
            case CompletionSignal signal:
                _round++;
                // LLM 호출 → tool calls 유무로 분기
                var response = CallLlm(msg);
                if (response.HasToolCalls)
                    Become(Acting);  // → Acting 상태로 전환
                else
                    Become(Complete); // → 최종 응답
                break;
        }
    }

    private void Acting(object msg)
    {
        // 도구 실행
        var result = ExecuteTool(msg);
        if (result.IsAsync)
        {
            SetReceiveTimeout(TimeSpan.FromSeconds(30));
            Become(Waiting);   // → 비동기 대기
        }
        else
            Become(Thinking);  // → 즉시 결과, 다시 생각
    }

    private void Waiting(object msg)
    {
        switch (msg)
        {
            case CompletionSignal signal:
                SetReceiveTimeout(null); // 타임아웃 해제
                Become(Thinking);        // → 시그널 도착, 다시 생각
                break;
            case ReceiveTimeout:
                Become(Thinking);        // → 타임아웃, 현재 상태 확인
                break;
        }
    }
}

동기 루프:  for → return → 끝. 이후 메시지는 허공으로 사라진다.
액터:       Become(Waiting) → 메시지 수신 대기. 언제든 깨어난다.

                    UserInput / CompletionSignal
                           │
                    ┌──────▼──────┐
          ┌────────│   Thinking   │←────────────┐
          │        │  (LLM 호출)  │              │
          │        └──────┬──────┘              │
          │               │                     │
          │    ToolCalls?  │  No ToolCalls?      │
          │    ┌───────────┼───────────┐        │
          │    ▼                       ▼        │
     ┌────┴────┐              ┌───────────┐    │
     │ Acting   │              │  Complete  │    │
     │(도구실행) │              │ (최종응답)  │    │
     └────┬────┘              └───────────┘    │
          │                                     │
          │ 즉시 결과?       비동기 대기?         │
          ├─────────────┬───────────────────────┤
          ▼             ▼                       │
   Become(Thinking)  ┌──────────┐              │
                     │ Waiting  │──completion──┘
                     │(시그널대기)│
                     └────┬─────┘
                          │ timeout (30s)
                          ▼
                   Become(Thinking)
                   "타임아웃됨, 현재 상태 확인"

term_send("npm test") → "Sent to term-0" (즉시 반환)
→ LLM: "결과 확인해야지" → term_read × 12 (55초간 동일 데이터 반복)
→ 10라운드 소진 → 루프 종료 → 테스트 결과 누락

term_send("npm test") → "Sent to term-0" (즉시 반환)
→ ReActActor: Become(Waiting) + ReceiveTimeout(30s)
→ 터미널에서 테스트 완료 → TerminalToBotMessage(TaskComplete)
→ Become(Thinking): "테스트 끝남, term_read로 결과 확인"
→ term_read → 최종 요약 → Complete

// ═══ ReAct 메시지 ═══

/// ReAct 세션 시작 (UI → ReActActor)
public sealed record StartReAct(
    string UserPrompt,
    ILlmProvider Provider,
    string Model,
    int MaxTokens,
    IAgentToolbox Toolbox);

/// ReAct 진행 상태 → UI 스트리밍
public sealed record ReActProgress(
    ReActPhase Phase,   // Thinking | Acting | Waiting | Complete | Error
    string Text,
    int Round);

/// 외부 완료 시그널 (터미널/타이머 → ReActActor)
public sealed record CompletionSignal(
    string Source,      // "terminal:term-0" / "timeout" / "user"
    string Summary);

/// ReAct 취소 (UI → ReActActor)
public sealed record CancelReAct;

ActorSystem("AgentZero")
└── /user/stage (StageActor)
    ├── /bot (AgentBotActor)
    │   └── /react (ReActActor)    ← 신규: Bot의 자식
    └── /ws-{name} (WorkspaceActor)
        └── /term-{id} (TerminalActor)

== Session Memory ==
현재 상태: Waiting (npm test 완료 대기 중)
라운드: 3/10
완료된 작업: [1] meeting_create 성공, [2] term_send("npm test") 전송
대기 중: term-0에서 테스트 결과
다음 예상: 테스트 결과 확인 후 meeting_say로 보고

트레이드오프: Akka는 Python 스크립트 한 줄로 시작할 수 없다. 학습 곡선이 있고, 인프라 설정이 필요하다. 하지만 프로덕션급 에이전트 시스템 — 신뢰성, 동시성, 확장성이 필요한 환경 — 에서는 액터 모델이 Python async 프레임워크보다 견고한 기반이 된다.

Phase 1 (NuGet + Bootstrap)          ✅ 완료
  │
  ├── Phase 2 (ReActActor 구현)      ← 현재 단계, 이 글의 핵심
  │     ├── Messages.cs — ReAct 메시지 4개 추가
  │     ├── ReActActor.cs — 상태 머신 구현
  │     ├── AgentBotActor — 자식 생성 + 시그널 포워딩
  │     └── ReActActorTests — 최소 10개 테스트
  │           └── Phase 3 (UI 통합)
  │                 ├── RunFunctionCallLoopAsync에 ReAct 분기
  │                 ├── ReActProgress → UI 실시간 표시
  │                 └── Settings에 EnableReAct 토글
  │
  └── Phase 4 (LmKitProvider 온디바이스)  ← 독립 진행
        ├── LM-Kit.NET 2026.4.2 통합
        ├── ILlmProvider 추상화로 ReActActor와 자연 호환
        └── 오프라인 환경에서 소형 모델 로컬 실행